( इस चुनौती से प्रेरित )

दो इनपुट स्ट्रिंग्स को देखते हुए, जिनमें से एक बिल्कुल दूसरे की तुलना में एक वर्ण लंबा है, ASCII कला में स्ट्रिंग्स की व्यवस्था करें जैसे कि वे एक ज़िप के दो हिस्सों हैं जो केवल आधे रास्ते में हैं। लंबा शब्द ज़िप के निचले भाग को बनाता है, और संयुक्त ज़िपर भाग का पहला और अंतिम चरित्र है। चूँकि उस अनुच्छेद को समझना कठिन है, इसलिए कुछ उदाहरण देखें:

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

ध्यान दें कि कैसे paragraph(लंबे समय तक शब्द) नीचे जिपर बनाता है, और g r a p hभाग के हिस्से को घेरता e r e dहै zippered, z i p pऔर p a r aभाग एक दूसरे से ऑफसेट होते हैं।

इनपुट

किसी भी सुविधाजनक प्रारूप में दो ASCII तार , एक गारंटी के साथ भी लंबाई में और दूसरा बिल्कुल एक वर्ण में।
न तो स्ट्रिंग में व्हॉट्सएप होगा, बल्कि कोई अन्य मुद्रण योग्य ASCII मान हो सकता है।
आप इनपुट को किसी भी क्रम में ले सकते हैं। कृपया अपने इनपुट ऑर्डर को सबमिट करें।

उत्पादन

परिणामी ASCII कला के रूप में, किसी भी सुविधाजनक प्रारूप में फिर से, ऊपर वर्णित zippered शब्दों का प्रतिनिधित्व करते हैं।

नियम

नए कथानकों या व्हाट्सएप को लीड करना या उनका अनुगमन करना सभी वैकल्पिक हैं, जब तक कि वर्ण स्वयं सही तरीके से पंक्तिबद्ध न हों।
या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

code-golf string ascii-art

— AdmBorkBork
स्रोत

क्या हम मान सकते हैं कि इनपुट में व्हॉट्सएप नहीं है?

— DJMcMayhem

@DJMcMayhem हाँ, यह एक उचित धारणा है।

— AdmBorkBork

1

@ टिट्स one guaranteed to be even in length and the other exactly one character longer. छोटी स्ट्रिंग हमेशा होती है

— बाल्ड्रिक

7

जाप , 31 28 बाइट्स

N®¬£ç iXYm½*Ul
uUo mw
y c ·y

इसे ऑनलाइन टेस्ट करें! पहले छोटी स्ट्रिंग लेता है।

व्याख्या

N®¬£ç iXYm½*Ul    First line: Set U to the result.
N®                Map each item (there's exactly 2 of them) in the input to
  ¬                 the item split into chars,
   £                with each item X and index Y mapped to
    ç                 the first input filled with spaces,
      iX              with X inserted at index
        Ym½*Ul          min(Y, 0.5 * U.length).
                  At the end each input is an array like
                  ["p    ", " p   ", "  c  ", "  g  "]
                  ["t    ", " e   ", "  s  ", "  t  ", "  s  "]

uUo mw    Second line: Set V to the result (though that's not important).
 Uo       Pop the last item (the array representing the second string) from U.
    m     Map each item by
     w      reversing.
u         Push the result to the beginning of U.
          At the end we have e.g.
          ["    t", "   e ", "  s  ", "  t  ", "  s  "]
          ["p    ", " p   ", "  c  ", "  g  "]

y c ·y    Last line: Output the result of this line.
y         Transpose: map [[A,B,C,...],[a,b,c,...]] to [[A,a],[B,b],[C,c],...].
  c       Flatten into one array. [A,a,B,b,C,c,...]
    ·     Join on newlines. Now we have the output transposed.
     y    Transpose rows with columns.

— ETHproductions
स्रोत

6

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

→Ｆ²«ＦＬθ«§θκ→¿‹κ÷Ｌθ²¿ι↑↓»Ｊ⁰ＬθＡηθ

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

→Ｆ²«

बदले में प्रत्येक स्ट्रिंग पर लूप करें।

ＦＬθ«

बदले में स्ट्रिंग के प्रत्येक चरित्र पर लूप।

§θκ→

चरित्र को प्रिंट करें और दाईं ओर एक अतिरिक्त वर्ग ले जाएं।

¿‹κ÷Ｌθ²¿ι↑↓»

स्ट्रिंग की पहली छमाही के लिए, कर्सर को नीचे या ऊपर भी ले जाएं।

Ｊ⁰ＬθＡηθ

पहले स्ट्रिंग को प्रिंट करने के बाद, दूसरे स्ट्रिंग के शुरुआती बिंदु पर कूदें, और पहले स्ट्रिंग को दूसरे के साथ बदलें, ताकि यह दूसरे लूप के लिए प्रिंट हो जाए। (कोड दोनों छोरों पर चलता है, लेकिन दूसरी बार यह नो-ऑप है।)

— नील
स्रोत

4

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

AQj.t.e+*d+lG*<klH*^_1k/h-lGk2b.iHG

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

— लीक नन
स्रोत

1

वह तेज तेज था!

— AdmBorkBork

@AdmBorkBork आप उम्मीद कर सकते हैं कि कई बार, विशेष रूप से इस उत्तरदाता से।

— आउटगॉल्फ

4

जेली , 27 26 बाइट्स

-1 बाइट के लिए धन्यवाद एग्री द आउटग्राफर (रिपीट का उपयोग करें, ¡यदि प्रतिस्थापित करने के लिए ?, और एक पारित क्लॉज ¹)

JCḂ¡€ṚH
żµL⁶ẋ;Ð€Fṙ"ÇZṙÇṀ$Y

एक पूर्ण कार्यक्रम जो प्रमुख श्वेत-स्थान के साथ परिणाम को प्रिंट करता है, जैसा कि प्रश्न में अनुमति दी गई है (या वर्णों की सूची को लौटाने वाला एक डायडिक लिंक)।

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

कैसे?

JCḂ¡€ṚH - Link 1, get rotations: list p        e.g.: ["a1","b2","c3","d4","e5","f6","g"]
J       - range of length of p                       [ 1, 2, 3, 4, 5, 6, 7]
    €   - for €ach:
   ¡    -   repeat link:
  Ḃ     - ...# of times: modulo 2                      1  0  1  0  1  0  1
 C      - ...link: complement (1-x)                    0  2 -2  4 -4  6 -6
     Ṛ  - reverse                                    [-6, 6,-4, 4,-2, 2, 0]
      H - halve                                      [-3, 3,-2, 2,-1, 1, 0]

żµL⁶ẋ;Ð€Fṙ"ÇZṙÇṀ$Y - Main link: longer (odd length); shorter (even length)
                   -                           e.g.: "abcdefg", "123456"
ż                  - zip them together               ["a1","b2","c3","d4","e5","f6","g"]
 µ                 - monadic chain separation, call that p
  L                - length of p                     7
   ⁶               - literal space character         ' '
    ẋ              - repeat                          "       "
        F          - flatten p                       "a1b2c3d4e5f"
      Ð€           - map with:
     ;             -   concatenation                 ["       a","       1","       b","       2","       c","       3","       d","       4","       e","       5","       f","       6","       g"]
           Ç       - call last link (1) as a monad with argument p
          "        - zip with (no action on left by trailing values of right):
         ṙ         -   rotate left by                ["  a     ","    1   "," b      ","     2  ","c       ","      3 ","       d","       4","       e","       5","       f","       6","       g"]
            Z      - transpose                       ["    c        ","  b          ","a            ","             "," 1           ","   2         ","     3       ","      d4e5f6g"]
                $  - last two links as a monad:
              Ç    -   call last link (1) as a monad with argument p
               Ṁ   -   maximum                       3
             ṙ     - rotate left by                  ["             "," 1           ","   2         ","     3       ","      d4e5f6g","    c        ","  b          ","a            "]
                 Y - join with newlines            '''             \n
                                                       1           \n
                                                         2         \n
                                                           3       \n
                                                            d4e5f6g\n
                                                          c        \n
                                                        b          \n
                                                      a            '''
                   - as full program: implicit print

— जोनाथन एलन
स्रोत

C¹Ḃ?->CḂ¡

— आउटगॉल्फ

3

अजगर 2 , 128 119 बाइट्स

f=lambda a,b,n=0:n/2<len(a)and' '*-~n+a[0]+'\n'+f(a[1:],b[1:],n+2)+'\n'+' '*n+b[0]or' '*n+''.join(sum(zip(b,a+' '),()))

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

— छड़ी
स्रोत

3

वी , 47 38 30 27 26 25 बाइट्स

अंत में वर्तमान जेली उत्तर को हरा दें \ /

शीर्ष पर लंबे समय तक शब्द के साथ इनपुट लेता है

स्पष्टीकरण आ रहा है, मत सोचो कि गोल्फ के लिए बहुत अधिक है।

òGxplòxãòd|>HÏpd|>GGÏphl

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

व्याख्या

ò     ò      ' <M-r>ecursively
             |abc
             def
 Gx          ' (G)oto the last line and (x) the first character
             abc
             |ef
            ' <C-O> Go back to the previous location
             |abc
             ef
    p        ' (p)aste the character cut
             a|dbc
             ef
     l       ' move one character right
             ad|bc
             ef

x                  ' (x) the last extraneous character from the previous loop
 ã                 ' <M-c>enter the cursor
  ò                ' <M-r>ecursively
   d|              ' (d)elete to the first co(|)umn
     >H            ' (>) Indent every line from here to (H)ome (first line)
                   ' this leaves the cursor on the first line
       Ïp          ' <M-O>n a newline above this (the first) (p)aste the deleted section
                   ' this leaves the cursor on the last character
         d|        ' (d)elete to the first co(|)umn
           >G      ' (>) Indent every line from here to the end (G)
                   ' unfortunately the cursor stays on the first line
             G     ' (G)oto the last line
              Ïp   ' <M-O>n a newline above this (the last) (p)aste the deleted section
                hl ' move left and then right (break the loop at the end)

— nmjcman101
स्रोत

2

वी , 79 बाइट्स

ãl}dÍ./ &
XòYf D"0Pr -Y;D"0pr +òGï"1pÓ./&ò
}dGÓ/&ò
{jpògJòÓó
|DÇ./d
MÙ"-pBr

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

निम्नलिखित को बहुत सारे कटाक्ष और हवा-उद्धरण के साथ पढ़ा जाना चाहिए ।

यहाँ मेरी गोल्फ-भाषा में एक उत्तर दिया गया है जो स्ट्रिंग-आधारित और ASCII- कला चुनौतियों के लिए कम उत्तरों पर अच्छा है ।

मैं अपने आप से ऐसा क्यों कर रहा हूं?

Hexdump:

00000000: e36c 167d 64cd 2e2f 2026 0a58 f259 6620  .l.}d../ &.X.Yf 
00000010: 4422 3050 7220 2d59 3b44 2230 7072 202b  D"0Pr -Y;D"0pr +
00000020: f247 ef22 3170 d32e 2f26 f20a 0f16 7d64  .G."1p../&....}d
00000030: 47d3 2f26 f20a 7b6a 70f2 674a f2d3 f30a  G./&..{jp.gJ....
00000040: 7c44 c72e 2f64 0a4d d922 2d70 4272 20    |D../d.M."-pBr

— DJMcMayhem
स्रोत

क्या V के पास "कॉलम के साथ ट्रांज़ोज़ पंक्तियाँ" कमांड है? 'कारण नहीं तो, आप उस में निवेश करना चाहते हो सकता है ...

— ETHproductions

2

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

HĊ©«Rµ®Ḥ_,Ṗ
ZLÇṬ€a"¥"o⁶ZẎz⁶Y

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

वू जेली वास्तव में एक स्ट्रिंग और एससीआई-कला चुनौती में प्रतिस्पर्धा कर रही है ! \ o /

— आउटगोल्फर को एरिक करें
स्रोत

मुख्य रूप से क्योंकि हर दूसरी भाषा में परेशानी हो रही है। जिसके बारे में बोलते हुए, कोई व्यक्ति V ...

— ETHproductions

अच्छा, मैंने 27 का प्रबंधन किया - लेकिन हो सकता है कि आप श्वेत-स्थान भत्ते का भी पालन कर सकें?

— जोनाथन एलन

@JonathanAllan दुख की बात है कि मुझे लगता है कि यह असंभव है। Ṗवसीयत को हटाने से ट्रेलिंग स्पेस नहीं बल्कि ट्रेलिंग जुड़ जाएगा 1। और रिक्त स्थान के साथ जो कुछ भी करना है उसे छोड़ देना अक्षरों की लाइन-अप को हटा देता है। आमतौर पर, यह एल्गोरिथ्म इंडेक्सिंग का उपयोग करता है ताकि अक्षरों को एक विशेष सूचकांक में एक कॉलम में मिल जाए और फिर बाकी को रिक्त स्थान से भर दिया जाए, इसलिए मुझे लगता है कि इसे आगे नहीं बढ़ाया जा सकता है। कम से कम मुझे खुशी है कि जेली सीजेएम द्वारा बहिष्कृत नहीं है। ;)

— आउटगॉल्फ

: | जैली चारकोल की तुलना में गोल्फर है

— एएससीआईआई-केवल

2

05AB1E , 26 23 बाइट्स

øS2ä`JIθ«¸«vyNúr})2äR˜»

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

व्याख्या

उदाहरण इनपुट के साथ = ppcg, tests

ø                           # zip the input strings
                            # STACK: ['tp', 'ep', 'sc', 'tg']
 S                          # split to a list of characters
                            # STACK: ['t', 'p', 'e', 'p', 's', 'c', 't', 'g'
  2ä                        # divide the list into 2 parts
    `                       # push them as separate to stack
                            # STACK: ['t', 'p', 'e', 'p'], ['s', 'c', 't', 'g']
     J                      # join the second part to a single string
      Iθ«                   # append the tail of the second input
         ¸«                 # concatenate the 2 lists
                            # STACK: ['t', 'p', 'e', 'p', 'sctgs']
           v                # for each y,N (element, index) in the list
            yNú             # prepend N spaces to y
               r            # reverse the stack
                })          # end loop and wrap the stack in a list
                            # STACK: ['    sctgs', '  e', 't', ' p', '   p']
                  2ä        # split the list into 2 parts
                    R       # reverse the list
                            # STACK: [[' p', '   p'], ['    sctgs', '  e', 't']]
                     ˜»     # flatten the list and join on newlines

— Emigna
स्रोत

1

मैंने एक हफ्ते पहले की तरह इस सवाल पर वास्तव में कड़ी मेहनत की और आपको बस जाना था और ... मुझे हरा दिया। +1 करने के लिए मुझे थोड़ा और प्रयास करें!

— nmjcman101

@ nmjcman101: मुझे उम्मीद है कि आप अपने आप को थोड़ा और नीचे ला सकते हैं। कुछ दोस्ताना प्रतियोगिता हमेशा मज़ेदार होती है :)

— Emigna

1

सी # (.NET कोर) , 163 बाइट्स

(l,s)=>{var o="";int i=0,k=s.Length;for(;i<k;)o+=i<k/2?s[i++]+"\n"+"".PadLeft(i):l[i]+""+s[i++];o+=l[i]+"\n";for(i=k/2;i>0;)o+="".PadLeft(--i)+l[i]+"\n";return o;}

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

संभवतः यहाँ बहुत से गोल्फिंग करने हैं, लेकिन यहाँ एक प्रारंभिक गैर-लाइनक्यू प्रयास है। लैम्ब्डा फ़ंक्शन जो पहले लंबे समय तक शब्द लेता है, और ओउप के साथ एक स्ट्रिंग देता है।

— jkelm
स्रोत

1

एक बाइट ( l=>s=>) को बचाने के लिए करी का उपयोग करें Func<input1, Func<input2, output>>।

— लाथेलकोडर

1

जावा 8, 216 बाइट्स

एक करीबी लैम्ब्डा: Stringएक लैम्ब्डा लेता है और उससे लौटाता StringहैString । बाहरी लैम्ब्डा का पैरामीटर छोटी स्ट्रिंग है।

Stringसरणी सिंटैक्स के साथ अनुक्रमणिका में सक्षम नहीं होना ... दुर्भाग्यपूर्ण है।

s->t->{int l=s.length(),i=l/2;String o="",p=o,n="\n";for(;i<l;p+="  ")o=o+t.charAt(i)+s.charAt(i++);o=p+o+t.charAt(i)+n;for(;i-->0;)o=p.substring(l-i--)+s.charAt(i/2)+n+o+p.substring(l-i)+t.charAt(i/2)+n;return o;}

अघोषित लंबोदर

s ->
    t -> {
        int
            l = s.length(),
            i = l / 2
        ;
        String
            o = "",
            p = o,
            n = "\n"
        ;
        for (; i < l; p += "  ")
            o = o + t.charAt(i) + s.charAt(i++);
        o = p + o + t.charAt(i) + n;
        for (; i-- > 0; )
            o =
                p.substring(l-i--)
                + s.charAt(i / 2)
                + n
                + o
                + p.substring(l-i)
                + t.charAt(i / 2)
                + n
            ;
        return o;
    }

व्याख्या

lछोटे इनपुट की लंबाई है और iएक बहुउद्देशीय सूचकांक है, जो छोटे इनपुट की दूसरी छमाही के पहले चरित्र को संदर्भित करता है। oपरिणाम जमा करता है, pअंततः पैडिंग के लिए रिक्त स्थान संग्रहीत करता है, और इसके nलिए एक उपनाम है"\n" ।

पहला लूप दो स्ट्रिंग्स के दूसरे हिस्सों को इंटरलेव करता है (लंबे इनपुट के अंतिम वर्ण को छोड़कर) और बनाता है p मध्य रेखा के लिए उचित मात्रा में पैडिंग है।

अगली पंक्ति आउटपुट की मध्य रेखा को पूरा करती है।

मैं दूसरे पाश के लिए जेम्स गोसलिंग से माफी मांगना चाहूंगा। यह अंदर की बाहर से मध्य रेखा के ऊपर और नीचे की रेखाओं को जोड़ता है। लूप में प्रवेश कर रहा iहै l - 1, इसलिए पैडिंग का एक चरित्र छोटी स्ट्रिंग के पहले छमाही के अंतिम चरित्र के साथ पहले से तैयार है। iको घटाया जाता है ताकि अगली गद्दी (परिणाम के लिए संलग्न) एक चरित्र छोटा हो। पूर्णांक विभाजन द्वारा, लंबे स्ट्रिंग का एक ही स्थिति वर्ण जोड़ा जाता है। यह दोहराता है, और पूरा हुआ परिणाम वापस आ जाता है।

सुन्दर सामान

लाइन 13 हुआ करती थी

o+=t.charAt(i)+""+s.charAt(i++);

क्योंकि खाली स्ट्रिंग के बिना, +वर्ण मानों को एक साथ जोड़ा और एक संख्यात्मक स्ट्रिंग को जोड़ा। यौगिक काम फैल कर, के संयोजन oऔर t.charAt(i)पहले मूल्यांकन किया जाता है, जो खाली स्ट्रिंग की आवश्यकता के बिना वांछित परिणाम पैदावार, 2 बाइट्स बचत। यह पहली बार है जब मैंने देखा है कि एक कंपाउंड असाइनमेंट अपने विस्तार से अलग व्यवहार करता है।

— जेकब
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 140 137 133 बाइट्स

A=(a,b,c=0)=>a[c/2]?` `[d=`repeat`](c+1)+a[0]+`
`+A(a.slice(1),b.slice(1),c+2)+`
`+` `[d](c)+b[0]:` `[d](c)+[...a].map((e,f)=>e+b[f])

काफी यकीन है कि यह आगे गोल्फ हो सकता है

— ल्यूक
स्रोत

उदाहरण के `<newline>`+` `लिए मर्ज नहीं किया जा सकता है `<newline> `? (मैं जेएस नहीं जानता)।

— काज़

@ काज: नहीं, क्योंकि हम रिपीट मेथड को सिर्फ स्पेस पर निष्पादित करते हैं, न कि न्यूलाइन + स्पेस पर।

— ल्यूक

0

गणितज्ञ, 174 बाइट्स

(a=(c=Characters)@#;b=c@#2;T=Table;Column[Join[T[T["  ",i]<>a[[i]],{i,g=Length@a/2}],{T["  ",g+1]<>Riffle[b[[-g-1;;]],a[[-g;;]]]},Reverse@T[T["  ",i]<>b[[i+1]],{i,0,g-1}]]])&

इनपुट

["zippered", "पैराग्राफ"]

— J42161217
स्रोत

0

TXR लिस्प , 126 बाइट्स

(defun f(a b :(n 0))(if(<(/ n 2)(length a))` @{""n}@[a 0]\n@(f(cdr a)(cdr b)(+ n 2))\n@{""n}@[b 0]``@{""n}@{(zip b`@a `)""}`))

— Kaz
स्रोत

0

PHP, 149 129 बाइट्स

for($r=" ";$x+1<$w=2*$e=strlen($argv[2]);++$x&1||$r[++$i*$w-1]="
")$r[$w*($x&1?$y-1:$e-$y+=$y<$e/2)+$x]=$argv[2-$x%2][$i];echo$r;

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

— टाइटस
स्रोत

0

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

@a=map{$s=.5*length;[/./g]}<>;say(($"x(2*$_)).$a[0][$_])for 0..$s-1;print$"x(2*$s);print$a[0][$_].$a[1][$_]for$s..@{$a[1]};print$/.($"x(1+2*$s)).$a[1][$s]while$s--

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

पहले लंबी स्ट्रिंग लेता है।

— Xcali
स्रोत

Zippered Paragraph

इनपुट

उत्पादन

नियम

उदाहरण

जाप , 31 28 बाइट्स

व्याख्या

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

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

जेली , 27 26 बाइट्स

कैसे?

अजगर 2 , 128 119 बाइट्स

वी , 47 38 30 27 26 25 बाइट्स

व्याख्या

वी , 79 बाइट्स

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

05AB1E , 26 23 बाइट्स

सी # (.NET कोर) , 163 बाइट्स

जावा 8, 216 बाइट्स

अघोषित लंबोदर

व्याख्या

सुन्दर सामान

जावास्क्रिप्ट (ईएस 6), 140 137 133 बाइट्स

गणितज्ञ, 174 बाइट्स

TXR लिस्प , 126 बाइट्स

PHP, 149 129 बाइट्स

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