Các thách thức

Cho hai chuỗi / một chuỗi các chuỗi, xuất chuỗi đầu tiên từ từ co lại và mở rộng trở lại chuỗi thứ hai.

Bạn có thể giả sử các chuỗi sẽ luôn bắt đầu với cùng một ký tự.

Thí dụ

Input:
"Test", "Testing"

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

Đầu tiên bạn xuất từ ​​đầu tiên:

Test

Sau đó, bạn tiếp tục xóa một chữ cái cho đến khi chuỗi dài một ký tự:

Tes
Te
T

Sau đó tiếp tục thêm một chữ cái của từ thứ hai cho đến khi hoàn thành:

Te
Tes
Test
Testi
Testin
Testing

(nếu cả hai chuỗi dài một ký tự, thì chỉ cần xuất một trong số chúng một lần.)

Các trường hợp thử nghiệm

"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

(lưu ý: trên không gian / trường hợp thử nghiệm thứ tư, thay thế S bằng dấu cách)

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng! Tiebreaker là bài viết nâng cao nhất. Người chiến thắng sẽ được chọn vào ngày 09/10/2016.

• Sơ hở tiêu chuẩn bị cấm.

Bình thường, 9 byte

j+_._Et._

Một chương trình lấy chuỗi thứ hai, rồi chuỗi thứ nhất, như chuỗi được trích dẫn trên STDIN và in kết quả.

Dùng thử trực tuyến

Làm thế nào nó hoạt động

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 byte

òYp$xhòjòÄ$xhh

Hãy thử trực tuyến!

Giải trình:

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

Bây giờ, bộ đệm trông như thế này:

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

Chúng ta chỉ cần làm điều tương tự ngược lại cho dòng tiếp theo:

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.

Giải pháp thay thế thú vị hơn :

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

Python, 93 byte

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)

Bắt đầu với chuỗi trống r, thêm avà một dòng mới và xóa ký tự cuối cùng acho đến khi atrống, sau đó thêm các phần cần thiết bvà một dòng mới bằng cách giữ một bộ đếm, ibắt đầu từ 2khi bvượt quá độ dài , sau đó trả về r. Có một dòng mới.

Tất cả các bài kiểm tra là trên ideone

05AB1E , 9 byte

.pRI.p¦«»

Giải trình

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

Hãy thử trực tuyến!

Võng mạc, 50 41 26 byte

Cảm ơn Martin Ender đã lưu 15 byte (!).

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

Đưa đầu vào với hai chuỗi được phân tách bằng một dòng mới:

Test
Testing

Hãy thử trực tuyến!

Giải trình

M&!r`.+

Dòng đầu tiên tạo ra "các bước" của cả hai từ:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mdành cho chế độ đối sánh, &xem xét các kết quả trùng lặp và !in các kết quả trùng khớp thay vì số lượng của chúng. Lý do nó bị đảo ngược là rtùy chọn ight-to-left: động cơ bắt đầu tìm kiếm các kết quả khớp ở cuối chuỗi và tiếp tục về đầu.

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

Điều này có được mọi thứ theo đúng thứ tự: đó là Otất cả các trận đấu của regex tiếp theo: Một ký tự trên dòng riêng của nó và mọi ký tự (bao gồm cả dòng mới) sau nó, khớp với toàn bộ nửa thứ hai dưới dạng một đoạn, hoặc nói cách khác là một dòng ký tự , phù hợp với từng dòng riêng lẻ. Các kết quả khớp này sau đó được sắp xếp theo điểm mã, do đó T theo dòng mới đi trước, theo sau là các dòng, tăng dần theo chiều dài.

A1`

Bây giờ chúng tôi chỉ có dòng ký tự đầu tiên trên đầu vì vậy chúng tôi sử dụng Achế độ ntigrep để loại bỏ kết quả khớp đầu tiên của regex mặc định .+.

Phiên bản cũ

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

Hãy thử phiên bản trực tuyến này!

Giải trình

Dòng đầu tiên là như nhau, vì vậy hãy xem giải thích cho điều đó ở trên.

O`\G..+¶

Điều này đảo ngược các dòng của nửa đầu (từ đầu vào thứ hai). Nó thực sự là Ocác dòng và regex giới hạn các kết quả khớp: nó phải là một dòng gồm hai hoặc nhiều ký tự ( ..+) theo sau là một dòng mới ( ¶) bắt đầu ở nơi cuối cùng rời khỏi ( \G). Trong ví dụ trên, đĩa đơn Tở giữa không khớp, vì vậy không có gì sau nó có thể.

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

Bây giờ chúng ta có hai thành phần đúng, nhưng theo thứ tự sai.

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

¶.¶khớp với chữ T đơn độc ở giữa, thứ mà chúng ta không cần nhưng tách hai phần. Cả hai (.*)nắm bắt mọi thứ trước và sau, bao gồm cả dòng mới nhờ schế độ ingle-line. Hai ảnh chụp được thay thế theo đúng thứ tự với một dòng mới ở giữa.

Bây giờ chúng ta đã hoàn thành, trừ khi các chuỗi đầu vào dài một ký tự, trong trường hợp đó, đầu vào không thay đổi. Để loại bỏ trùng lặp, chúng ta thay thế ¶.$(khi dòng cuối cùng của chuỗi một ký tự) không có gì.

Python 2, 88 82 byte

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

Có hai đầu vào, mỗi đầu vào được bao quanh bởi dấu ngoặc kép.

Cảm ơn @Jonathan ALLan vì đã lưu một số byte và chỉ ra một lỗi.

Perl, 34 28 byte

Bao gồm +2cho-0n

Chạy với các chuỗi trên các dòng riêng biệt trên STDIN:

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

slow.pl:

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

Hãy để regex backtracking thực hiện công việc ...

Cheddar , 76 byte

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

Một chút lâu hơn tôi muốn. Tôi sẽ thêm một lời giải thích sớm

Hãy thử trực tuyến!

Brachylog , 32 byte

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

Hãy thử trực tuyến!

Giải trình

Brachylog không có tiền tố tích hợp, do đó chúng tôi sẽ nhận được các tiền tố bằng cách sử dụng concatenate(Xem vị ngữ 2): tiền tố Slà Pnếu được Pnối với Q(bất kể đó là gì) dẫn đến S.

• Vị ngữ chính:

  :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
  

• Vị ngữ 1:

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

• Vị ngữ 2:

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

Javascript, 103 81 byte

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

Thí dụ: f("Test", "Testing")

Đầu ra:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Câu trả lời gốc

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 byte

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

Cập nhật

• Đã xóa biến s, lưu 9 byte

Ung dung :

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

Cách sử dụng :

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

Haskell, 54 53 47 byte

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

Ví dụ sử dụng: ((.reverse.t).(++).init.t) "Hello" "Hi!"-> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

Một số phép thuật vô nghĩa. Nó giống như f x y = (init(t x))++reverse (t y)nơit tạo ra một danh sách tất cả các chuỗi con ban đầu, ví dụ t "HI!"-> ["H","HI","HI!"].

Pyke, 14 byte

VDO)KKQlFh<)_X

Hãy thử nó ở đây!

Và 17 byte chỉ vì đó là một giải pháp tuyệt vời:

mVDO)Fto!I_O(RKsX

Hãy thử nó ở đây!

GNU sed, 57 45 + 2 (cờ rn) = 47 byte

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

Chạy:

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

Đầu vào phải là hai chuỗi cách nhau bởi một dòng mới. Mã được chạy bởi sed cho mỗi dòng.

Vòng lặp :xóa một ký tự từ cuối chuỗi lặp. Đầu ra liên quan đến chuỗi đầu tiên được in trực tiếp, ngoại trừ ký tự đầu tiên : 1{/../p}. Đầu ra cho chuỗi thứ hai được lưu trữ trong không gian giữ theo thứ tự ngược lại ( 2G;2h) trong khi xóa và được in ở cuối.

C (gcc) , 102 97 95 93 byte

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

Hãy thử trực tuyến!

Vòng lặp đầu tiên ghi đè chuỗi có 0 byte bắt đầu từ cuối và sử dụng puts() để in chuỗi. Vòng lặp thứ hai không thể ghi đè ngay từ đầu, nó phải lưu trữ giá trị cũ để có thể đặt lại; 0 byte chỉ là đi về phía cuối.

Cảm ơn @homersimpson và @ceilingcat cho mỗi lần cạo 2 byte!

Python 3, 104 byte

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

Cảm ơn @DJMcMayhem vì đã chơi golf 21 byte.

Nghĩa là nó!

REPL / Javascript, 109 byte

Sử dụng chuỗi sai để giảm chuỗi gốc

Lạm dụng chuỗi con với số lượng lớn hơn để tăng số thứ hai, dừng lại khi nó sắp in cùng một từ như lần trước.

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

Bản giới thiệu:

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

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

Chỉnh sửa: bao gồm các dòng mới trong đầu ra

Thuốc nhuộm APL , 20 13 byte

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

↑ hôn nhân

(⌽,\⍞) đảo ngược (⌽ tích lũy ) tích lũy ( ,\) của ký tự đầu vào ( ⍞)

, dự kiến

1↓ một yếu tố rơi từ

,\⍞ tích lũy nối của đầu vào ký tự

Dùng thử trực tuyến!

Vợt 193 byte

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

Kiểm tra:

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

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)

Đó là một sự khởi đầu. Lấy đầu vào từ STDIN.

Tủ thử

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,`
$\`$&`)

Các replacecâu lệnh xây dựng một tam giác chuỗi, chính xác là những gì cần thiết cho nửa sau của đầu ra, tuy nhiên nửa đầu cần phải được đảo ngược và xóa dòng ký tự đơn trùng lặp. Lưu ý: xuất ra một dòng mới hàng đầu nếu chuỗi đầu tiên là một ký tự đơn. Nếu điều này là không mong muốn thì đối với một byte bổ sung, phiên bản này luôn xuất ra một dòng mới:

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

C, 142 byte

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

Cung cấp f(char* str1, char* str2).

TI-Basic, 56 byte

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

Ví dụ sử dụng

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 byte

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

Chương trình thử nghiệm

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 byte

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

Dễ đọc hơn, nhưng hai byte dài hơn:

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

Đầu ra:

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

J, 18 byte

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

Ung dung:

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

Đây là 7 chuyến tàu:

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

Tàu trong cùng [: |. ]\@[bao gồm một nắp [:ở bên trái, vì vậy chúng tôi áp dụng |.(đảo ngược) cho kết quả của ]\@[, đó là]\ (tiền tố) trên [(đối số bên trái).

Đây là những gì trông giống như trên testing, testđầu vào:

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

Điều này cho chúng ta phần đầu tiên, gần như. Tàu 5 bên ngoài đó là ([: }: ([: |. ]\@[)), áp dụng }:(đặt cược, loại bỏ phần tử cuối cùng) cho biểu thức trên:

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

(Điều này là do chúng ta không thể có một điểm giữa trùng lặp.)

Phần bên ngoài cuối cùng là:

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

Nó bao gồm ]\@] (tiền tố của đối số bên trái) và ,~(nối những gì bên trái với những gì bên phải), để lại cho chúng tôi kết quả mong muốn:

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

Các trường hợp thử nghiệm

   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 byte

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 byte (không hoạt động với chuỗi chứa 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 byte

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

Bài kiểm tra

#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 byte

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

Hãy thử nó ở đây

Đầu vào lấy hai chuỗi được phân tách bằng một dòng cấp.

Chương trình đầu tiên với brianfuck và mã golf đầu tiên vì vậy tôi chắc chắn có rất nhiều tối ưu hóa phải được thực hiện. Có niềm vui khi làm điều đó mặc dù.

Ung dung

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