Com pouco dinheiro, você se inscreveu para criar rosquinhas para a The Donut Shop ™, a maior empresa de rosquinhas digitais do mundo, principalmente porque elas vendem todos os tamanhos de rosquinha imagináveis.

Agora, considerando que os padrões de negociação atualmente são muito difíceis, você precisa escrever um pedaço de código o mais curto possível para criar esses anéis de espuma, para que o código-fonte que os criou possa ser colocado na parte externa do pacote.

Desafio

Dadas 4 entradas, raio do anel externo, raio do anel interno, as possíveis polvilhas e a chance de uma célula ser polvilhada, produz uma rosquinha coberta nessas polvilhas com os raios interno e externo corretos.

• A entrada pode ser tomada como você deseja (argumentos para uma função, stdin, argumentos do programa) e em qualquer ordem.
  • As polvilhas serão dadas na forma de 1 caractere por tipo de polvilha
  • ^+*-como entrada pitada seria uma lista de 4 polvilha, ^, +, *,-
  • A possibilidade de uma pitada será inserido como um valor de ponto flutuante entre 0 e 1. por exemplo,: 0.1,0.23
• Você deve imprimir a saída para stdout ou equivalente.
• Granulado não pode estar nas bordas da rosquinha.
• Cada tipo de aspersão deve ter uma chance igualmente provável de estar em cada célula.
• Os raios são dados em unidades de 1 célula.
• Se o raio interno for igual a 0 OU ao raio externo, diz-se que o anel não possui anel.
• Ambos os raios serão números inteiros não negativos.
• As bordas interna e externa da rosquinha devem ser representadas usando hashes ( #)

• Um teste para ver se um ponto está em um círculo, dado um raio e o centro do círculo é:

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

Exemplo de entrada com saída

(raio externo, raio interno, granulado, possibilidade de granulado)

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

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

• 5, 2, ": ^ + *", 0,9

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

Isso é código de golfe, a resposta mais curta em bytes ganha

MATLAB, 231 bytes

Aqui está uma solução 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)=' ';

Alguns exemplos:

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

Então, vi um desafio sem respostas que parecia relativamente fácil, mas também interessante e que pensei:

Hmm ... Se eu sou o único com uma resposta, vencerei até que uma resposta melhor apareça inevitavelmente.

Então, sentei-me com o Python por alguns minutos e criei um rascunho que, com a ajuda das sugestões da comunidade, estive aprimorando para reduzir seu tamanho.

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 os exemplos acima, isso cria

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

e

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

Duvido muito que essa seja a solução mais curta possível, mas acho que funcionou muito bem na tentativa de um adolescente autodidata de perder tempo. Como esse foi projetado para ser o menor possível, não incluí comentários e atalhos para todos os nomes de variáveis ​​e, como tal, esse programa é mais para usabilidade do que legibilidade.

Se você quiser usar esse código por algum motivo sem o meu conhecimento, execute-o em IDLE e digite o comando

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

no formato descrito acima.