আস্তে আস্তে একটি স্ট্রিংটিকে অন্যটিতে পরিণত করুন

31

চ্যালেঞ্জ

দুটি স্ট্রিং / স্ট্রিংয়ের একটি অ্যারে দেওয়া, আউটপুট প্রথম স্ট্রিংটি আস্তে আস্তে সঙ্কুচিত হয়ে দ্বিতীয় স্ট্রিংয়ে ফিরে প্রসারিত হবে।

আপনি ধরে নিতে পারেন স্ট্রিংগুলি সর্বদা একই অক্ষর দিয়ে শুরু হবে।

উদাহরণ

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

(দ্রষ্টব্য: স্পেস / চতুর্থ পরীক্ষার ক্ষেত্রে, স্পেস দিয়ে এস প্রতিস্থাপন করুন)

বিধি

  • এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর! টাইব্রেকার হ'ল সর্বাধিক উন্নত পোস্ট। বিজয়ী নির্বাচন করা হবে 09/10/2016 এ।

  • স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।

code-golf  string 
— acrolith
সূত্র
2 টি ট্রিলিং করা নতুনলাইনগুলি (ক্রমের পরে একটি দৃশ্যমান ফাঁকা লাইন) অনুমতি পাবে কি না?
— সেশোমারা

উত্তর:

11

পাইথ, 9 বাইট

j+_._Et._

একটি প্রোগ্রাম যা দ্বিতীয় স্ট্রিং নেয় এবং তারপরে প্রথম স্ট্রিংটি এসটিডিআইএন-এ উদ্ধৃত স্ট্রিং হিসাবে ফলাফল প্রিন্ট করে।

এটি অনলাইনে চেষ্টা করুন

কিভাবে এটা কাজ করে

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.

এখন, বাফারটি দেখতে এটির মতো দেখাচ্ছে:

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

আমাদের কেবল পরবর্তী লাইনের বিপরীতে একই জিনিসটি করা দরকার:

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
— ডিজেএমসিএমহেম
সূত্র
3
এটি ভিমের মতো
— যাবতীয়
নিখুঁতভাবে ডাউনলোড করুন এজন্য আপনাকে ভি। তে গল্ফ করা শুরু করতে হবে: পি
— ডিজেএমসিএমহেম
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। একটি ট্রেলিং নিউলাইন রয়েছে।

সমস্ত পরীক্ষার উপর ideone

— জোনাথন অ্যালান
সূত্র
2 জিনিস। 1) আমি বিশ্বাস করি যে আপনি অক্ষরগুলি ভুলভাবে গণনা করেছেন এবং এটি আসলে 93 এবং 2) আপনার বলার দরকার নেই r=""। সরল rএখনও কাজ করবে।
ধন্যবাদ @ জ্যাকবেটস 1. সঠিক, এবং আপডেট - আমি সম্ভবত ভুলে গেছি f=। 2. r=''বর্তমান ছাড়া f('test','testing')কাজ করবে না; হ্যাঁ f('test','testing',''), তবে আমাদের অবশ্যই বিশদটি অনুসরণ করতে হবে।
— জোনাথন অ্যালান
আমাকে ক্ষমা কর. আমি কেবল কোডটি দেখছিলাম উদাহরণগুলি নয়।
7

রেটিনা, 50 41 26 বাইট

15 (!) বাইট সংরক্ষণের জন্য মার্টিন ইন্ডারকে ধন্যবাদ

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

একটি নতুন লাইনের দ্বারা পৃথক দুটি স্ট্রিংয়ের সাথে ইনপুট নেয়:

Test
Testing

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

M&!r`.+

প্রথম লাইন উভয় শব্দের "পদক্ষেপ" উত্পন্ন করে:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mম্যাচ মোডের জন্য, &ওভারল্যাপিং ম্যাচগুলিকে বিবেচনা করে এবং !সেগুলির সংখ্যার পরিবর্তে ম্যাচগুলি মুদ্রণ করে। এটির বিপরীত কারণ হ'ল স্পষ্ট r-থেকে-বাম বিকল্প: ইঞ্জিনটি স্ট্রিংয়ের শেষে ম্যাচগুলি সন্ধান করতে শুরু করে এবং শুরুতে অগ্রসর হয়।

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

এটি যথাযথ ক্রমে সমস্ত কিছু পায়: এটি Oপরবর্তী রেজেক্সের সমস্ত মিল মেলে: তার নিজস্ব লাইনে একটি চরিত্র এবং তার পরে প্রতিটি চরিত্র (নিউলাইনগুলি সহ), যা পুরো দ্বিতীয়ার্ধটিকে এক খণ্ড হিসাবে মিলায়, বা অন্যথায় অক্ষরের একটি লাইন , যা প্রতিটি পৃথক লাইনের সাথে মেলে। এই ম্যাচগুলি তারপরে কোড পয়েন্ট অনুসারে বাছাই করা হয়, তাই টি লাইন অনুসরণ করে প্রথমে লাইন অনুসরণ করে লম্বা দ্বারা আরোহণ করে।

A1`

এখন আমাদের উপরে প্রথম অক্ষরের রেখাটি রয়েছে তাই আমরা Aডিফল্ট রেজেক্সের প্রথম ম্যাচটি বাতিল করতে এনটিগ্রিপ মোড ব্যবহার করি .+।

পুরনো সংস্করণ

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

এই সংস্করণটি অনলাইনে ব্যবহার করে দেখুন!

ব্যাখ্যা

প্রথম লাইনটি একই, সুতরাং উপরের জন্য ব্যাখ্যাটি দেখুন।

O`\G..+¶

এটি প্রথমার্ধের (দ্বিতীয় ইনপুট শব্দ) লাইনগুলিকে বিপরীত করে। এটি প্রকৃতপক্ষে Oলাইনগুলিকে আর্টস করে এবং রেজেক্স ম্যাচগুলিকে সীমাবদ্ধ করে: এটি অবশ্যই দুটি বা ততোধিক অক্ষরের একটি লাইন হতে হবে ( ..+) এর পরে একটি নতুন লাইন ( ) শুরু হবে যেখানে শেষটি ছেড়ে গিয়েছিল ( \G)। উপরের উদাহরণে, Tমাঝের এককটি মেলে না, সুতরাং এটির পরে আর কিছুই না।

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

এখন আমাদের সঠিক দুটি উপাদান রয়েছে তবে ভুল ক্রমে।

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

¶.¶মাঝখানে একাকী টিয়ের সাথে মেলে যা আমাদের প্রয়োজন হয় না তবে দুটি অংশ পৃথক করে। দুজন (.*)আগে এবং পরে সমস্ত কিছু ক্যাপচার করে, sইনলাইন-লাইন মোডকে নতুন লাইনের ধন্যবাদ সহ । দুটি ক্যাপচারের মাঝখানে একটি নতুন লাইনের সাথে সঠিক ক্রমে প্রতিস্থাপন করা হয়।

Now we're done, unless the input strings are one character long, in which case the input hasn't changed. To get rid of the duplicate, we replace ¶.$ (when the last line of the string a single character) with nothing.

— NinjaBearMonkey
সূত্র
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

Takes two inputs, each surrounded by quotes.

Thanks @JonathanAllan for saving some bytes and pointing out a bug.

— atlasologist
সূত্র
1
No need for the len(x) in x=x[:len(x)-1] since negative offset slicing works - you can just write x=x[:-1]. Only problem is your code wont handle the " ", " " test case very well.
— Jonathan Allan
1
You can drop the second input() and use an input format like "<str1>", "<str2>"
— LevitatingLion
You could change the second line to for i in range(x):print x[-i:], and the fourth line to for i in range(1,y):print y[:-i]. Not sure it would work, though.
— clismique
4

Perl, 34 28 bytes

Includes +2 for -0n

Run with the strings on separate lines on STDIN:

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

slow.pl:

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

Let regex backtracking do the work...

— Ton Hospel
সূত্র
3

Brachylog, 32 bytes

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

Try it online!

Explanation

Brachylog has no prefix built-in, therefore we will get the prefixes by using concatenate (See predicate 2): a prefix of S is P if P concatenated to Q (whatever it is) results in S.

  • Main predicate:

    :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

  • Predicate 1:

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

  • Predicate 2:

    ~c[A:B]               Input is the result of concatenating A to B
       h              Output is A
— Fatalize
সূত্র
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):''

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

Output:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Original answer

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

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

Update

  • Removed s variable, saved 9 bytes

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

Usage:

$ java E 'test' 'testing'
test
tes
te
t
te
tes
test
testi
testin
testing
— Master_ex
সূত্র
3

Haskell, 54 53 47 bytes

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

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

Some pointfree magic. It's the same as f x y = (init(t x))++reverse (t y) where t makes a list of all initial substrings e.g. t "HI!" -> ["H","HI","HI!"].

— nimi
সূত্র
Hm, t=reverse.tail.inits?
— Bergi
@Bergi: sure, but inits needs import Data.List.
— nimi
3

GNU sed, 57 45 + 2(rn flags) = 47 bytes

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

Run:

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

The input should be the two strings separated by a newline. The code is run by sed for each line.

The loop : deletes one character from the end of the string iteratively. The output related to the first string is printed directly, except the first character: 1{/../p}. The output for the second string is stored in hold space in reverse order (2G;2h) during deletion and printed at the end.

— seshoumara
সূত্র
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);}

Try it online!

The first loop overwrites the string with 0 bytes starting from the end, and uses puts() to print the string. The second loop can't just overwrite from the beginning, it has to store the old value so it can put it back; the 0 byte is just walking towards the end.

Thanks to @homersimpson and @ceilingcat for each shaving off 2 bytes!

— G. Sliepen
সূত্র
1
You can save a couple bytes by declaring n as a global int like: n;f(char*a,char*b){n=strlen(a).... And you can probably do n=*a=0 as a chained assignment in the body of your for loop.
— homersimpson
Thanks @homersimpson. But n=*a=0 is not the same as 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))

Thanks to @DJMcMayhem for golfing 21 bytes off.

Ideone it!

— Beta Decay
সূত্র
1
You can take 5 bytes of if you do n='\n' and use n instead of '\n'. You could take another 8 off if you used a lambda instead of printing: 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

Uses false string to whittle down the original string

Abuses substring with larger numbers to grow the second one, stops when its about to print the same word as last time.

(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
সূত্র
1
it's 1 byte shorter to do a=>b=>... and call the function with (a)(b)
— Zwei
2

Brainfuck, 38 55 bytes

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

Edit: included newlines in output

— Jeff
সূত্র
I can't get your code to work. Is the input separated by a new line? Which interpreter are you using?
— acrolith
2

Dyalog APL, 20 13 bytes

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

↑ matrify

(⌽,\⍞) reversed (⌽) cumulative concatenation (,\) of character input (⍞)

, prepended to

1↓ one element dropped from

,\⍞ cumulative concatenation of character input

TryAPL online!

— Adám
সূত্র
2

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

Testing: 

(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
সূত্র
It should delete last character from input string, not the first one.
— 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)

It's a start. Takes the input from STDIN.

Testcases

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

Input: O O
Output: O
— Yytsi
সূত্র
1

JavaScript (ES6), 92 bytes

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

The replace statements build up a triangle of strings, which is exactly what's required for the second half of the output, however the first half needs to be reversed and the duplicate single-character line removed. Note: outputs a leading newline if the first string is a single character. If this is undesirable then for an extra byte this version always outputs a trailing newline:

(s,t)=>s.replace(/./g,`
$\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,`
$\`$&\n`)
— Neil
সূত্র
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))}

Provide f(char* str1, char* str2).

— Keyu Gan
সূত্র
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

Example usage

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

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 test program

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
সূত্র
1

(Lambdabot) Haskell - 41 bytes

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

More readable, but two bytes longer:

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


Output:

f "Hello" "Hi!"
["Hello","Hell","Hel","He","H","Hi","Hi!"]
— BlackCap
সূত্র
1

J, 18 bytes

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

Ungolfed:

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

This is a 7-train:

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

The innermost train [: |. ]\@[ consists of a cap [: on the left, so we apply |. (reverse) to the result of ]\@[, which is ]\ (prefixes) over [ (left argument).

Here's what that looks like on the testing, test input:

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

This gives us the first portion, almost. The 5-train outside of that is ([: }: ([: |. ]\@[)), which applies }: (betail, remove last element) to the above expression:

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

(This is because we can't have a duplicate midpoint.)

The outer part is finally:

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

This is composed of ]\@] (prefixes of left argument) and ,~ (append what's to the left with what's to the right), leaving us with the desired result:

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

Test cases

   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
সূত্র
You can rearrange it to 14 bytes using (,~}:@|.)&(]\)
— 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 (not working with strings containing 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)." ";
— Crypto
সূত্র
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
সূত্র
1

brainfuck, 162 bytes

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

Try it here

Input takes the two strings separated by a linefeed.

First program with brianfuck and first code golf so I'm sure there is plenty of optimization to be done. Had fun doing it though.

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
সূত্র
Welcome to PPCG! Impressive first post!
— Rɪᴋᴇʀ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.