Медленно превратить строку в другую

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

(примечание: в пробеле / ​​четвертом контрольном примере замените S пробелами)

правила

  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах! Tiebreaker - самая популярная публикация. Победитель будет выбран 09.10.2016.

  • Стандартные лазейки запрещены.

code-golf string акролит
источник
Будут ли разрешены 2 конечных символа новой строки (одна видимая пустая строка после последовательности) или нет?
Сешумара

Ответы:

11

Pyth, 9 байт

j+_._Et._

Программа, которая принимает вторую строку, а затем первую строку в виде строк в кавычках в STDIN и печатает результат.

Попробуйте онлайн

Как это работает

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

V , 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
DJMcMayhem
источник
3
Это как будто vim всегда правильный инструмент для работы
Downgoat
@ Downgoat Точно. Вот почему вы должны начать играть в гольф в V.: P
DJMcMayhem
9

Python, 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все равно будет работать.
Спасибо @JackBates. 1. Исправьте и обновите - я наверное забыл f=. 2. Без r=''настоящего f('test','testing')не будет работать; да f('test','testing',''), но мы должны следовать спецификациям.
Джонатан Аллан
Прости меня. Я просто смотрю на код, а не на примеры.
7

Retina, 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все совпадения последующего регулярного выражения: символ в отдельной строке и каждый символ (включая символы новой строки) после него, который соответствует всей второй половине как один фрагмент, или иначе строка символов , который соответствует каждой отдельной строке. Эти совпадения затем сортируются по кодам, поэтому буква T, за которой следует новая строка, идет первой, а затем строки по возрастанию по длине.

A1`

Теперь у нас есть только первая строка символов сверху, поэтому мы используем Aрежим ntigrep, чтобы отменить первое совпадение регулярного выражения по умолчанию .+.

Старая версия

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

¶.¶соответствует одиночке T посередине, которая нам не нужна, но разделяет две части. Они (.*)захватывают все до и после, в том числе и sновые строки благодаря режиму сингла. Два снимка заменяются в правильном порядке с новой строки между ними.

Теперь мы закончили, если только входные строки не состоят из одного символа, в этом случае ввод не изменился. Чтобы избавиться от дубликата, мы заменяем ¶.$(когда в последней строке строки один символ) ничего.

NinjaBearMonkey
источник
4

Python 2, 88 82 байта

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

Принимает два входа, каждый в кавычках.

Спасибо @JonathanAllan за сохранение некоторых байтов и указание на ошибку.

atlasologist
источник
1
Нет необходимости len(x)в x=x[:len(x)-1]In, так как срезы с отрицательным смещением работает - вы можете просто написать x=x[:-1]. Единственная проблема в том, что ваш код не " ", " "очень хорошо справляется с тестовым примером.
Джонатан Аллан
1
Вы можете отбросить второй input()и использовать формат ввода, например"<str1>", "<str2>"
LevitatingLion
Вы можете изменить вторую строку на for i in range(x):print x[-i:], а четвертую строку на for i in range(1,y):print y[:-i]. Не уверен, что это сработает.
clismique
4

Perl, 34 28 байт

Включает +2в себя для-0n

Запустите строки в отдельных строках на STDIN:

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

slow.pl:

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

Пусть regex backtracking сделает всю работу ...

Тон Хоспел
источник
3

Чеддер , 76 байт

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

Чуть дольше, чем мне бы хотелось. Я скоро добавлю объяснение

Попробуйте онлайн!

Downgoat
источник
Что делает |>?
Cyoce
@Cyoce unary |> - диапазон [0, n), двоичный файл - [a, b]
Downgoat
3

Брахилог , 32 байта

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

Попробуйте онлайн!

объяснение

Brachylog не имеет встроенного префикса, поэтому мы получим префиксы с помощью concatenate(См. Предикат 2): префикс Sis, Pесли Pобъединяется с Q(каким бы он ни был), приводит к S.

  • Основной предикат:

    :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

  • Предикат 1:

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

  • Предикат 2:

    ~c[A:B]               Input is the result of concatenating A to B
       h              Output is A
Fatalize
источник
3

Javascript, 103 81 байт

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

Пример: f("Test", "Testing")

Выход:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Оригинальный ответ

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)):''
Хеди
источник
3

Ява, 188 179 байт

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

Обновить

  • Удалена переменная s, сохранено 9 байт.

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

Использование :

$ java E 'test' 'testing'
test
tes
te
t
te
tes
test
testi
testin
testing
Master_ex
источник
3

Haskell, 54 53 47 байт

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

Пример использования: ((.reverse.t).(++).init.t) "Hello" "Hi!"-> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

Некоторая бессмысленная магия. Это то же самое, что и f x y = (init(t x))++reverse (t y)где tсоставляется список всех исходных подстрок, например t "HI!"-> ["H","HI","HI!"].

Ними
источник
Хм t=reverse.tail.inits?
Берги
@ Берги: конечно, но initsнужно import Data.List.
Nimi
3

GNU sed, 57 45 + 2 (рН-флаги) = 47 байт

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

Бег:

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

На входе должны быть две строки, разделенные новой строкой. Код запускается с помощью sed для каждой строки.

Цикл :итеративно удаляет один символ из конца строки. Выход связан с первой строки печатается непосредственно, за исключением первого символа: 1{/../p}. Вывод для второй строки сохраняется во 2G;2hвремя удаления в обратном порядке ( ) во время удаления и печатается в конце.

seshoumara
источник
3

C (gcc) , 102 97 95 93 байта

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

Попробуйте онлайн!

Первый цикл перезаписывает строку с 0 байтами, начиная с конца, и использует ее puts()для печати строки. Второй цикл не может просто перезаписать с самого начала, он должен хранить старое значение, чтобы он мог вернуть его обратно; 0 байт просто идет к концу.

Спасибо @homersimpson и @ceilingcat за каждое бритье на 2 байта!

Г. Слипен
источник
1
Вы можете сэкономить пару байт, объявляя в nкачестве глобального междунар как: n;f(char*a,char*b){n=strlen(a).... И вы, вероятно, можете сделать это n=*a=0как цепочечное задание в теле вашего цикла for.
homersimpson
Спасибо @homersimpson. Но n = * a = 0 - это не то же самое, что n = * a, * a = 0.
Г. Слипен
2

Python 3, 104 байта

Мех.

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

Спасибо @DJMcMayhem за игру в гольф на 21 байт.

Идео это!

Бета распад
источник
1
Вы можете взять 5 байтов, если вы делаете n='\n'и использовать n вместо '\n'. Вы могли бы снять еще 8, если бы вместо печати использовали лямбду: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 байт

Использует ложную строку, чтобы уменьшить исходную строку

Злоупотребляет подстрокой с большими числами для увеличения второй, останавливается, когда собирается напечатать то же слово, что и в прошлый раз.

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

Демо-версия:

> ((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
Вартан
источник
1
это на 1 байт короче, чтобы сделать a=>b=>...и вызвать функцию с (a) (b)
Zwei
2

Brainfuck, 38 55 байт

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

Изменить: включены новые строки в выводе

Джефф
источник
Я не могу заставить твой код работать. Разделен ли ввод новой строкой? Какой переводчик вы используете?
Акролит
2

Dyalog APL , 20 13 байтов

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

↑ matrify

(⌽,\⍞)reversed ( ⌽) совокупная конкатенация (,\ ) ввода символов ( ⍞)

, приурочен к

1↓ один элемент выпал из

,\⍞ кумулятивная конкатенация ввода символов

Попробуй APL онлайн!

Адам
источник
2

Ракетка 193 байта

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

Тестирование: 

(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
источник
Следует удалить последний символ из входной строки, а не первый.
Агилоб
2

Флорид , 69 байт

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)

Это начало. Принимает вход от 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 байта

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

Эти replaceоператоры образуют треугольник строк, который является именно тем, что требуется для второй половины вывода, однако первую половину необходимо перевернуть и удалить дублирующую односимвольную строку. Примечание: выводит начальный символ новой строки, если первая строка представляет собой один символ. Если это нежелательно, то для дополнительного байта эта версия всегда выводит завершающий символ новой строки:

(s,t)=>s.replace(/./g,`
$\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,`
$\`$&\n`)
Нил
источник
1

C, 142 байта

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

Обеспечить f(char* str1, char* str2).

Кейу Ган
источник
1

TI-Basic, 56 байт

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

Пример использования

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

Ява, 168 136 байт

(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

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

}
Шон Уайлд
источник
1

(Lambdabot) Haskell - 41 байт

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

Более читаемый, но на два байта длиннее:

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


Выход:

f "Hello" "Hi!"
["Hello","Hell","Hel","He","H","Hi","Hi!"]
судейская шапочка
источник
1

J, 18 байт

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

Ungolfed:

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

Это 7 поезд

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

Самая внутренняя [: |. ]\@[последовательность состоит из верхнего колпачка [:слева, поэтому мы применяем |.(реверс) к результату ]\@[, который является ]\(префиксы) над [(левый аргумент).

Вот как это выглядит на testing, testвходе:

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

Это дает нам первую порцию, почти. 5-поезд вне этого ([: }: ([: |. ]\@[)), который применяется }:(betail, удалить последний элемент) к вышеприведенному выражению:

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

(Это потому, что у нас не может быть дубликата средней точки.)

Внешняя часть наконец-то:

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

Это состоит из ]\@](префиксы левого аргумента) и ,~(добавьте то, что слева, а что справа), оставляя нам желаемый результат:

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

Контрольные примеры

   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
Конор О'Брайен
источник
Вы можете изменить его на 14 байтов, используя(,~}:@|.)&(]\)
миль
1

PHP, 117 109 байт

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 байт (не работает со строками, содержащими 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)." ";
крипто-
источник
1

C 111 байтов

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

Тест на недолговечность

#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

брейкфук, 162 байта

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

Попробуй здесь

Ввод принимает две строки, разделенные переводом строки.

Первая программа с brianfuck и первым гольф-кодом, так что я уверен, что предстоит много оптимизации. Хотя было весело делать это.

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
источник
Добро пожаловать в PPCG! Впечатляющий первый пост!
R