एक भंवर बनाएँ!

Question

आपका मिशन आज एक एकल पैरामीटर दिया गया एक भंवर बनाना है।

यह पैरामीटर वर्णों में प्रत्येक हाथ की लंबाई निर्धारित करता है।

प्रत्येक हाथ की प्रत्येक "परत" में पिछले से एक अधिक चरित्र होता है।

यहां बताया गया है कि भंवर कैसे दिखेगा, बांह की लंबाई:

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

##  #
  # #
 ### 
# #  
#  ##

4:

#     #
 ##  #
   # #
  ###  
 # #   
 #  ## 
#     #

10:

             #
             #
             #     
             #   
            #      
####        #      
    ###     #      
       ##  #      
         # #       
        ###       
       # #         
       #  ##       
      #     ###    
      #        ####
      #            
     #             
     #             
     #             
     #             

स्टैंडर्ड लूपहोल्स लागू होते हैं, व्हाट्सएप को पीछे छोड़ते हुए, ASCII में कोई भी एकल गैर-व्हाट्सएप चरित्र "#" को बदल सकता है।

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

Comments

कल्पना (जैसे कि वहाँ है) उदाहरणों के विपरीत है। पिछले दो में विषमता कहां से आई?

— पीटर टेलर

यहाँ एक सही संस्करण है।

— rahnema1

@JonathanAllan मेरे संपादन विवरण देखें: बदसूरत काले गैर-चरित्र को हटा दिया, लेकिन वे अभी भी असममित हैं । और नहीं, मैं नहीं ले रहा हूँ ... मेरे लिए एक उबाऊ चुनौती की तरह लगता है (कोई अपराध नहीं)

— श्री Xcoder

कृपया इसे पुनः खोलें। यह अब स्पष्ट है।

— प्रोग्रामर

@JonathanAllan हाँ, उनके पास एक मुद्दा था जैसा आपने कहा। फिक्स्ड।

— Papayaman1000

Answer 1

MATL , 60 बाइट्स

3<G+Eqt&OlG8M+t&(1G:8*X^Q2/kG+G:Gq+&vG2=+Z{(XJ3:"J@X!+]g35*c

इसे ऑनलाइन आज़माएं! या परीक्षण मामलों को सत्यापित करें: 0 , 1 , 2 , 3 , 4 , 10 ।

यह मेरी अपेक्षा से अधिक मजेदार था। समझा जाना कठिन है, हालांकि ...

Answer 2

जेली , 48 बाइट्स

Rȯ1ĖŒṙ‘Ė’ḣµ;NµN0¦€U;
Ç+;ẋ2W$+⁸<3¤µFṀR,þ$e€€ị⁾# Y

इसे ऑनलाइन आज़माएं!

( प्रत्येक कॉलम के बीच एक स्थान जोड़कर, फाइनल Yको प्रतिस्थापित करके इसे और अधिक चौकोर बनाएं G)।

कैसे?

#केंद्र के सापेक्ष एक हाथ के निर्देशांक की एक सूची बनाता है । ट्रांसफ़ॉर्म करता है जो शीर्ष-बाएँ कोने से चार भुजाओं के निर्देशांक में जुड़ता है और केंद्र समन्वय को जोड़ता है। अंतरिक्ष में सभी निर्देशांक की एक तालिका बनाता है और हथियारों को #और नए सिरे से पंक्तियों में शामिल होने के लिए और अंतरिक्ष सेट करता है।

Rȯ1ĖŒṙ‘Ė’ḣµ;NµN0¦€U; - Link 1, arm coordinates relative to centre: arm-length a
R                    - range: [1,2,...,a]
 ȯ1                  - or 1 (stops Œṙ erroring with arm-length 0; builds no redundant coordinates in the end)
   Ė                 - enumerate: [[1,1],[2,2],...[a,a]]  (or [[1,1]] if a=0)
    Œṙ               - run-length decode: [1,2,2,...,a,a,...,a] (or [1] if a=0)
      ‘              - increment: [2,3,3,...,a+1,a+1,...,a+1] (or [2] if a=0)
       Ė             - enumerate: [[1,2],[2,3],...,[T(a)-a,a+1],[T(a)-a+1,a+1],...,[T(a),a+1]] where T(a)=(a+1)*a/2 (or [[1,2]] if a=0)
        ’            - decrement: [[0,1],[1,2],...,[T(a)-a-1,a],[T(a)-a,a],...a[T(a)-1),a]] (or [[0,1]] if a=0)
         ḣ           - head to a (first a of those) - these are an arm's relative coordinates from the central `#` at [0,0])
          µ          - monadic chain separation (call that list r)
           ;         - r concatenated with
            N        - negate r (gets the opposite arm)
             µ       - monadic chain separation (call that list s)
                 €   - for €ach coordinate pair in s:
               0¦    -     apply to index 0 (the right of the two values):
              N      -         negate
                  U  - upend (reverse each pair of that, gives the other two arms)
                   ; - concatenate that list with s (gives all four arms)

Ç+;ẋ2W$+⁸<3¤µFṀR,þ$e€€ị⁾# Y - Main link: arm-length a
Ç                           - call the last link(1) as a monad (get centre-relative coordinates)
 +                          - add a (make the coordinates relative to the top-left)
      $                     - last two links as a monad:
   ẋ2                       -     repeat a twice: [a,a]
     W                      -     wrap in a list: [[a,a]] (the centre coordinate)
  ;                         - concatenate (add the centre coordinate)
           ¤                - nilad followed by link(s) as a nilad:
        ⁸                   -     link's left argument, a
         <3                 -     less than three?
       +                    - add (a in 0,1,2 are special cases requiring a grid one-by-one more than all the rest)
            µ               - monadic separation (call that c)
             F              - flatten c into one list
              Ṁ             - get the maximum (the side-length of the space)
                  $         - last two links as a monad:
               R            -     range: [1,2,...,side-length]
                ,þ          -     pair table: [[[1,1],[1,2],...,[1,side-length]],[[2,1],[2,2],...,[2,side-length]],...,[[side-length,1],[side-length,2],[side-length, side-length]]]
                   e€€      - exists in c? for €ach for €ach (1 if a # coordinate, 0 otherwise)
                       ⁾#   - literal ['#',' ']
                      ị     - index into
                          Y - join with new line characters
                            - implicit print

Answer 3

गणितज्ञ 139 172 बाइट्स

एक फ़ंक्शन के साथ एक एकल हाथ बनाने के लिए विचार है - {⌊.5+.5(-7+8#)^.5⌋,#-1}जो हाथ के प्रत्येक तत्व के सूचकांक को बाहर निकालता है मान लें कि मध्य तत्व में सूचकांक (0,0) है। उस पर अभी तक किसी ने भी विचार नहीं किया है, लेकिन मुझे संदेह है कि इस विचार का परिणाम बेहतर गोल्फ भाषा में विजयी उत्तर होगा। फिर मैं हाथ को 90 डिग्री के गुणक के माध्यम से घुमाता हूं, फिर से अनुक्रमित करता हूं और मैट्रिक्स का निर्माण करता हूं।

SparseArrayमैट्रिक्स के निर्माण के लिए स्पष्ट पसंद की तरह लग रहा था, लेकिन BoxMatrixऔर साथ जा सकता था ReplacePart।

Grid[SparseArray[Max@#+#+1&[Join@@Table[RotationMatrix[i Pi/2].#&/@{{0,0}}~Join~Array[{⌊.5+.5(-7+8#)^.5⌋,#-1}&,#],{i,4}]]->X,2#+1,""]]&

Ungolfed (हाथ की लंबाई के लिए कठोर कोड = 3, %पिछले आउटपुट का मतलब है):

{{0,0}}~Join~Table[{Floor[1/2 (1+Sqrt[-7+8x])],x-1},{x,1,3}]
Table[RotationMatrix[i Pi/2].#&/@%,{i,4}]
Flatten[%,1]
Max[%]+%+1
Normal@SparseArray[%->X,Automatic,""]
Grid[%/. 0->""]

उपयोग% @ ४

X                       X   
    X   X           X       
            X       X       
        X   X   X           
    X       X               
    X           X   X       
X                       X

जैसा कि मैंने सीखा है कि अतिरिक्त ASCII का उत्पादन शुद्ध होना चाहिए या अतिरिक्त स्वरूपण के बिना, कोड को थोड़ा लंबा (172 बाइट्स) प्राप्त करना होगा:

StringRiffle[ReplacePart[Array[" "&,{1,1}*2#+1],Max@#+#+1&[Join@@Table[RotationMatrix[i Pi/2].#&/@{{0,0}}~Join~Array[{⌊.5+.5(-7+8 #)^.5⌋,#-1}&,#],{i,4}]]->"#"],"\n",""]

#     #  
 ##  #   
   # #   
  ###    
 # #     
 #  ##   
#     #  

Comments

क्या कॉलम के बीच की अतिरिक्त रिक्ति को हटाया जा सकता है? जैसा कि यह एक ASCII- कला चुनौती है, आउटपुट बिल्कुल निर्दिष्ट होना चाहिए, जिसमें कोई अतिरिक्त अंतर नहीं है (@ Papayaman1000 कृपया पुष्टि करें कि क्या यह छूट दी जा सकती है)

— HyperNeutrino

मैं इसके लिए एक संपादन करता हूं यदि यह आवश्यक हो जाता है। अभी यह बहस का मुद्दा लगता है।

— केली लोडर

हम्म ... मैं पसंद करूंगा, प्रतियोगिता के लिए, आप उस उत्तर का उपयोग करें जो सटीक आउटपुट देता है। जैसा कि @HyperNeutrino ने कहा, यह ASCII- कला है, इसलिए इसे निर्दिष्ट किया जाना चाहिए।

— Papayaman1000

ठीक है, मैंने इसे ठीक कर दिया।

— केली लोडर

Answer 4

चारकोल , 30 बाइट्स

#ＮβＦβ«¿ι«×#⌊⟦ιβ⟧Ａ⁻βιβ↑»»‖←⟲Ｏ²⁴⁶

व्याख्या

#                                    Print "#"
 Ｎβ                                 Input number to b
    Ｆβ«                  »          For i in range(b)
        ¿ι«              »           If i is truthy (to skip 0)
           ×#⌊⟦ιβ⟧                   Print "#" * minimum of i and b
                  Ａ⁻βιβ↑            Assign b-i to b
                           ‖         Reflect right
                            ⟲Ｏ²⁴⁶  Rotate overlap 90, 180 and 270 degrees

इसे ऑनलाइन आज़माएं!

Comments

Trimलगता है कि गोल्फर काम कर रहा है: ＮθＦθ⁺¶#×#ιＪ⁰¦⁰Ｔθ⁺¹θ#⟲Ｏ↖²⁴⁶( ⁺¹वर्कअराउंड है क्योंकि Ｔ⁰¦⁰किसी कारणवश काम नहीं करता। और ⊕फिर वापस मौजूद नहीं होता।)

— नील