Al no tener dinero en efectivo, se ha registrado para construir donas para The Donut Shop ™, la compañía de donas digital más grande del mundo, principalmente porque venden donas de todos los tamaños imaginables.

Ahora, dado que los estándares comerciales hoy en día son muy difíciles, debe escribir un fragmento de código lo más corto posible para crear estas donas para que el código fuente que las creó pueda colocarse en el exterior del paquete.

Desafío

Dadas 4 entradas, radio del anillo exterior, radio del anillo interior, las posibles aspersiones y la posibilidad de que una celda tenga una aspersión, genera una rosquilla cubierta en esas aspersiones que tiene los radios internos y externos correctos.

• La entrada puede tomarse como desee (argumentos de una función, stdin, argumentos de programa) y en cualquier orden.
  • Las aspersiones se darán en forma de 1 carácter por tipo de aspersión.
  • ^+*-como entrada espolvorear sería una lista de 4 asperja, ^, +, *,-
  • La posibilidad de una aspersión se introduce como un valor de punto flotante entre 0 y 1. Por ejemplo: 0.1,0.23
• Debe imprimir la salida en stdout o equivalente.
• Las chispas no pueden estar en los bordes de la rosquilla.
• Cada tipo de aspersión debe tener una probabilidad igualmente probable de estar en cada celda.
• Los radios se dan en unidades de 1 celda.
• Si el radio interno es igual a 0 O al radio externo, se dice que la rosquilla no tiene anillo.
• Ambos radios serán enteros no negativos.
• Los bordes interno y externo de la rosquilla se deben representar con hashes ( #)

• Una prueba para ver si un punto está en un círculo, dado un radio y el centro del círculo es:

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

Ejemplo de entrada con salida

(radio exterior, radio interior, aspersiones, posibilidad de aspersión)

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

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

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

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

Este es el código de golf, la respuesta más corta en bytes gana

MATLAB, 231 bytes

Aquí una solución 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)=' ';

Algunos ejemplos:

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

Entonces vi un desafío sin respuestas que parecía relativamente fácil pero también interesante y pensé para mí mismo:

Hmm ... Si soy el único con una respuesta, estaré ganando hasta que inevitablemente aparezca una mejor respuesta.

Así que me senté con Python durante unos minutos y se me ocurrió un borrador que, con la ayuda de las sugerencias de la comunidad, he estado modificando para reducir su tamaño.

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)

Para los ejemplos anteriores, esto crea

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

y

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

Dudo mucho que esta sea la solución más corta posible, pero creo que funcionó bastante bien para el intento de un adolescente autodidacta de matar el tiempo. Dado que esto fue diseñado para ser lo más pequeño posible, no he incluido comentarios y he tomado atajos en cada nombre de variable y, como tal, este programa es más de usabilidad que de legibilidad.

Si desea utilizar este código por alguna razón que yo desconozco, simplemente ejecútelo en IDLE y escriba el comando

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

en el formato descrito anteriormente.