Wyzwanie

Biorąc pod uwagę dwa łańcuchy / tablicę łańcuchów, wypisz pierwszy łańcuch powoli zmniejszając się i rozszerzając z powrotem do drugiego łańcucha.

Możesz założyć, że ciągi zawsze będą zaczynać się od tego samego znaku.

Przykład

Input:
"Test", "Testing"

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

Najpierw wypisujesz pierwsze słowo:

Test

Następnie usuwasz jedną literę, dopóki ciąg nie będzie miał jednego znaku:

Tes
Te
T

Następnie dodawaj jedną literę drugiego słowa, aż się skończy:

Te
Tes
Test
Testi
Testin
Testing

(jeśli oba ciągi mają jeden znak, wypisz jeden z nich raz).

Przypadki testowe

"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

(uwaga: na spacji / czwartym przypadku testowym zamień S na spacje)

Zasady

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach! Tiebreaker jest najbardziej cenionym postem. Zwycięzca zostanie wybrany 09.10.2016.

• Standardowe luki są zabronione.

Pyth, 9 bajtów

j+_._Et._

Program, który pobiera drugi ciąg, a następnie pierwszy ciąg, jako ciągi cytowane na STDIN i wypisuje wynik.

Wypróbuj online

Jak to działa

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

V , 14 bajtów

òYp$xhòjòÄ$xhh

Wypróbuj online!

Wyjaśnienie:

ò     ò     "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.

Teraz bufor wygląda następująco:

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

Musimy tylko zrobić to samo w odwrotnej kolejności dla następnej linii:

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.

Bardziej interesujące alternatywne rozwiązanie :

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

Python, 93 bajty

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)

Zaczyna się od pustego ciągu r, dodaje ai nową linię i usuwa ostatni znak z ado, aż ajest pusty, następnie dodaje wymagane części bi nową linię, utrzymując licznik i, który zaczyna się 2do momentu bprzekroczenia długości , a następnie wraca r. Ma końcowy znak nowej linii.

Wszystkie testy są na ideone

05AB1E , 9 bajtów

.pRI.p¦«»

Wyjaśnienie

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

Wypróbuj online!

Siatkówka, 50 41 26 bajtów

Podziękowania dla Martina Endera za oszczędność 15 (!) Bajtów.

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

Pobiera dane wejściowe z dwoma ciągami znaków oddzielonymi znakiem nowej linii:

Test
Testing

Wypróbuj online!

Wyjaśnienie

M&!r`.+

Pierwszy wiersz generuje „kroki” obu słów:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mjest w trybie dopasowania, &uwzględnia nakładające się dopasowania i !drukuje dopasowania zamiast ich liczby. Powodem odwrócenia jest ropcja ight-to-left: silnik zaczyna szukać dopasowań na końcu łańcucha i kontynuuje w kierunku początku.

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

Otrzymuje to wszystko w odpowiedniej kolejności: Ozestawia wszystkie dopasowania kolejnego wyrażenia regularnego: znak w osobnej linii i każdy znak (w tym nowe wiersze) po nim, który dopasowuje całą drugą połowę jako jeden fragment lub w inny sposób linię znaków , który pasuje do każdej linii. Te dopasowania są następnie sortowane według punktu kodowego, więc najpierw następuje T, po którym następuje nowa linia, a następnie linie, rosnąco według długości.

A1`

Teraz mamy tylko pierwszą linię znaków na górze, więc używamy Atrybu ntigrep, aby odrzucić pierwsze dopasowanie domyślnego wyrażenia regularnego .+.

Stara wersja

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

Wypróbuj tę wersję online!

Wyjaśnienie

Pierwszy wiersz jest taki sam, więc wyjaśnij to powyżej.

O`\G..+¶

Odwraca to linie pierwszej połowy (drugie słowo wejściowe). W rzeczywistości Oustawia wiersze, a wyrażenie regularne ogranicza dopasowania: musi to być wiersz składający się z dwóch lub więcej znaków ( ..+), po których następuje nowa linia ( ¶) rozpoczynająca się w miejscu, w którym ostatni został przerwany ( \G). W powyższym przykładzie singiel Tw środku nie pasuje, więc nic po nim nie może.

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

Teraz mamy odpowiednie dwa elementy, ale w niewłaściwej kolejności.

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

¶.¶pasuje do samotnej litery T na środku, której nie potrzebujemy, ale dzieli dwie części. Obaj (.*)rejestrują wszystko przed i po, w tym nowe linie dzięki strybowi ingle-line. Dwa przechwytywania są zastępowane w odpowiedniej kolejności nową linią pośrodku.

Teraz skończyliśmy, chyba że ciągi wejściowe mają jeden znak, w którym to przypadku dane wejściowe się nie zmieniły. Aby pozbyć się duplikatu, zastępujemy ¶.$(gdy w ostatnim wierszu łańcucha jeden znak) niczym.

Python 2, 88 82 bajtów

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

Pobiera dwa dane wejściowe, każdy otoczony cudzysłowami.

Dzięki @JonathanAllan za uratowanie niektórych bajtów i wskazanie błędu.

Perl, 34 28 bajtów

Obejmuje +2dla-0n

Uruchom z ciągami w osobnych liniach na STDIN:

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

slow.pl:

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

Pozwól, aby cofanie się wyrażenia regularnego wykonało pracę ...

ser Cheddar , 76 bajtów

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

Trochę dłużej niż chciałbym. Wkrótce dodam wyjaśnienie

Wypróbuj online!

Brachylog , 32 bajty

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

Wypróbuj online!

Wyjaśnienie

Brachylog nie ma wbudowanego prefiksu, dlatego otrzymamy prefiksy za pomocą concatenate(Patrz predykat 2): prefiks Sjest, Pjeśli Ppołączy się z Q(czymkolwiek jest) wynikiem S.

• Główny predykat:

  :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
  

• Predykat 1:

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

• Predykat 2:

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

JavaScript, 103 81 bajtów

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

Przykład: f("Test", "Testing")

Wydajność:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Oryginalna odpowiedź

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)):''

Java, 188 179 bajtów

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++));}}

Aktualizacja

• Usunięto zmienną s, zapisano 9 bajtów

Nie golfowany :

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++));
        }
    }
}

Zastosowanie :

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

Haskell, 54 53 47 bajtów

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

Przykład użycia: ((.reverse.t).(++).init.t) "Hello" "Hi!" -> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

Jakaś bezcelowa magia. Jest to to samo, co f x y = (init(t x))++reverse (t y)gdzie ttworzy listę wszystkich początkowych podciągów, np. t "HI!"-> ["H","HI","HI!"].

Pyke, 14 bajtów

VDO)KKQlFh<)_X

Wypróbuj tutaj!

I 17 bajtów tylko dlatego, że to niesamowite rozwiązanie:

mVDO)Fto!I_O(RKsX

Wypróbuj tutaj!

GNU sed, 57 45 + 2 (flagi rn) = 47 bajtów

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

Biegać:

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

Dane wejściowe powinny być dwoma ciągami znaków oddzielonymi znakiem nowej linii. Kod jest uruchamiany przez sed dla każdej linii.

Pętla :iteracyjnie usuwa jeden znak z końca łańcucha. Wyjście podobne do pierwszego ciągu są drukowane bezpośrednio, z wyjątkiem pierwszego znaku: 1{/../p}. Dane wyjściowe dla drugiego łańcucha są przechowywane w przestrzeni wstrzymania w odwrotnej kolejności ( 2G;2h) podczas usuwania i drukowane na końcu.

C (gcc) , 102 97 95 93 bajtów

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);}

Wypróbuj online!

Pierwsza pętla zastępuje ciąg 0 bajtami zaczynającymi się od końca i używa puts() do wydrukowania ciągu. Druga pętla nie może po prostu nadpisać od początku, musi przechowywać starą wartość, aby mogła ją przywrócić; bajt 0 właśnie idzie w kierunku końca.

Dzięki @homersimpson i @ceilingcat za każde golenie 2 bajtów!

Python 3, 104 bajty

Meh

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))

Dzięki @DJMcMayhem za grę w golfa o 21 bajtów.

Ideone to!

REPL / JavaScript, 109 bajtów

Używa fałszywego ciągu, aby rozłożyć oryginalny ciąg

Nadużywa podciągów o większych liczbach, aby urosnąć do drugiego, zatrzymuje się, gdy ma zamiar wydrukować to samo słowo, co ostatnim razem.

(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)}}

Próbny:

> ((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

Brainfuck, 38 55 bajtów

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

Edycja: uwzględniono nowe wiersze w danych wyjściowych

Dyalog APL , 20 13 bajtów

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

↑ matrify

(⌽,\⍞)reverse ( ⌽) kumulatywna konkatenacja ( ,\) wprowadzania znaków ( ⍞)

, uprzedzony do

1↓ jeden element spadł z

,\⍞ kumulatywna konkatenacja wprowadzania znaków

Wypróbuj APL online!

Rakieta 193 bajtów

(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))))))

Testowanie:

(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."

Floroid , 69 bajtów

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)

To poczatek. Pobiera dane wejściowe z STDIN.

Przypadki testowe

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

Input: O O
Output: O

JavaScript (ES6), 92 bajty

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

Te replacewypowiedzi zbudować trójkąt strun, która jest dokładnie to, co jest wymagane na drugą połowę wyjścia, jednak pierwsza połowa musi być odwrócone, a duplikat linia pojedynczych znaków usunięte. Uwaga: wypisuje wiodący nowy wiersz, jeśli pierwszy ciąg jest pojedynczym znakiem. Jeśli jest to niepożądane, to dla dodatkowego bajtu ta wersja zawsze wyświetla końcowy znak nowej linii:

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

C, 142 bajty

#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))}

Zapewnić f(char* str1, char* str2).

TI-Basic, 56 bajtów

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

Przykładowe użycie

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

Java, 168 136 bajtów

(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));};

Nie testowany program testowy

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");

}

(Lambdabot) Haskell - 41 bajtów

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

Bardziej czytelny, ale o dwa bajty dłuższy:

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

Wydajność:

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

J, 18 bajtów

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

Nie golfowany:

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

To 7 pociągów:

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

Najbardziej wewnętrzny pociąg [: |. ]\@[składa się z czapki [:po lewej stronie, więc nakładamy |.(odwrotnie) na wynik ]\@[, który jest ]\(przedrostki) ponad[ (lewy argument).

Oto jak to wygląda na testing, testwejściu:

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

To prawie pierwsza część. 5-pociąg poza tym jest ([: }: ([: |. ]\@[)), co stosuje się }:(betail, usuń ostatni element) do powyższego wyrażenia:

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

(Jest tak, ponieważ nie możemy mieć zduplikowanego punktu środkowego.)

Część zewnętrzna to w końcu:

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

Składa się z ]\@](prefiksów lewego argumentu) i ,~(dodaj to, co jest po lewej stronie, a to, co jest po prawej stronie), pozostawiając nam pożądany wynik:

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

Przypadki testowe

   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

PHP, 117 109 bajtów

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 bajtów (nie działa z ciągami zawierającymi 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)." ";

C, 111 bajtów

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);}

Test bez golfa

#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]));
}

pieprzenie mózgu, 162 bajty

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

Wypróbuj tutaj

Wejście pobiera dwa ciągi znaków oddzielone wierszem.

Pierwszy program z brianfuck i golfem pierwszego kodu, więc jestem pewien, że jest wiele do zrobienia. Świetnie się to robiło.

Bez golfa

,[>,] 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
    >
]