Étant à court d'argent, vous vous êtes inscrit pour construire des beignets pour The Donut Shop ™, la plus grande entreprise de beignets numériques au monde, principalement parce qu'ils vendent toutes les tailles de beignets imaginables.

Maintenant, étant donné que les normes commerciales sont de nos jours très difficiles, vous devez écrire un morceau de code aussi court que possible pour créer ces beignets afin que le code source qui les a créés puisse être placé à l'extérieur du paquet.

Défi

Étant donné 4 entrées, le rayon de l'anneau extérieur, le rayon de l'anneau intérieur, les paillettes possibles et la chance d'une cellule ayant une paillette, sortez un beignet recouvert de ces paillettes qui a les rayons intérieurs et extérieurs corrects.

• L'entrée peut être prise comme vous le souhaitez (arguments d'une fonction, stdin, arguments du programme) et dans n'importe quel ordre.
  • Les arrosages seront donnés sous forme de 1 caractère par type d'arrosage
  • ^+*-comme entrée de saupoudrer serait une liste de 4 arrose, ^, +, *,-
  • La chance d'un Saupoudrez sera entré comme une valeur en virgule flottante compris entre 0 et 1. par exemple: 0.1,0.23
• Vous devez imprimer la sortie sur stdout ou équivalent.
• Les paillettes ne peuvent pas être sur les bords du beignet.
• Chaque type de saupoudrage doit avoir une chance tout aussi probable d'être sur chaque cellule.
• Les rayons sont donnés en unités à 1 cellule.
• Si le rayon intérieur est égal à 0 OU au rayon extérieur, le beignet est dit sans anneau.
• Les deux rayons seront des entiers non négatifs.
• Les bords intérieurs et extérieurs du beignet doivent être représentés à l'aide de hachages ( #)

• Un test pour voir si un point est dans un cercle, étant donné un rayon et le centre du cercle est:

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

Exemple d'entrée avec sortie

(rayon extérieur, rayon intérieur, arrose, risque d'arroser)

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

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

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

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

Ceci est le golf de code, la réponse la plus courte en octets gagne

MATLAB, 231 octets

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

Quelques exemples:

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

J'ai donc vu un défi sans réponse qui semblait relativement facile, mais aussi intéressant et j'ai pensé:

Hmm ... Si je suis le seul à avoir une réponse, je gagnerai jusqu'à ce qu'une meilleure réponse apparaisse inévitablement.

Je me suis donc assis avec Python pendant quelques minutes et j'ai trouvé un brouillon que, avec l'aide des suggestions de la communauté, j'ai peaufiné pour réduire sa taille.

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)

Pour les exemples ci-dessus, cela crée

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

et

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

Je doute fortement que ce soit la solution la plus courte possible, mais je pense que cela a plutôt bien fonctionné pour la tentative d'un adolescent autodidacte de tuer le temps. Étant donné que cela a été conçu pour être aussi petit que possible, je n'ai pas inclus de commentaires et j'ai pris des raccourcis sur chaque nom de variable et en tant que tel, ce programme est plus pour la convivialité que pour la lisibilité.

Si vous souhaitez utiliser ce code pour une raison inconnue, exécutez-le dans IDLE et tapez la commande

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

dans le format décrit ci-dessus.