Brakuje Ci gotówki, więc postanowiłeś zbudować pączki dla The Donut Shop ™, największej na świecie cyfrowej firmy oferującej pączki, głównie dlatego, że sprzedają pączki każdej wielkości, jakie można sobie wyobrazić.

Teraz, biorąc pod uwagę, że obecnie standardy handlu są bardzo trudne, musisz napisać jak najkrótszy kawałek kodu, aby utworzyć te pączki, aby kod źródłowy, który je utworzył, mógł zostać umieszczony na zewnątrz pakietu.

Wyzwanie

Biorąc pod uwagę 4 dane wejściowe, promień pierścienia zewnętrznego, promień pierścienia wewnętrznego, możliwe posypki i szansę, że komórka będzie miała posypkę, wyjmij pączka pokrytego w tych posypkach, które mają prawidłowe promienie wewnętrzne i zewnętrzne.

• Dane wejściowe można pobierać według własnego uznania (argumenty funkcji, standardowe, argumenty programu) i w dowolnej kolejności.
  • Kropienia będą podawane w postaci 1 znaku na każdy rodzaj kropienia
  • ^+*-jako wejście posypać byłaby lista 4 posypki, ^, +, *,-
  • Szansa posypać zostaną wprowadzone jako wartości zmiennoprzecinkowej pomiędzy 0 a 1. np: 0.1,0.23
• Musisz wydrukować dane wyjściowe na standardowe lub równoważne.
• Krople nie mogą znajdować się na krawędziach pączka.
• Każdy rodzaj posypki musi mieć jednakową szansę znalezienia się w każdej komórce.
• Promienie podano w jednostkach jednokomórkowych.
• Jeśli promień wewnętrzny jest równy 0 LUB promień zewnętrzny, mówi się, że pączek nie ma pierścienia.
• Oba promienie będą liczbami całkowitymi nieujemnymi.
• Wewnętrzne i zewnętrzne krawędzie pączka muszą być reprezentowane za pomocą skrótów ( #)

• Test sprawdzający, czy punkt znajduje się na okręgu, biorąc pod uwagę promień, a środkiem koła jest:

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

Przykładowe wejście z wyjściem

(promień zewnętrzny, promień wewnętrzny, kropi, szansa na kropienie)

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

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

• 5, 2, „: ^ + *”, 0,9

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

To jest kod golfowy, wygrywa najkrótsza odpowiedź w bajtach

MATLAB, 231 bajtów

Oto rozwiązanie 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)=' ';

Kilka przykładów:

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

Widziałem więc wyzwanie bez odpowiedzi, które wydawało się stosunkowo łatwe, ale również interesujące i pomyślałem sobie:

Hmm ... Jeśli tylko ja mam odpowiedź, będę wygrywać, dopóki nie pojawi się lepsza odpowiedź.

Usiadłem więc z Pythonem przez kilka minut i opracowałem wstępny szkic, który przy pomocy sugestii społeczności zmieniłem, aby zmniejszyć jego rozmiar.

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)

W powyższych przykładach tworzy to

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

i

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

Bardzo wątpię, aby było to najkrótsze możliwe rozwiązanie, ale myślę, że całkiem dobrze się spisało w przypadku samouka nastolatka, który chciał zabić czas. Ponieważ został on zaprojektowany tak, aby był jak najmniejszy, nie dołączałem komentarzy i wprowadziłem skróty do każdej nazwy zmiennej, i jako taki, ten program jest bardziej przydatny niż czytelny.

Jeśli chcesz użyć tego kodu z jakiegoś nieznanego mi powodu, po prostu uruchom go w IDLE i wpisz polecenie

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

w formacie opisanym powyżej.