एक स्ट्रिंग को अनफॉलो करें

Question

एक वर्गाकार स्ट्रिंग को देखते हुए, स्ट्रिंग के लिए सभी आउटपुट का उत्पादन हर चरण में करें।

स्ट्रिंग को एक बार में एक घड़ी की दिशा में एक दक्षिणावर्त दिशा में उधेड़ना चाहिए।

उदाहरण

इनपुट :

A

आउटपुट :

A

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

इनपुट :

DC
AB

आउटपुट :

DC
AB

  D
ABC

ABCD

इनपुट :

GFE
HID
ABC

आउटपुट :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

इनपुट :

JIHG
KPOF
LMNE
ABCD

आउटपुट :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

नियम

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

• किसी भी उचित प्रारूप का उपयोग I / O के लिए किया जा सकता है यह मानकर कि यह सुसंगत है।
• आउटपुट के शीर्ष लाइनों को पैड करने के लिए रिक्त स्थान का उपयोग किया जाना चाहिए।
• सभी मुद्रण योग्य वर्णों के इनपुट को संभालने में सक्षम होना चाहिए (स्थान सहित: \x20- \x7e):

 !।? "# $% & '() * +, - / 0123456789: @ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _` abcdefghijklmnopqrstuvwxyz {|} ~

• व्हाट्सएप पर लीडिंग / ट्रेलिंग की अनुमति है।
• आप मान सकते हैं कि स्ट्रिंग हमेशा एक वर्ग होगी।
• सभी मानक कमियां निषिद्ध हैं।

प्रेरणा: एक स्क्वायर प्रोग्राम लिखें जो कई बार "अनियंत्रित" हो गया है ।

Comments

हम उत्पादन मई ["A","A"]के लिए "A", की तरह मेरे कार्यक्रम (बजाय करता है ["A"])? यह मेरे लिए उचित लगता है क्योंकि वे सिर्फ शुरुआती और अंतिम स्थान हैं, और आप केवल एक बार इसे अनफॉलो करने का प्रयास करते हैं।

— श्री Xcoder

@ Mr.Xcoder मैं सहमत हूं, उस विशिष्ट परीक्षण के मामले को पूरा करने के लिए कोड जोड़ना बाइट्स की बर्बादी की तरह लगता है। मैं इसे सिंगल बाइट इनपुट के लिए स्वीकार करूंगा और तदनुसार प्रश्न को अपडेट करूंगा!

— डोम हेस्टिंग्स

मेरे से +1, बहुत दिलचस्प चुनौती। इस साइट को इनकी अधिक आवश्यकता है, क्योंकि वे कठिनाई स्तर बढ़ाते हैं और अधिकांश समाधानों की तुच्छता से छुटकारा पा लेते हैं। यह सीधे मेरी पसंदीदा चुनौतियों की सूची में जाता है। मैं निराश हूं कि इसके कुछ उत्तर हैं, मैं वास्तव में अन्य चतुर दृष्टिकोण देखना चाहता हूं

— श्री एक्सकोडर

@ Mr.Xcoder मुझे खुशी है कि आप इसे पसंद करेंगे! काश मैं अकेले इस विचार के साथ आने का श्रेय ले सकता, लेकिन यह @ हेल्कोहॉम्बा की चुनौती के लिए धन्यवाद !

— डोम हेस्टिंग्स

Answer 1

SOGL V0.12 , 21 20 19 18 17 बाइट्स

ø;[;ο⁴№č▓┼№TJι;jI

यह कोशिश करो! ( →जोड़ा गया क्योंकि इससे स्टैक पर इनपुट की उम्मीद है)

स्पष्टीकरण:

ø;[;ο⁴№č▓┼№TJι;jI
ø;               push an empty string below the input           stack with the input GFE,HID,ABC
  [              while [ToS (the array) isn't empty] do       ["", [["G","F","E"],["H","I","D"],["A","B","C"]]]  
                                                                stack at the second time looping
   ;               duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], "ABC"]
    ο              wrap it in an array                        [[[H,G], [I,F], [D,E]], ["ABC"]]
     ⁴             duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], ["ABC"], [[H,G], [I,F], [D,E]]]
      №            reverse vertically                         [[[H,G], [I,F], [D,E]], ["ABC"], [[D,E], [I,F], [H,G]]]
       č▓          join the inner arrays (┼ fails otherwise)  [[[H,G], [I,F], [D,E]], ["ABC"], ["DE", "IF", "HG"]]
         ┼         add the 2 parts together                   [[[H,G], [I,F], [D,E]], ["ABCDE", "   IF", "   HG"]]
          №        reverse vertically again                   [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
           T       print that without popping                 [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
            J      take the last line off                     [[[H,G], [I,F], [D,E]], ["   HG", "   IF"], "ABCDE"]
             ι     remove the rest of the array               [[[H,G], [I,F], [D,E]], "ABCDE"]
              ;j   remove the last line of the original array ["ABCDE", [[H,G], [I,F]]]
                I  rotate it clockwise                        ["ABCDE", [[I,H], [F,G]]]

Answer 2

पायथन 2 , 209 207 205 203 202 201 200 196 बाइट्स

-4 बाइट्स @Quelklef को धन्यवाद !

s=input();l=len;k=''.join;exec"print s;s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

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

पायथन 2 , 219 217 215 213 212 211 207 बाइट्स

s=input();l=len;k=''.join;exec"print'\\n'.join(s);s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

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

पहला एक स्ट्रिंग्स की सूची के रूप में आउटपुट करता है, दूसरा एक ASCII- कला के रूप में आउटपुट करता है।

Comments

मुझे लगता है कि लिन के जवाब में [::-1][1:]हो सकता है [-2::-1]।

— क्वेलक्लेफ

@Quelklef बहुत बहुत धन्यवाद!

— श्री एक्सकोडर

Answer 3

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

ＡＥθＳθＷ⊟θ«⪫θ¶ＡＥι⮌⪫Ｅθ§μλωθ⊞υι↙←⮌⪫υωＤ⎚

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: सहेजे गए 7 बाइट्स अधिकतर वर्ण सरणियों से तारों तक स्विच करके। स्पष्टीकरण:

ＡＥθＳθ

चर में सरणी के एक सरणी के रूप में इनपुट वर्ग पढ़ें q।

Ｗ⊟θ«

जबकि सरणी में अंतिम स्ट्रिंग खाली नहीं है, इसे हटा दें।

⪫θ¶

बाकी सरणी को प्रिंट करें।

ＡＥι⮌⪫Ｅθ§μλωθ

अंतिम स्ट्रिंग के प्रत्येक चरित्र के माध्यम से लूप करके शेष सरणी को घुमाएं और lउलटे सरणी में प्रत्येक शेष स्ट्रिंग के वें चरित्र को जोड़ दें।

⊞υι↙←⮌⪫υω

पहले से हटाए गए अंतिम स्ट्रिंग को जोड़ें u, जो कि अपरिचित मूल्य रखता है, और इसे प्रिंट करें।

Ｄ⎚

परिणाम को आउटपुट करें और फिर अगले पुनरावृत्ति के लिए तैयार कैनवास को साफ़ करें।

ध्यान दें कि यह संस्करण एक अलग लाइन पर अंतिम अनफ्लो को आउटपुट करता है, यदि यह अवांछनीय है तो 38 बाइट्स के लिए:

ＡＥθＳθＷ⊟θ«⊞υι←Ｅ⁺⟦⪫υω⟧⮌θ⮌κＡＥι⮌⪫Ｅθ§μλωθＤ⎚

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κवर्तमान सरणी को उलट देता है, अनफिल्ड लाइन को प्रीपेंड करता है, फिर प्रत्येक पंक्ति में वर्णों को उलट देता है, फिर सब कुछ उल्टा प्रिंट करता है, इस प्रकार वांछित परिणाम उत्पन्न करता है।

Comments

मैंने इसे और अधिक चारकोल-वाई तरीके से करने की कोशिश की, लेकिन मैं काम नहीं कर सका जहाँ Rotateऔर Trimकमांड कर्सर को छोड़ते हैं ...

— नील

Answer 4

हास्केल , 127 120 बाइट्स

e=[]:e
i#[x]=[]
i#s|t<-foldl(flip$zipWith(:))e$init s,j<-i++last s=(map((j>>" ")++)(init t)++[j++last t]):j#t
f s=s:""#s

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

इनपुट लाइनों की एक सूची है, उदाहरण ["DC","AB"]के लिए दूसरे परीक्षण के मामले में, आउटपुट लाइनों की सूची की एक सूची है [["DC","AB"],[" D","ABC"],["ABCD"]]:। mapM (putStrLn . unlines)परिणाम को सुंदर प्रिंट करने के लिए उपयोग करें ।

संपादित करें: 7 बाइट्स को ध्यान में रखते हुए सहेजा गया है कि छोटीtranspose मैंने कुछ पाया जबकि एक काम आता है क्योंकि इसे सीधे प्रत्येक प्रत्यारोपित रिवर्स करने के लिए संशोधित किया जा सकता है।

Answer 5

05AB1E , 18 बाइट्स

[Dí.Bí»,¤UR¦ζŽ`Xì)

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

व्याख्या

[            Ž       # while stack is not empty, do:
 D                   # duplicate current list
  í                  # reverse each element
   .B                # pad with spaces to equal length
     í               # reverse each element again
      »,             # join with newlines and print
        ¤U           # store the last element in X
          R¦         # reverse the list and remove the first element
            ζ        # zip with spaces as filler
              `      # split elements separately to stack
               Xì    # prepend X to the last element
                 )   # join the stack to a list

Answer 6

जे, 62 बाइट्स

|."1@([:(#~[:-.[:*/"1' '=])|.@{:(}:@],{:@],[)|:@}:)^:(1<#)^:a:

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

मुझे यकीन है कि यह बहुत बड़ा हो सकता है। यह अतिरिक्त व्हाट्सएप को प्रिंट करता है, लेकिन केवल उसी वजह से कि जे आउटपुट स्वरूपित सरणी के भीतर समाहित एर को समान आकार देता है।

मुझे लगता है कि एक बार जब मैं अंदर जाता हूं और टिप्पणी करता हूं कि मैं क्या कर रहा हूं, तो मुझे इस बात का बेहतर अंदाजा हो सकता है कि इसे कैसे पूरा किया जाए (अब ऐसा किया है, मैं वास्तव में नहीं जानता ...)। गोल्फ के प्रयोजनों के लिए, यह ध्यान देने योग्य है

• मुझे विशेष मामले में 1 पंक्ति इनपुट (लूप के समय का हिस्सा) है
• मुझे पूरी तरह से व्हॉट्सएप से युक्त सभी लाइनों को खत्म करना होगा (निश्चित रूप से या तो इसके लिए एक बेसिन होना चाहिए या इसे करने का एक बेहतर तरीका है), जो अंत के पास फिल्टर है
• बहुत सारे कैप, पहचान कार्य और परमाणु हैं

व्याख्या

इसे अनगलॉगिंग में, मैं तीन में मुख्य फ़ंक्शन को विभाजित करूंगा।

unfurl_reversed   =. |.@{: (}:@] , {:@] , [) |:@}:
whitespace_filter =. #~ [: -. [: */"1 ' ' = ]
unfurl            =. |."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

test_case         =. 3 3 $ 'GFEHIDABC'

हम दूसरे परीक्षण मामले के साथ काम करेंगे।

unfurl_reversed

|.@{: (}:@] , {:@] , [) |:@}:

यह एक स्ट्रिंग को एक बार फहराता है, लेकिन रिवर्स में। यह सब रिवर्स और एक विशिष्ट क्रम में किया जा रहा है ताकि जिस तरह से जे स्वचालित रूप से रिक्त स्थान के साथ तार को उस सरणी के आकार से मेल खाने के लिए हो जिसमें वे सही रिक्ति दें।

|:@}: इनपुट के घुमाव का संक्रमण है

   |:@}: test_case
GH
FI
ED

|.@{: इनपुट की पूंछ के विपरीत है

   |.@{: test_case
CBA

मुझे लगता है कि आप देख सकते हैं कि हम क्या करना चाहते हैं: हम पूंछ के रिवर्स को कर्ल के संक्रमण के अंतिम भाग में जोड़ना चाहते हैं (यह एक कौर है, लेकिन मूल रूप CBAसे अंत में संलग्न है ED)। यह हमें उलटने का एक कदम देगा, उलटा।

(}:@],{:@],[) बस यही करता है।

यह संलग्न CBAहै ED, फिर बाकी सरणी के साथ जुड़ता है। इसलिए हमारा आउटपुट है

   unfurl_reversed test_case
GH   
FI   
EDCBA

whitespace_filter

#~ [: -. [: */"1 ' ' = ]
                 ' ' = ]  Equate each element to space
            */"1          Product of each row (all true?)
      -.                  Negate
#~                        Filter rows that are true

मूल रूप से, यह देखने के लिए परीक्षण करता है कि क्या कोई पंक्ति पूरी तरह से रिक्त स्थान है, और यदि है तो उसे हटा देती है। यह परीक्षण मामले के पहले पुनरावृत्ति के लिए कुछ भी नहीं करता है।

यह आवश्यक है (कम से कम जब तक मुझे कोई विकल्प नहीं मिल जाता है) अन्यथा हम अंततः अपने आउटपुट स्ट्रिंग में व्हाट्सएप को अनफॉलो कर देंगे।

प्रसारित

|."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

Unfurl मूल रूप से अन्य कार्यों को एक साथ रखता है और विशेष मामलों में एकल वर्ण इनपुट।

जब क्रिया ( ^:) की शक्ति को खाली बॉक्स ( a:) दिया जाता है , तो यह इनपुट पर एक फ़ंक्शन लागू करता है जब तक कि यह एक सरणी में परिणाम को एकत्रित और एकत्र नहीं करता है।

(1 < #) जाँचता है कि पंक्तियाँ हमेशा 1 से अधिक होती हैं (विशेष स्थिति 1 पंक्ति इनपुट के लिए)।

|."1प्रत्येक पंक्ति को उलट देता है, इसलिए यह परिणामों को प्रभावित करता है whitespace_filter @: unfurl।

Answer 7

पायथन 2 , 143 132 बाइट्स

a=input()
while 1:print'\n'.join(a);b=map(''.join,zip(*map(str.strip,a[-2::-1])));a[-1]+=b.pop();a[:-1]=[len(a[0])*' '+x for x in b]

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

प्रत्येक पुनरावृत्ति में, bस्ट्रिंग का "सिर" (पहली n) 1 पंक्तियाँ), 90 डिग्री घुमाया aजाता है : यदि [" NML", " OPK", "ABCDEFGHIJ"]तब bहै ["ON", "PM", "KL"]।

एक बार एक स्ट्रिंग फहरा के लिए, हम के अंतिम पंक्ति संलग्न bकरने के लिए a[-1](दे "ABCDEFGHIJKL") और फिर recompute a[:-1]में तार के आराम करने के रिक्त स्थान को जोड़कर b।

bखाली होने पर हम पॉप से ​​प्रयास करके समाप्त करते हैं।

पायथन 2 , 132 बाइट्स

a=input()
while 1:s=str.strip;print'\n'.join(a);a[:-1]=[len(a[0])*' '+''.join(x)for x in zip(*map(s,a[-2::-1]))];a[-1]+=s(a.pop(-2))

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

एक ही विचार, अलग तरह से लिखा गया। हम के प्रयास के द्वारा समाप्त a.pop(-2)जब aकेवल एक ही तत्व है।

Answer 8

पर्ल 5 , 155 बाइट्स

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@$_"for@a[0..@a-2];say$s.="@{pop@a}";say@b=();for$i(0..$#a){$q=0;$b[$q++][$#a-$i]=$_ for@{$a[$i]}}@a=@b}

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

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

# पर्ल 5 , 163 बाइट्स

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@{$a[$_]}"for 0..@a-2;say$s.="@{pop@a}";say@b=();for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}@a=@b}

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

कैसे?

$"=$,; #set the array output separator to null
@a=map[/./g],<>;   # take the input as a 2-D array @a
while(@a){         # repeat while there are still things to unfurl
  say' 'x(length$s)."@{$a[$_]}"for 0..@a-2; # output all but last
                                            # line of the remaining
                                            # square
  say$s.="@{pop@a}";  # remove bottom row, add it to the unfurled string $s
                      # and output it
  say@b=();           # clear temporary array; output empty array, causing
                      # a newline to output

                      # rotate remaining shape 90 degrees:
  for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}
  @a=@b               # replace input with rotated array
}

Comments

अच्छा तरीका है, लेकिन मैं उत्पादन के बाद के हर चरण में हूं, क्या आप सभी चरणों को प्रिंट करने के लिए अपडेट कर सकते हैं? माफ़ कीजिये!

— डोम हेस्टिंग्स

ठीक है, मैंने इसे फिर से लिखा।

— Xcali

बहुत बहुत धन्यवाद! हालांकि अतिरिक्त बाइट्स के लिए क्षमा करें ...

— डोम हेस्टिंग्स