Da Sie kein Geld mehr haben, haben Sie sich dazu angemeldet, Donuts für The Donut Shop ™ zu bauen, das größte digitale Donut-Unternehmen der Welt, hauptsächlich, weil es Donuts jeder erdenklichen Größe verkauft.

Angesichts der Tatsache, dass Handelsstandards heutzutage sehr schwierig sind, müssen Sie einen Code schreiben, der so kurz wie möglich ist, um diese Donuts zu erstellen, damit der Quellcode, der sie erstellt hat, außerhalb des Pakets platziert werden kann.

Herausforderung

Bei 4 Eingaben, Radius des Außenrings, Radius des Innenrings, den möglichen Streuseln und der Wahrscheinlichkeit, dass eine Zelle streut, wird ein Ring ausgegeben, der mit den Streuseln bedeckt ist, die die richtigen Innen- und Außenradien aufweisen.

• Die Eingabe kann nach Belieben (Argumente zu einer Funktion, stdin, Programmargumente) und in beliebiger Reihenfolge erfolgen.
  • Die Streusel werden in Form von 1 Zeichen pro Streuselart angegeben
  • ^+*-als bestreuen Eingabe wäre eine Liste von 4 besprüht sein, ^, +, *,-
  • : Die Wahrscheinlichkeit eines Streuen wird als ein Gleitkommawert zwischen 0 und 1 zum Beispiel eingegeben werden 0.1,0.23
• Sie müssen die Ausgabe als Standardausgabe oder gleichwertig ausdrucken.
• Streusel dürfen nicht an den Rändern des Donuts sein.
• Jede Art von Streuung muss die gleiche Wahrscheinlichkeit haben, in jeder Zelle zu sein.
• Die Radien sind in 1-Zellen-Einheiten angegeben.
• Wenn der innere Radius entweder 0 ODER der äußere Radius ist, hat der Ring keinen Ring.
• Beide Radien sind nicht negative ganze Zahlen.
• Die inneren und äußeren Ränder des Donuts müssen mit Hashes ( #) dargestellt werden

• Ein Test, um zu sehen, ob sich ein Punkt in einem Kreis befindet, wenn ein Radius und der Mittelpunkt des Kreises gegeben sind:

  (x-center)**2+(y-center)**2 < radius**2

Beispiel Eingabe mit Ausgabe

(Außenradius, Innenradius, Streusel, Streuwahrscheinlichkeit)

• 10, 4, ^ + * -, 0,1

       #########
      #         #
    ##  ++   *  *##
    #             #
   #       ^^ - *  #
  #      #####   ^  #
  #+    #     #     #
  #    #       #-   #
  #    #       #  * #
  #    #       #+   #
  #    #       #    #
  #^  +#       #    #
  #     #     #     #
  # *    #####      #
   #       +  -    #
    #        ^    #
    ##  ^  +     ##
      #       ^ #
       #########
  

• 5, 2, 0,9

    #####
   #^^+ ^#
  #**###  #
  #:#   #^#
  #^#   #*#
  #:#   #*#
  #:+###* #
   # *:^:#
    #####
  

Dies ist Codegolf, die kürzeste Antwort in Bytes gewinnt

MATLAB, 231 Bytes

Hier eine Matlab-Lösung:

function g=z(r,q,s,p);[x,y]=meshgrid(1:2*r,1:2*r);d=(x-r).^2+(y-r).^2;h=size(d);e=zeros(h);e(d<r^2 & d>=q^2)=1;f=bwperim(e,4);k=rand(h);j=numel(s);l=changem(randi(j,h),s,1:j);g=char(e);g(:,:)=' ';g(k<=p)=l(k<=p);g(f)='#';g(~e)=' ';

Einige Beispiele:

>> z(10, 4, '^+*-', 0.1)

ans =

     #########      
    #         #     
  ##           ##   
  #    -       -#   
 #               #  
#   -  #####    ^ # 
#     #     #     # 
#   -#       #    # 
# *  #       #+   # 
#**  #       #    # 
#  * #       # -  # 
#+  *#       #    # 
#     #     #     # 
#      #####      # 
 #           ^   #  
  #     *       #   
  ##+          ##   
    #         #     
     #########      

>> z(5, 2, ':^+*', 0.9)

ans =

  #####   
 #++::*#  
#^^###++# 
# #   #+# 
#^#   #^# 
#*#   #*# 
#+:###^*# 
 #*:^+^#  
  #####   

>> z(20,6, 'erthhjjjjkjkk', 0.4)

ans =

             #############              
           ##jh  k  k  k  ##            
         ##  jjj    j khh   ##          
        #r kj h   k tjhj j    #         
      ##jk    t k  jh j       h##       
     #k       rre            k j #      
    # j   j j  j  khtkt jr     kj #     
    #  k   rk je    j      h   j  #     
   # j   k   k  jth e k j   j    j #    
  #h   h h e     t e ej  j  r k r e #   
  #    j   r  jh  jk     j  kk   j  #   
 #      k     k    h k  jk     k j   #  
 #  jjk   hh k hj  r  j  je rjj k j  #  
#  ek  j j jj  h#######          hke  # 
#hj      k j j #       #ke jhkt  jee  # 
#        jk  k#         # k    j   t  # 
#k        j  #           #khk  r     j# 
#   tj  j te #           # j  r j j   # 
#e   je   jhk#           #        t j # 
#jj    j  h  #           #     k jj e # 
# j j   hj j #           # jkt kjjjr e# 
#j k    e    #           #       r   k# 
#jj  k    ek #           # hj  j rtj  # 
#   k j   hk h#         #     j  h j  # 
#   h trt  jrht#       #   et        k# 
#j  ehjj      j #######ett  kh kjj k  # 
 #   r  jj    ekk jk    th k   kkk h #  
 #hj       khe kj hr  jj   kk  r j   #  
  #r t    k j  k r  j  jk k hh    jj#   
  #  kjj  h k j       j rrr j  r j  #   
   #j kej  jj    t       h  j   hh #    
    #  he   e  tje j  tjhkjk kj   #     
    #j kt rjk    j j  ee    rkj   #     
     #   jjr e  j jkt j   e  j  j#      
      ##k  thhjj je   kj  kh   ##       
        # hje  j     jj kk t j#         
         ## k       h     e ##          
           ## e jje   kkhj##            
             #############              

Python, 263 Bytes

So sah ich eine Herausforderung ohne Antworten, die relativ einfach, aber auch interessant aussah und dachte für mich:

Hmm ... Wenn ich der einzige bin, der eine Antwort hat, werde ich gewinnen, bis unweigerlich eine bessere Antwort auftaucht.

Also habe ich mich ein paar Minuten mit Python zusammengesetzt und mir einen groben Entwurf überlegt, den ich mithilfe der Vorschläge der Community optimiert habe, um seine Größe zu reduzieren.

from random import*
def D(O,I,S,P):
 a=range(-O,O+1);C=lambda x,y,z,n:(n-.5)**2<x*x+y*y<(z+.5)**2
 if I>=O:I=0
 for y in a:
  R=''
  for x in a:
   if C(x,y,O,O)+(C(x,y,I,I)&(I!=0)):R+='#'
   elif C(x,y,O,I)&(uniform(0,1)<P):R+=choice(s)
   else:R+=' '
  print(R)

Für die obigen Beispiele wird dies erstellt

>>> D(10, 4, "^+*-", 0.1)
       #######       
     ##       ##     
    #         * #    
   #             #   
  #          + ^  #  
 # +               # 
 #   + +#####   -  # 
#      ##   ##    ^ #
#     ##     ##  *  #
#-    #       #     #
#     #       #  +  #
# +   #       #     #
#     ##     ##     #
#      ##   ##  *   #
 #+-    #####      # 
 #             - - # 
  #   -    -     +#  
   #      ^      #   
    # -    +    #    
     ## *     ##     
       #######       
>>> 

und

>>> D(5, 2, ":^+*", 0.9)
   #####   
  #*^:* #  
 #^::*:^*# 
#* :###+*:#
#:*#   #+:#
#::#   #+ #
#+:#   #*:#
#^^:###::^#
 # + :*^ # 
  # *:+*#  
   #####   
>>> 

Ich bezweifle sehr, dass dies die kürzestmögliche Lösung ist, aber ich denke, es hat ziemlich gut geklappt, wenn ein autodidaktischer Teenager versucht hat, die Zeit totzuschlagen. Da dies so klein wie möglich ist, habe ich keine Kommentare eingefügt und Verknüpfungen zu jedem Variablennamen verwendet. Daher dient dieses Programm eher der Benutzerfreundlichkeit als der Lesbarkeit.

Wenn Sie diesen Code aus einem mir unbekannten Grund verwenden möchten, führen Sie ihn einfach in IDLE aus und geben Sie den Befehl ein

D(Outer Radius, Inner Radius, Sprinkles, Chance of Sprinkle)

im oben beschriebenen Format.