Essendo a corto di soldi, ti sei registrato per costruire ciambelle per The Donut Shop ™, la più grande azienda di ciambelle digitali al mondo, principalmente perché vendono ogni dimensione di ciambella immaginabile.

Ora, dato che gli standard di trading al giorno d'oggi sono molto difficili, è necessario scrivere un pezzo di codice il più corto possibile per creare queste ciambelle in modo che il codice sorgente che le ha create possa essere inserito all'esterno del pacchetto.

Sfida

Dati 4 ingressi, raggio dell'anello esterno, raggio dell'anello interno, possibili spruzzi e la possibilità che una cella abbia uno spruzzo, emetta una ciambella coperta in quegli spruzzi che ha i raggi interni ed esterni corretti.

• L'input può essere preso come desideri (argomenti di una funzione, stdin, argomenti del programma) e in qualsiasi ordine.
  • Gli spruzzi verranno dati sotto forma di 1 carattere per tipo di spruzzo
  • ^+*-come input cospargere sarebbe un elenco di 4 spruzza, ^, +, *,-
  • La possibilità di una spruzzatura viene inserito come un valore in virgola mobile tra 0 e 1. esempio: 0.1,0.23
• È necessario stampare l'output su stdout o equivalente.
• Gli spruzzi non possono essere sui bordi della ciambella.
• Ogni tipo di spruzzatura deve avere una probabilità altrettanto probabile di trovarsi su ogni cella.
• I raggi sono indicati in unità di 1 cella.
• Se il raggio interno è uguale a 0 O al raggio esterno, si dice che la ciambella non ha anello.
• Entrambi i raggi saranno numeri interi non negativi.
• I bordi interno ed esterno della ciambella devono essere rappresentati usando gli hash ( #)

• Un test per vedere se un punto si trova in un cerchio, dato un raggio e il centro del cerchio è:

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

Esempio di input con output

(raggio esterno, raggio interno, spruzzi, possibilità di spruzzi)

• 10, 4, "^ + * -", 0.1

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

• 5, 2, ": ^ + *", 0.9

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

Questo è il codice golf, vince la risposta più breve in byte

MATLAB, 231 byte

Ecco una soluzione matlab:

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)=' ';

Qualche esempio:

>> 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 byte

Quindi ho visto una sfida senza risposte che sembrava relativamente facile ma anche interessante e pensavo:

Hmm ... Se sono l'unico con una risposta, vincerò fino a quando una risposta migliore si presenterà inevitabilmente.

Quindi mi sono seduto con Python per alcuni minuti e ho escogitato una bozza approssimativa che, con l'aiuto dei suggerimenti della comunità, ho modificato per ridurne le dimensioni.

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)

Per gli esempi sopra, questo crea

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

e

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

Dubito fortemente che questa sia la soluzione più breve possibile, ma penso che abbia funzionato abbastanza bene per il tentativo di un adolescente autodidatta di ammazzare il tempo. Poiché questo è stato progettato per essere il più piccolo possibile, non ho incluso commenti e ho preso scorciatoie su ogni nome di variabile e come tale, questo programma è più per usabilità che leggibilità.

Se desideri utilizzare questo codice per qualche motivo a mia insaputa, eseguilo in IDLE e digita il comando

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

nel formato sopra descritto.