चुनौती

दो तारों / तारों की एक सरणी को देखते हुए, पहले स्ट्रिंग को धीरे-धीरे सिकुड़ते हुए और दूसरे स्ट्रिंग में वापस विस्तार करते हुए आउटपुट करें।

आप मान सकते हैं कि तार हमेशा एक ही चरित्र से शुरू होंगे।

उदाहरण

Input:
"Test", "Testing"

Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

पहले आप पहले शब्द का उत्पादन करें:

Test

तब तक आप एक अक्षर को हटाते रहें जब तक कि स्ट्रिंग एक वर्ण लंबा न हो जाए:

Tes
Te
T

तब तक दूसरे शब्द के एक अक्षर को तब तक जोड़ते रहें जब तक वह पूरा न हो जाए:

Te
Tes
Test
Testi
Testin
Testing

(यदि दोनों तार एक वर्ण लंबे हैं, तो बस एक बार उनमें से एक का उत्पादन करें।)

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

"Hello!", "Hi."
Hello!
Hello
Hell
Hel
He
H
Hi
Hi.

"O", "O"

O

"z", "zz"

z
zz

".vimrc", ".minecraft"

.vimrc
.vimr
.vim
.vi
.v
.
.m
.mi
.min
.mine
.minec
.minecr
.minecra
.minecraf
.minecraft

"     ", "   "

SSSSS
SSSS
SSS
SS
S
SS
SSS

"0123456789", "02468"

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0
02
024
0246
02468

(नोट: अंतरिक्ष / चौथे परीक्षण के मामले में, S को रिक्त स्थान से बदलें)

नियम

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है! टाईब्रेकर सबसे अधिक उत्कीर्ण पद है। विजेता को 09/10/2016 को चुना जाएगा।
मानक खामियों को मना किया जाता है।

code-golf string

— acrolith
स्रोत

2 अनुगामी न्यूलाइन्स (अनुक्रम के बाद एक दिखाई देने वाली खाली लाइन) की अनुमति होगी या नहीं?

— शीशमारा

11

अजगर, 9 बाइट्स

j+_._Et._

एक प्रोग्राम जो दूसरी स्ट्रिंग लेता है, और फिर पहला स्ट्रिंग, जैसा कि STDIN पर उद्धृत स्ट्रिंग्स और परिणाम प्रिंट करता है।

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

यह काम किस प्रकार करता है

j+_._Et._  Program. Inputs: Q, E
   ._E     Yield prefixes of E as a list
  _        Reverse the above
       ._  Yield prefixes of Q as a list (implicit input fill)
      t    All but the first element of above
 +         Merge the two lists
j          Join on newlines
           Implicitly print

— TheBikingViking
स्रोत

14

वी , 14 बाइट्स

òYp$xhòjòÄ$xhh

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

स्पष्टीकरण:

ò     ò     "Recursively:
 Yp         "  Yank the current line and paste it
   $        "  Move to the end of the current line
    x       "  Delete one character
     h      "  Move One character to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only one character on the current line.

अब, बफर इस तरह दिखता है:

हमें अगली पंक्ति के लिए बस एक ही काम करना होगा:

j           "Move down one line
 ò     ò    "Recursively (The second ò is implicit)
  Ä         "  Duplicate this line up
   $        "  Move to the end of the current line
    x       "  Delete one character
     hh     "  Move two characters to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only two characters on the current line.

अधिक दिलचस्प वैकल्पिक समाधान :

òÄ$xhòç^/:m0
ddGp@qd

— DJMcMayhem
स्रोत

3

यह नौकरी के लिए हमेशा सही उपकरण है जैसे विम

— डाउनगेट

@Downgoat बिल्कुल। के क्यों कि आप पी: वी में गोल्फ शुरू करने की आवश्यकता

— DJMcMayhem

9

पायथन, 93 बाइट्स

f=lambda a,b,r='',i=2:a and f(a[:-1],b,r+a+'\n')or(len(b)>=i and f(a,b,r+b[:i]+'\n',i+1)or r)

खाली स्ट्रिंग के साथ शुरू होता है r, जोड़ता है aऔर एक नई लाइन और अंतिम चरित्र को aतब तक हटाता है जब तक aखाली न हो bऔर एक काउंटर रखकर एक नई लाइन के आवश्यक भागों को जोड़ता है i, जो 2तब तक शुरू होता है जब तक कि लंबाई bअधिक नहीं हो जाती है, फिर वापस आ जाता है r। एक अनुगामी न्यूलाइन है।

सभी परीक्षण आइडोन पर हैं

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

२ बातें। 1) मेरा मानना है कि आपने पात्रों को मिस किया है और यह वास्तव में 93 है और 2) आपको कहने की आवश्यकता नहीं है r=""। सरल rअभी भी काम करेंगे।

धन्यवाद @JackBates। 1. सही, और अद्यतन - मैं शायद भूल गया f=। 2. r=''वर्तमान के बिना f('test','testing')काम नहीं चलेगा; हां f('test','testing',''), लेकिन हमें विनिर्देशों का पालन करना चाहिए।

— जोनाथन एलन

मुझे माफ़ करदो। मैं सिर्फ कोड देख रहा था न कि उदाहरण।

7

05AB1E , 9 बाइट्स

.pRI.p¦«»

व्याख्या

.pR           # prefixes of first word
     I.p       # prefixes of second word
         ¦       # remove first prefix
          «     # concatenate
           »    # join with newlines

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

— Emigna
स्रोत

7

रेटिना, 50 41 26 बाइट्स

बाइट्स को बचाने के लिए मार्टिन एंडर का धन्यवाद।

M&!r`.+
Om`^.¶[^·]+|.+
A1`

एक नई रेखा द्वारा अलग किए गए दो तारों के साथ इनपुट लेता है:

Test
Testing

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

व्याख्या

M&!r`.+

पहली पंक्ति दोनों शब्दों के "चरण" उत्पन्न करती है:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mमैच मोड के लिए है, &ओवरलैपिंग मैचों पर विचार करता है, और !उनमें से संख्या के बजाय मैचों को प्रिंट करता है। इसका उल्टा होने का कारण right-to-left विकल्प है: इंजन स्ट्रिंग के अंत में मैचों की तलाश शुरू करता है और शुरुआत की ओर जारी रहता है।

Om`^.¶[^·]+|.+

यह सब कुछ सही क्रम में हो जाता है: यह Oबाद के रेगेक्स के सभी मैचों को आरटीएस करता है: इसकी रेखा पर एक चरित्र और इसके बाद हर वर्ण (नए वर्णों सहित), जो पूरे दूसरे छमाही को एक चंक के रूप में मेल खाता है, या अन्यथा वर्णों की एक पंक्ति। , जो प्रत्येक व्यक्तिगत रेखा से मेल खाता है। फिर इन बिंदुओं को कोड बिंदु के आधार पर क्रमबद्ध किया जाता है, इसलिए नई पंक्ति के बाद T पहले आता है, उसके बाद रेखाएं, लंबाई से आरोही हो जाती हैं।

A1`

अब हमारे पास शीर्ष पर पहली वर्ण रेखा है, इसलिए हम Aडिफ़ॉल्ट रेगेक्स के पहले मैच को छोड़ने के लिए ntigrep मोड का उपयोग करते हैं .+।

पुराना संस्करण

M&!r`.+
O`\G..+¶
s`(.*)¶.¶(.*)
$2¶$1
¶.$

ऑनलाइन इस संस्करण की कोशिश करो!

व्याख्या

पहली पंक्ति समान है, इसलिए उस के लिए स्पष्टीकरण देखें।

O`\G..+¶

यह पहली छमाही (दूसरी इनपुट शब्द) की पंक्तियों को उलट देता है। यह वास्तव Oमें पंक्तियों को rts करता है, और regex मैचों को सीमित करता है: यह दो या दो से अधिक वर्णों ( ..+) की एक पंक्ति होनी चाहिए, इसके बाद एक नई ¶रेखा ( ) शुरू होती है, जहां अंतिम एक को छोड़ दिया जाता है ( \G)। उपरोक्त उदाहरण Tमें, बीच का एकल मेल नहीं खाता है, इसलिए इसके बाद कुछ भी नहीं हो सकता है।

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

अब हमारे पास दो घटक हैं, लेकिन गलत क्रम में।

s`(.*)¶.¶(.*)
$2¶$1

¶.¶बीच में लोन टी से मेल खाता है, जिसकी हमें जरूरत नहीं है लेकिन दोनों भागों को अलग करता है। दोनों (.*)पहले और बाद में सब कुछ कैप्चर करते हैं, जिसमें न्यूलाइन को sइंग्ले-लाइन मोड के लिए धन्यवाद शामिल है । दो कैप्चर को सही क्रम में एक नई रेखा के बीच में प्रतिस्थापित किया जाता है।

अब हम कर रहे हैं, जब तक कि इनपुट तार एक वर्ण लंबे न हों, जिस स्थिति में इनपुट परिवर्तित नहीं हुआ है। डुप्लिकेट से छुटकारा पाने के लिए, हम ¶.$कुछ भी नहीं के साथ प्रतिस्थापित करते हैं (जब स्ट्रिंग की अंतिम पंक्ति एकल वर्ण)।

— NinjaBearMonkey
स्रोत

4

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

x,y=input(),input()
for i in x:print x;x=x[:-1]
s=y[0]
for i in y[1:]:s+=i;print s

दो इनपुट लेता है, प्रत्येक उद्धरण से घिरा हुआ है।

कुछ बाइट्स को बचाने और बग को इंगित करने के लिए @JonathanAllan धन्यवाद।

— atlasologist
स्रोत

1

के लिए कोई ज़रूरत नहीं len(x)में x=x[:len(x)-1]आप सिर्फ लिख सकते हैं - के बाद से नकारात्मक ऑफसेट टुकड़ा करने की क्रिया से काम करता है x=x[:-1]। केवल समस्या यह है कि आपका कोड " ", " "टेस्ट केस को बहुत अच्छी तरह से हैंडल नहीं करेगा ।

— जोनाथन एलन

1

आप दूसरे को छोड़ सकते हैं input()और इनपुट प्रारूप का उपयोग कर सकते हैं जैसे"<str1>", "<str2>"

— लेविटेटिंगियन

आप दूसरी पंक्ति को बदल सकते हैं for i in range(x):print x[-i:], और चौथी पंक्ति को for i in range(1,y):print y[:-i]। यकीन नहीं है कि यह काम करेगा, हालांकि।

— ०६

4

पर्ल, 34 28 बाइट्स

के लिए शामिल +2है-0n

STDIN पर अलग लाइनों पर तार के साथ चलाएं:

perl -M5.010 -0n slow.pl
Test
Testing
^D

slow.pl:

/(^..+|
\K.+?)(?{say$&})^/

रेगेक्स बैकट्रैकिंग को काम करने दें ...

— टन हास्पेल
स्रोत

3

चेडर , 76 बाइट्स

(a,b,q=s->(|>s.len).map((_,i)->s.head(i+1)))->(q(a).rev+q(b).slice(1)).vfuse

मुझे पसंद है की तुलना में थोड़ा लंबा। मैं जल्द ही एक स्पष्टीकरण जोड़ूंगा

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

— Downgoat
स्रोत

क्या करता |>है?

— Cycece

@Cyoce unary |> is range [0, n) बाइनरी है [a, b]

— डाउनगेट

3

ब्रेकीलॉग , 32 बाइट्स

:1aLtT,Lhbr:Tc~@nw
:2fb
~c[A:B]h

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

व्याख्या

Brachylog का कोई उपसर्ग अंतर्निहित नहीं है, इसलिए हम उपयोग करके उपसर्ग प्राप्त करेंगे concatenate(देखें विधेय 2): यदि उपसर्ग को (जो भी हो) के परिणाम में उपसर्ग मिल Sजाता है ।PPQS

मुख्य विधेय:

:1aL                  L is all prefixes of both elements of the input (see predicate 1)
   LtT,               T is the second element of L
       Lhbr           Remove the first prefix of the first list of L and reverse it
           :Tc        Concatenate with T
              ~@n     Join with newlines
                 w    Write to STDOUT

1 समर्पित करें:

:2f                   Find all prefixes of the input string (see predicate 2)
   b                  Remove the first one (empty string)

2 समर्पित करें:

~c[A:B]               Input is the result of concatenating A to B
       h              Output is A

— Fatalize
स्रोत

3

जावास्क्रिप्ट, 103 81 बाइट्स

f=(x,y,n=1)=>x?`
`+x+f(x.slice(0,-1),y):n++<y.length?`
`+y.slice(0,n)+f(x,y,n):''

उदाहरण: f("Test", "Testing")

आउटपुट:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

मूल उत्तर

f=(x,y,n=1)=>x?(console.log(x),f(x.slice(0,-1),y)):n++<y.length?(console.log(y.slice(0,n)),f(x,y,n)):''

— Hedi
स्रोत

3

जावा, 188 179 बाइट्स

interface E{static void main(String[]a){int i=a[0].length();while(i>1)System.out.println(a[0].substring(0,i--));while(i<=a[1].length())System.out.println(a[1].substring(0,i++));}}

अद्यतन करें

हटाए गए चर, 9 बाइट्स को बचाया

अघोषित :

interface E {

    static void main(String[] a) {
        int i = a[0].length();
        while (i > 1) {
            System.out.println(a[0].substring(0, i--));
        }
        while (i <= a[1].length()) {
            System.out.println(a[1].substring(0, i++));
        }
    }
}

उपयोग :

$ java E 'test' 'testing'
test
tes
te
t
te
tes
test
testi
testin
testing

— Master_ex
स्रोत

3

हास्केल, 54 53 47 बाइट्स

t[]=[]
t x=x:t(init x)
(.reverse.t).(++).init.t

प्रयोग उदाहरण: ((.reverse.t).(++).init.t) "Hello" "Hi!"-> ["Hello","Hell","Hel","He","H","Hi","Hi!"]।

कुछ पॉइंटफ्री मैजिक। यह वही है f x y = (init(t x))++reverse (t y)जहाँ tसभी प्रारंभिक सबस्ट्रिंग की सूची बनाता है जैसे t "HI!"-> ["H","HI","HI!"]।

— nimi
स्रोत

हम्म t=reverse.tail.inits,?

— बरगी

@ बर्गी: यकीन है, लेकिन initsजरूरत है import Data.List।

— nimi

3

पाइके, 14 बाइट्स

VDO)KKQlFh<)_X

यहाँ कोशिश करो!

और 17 बाइट्स सिर्फ इसलिए कि यह एक भयानक समाधान है:

mVDO)Fto!I_O(RKsX

यहाँ कोशिश करो!

— नीला
स्रोत

3

GNU सेड, 57 45 + 2 (आरएन झंडे) = 47 बाइट्स

:;1{/../p};2G;2h;s/.(\n.*)?$//;/./t;g;s/.$//p

चलाएँ:

echo -e "Test\nTesting" | sed -rnf morphing_string.sed

इनपुट एक नई रेखा द्वारा अलग किए गए दो तार होना चाहिए। कोड प्रत्येक पंक्ति के लिए sed द्वारा चलाया जाता है।

लूप :स्ट्रिंग के अंत से एक वर्ण को पुनरावृति से हटाता है। पहले स्ट्रिंग से संबंधित आउटपुट सीधे मुद्रित होता है, पहले चरित्र को छोड़कर 1{/../p}:। दूसरे स्ट्रिंग के लिए आउटपुट को 2G;2hविलोपन के दौरान रिवर्स ऑर्डर में होल्ड में रखा जाता है और अंत में प्रिंट किया जाता है।

— seshoumara
स्रोत

3

सी (जीसीसी) , 102 97 95 93 बाइट्स

n;f(char*a,char*b){for(n=strlen(a);n;puts(a))a[n--]=0;for(a=b+1;*a++;*a=n)n=*a,*a=0,puts(b);}

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

पहला लूप अंत से शुरू होने वाले 0 बाइट्स के साथ स्ट्रिंग को ओवरराइट करता है, और puts()स्ट्रिंग को प्रिंट करने के लिए उपयोग करता है। दूसरा लूप शुरुआत से ही अधिलेखित नहीं हो सकता है, इसे पुराने मूल्य को संग्रहीत करना होगा ताकि यह इसे वापस रख सके; 0 बाइट बस अंत की ओर चल रही है।

2 बाइट्स से प्रत्येक शेविंग के लिए @homersimpson और @ceilingcat को धन्यवाद!

— जी। स्लीपेन
स्रोत

1

आप की घोषणा के द्वारा एक जोड़े बाइट्स बचा सकता है nकी तरह एक वैश्विक पूर्णांक के रूप में: n;f(char*a,char*b){n=strlen(a)...। और आप शायद n=*a=0अपने लूप के लिए शरीर में एक जंजीर असाइनमेंट के रूप में कर सकते हैं ।

— होमपिसम्पसन

साभार @homersimpson लेकिन n = * a = 0 n = * a, * a = 0 के समान नहीं है।

— जी। स्लिपेन

2

पायथन 3, 104 बाइट्स

भावहीन।

n='\n';lambda x,y:x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1))

21 बाइट्स बंद करने के लिए @DJMcMayhem को धन्यवाद।

Ideone यह!

— बीटा डिके
स्रोत

1

आप 5 बाइट ले सकते हैं यदि आप करते हैं n='\n'और इसके बजाय n का उपयोग करते हैं '\n'। आप एक और 8 से दूर ले सकता है अगर आप के बजाय मुद्रण के एक लैम्ब्डा प्रयोग किया है:n='\n';lambda x,y:n.join(x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1)))

— DJMcMayhem

2

आरईपीएल / जावास्क्रिप्ट, 109 बाइट्स

मूल स्ट्रिंग को नीचे करने के लिए झूठी स्ट्रिंग का उपयोग करता है

दूसरे नंबर पर बढ़ने के लिए बड़ी संख्या के साथ एब्यूज, रुक जाता है, जब पिछली बार के समान शब्द प्रिंट करने के बारे में।

(a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}}

डेमो:

> ((a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}})("asdf","abcd")
[Log] asdf
[Log] asd
[Log] as
[Log] a
[Log] ab
[Log] abc
[Log] abcd

— Vartan
स्रोत

1

यह 1 बाइट करने के लिए छोटा है a=>b=>...और फंक्शन (a) (b)

— Zwei

2

ब्रेनफक, 38 55 बाइट्स

>++++++++++>,[>,]<[<]>>[[.>]<[-]<[<]>.>],.[[<]>.>[.>],]

संपादित करें: आउटपुट में newlines शामिल हैं

— जेफ
स्रोत

मुझे आपका कोड काम नहीं मिल रहा है। क्या इनपुट को एक नई लाइन द्वारा अलग किया जाता है? आप किस दुभाषिया का उपयोग कर रहे हैं?

— 22

2

दिल्लोग एपीएल , 20 13 बाइट्स

↑(⌽,\⍞),1↓,\⍞

↑ matrify

(⌽,\⍞)वर्ण इनपुट का उलट ( ⌽) संचयी संघनन ( ,\)⍞ )

, करने के लिए तैयार है

1↓ एक तत्व से गिरा

,\⍞ चरित्र इनपुट का संचयी संयोजन

TryAPL ऑनलाइन!

— एडम
स्रोत

2

रैकेट 193 बाइट्स

(define(f l)
(let*((s(list-ref l 0))
(x(string-length s)))
(for((n x))
(println(substring s 0(- x n))))
(set! s(list-ref l 1))
(for((n(range 1(string-length s))))
(println(substring s 0(add1 n))))))

परिक्षण:

(f(list "Test" "Testing"))

"Test"
"Tes"
"Te"
"T"
"Te"
"Tes"
"Test"
"Testi"
"Testin"
"Testing"


(f(list "Hello!" "Hi."))

"Hello!"
"Hello"
"Hell"
"Hel"
"He"
"H"
"Hi"
"Hi."

— rnso
स्रोत

इसे इनपुट स्ट्रिंग से अंतिम वर्ण को हटाना चाहिए, पहले वाले को नहीं।

— एजिलोब

2

फ्लोराइड , 69 बाइट्स

a,b=L.J
c=1
NZ(a)!=1:z(a);a=a[:-1]
z(a)
NZ(a)!=Z(b):c+=1;a=b[:c];z(a)

यह एक शुरुआत है। STDIN से इनपुट लेता है।

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

Input: Test Testing
Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Input: O O
Output: O

— Yytsi
स्रोत

1

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

(s,t)=>s.replace(/./g,`
$\`$&`).split`
`.slice(2).reverse().join`
`+t.replace(/./g,`
$\`$&`)

replaceबयान, तार के एक त्रिकोण है, जो वास्तव में क्या उत्पादन की दूसरी छमाही के लिए आवश्यक है का निर्माण लेकिन पहली छमाही उलट होने की जरूरत है और डुप्लिकेट एकल चरित्र लाइन हटा दिया। नोट: पहला स्ट्रिंग एक एकल वर्ण है, तो एक प्रमुख नईलाइन को आउटपुट करता है। यदि यह अवांछनीय है तो एक अतिरिक्त बाइट के लिए यह संस्करण हमेशा एक अनुगामी न्यूलाइन को आउटपुट करता है:

(s,t)=>s.replace(/./g,`
$\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,`
$\`$&\n`)

— नील
स्रोत

1

सी, 142 बाइट्स

#define _(x,y) while(y)printf("%.*s\n",d,x-c);
f(char*a,char*b){int c=1,d=strlen(a)+1;while(*++a==*++b)c++;_(a,--d>=c)d++;_(b,d++<strlen(b-c))}

प्रदान करें f(char* str1, char* str2)।

— कीउ गण
स्रोत

1

टीआई-बेसिक, 56 बाइट्स

Prompt Str1,Str2
Str1
While 1<length(Ans
Disp Ans
sub(Ans,1,length(Ans)-1
End
For(I,1,length(Str2
Disp sub(Str2,1,I
End

उदाहरण उपयोग

Str1=?Test
Str2=?Testing
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Str1=?O
Str2=?O
O

Str1=?z
Str2=?zz
z
zz

— Timtech
स्रोत

1

जावा, 168 136 बाइट्स

(s,d)->{int i=s.length()+1;while(i-->1)System.out.println(s.substring(0,i));while(i++<d.length())System.out.println(d.substring(0,i));};

अनगढ़ परीक्षण कार्यक्रम

public static void main(String[] args) {

    BiConsumer<String, String> biconsumer = (s, d) -> {
        int i = s.length() + 1;
        while (i-- > 1) {
            System.out.println(s.substring(0, i));
        }
        while (i++ < d.length()) {
            System.out.println(d.substring(0, i));
        }
    };

    biconsumer.accept("Test", "Testing123");

}

— शॉन वाइल्ड
स्रोत

1

(लैंबडॉट) हास्केल - 41 बाइट्स

f=(.drop 2.inits).(++).reverse.tail.inits

अधिक पठनीय, लेकिन दो बाइट्स लंबे समय तक:

a!b=(reverse.tail$inits a)++drop 2(inits b)

आउटपुट:

f "Hello" "Hi!"
["Hello","Hell","Hel","He","H","Hi","Hi!"]

— BlackCap
स्रोत

1

जे, 18 बाइट्स

]\@],~[:}:[:|.]\@[

Ungolfed:

]\@] ,~ [: }: [: |. ]\@[

यह एक 7-ट्रेन है:

]\@] ,~ ([: }: ([: |. ]\@[))

अंतरतम ट्रेन [: |. ]\@[एक टोपी के होते हैं [:, बाईं तरफ तो हम लागू |.(रिवर्स) के परिणाम के ]\@[, जो कि ]\अधिक (उपसर्गों)[ (बाएं तर्क)।

यहाँ वह है जो testing, testइनपुट पर दिखता है :

   'testing' ([: |. ]\@]) 'test'
test
tes
te
t

यह हमें पहला भाग देता है, लगभग। 5-ट्रेन उस के बाहर है([: }: ([: |. ]\@[))}:उपरोक्त अभिव्यक्ति के लिए , जो लागू होती है (शर्त, अंतिम तत्व को हटा दें):

   'testing' ([: }: [: |. ]\@]) 'test'
test
tes
te

(ऐसा इसलिए है क्योंकि हमारे पास डुप्लिकेट मिडपॉइंट नहीं हो सकता है।)

बाहरी भाग अंत में है:

]\@] ,~ ([: }: ([: |. ]\@[))

यह ]\@](बाएं तर्क के उपसर्ग) और से बना है,~ (वांछित के साथ हमें छोड़ दिया है क्या सही है के साथ छोड़ दिया है), वांछित परिणाम के साथ हमें छोड़:

   'testing' (]\@] ,~ ([: }: ([: |. ]\@[))) 'test'
testing
testin
testi
test
tes
te
t
te
tes
test

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

   k =: ]\@] ,~ ([: }: ([: |. ]\@[))
   'o' k 'o'
o
   k~ 'o'
o
   'test' k 'test'
test
tes
te
t
te
tes
test
   k~ 'test'
test
tes
te
t
te
tes
test
   '. . .' k '...'
. . .
. .
. .
.
.
..
...
   'z' k 'zz'
z
zz

— कोनोर ओ ब्रायन
स्रोत

आप का उपयोग कर 14 बाइट्स के लिए यह पुनर्व्यवस्थित कर सकते हैं(,~}:@|.)&(]\)

— मील की दूरी पर

1

PHP, 117 109 बाइट्स

for($i=strlen($a=$argv[1]);$i>1;)echo" ".substr($a,0,$i--);
for(;$j<strlen($b=$argv[2]);)echo" ".$c.=$b[$j++];

~~for($i=strlen($a=$argv[1]);$i>1;)echo substr($a,0,$i--)." "; for(;$i<=strlen($b=$argv[2]);)echo substr($b,0,$i++)." ";~~

PHP, 107 बाइट्स (जिसमें तार युक्त काम नहीं कर रहे हैं `0`)

for($a=$argv[1];$a[$i];)echo substr($a.a,0,-++$i)." ";
for($b=$argv[2];$b[$j];)echo substr($b,0,++$j+1)." ";

— क्रिप्टो
स्रोत

1

सी, 111 बाइट्स

f(char*a, char*b){int l=strlen(a),k=1;while(*a){printf("%s\n",a);a[--l]=0;}while(b[k]) printf("%.*s\n",++k,b);}

अघोषित परीक्षण

#include <stdio.h>
#include <string.h>

f(char*a, char*b) {
  int l=strlen(a), k=1;
  while(*a) {
    printf("%s\n",a);
    a[--l]=0;
  }
  while(b[k])
    printf("%.*s\n",++k,b);
}

int main() {
  char a[10] = {0};
  char b[10] = {0};

  for (int i=0; i<5; ++i) {
    a[i] = 'a' + i;
    b[i] = 'a' + i*2;
  }

  f(&(a[0]), &(b[0]));
}

— UKMonkey
स्रोत

1

ब्रेनफक, 162 बाइट्स

,[>,]++++++++++[[-<]>[->]<]++++++++++[<[+<]<[+<]>[+>]>[+>]<---]<[<]<[<]>[[.>]++++++++++.----------<[-]<[[->+<]<]>>]>[<+>-]>[[<+>-]<[<]>[.>]++++++++++.---------->]

इसे यहाँ आज़माएँ

इनपुट एक लाइनफीड द्वारा अलग किए गए दो तारों को लेता है।

ब्रायनफुक और फर्स्ट कोड गोल्फ के साथ पहला कार्यक्रम इसलिए मुझे यकीन है कि बहुत सारे अनुकूलन किए जाने हैं। मज़ा हालांकि यह कर रहा था।

Ungolfed

,[>,] Read all input
++++++++++ Flag for 10
[                   Subtract 10 from each cell to flag space for blank
    [-<]            
    >
        [->]
        <
]
++++++++++ Flag for 10
[                   Add 10 back to each cell with value in it
    <[+<]<[+<]
    >[+>]>[+>]<---
]
<[<]<[<]>               goto first cell in first string string      

[                           Print first word subtracting one each time
    [.>]                    Print first string
    ++++++++++.----------   Print new line
    <[-]                    Kill last letter of first string
    <                       Back one
    [                       Move each first string character up one
          [->+<]
          <
    ]>>
]
>[<+>-]>                    Move to first letter of scond string back one goto second letter
[                               
    [<+>-]                  Move next letter back
    <[<]>                   Move to start of string
    [.>]                    Print string
    ++++++++++.----------   Print new line
    >
]

— gtwebb
स्रोत

PPCG में आपका स्वागत है! प्रभावशाली पहली पोस्ट!

— R

धीरे-धीरे एक स्ट्रिंग को दूसरे में बदल दें

चुनौती

उदाहरण

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

नियम

अजगर, 9 बाइट्स

वी , 14 बाइट्स

पायथन, 93 बाइट्स

05AB1E , 9 बाइट्स

रेटिना, 50 41 26 बाइट्स

व्याख्या

पुराना संस्करण

व्याख्या

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

पर्ल, 34 28 बाइट्स

चेडर , 76 बाइट्स

ब्रेकीलॉग , 32 बाइट्स

व्याख्या

जावास्क्रिप्ट, 103 81 बाइट्स

जावा, 188 179 बाइट्स

हास्केल, 54 53 47 बाइट्स

पाइके, 14 बाइट्स

GNU सेड, 57 45 + 2 (आरएन झंडे) = 47 बाइट्स

सी (जीसीसी) , 102 97 95 93 बाइट्स

पायथन 3, 104 बाइट्स

आरईपीएल / जावास्क्रिप्ट, 109 बाइट्स

ब्रेनफक, 38 55 बाइट्स

दिल्लोग एपीएल , 20 13 बाइट्स

रैकेट 193 बाइट्स

फ्लोराइड , 69 बाइट्स

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

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

सी, 142 बाइट्स

टीआई-बेसिक, 56 बाइट्स

जावा, 168 136 बाइट्स

अनगढ़ परीक्षण कार्यक्रम

(लैंबडॉट) हास्केल - 41 बाइट्स

जे, 18 बाइट्स

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

PHP, 117 109 बाइट्स

PHP, 107 बाइट्स (जिसमें तार युक्त काम नहीं कर रहे हैं 0)

सी, 111 बाइट्स

ब्रेनफक, 162 बाइट्स

PHP, 107 बाइट्स (जिसमें तार युक्त काम नहीं कर रहे हैं `0`)