यूक्लिडियन एल्गोरिथ्म को फिर से देखें

Question

कार्य

दो सकारात्मक पूर्णांक दिए गए:

1. दो पूर्णांकों द्वारा निर्दिष्ट आयामों के साथ आयत खींचें।
2. चरण 3 को दोहराएं जब तक कि अधिक जगह न हो।
3. (शेष) आयत के तीन किनारों को छूने वाले सबसे बड़े वर्ग को ड्रा करें और भरें।
4. परिणामी आयत का उत्पादन।

उदाहरण

उदाहरण के लिए, हमारे इनपुट है 6और 10।

हम 6 x 10 आकार के खोखले आयत बनाते हैं:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

वर्गों को बार-बार भरने के बाद, हम यही प्राप्त करेंगे:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

वहाँ 4 वर्गों यहाँ हैं ( a, b, c, d), पक्ष की लंबाई के साथ प्रत्येक 6, 4, 2, 2क्रमशः।

नियम और स्वतंत्रता

1. आपको प्रत्येक वर्ग के लिए एक अलग अक्षर का उपयोग करना चाहिए।
2. आप चुन सकते हैं कि किन अक्षरों का समर्थन करना है, जब तक कि समर्थित अक्षर सभी प्रिंट करने योग्य वर्ण हैं और कम से कम 10वर्ण समर्थित हैं।
3. ऊपर चरण 3 के प्रत्येक पुनरावृत्ति में, आपके पास दो विकल्प होते हैं (अंतिम पुनरावृत्ति को छोड़कर, जहां आपके पास केवल एक विकल्प होता है)। दोनों विकल्प वैध हैं।
4. आवश्यक वर्गों की संख्या आपके द्वारा समर्थित पत्रों की संख्या से अधिक नहीं होगी।
5. आप किसी भी क्रम में समर्थन पत्र के साथ वर्गों में भर सकते हैं ।

परीक्षण के मामलों

इनपुट: 6, 10

आउटपुट:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

या

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

या

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

या

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

या

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

इनपुट: 1,1

आउटपुट:

a

इनपुट: 1,10

आउटपुट:

abcdefghij

इनपुट: 10,1

आउटपुट:

a
b
c
d
e
f
g
h
i
j

ध्यान दें कि ऊपर दिए गए टेस्टकेस के लिए मुझे शामिल करने की तुलना में अधिक संभावनाएं हैं।

स्कोरिंग

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

मानक खामियां लागू होती हैं।

Comments

संबंधित ।

— लीक नून

Answer 1

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

ＮδＮγＦβ¿×γδ«ＵＯγδι¿‹γδＡ⁻δγδＡ⁻γδγ

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

Ｎδ      Input d
Ｎγ      Input g
Ｆβ      For i In ['a' ... 'z']
 ¿×γδ«   If g * d
  ＵＯγδι   Oblong g, d, i
  ¿‹γδ    If g < d
   Ａ⁻δγδ   d = d - g
   Ａ⁻γδγ   Else g = g - d

वार्षिक रूप से चारकोल की ओबलोंग कमांड 0एक आयाम के लिए नहीं होगी , जिसकी कीमत मुझे 4 बाइट्स में चुकानी होगी। अन्य दृष्टिकोण लूप करने के लिए होगा g * d, लेकिन फिर मैं यह कैसे काम कर सकता हूं कि यह कैसे खत्म हो जाए b(जो निचले अक्षरों में पूर्वनिर्धारित है)।

Comments

ओह, क्षमा करें, यह एक सचेत डिजाइन निर्णय था, क्या आपको लगता है कि नकारात्मक इनपुट को भी अनुमति दी जानी चाहिए?

— केवल

@ ASCII- केवल वर्तमान व्यवहार क्या है (0 और नकारात्मक दोनों के लिए)? मेरा सबसे अच्छा विचार यह होगा कि नकारात्मक दाएं / नीचे के बजाय बाईं ओर / शीर्ष पर आकर्षित होगा। (इसके अलावा, अगर मैं उपयोग Ｗ×γδकरता हूं, तो मैं हर बार एक अलग पत्र कैसे प्रिंट कर सकता हूं?)

— नील

@ नील वाह, मैं देख रहा हूं कि आपका क्या मतलब है कि WOULD कष्टप्रद हो सकता है।

— मैजिक ऑक्टोपस

Answer 2

पायथ , 34 बाइट्स

M?*GH?<HGCgHG+*G]jk*G]~hZgG-HGYjgF

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

Answer 3

हास्केल , 90 बाइट्स

(['a'..]!)
a?x=a<$[1..x]
((a:b)!y)x|x*y<1=""?y|x>y=map(a?y++)$b!y$x-y|z<-y-x=a?x?x++(b!z)x

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

Answer 4

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

Ṁ,ạ/y
³,⁴ÇÐĿp/€Fs2
pµ¢ṣLµ€+95ỌsY

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

Ṁ,ạ/yआप एक स्पष्टीकरण चाहते हैं? यही पर है।

Ṁ,ạ/y          - perform one step of the Euclidean Algorithm, input 2-element list
 ,             - pair of the following two:
Ṁ              -  maximum of the the input list
  ạ/           -  absolute difference of the two elements
    y          - use this as a mapping on the input.

³,⁴ÇÐĿp/€Fs2   - apply Euclidean Algorithm
³,⁴            - start with the pair [input 1, input 2]
   Ç           - apply a step of the Euclidean Algorithm
    ÐĿ         - repetitively until the results repeat
      p/€      - take the Cartesian product of each step
         Fs2   - flatten and split into all coordinate pairs of letters

pµ¢ṣLµ€+95ỌsY
p              - Cartesian product of inputs: provides all possible coordinate pairs.
 µ   µ€       - for each coordinate
   ṣL         - find the number of times it is included in
  ¢           - the above list of covered coordinates.
       +95Ọ   - convert number of times to letters
           s  - split into rows
            Y - join by newlines.

मैं इसके बजाय निहित तर्क का उपयोग करके थोड़ा अधिक गोल्फ की संभावना कर सकता हूं ³,⁴।

Answer 5

हास्केल , 181 बाइट्स

import Data.List
(['!'..'~']&)
a#[]=a
a#b=zipWith(++)a$transpose b
(s&a)b|b<1=[]|b>a=transpose$s&b$a|n<-div a b,(t,u)<-splitAt n s=foldl1(#)((<$[1..b]).(<$[1..b])<$>t)#(u&b$mod a b)

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

10बाइट्स के लिए आपको इसके बजाय एक अच्छा सर्पिल मिलता है :)

!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!%%'#####
!!!!!!!!!!!!!%%&#####
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""

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

Ungolfed

(#)ऑपरेटर कहते हैं एक दूसरे के बगल दो मैट्रिक्स, लेकिन सही है, जैसे transposes:

!!!                !!!"
!!! # "#$    ->    !!!#
!!!                !!!$

a # [] = a
a # b  = zipWith (++) a $ transpose b

यह मूल रूप से यूक्लिड के एल्गोरिथ्म का पुनरावर्ती संस्करण है, लेकिन विभाजकों और अवशेषों को भूलकर और वापस लौटने के बजाय gcd, यह इससे वर्ग बनाता है और इन के साथ जम जाता है (#)। sचर शेष वर्ण है कि हम का उपयोग कर सकते हैं:

(s & a) b
  | b == 0 = []                     -- Base case
  | b > a = transpose $ (s & b) a   -- In this case we can just flip the arguments and rotate the result by 90 degrees
  | n <- div a b                    -- set n to the number of squares we need
  , (t,u) <- splitAt n s =          -- take n characters, ..
               ((<$[1..b]).(<$[1..b]) <$> t)                     -- .. build squares from them and ..
    foldl1 (#)                                                   -- put them next to each other
                                             (u & b $ mod a b)   -- recursively build the smaller squares with the remaining characters..
                                            #                    -- .. flip them and put them next to the previous one(s)

वास्तविक फ़ंक्शन केवल ऊपर से फ़ंक्शन को सभी मुद्रण योग्य वर्णों की एक स्ट्रिंग के साथ कहता है:

(['!'..'~']&)

Comments

आपको import Data.Listउपयोग करने के लिए गिनने की जरूरत है transpose।

— एंडर्स कासोर्ग

जब मैंने पॉइंटफ्री फ़ंक्शन का उपयोग किया, तो मैंने उस आयात को करना संभव नहीं किया। लेकिन मैंने इसे बाइट की गिनती में शामिल किया, कृपया 164

— टीआईओ

ओह। आप निराला प्रीप्रोसेसर खेल खेल सकते हैं , लेकिन कुछ बिंदु पर यह केवल TIO से कॉपी करने के बाद मैन्युअल रूप से अपने पोस्ट में कोड को संपादित करने के लिए अधिक समझ में आता है।

— एंडर्स कासोर्ग