Verwandle langsam eine Saite in eine andere

31

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.

code-golf string Akrolith
quelle
Sind 2 nachgestellte Zeilenumbrüche (eine sichtbare leere Zeile nach der Sequenz) zulässig oder nicht?
Seshoumara

Antworten:

11

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
TheBikingViking
quelle
14

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
DJMcMayhem
quelle
3
Es ist, als ob vim immer das richtige Werkzeug für einen Job ist
Downgoat
@ Downgoat Genau. Aus diesem Grund müssen Sie mit dem Golfen in V. beginnen: P
DJMcMayhem
9

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

Jonathan Allan
quelle
2 Dinge. 1) Ich glaube, dass Sie Zeichen falsch gezählt haben und es tatsächlich 93 und 2) Sie brauchen nicht zu sagen r="". Einfach rwürde immer noch funktionieren.
Vielen Dank an JackBates. 1. Richtig und aktualisiert - ich habe das wahrscheinlich vergessen f=. 2. Ohne die r=''Gegenwart f('test','testing')würde nicht funktionieren; ja f('test','testing','')würde, aber wir müssen die spezifikationen befolgen.
Jonathan Allan
Vergib mir. Ich habe mir nur den Code angesehen und nicht die Beispiele.
7

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!

Emigna
quelle
7

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.

NinjaBearMonkey
quelle
4

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.

Atlasologe
quelle
1
Keine Notwendigkeit für die len(x)in x=x[:len(x)-1]da negative Offset - Slicing arbeitet - man muss nur schreiben kann x=x[:-1]. Das einzige Problem ist, dass Ihr Code den " ", " "Testfall nicht sehr gut handhabt .
Jonathan Allan
1
Sie können die Sekunde fallen lassen input()und ein Eingabeformat wie"<str1>", "<str2>"
LevitatingLion
Sie können die zweite Zeile in for i in range(x):print x[-i:]und die vierte Zeile in ändern for i in range(1,y):print y[:-i]. Ich bin mir jedoch nicht sicher, ob es funktionieren würde.
Clismique
4

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

Tonne Hospel
quelle
3

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!

Downgoat
quelle
Was macht |>das?
Cyoce
@Cyoce unary |> ist Bereich [0, n) binär ist [a, b]
Downgoat
3

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
Tödlich
quelle
3

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)):''
Hedi
quelle
3

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
Master_ex
quelle
3

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!"].

nimi
quelle
Hm t=reverse.tail.inits?
Bergi
@Bergi: klar, initsbraucht aber import Data.List.
nimi
3

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.

Seshoumara
quelle
3

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!

G. Sliepen
quelle
1
Sie können , indem er erklärt , ein paar Bytes speichern nwie als globalen int: n;f(char*a,char*b){n=strlen(a).... Und Sie können dies wahrscheinlich n=*a=0als verkettete Zuweisung im Rumpf Ihrer for-Schleife tun .
Homersimpson
Vielen Dank @homersimpson. Aber n = * a = 0 ist nicht dasselbe wie n = * a, * a = 0.
G. Sliepen
2

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!

Beta-Zerfall
quelle
1
Sie können 5 Bytes nehmen , wenn Sie tun , n='\n'und verwenden n statt '\n'. Sie könnten weitere 8 ausziehen, wenn Sie Lambda anstelle von Drucken verwenden: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

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
Vartan
quelle
1
es ist 1 Byte kürzer, a=>b=>...um die Funktion mit (a) (b) aufzurufen
Zwei
2

Brainfuck, 38 55 Bytes

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

Bearbeiten: Zeilenumbrüche wurden in die Ausgabe aufgenommen

Jeff
quelle
Ich kann Ihren Code nicht zum Laufen bringen. Ist die Eingabe durch eine neue Zeile getrennt? Welchen Dolmetscher verwenden Sie?
Acrolith
2

Dyalog APL , 20 13 Bytes

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

↑ matrifizieren

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

, vorangestellt

1↓ ein Element fiel aus

,\⍞ kumulative Verkettung der Zeicheneingabe

TryAPL online!

Adam
quelle
2

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."
rnso
quelle
Es sollte das letzte Zeichen aus der Eingabezeichenfolge löschen, nicht das erste.
Agilob
2

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
Yytsi
quelle
1

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`)
Neil
quelle
1

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

Keyu Gan
quelle
1

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
Timtech
quelle
1

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

}
Shaun Wild
quelle
1

(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!"]
BlackCap
quelle
1

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
Conor O'Brien
quelle
Sie können es mit(,~}:@|.)&(]\)
miles
1

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)." ";
Krypto
quelle
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]));
}
UKMonkey
quelle
1

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
    >
]
gtwebb
quelle
Willkommen bei PPCG! Beeindruckender erster Beitrag!
9.