Die Herausforderung

Geben Sie bei zwei Zeichenfolgen / einem Array von Zeichenfolgen die erste Zeichenfolge aus, die langsam schrumpft und sich wieder in die zweite Zeichenfolge ausdehnt.

Sie können davon ausgehen, dass die Zeichenfolgen immer mit demselben Zeichen beginnen.

Beispiel

Input:
"Test", "Testing"

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

Zuerst geben Sie das erste Wort aus:

Test

Dann entfernen Sie einen Buchstaben, bis die Zeichenfolge ein Zeichen lang ist:

Tes
Te
T

Fügen Sie dann einen Buchstaben des zweiten Wortes hinzu, bis es fertig ist:

Te
Tes
Test
Testi
Testin
Testing

(Wenn beide Zeichenfolgen ein Zeichen lang sind, geben Sie eine davon nur einmal aus.)

Testfälle

"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

(Hinweis: Ersetzen Sie im Leerzeichen / vierten Testfall das S durch Leerzeichen.)

Regeln

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes! Tiebreaker ist der am besten bewertete Beitrag. Der Gewinner wird am 09.10.2016 ermittelt.

• Standardlücken sind verboten.

Pyth, 9 Bytes

j+_._Et._

Ein Programm, das die zweite und dann die erste Zeichenfolge in Anführungszeichen auf STDIN setzt und das Ergebnis ausgibt.

Probieren Sie es online aus

Wie es funktioniert

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 Bytes

òYp$xhòjòÄ$xhh

Probieren Sie es online!

Erläuterung:

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

Der Puffer sieht nun so aus:

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

Für die nächste Zeile müssen wir nur dasselbe in umgekehrter Reihenfolge tun:

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.

Interessantere alternative Lösung :

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

Python, 93 Bytes

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)

Beginnt mit der leeren Zeichenfolge r, fügt aeine neue Zeile hinzu und entfernt das letzte Zeichen von abis, aund fügt dann die erforderlichen Teile von bund eine neue Zeile hinzu, indem ein Zähler beibehalten wird i, der beginnt, 2bis die Länge von büberschritten wird, und dann zurückkehrt r. Hat einen nachgestellten Zeilenumbruch.

Alle Tests sind auf ideone

05AB1E , 9 Bytes

.pRI.p¦«»

Erläuterung

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

Probieren Sie es online!

Retina, 50 41 26 Bytes

Vielen Dank an Martin Ender für das Speichern von 15 (!) Bytes.

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

Nimmt die Eingabe mit den beiden durch einen Zeilenumbruch getrennten Zeichenfolgen vor:

Test
Testing

Probieren Sie es online!

Erläuterung

M&!r`.+

Die erste Zeile generiert die "Schritte" beider Wörter:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mgilt für den Übereinstimmungsmodus, &berücksichtigt überlappende Übereinstimmungen und !druckt die Übereinstimmungen anstelle der Anzahl aus. Der Grund für die Umkehrung ist die rOption von rechts nach links: Die Suchmaschine sucht am Ende der Zeichenfolge nach Übereinstimmungen und fährt am Anfang fort.

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

Dies bringt alles in die richtige Reihenfolge: Es werden Oalle Übereinstimmungen des nachfolgenden regulären Ausdrucks angezeigt: Ein Zeichen in einer eigenen Zeile und jedes Zeichen (einschließlich Zeilenvorschub) danach, das der gesamten zweiten Hälfte als ein Teil oder auf andere Weise als eine Zeichenzeile entspricht , die zu jeder einzelnen Zeile passt. Diese Übereinstimmungen werden dann nach Codepunkten sortiert, sodass zuerst das T gefolgt von der neuen Zeile und dann die Zeilen in aufsteigender Reihenfolge angezeigt werden.

A1`

Jetzt haben wir nur die erste AZeichenzeile oben, sodass wir den ntigrep-Modus verwenden, um die erste Übereinstimmung der Standard-Regex zu verwerfen .+.

Alte Version

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

Probieren Sie diese Version online aus!

Erläuterung

Die erste Zeile ist die gleiche, siehe die Erklärung dazu oben.

O`\G..+¶

Dies kehrt die Zeilen der ersten Hälfte (zweites Eingangswort) um. Es ist eigentlich Orts die Linien, und die Regex begrenzt die Spiele: es muss eine Linie von zwei oder mehr Zeichen lang sein ( ..+) durch eine neue Zeile gefolgt ( ¶) , die dort beginnt , wo die letzte aufgehört hat ( \G). Im obigen Beispiel Tstimmt die Single in der Mitte nicht überein, also nichts danach.

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

Jetzt haben wir die richtigen zwei Komponenten, aber in der falschen Reihenfolge.

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

¶.¶Passt zum einsamen T in der Mitte, das wir nicht brauchen, sondern die beiden Teile trennen. Die beiden (.*)erfassen alles davor und danach, einschließlich der Zeilenumbrüche dank des sIngle-Line-Modus. Die beiden Captures werden in der richtigen Reihenfolge durch einen Zeilenumbruch dazwischen ersetzt.

Jetzt sind wir fertig, es sei denn, die Eingabezeichenfolgen sind ein Zeichen lang. In diesem Fall hat sich die Eingabe nicht geändert. Um das Duplikat loszuwerden, ersetzen wir ¶.$(wenn die letzte Zeile des Strings ein einzelnes Zeichen enthält) durch nichts.

Python 2, 88 82 Bytes

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

Nimmt zwei Eingaben an, die jeweils von Anführungszeichen umgeben sind.

Vielen Dank an JonathanAllan für das Speichern einiger Bytes und den Hinweis auf einen Fehler.

Perl, 34 28 Bytes

Enthält +2für-0n

Führen Sie mit den Zeichenfolgen in separaten Zeilen auf STDIN aus:

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

slow.pl:

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

Lassen Sie Regex Backtracking die Arbeit machen ...

Cheddar , 76 Bytes

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

Ein bisschen länger als ich wollte. Ich werde bald eine Erklärung hinzufügen

Probieren Sie es online!

Brachylog , 32 Bytes

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

Probieren Sie es online!

Erläuterung

In Brachylog ist kein Präfix integriert, daher erhalten wir die Präfixe mit concatenate(siehe Prädikat 2): Ein Präfix von Sist, Pwenn es Pmit Q(was auch immer es ist) verkettet wird S.

• Hauptprädikat:

  :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
  

• Prädikat 1:

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

• Prädikat 2:

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

Javascript, 103 81 Bytes

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

Beispiel: f("Test", "Testing")

Ausgabe:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Ursprüngliche Antwort

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 Bytes

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

Aktualisieren

• Entfernte s Variable, 9 Bytes gespeichert

Ungolfed :

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

Verwendung :

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

Haskell, 54 53 47 Bytes

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

Anwendungsbeispiel: ((.reverse.t).(++).init.t) "Hello" "Hi!"-> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

Etwas sinnlose Magie. Es ist das gleiche wie in f x y = (init(t x))++reverse (t y)dem tmacht eine Liste aller anfänglichen Teil zB t "HI!"-> ["H","HI","HI!"].

Pyke, 14 Bytes

VDO)KKQlFh<)_X

Probieren Sie es hier aus!

Und 17 Bytes, nur weil es eine großartige Lösung ist:

mVDO)Fto!I_O(RKsX

Probieren Sie es hier aus!

GNU sed, 57 45 + 2 (rn Flags) = 47 Bytes

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

Lauf:

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

Die Eingabe sollte aus den zwei durch einen Zeilenumbruch getrennten Zeichenfolgen bestehen. Der Code wird von sed für jede Zeile ausgeführt.

Die Schleife :löscht iterativ ein Zeichen vom Ende der Zeichenfolge. Der Ausgang der ersten Saite in Beziehung steht direkt gedruckt, außer dem ersten Zeichen: 1{/../p}. Die Ausgabe für den zweiten String wird 2G;2hbeim Löschen in umgekehrter Reihenfolge ( ) im Hold-Space abgelegt und am Ende ausgedruckt.

C (gcc) , 102 97 95 93 Bytes

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

Probieren Sie es online!

Die erste Schleife überschreibt die Zeichenfolge beginnend mit dem Ende mit 0 Byte und puts()druckt die Zeichenfolge aus. Die zweite Schleife kann nicht einfach von Anfang an überschreiben, sondern muss den alten Wert speichern, um ihn zurückzusetzen. Das 0-Byte läuft gerade gegen Ende.

Vielen Dank an @homersimpson und @ceilingcat für jede Abspaltung von 2 Bytes!

Python 3, 104 Bytes

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

Vielen Dank an @DJMcMayhem für 21 Bytes Golf.

Ideone es!

REPL / Javascript, 109 Bytes

Verwendet eine falsche Zeichenfolge, um die ursprüngliche Zeichenfolge zu verkürzen

Missbraucht Teilzeichenfolge mit größeren Zahlen, um die zweite zu vergrößern, und stoppt, wenn das gleiche Wort wie beim letzten Mal gedruckt werden soll.

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

Demo:

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

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

Bearbeiten: Zeilenumbrüche wurden in die Ausgabe aufgenommen

Dyalog APL , 20 13 Bytes

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

↑ matrifizieren

(⌽,\⍞)umgekehrte ( ⌽) kumulative Verkettung ( ,\) der Zeicheneingabe ( ⍞)

, vorangestellt

1↓ ein Element fiel aus

,\⍞ kumulative Verkettung der Zeicheneingabe

TryAPL online!

Schläger 193 Bytes

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

Testen:

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

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)

Es ist ein Anfang. Übernimmt die Eingabe von STDIN.

Testfälle

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

Input: O O
Output: O

JavaScript (ES6), 92 Byte

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

Die replaceAnweisungen bilden ein Dreieck aus Zeichenfolgen. Dies ist genau das, was für die zweite Hälfte der Ausgabe erforderlich ist. Die erste Hälfte muss jedoch umgekehrt und die doppelte Einzelzeichenzeile entfernt werden. Hinweis: Gibt eine führende neue Zeile aus, wenn die erste Zeichenfolge ein einzelnes Zeichen ist. Wenn dies unerwünscht ist, gibt diese Version für ein zusätzliches Byte immer eine abschließende neue Zeile aus:

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

C 142 Bytes

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

Zur Verfügung stellen f(char* str1, char* str2).

TI-Basic, 56 Bytes

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

Anwendungsbeispiel

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 Bytes

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

Ungolfed Testprogramm

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 Bytes

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

Mehr lesbar, aber zwei Bytes länger:

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

Ausgabe:

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

J, 18 Bytes

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

Ungolfed:

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

Dies ist ein 7-Zug:

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

Der innerste Zug [: |. ]\@[besteht aus einer Begrenzung [:links, daher wenden wir |.(in umgekehrter Reihenfolge) auf das Ergebnis von an ]\@[, das ]\(Präfixe) über [(Argument links) steht.

So sieht das bei der testing, testEingabe aus:

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

Dies gibt uns fast die erste Portion. Der 5-Zug außerhalb davon ist ([: }: ([: |. ]\@[)), der für }:den obigen Ausdruck gilt (Detail, letztes Element entfernen):

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

(Dies liegt daran, dass wir keinen doppelten Mittelpunkt haben können.)

Der äußere Teil ist schließlich:

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

Dies setzt sich zusammen aus ]\@](Präfixe des linken Arguments) und ,~(Links an Rechts anhängen ) und liefert das gewünschte Ergebnis:

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

Testfälle

   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 Bytes

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 Bytes (funktioniert nicht mit Strings, die enthalten 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 Bytes

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

Ungolfed Test

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

Brainfuck, 162 Bytes

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

Probieren Sie es hier aus

Für die Eingabe werden die beiden durch einen Zeilenvorschub getrennten Zeichenfolgen verwendet.

Erstes Programm mit Brianfuck und erstem Code-Golf, daher bin ich sicher, dass es noch viel zu optimieren gibt. Hatte aber Spaß dabei.

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