Подожди ..... это не троллинг.

Фон

В эти дни на YouTube разделы комментариев завалены такими шаблонами:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

где String- просто заполнитель и относится к любой комбинации символов. Эти паттерны обычно сопровождаются чем-то It took me a lot of time to make this, pls likeили чем-то, и часто ФП удается накапливать множество лайков.

Задание

Несмотря на то, что вы обладаете огромным талантом накапливать отклики на PPCG с помощью своих очаровательных навыков игры в гольф, вы определенно не лучший выбор для создания остроумных замечаний или ссылок на мемы в разделах комментариев YouTube. Таким образом, ваши конструктивные комментарии, сделанные с осознанной мыслью, на YouTube набирают от нескольких до «лайков». Вы хотите, чтобы это изменилось. Таким образом, вы прибегаете к созданию вышеупомянутых шаблонов клише для достижения ваших конечных амбиций, но не теряете времени, пытаясь написать их вручную.

Проще говоря, ваша задача - взять строку, скажем s, и вывести 2*s.length - 1подстроки s, разделенные новой строкой, чтобы соответствовать следующему шаблону:

(for s= "Hello")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

вход

Одна строка s. Входные значения по умолчанию сообщества применяются. Вы можете предположить, что входная строка будет содержать только печатные символы ASCII.

Выход

Несколько строк разделены новой строкой, образуя соответствующий шаблон, как описано выше. Выходные значения по умолчанию сообщества применяются. Допускаются начальные и конечные пробелы (не содержащие символов или символов, которые нельзя увидеть, например, пробел) в выходных данных.

Прецедент

Тестовый набор из нескольких слов:

Input => "Oh yeah yeah"

Output =>

O
Oh
Oh 
Oh y
Oh ye
Oh yea
Oh yeah
Oh yeah 
Oh yeah y
Oh yeah ye
Oh yeah yea
Oh yeah yeah
Oh yeah yea
Oh yeah ye
Oh yeah y
Oh yeah 
Oh yeah
Oh yea
Oh ye
Oh y
Oh 
Oh
O

Обратите внимание, что в форме выходных данных вышеприведенного тестового примера имеются явные искажения (например, вторая и третья строки выходных данных выглядят одинаково). Это потому, что мы не можем видеть конечные пробелы. Ваша программа не должна пытаться исправить эти искажения.

Критерий победы

Это код-гольф , поэтому выигрывает самый короткий код в байтах на каждом языке!

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

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

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

Один и тот же цикл используется для обеих половин шаблона.

Объяснение:

,             Take first input character as initial line
[             Until line to output is empty:
  [<]>        Move to beginning of line
  [.>]        Output all characters in line
  ++++++++++. Output newline
  ,           Input next character
  [>>]        Move two cells right if input character nonzero
  <[-]        Otherwise remove last character in line
  <           Move to new last character in line
]

JavaScript (ES6), 36 байт

f=([c,...r],s=`
`)=>c?s+f(r,s+c)+s:s

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

комментарии

f = (             // f is a recursive function taking:
                  //   the input string split into:
  [c,             //     c   = next character (may be undefined if we've reached the end)
      ...r],      //     r[] = array of remaining characters
  s = `\n`        //   the output string s, initialized to a linefeed
) =>              // 
  c ?             // if c is defined:
    s +           //   append s (top of the ASCII art)
    f(r, s + c) + //   append the result of a recursive call to f, using r[] and s + c
    s             //   append s again (bottom of the ASCII art)
  :               // else:
    s             //   append s just once (this is the final middle row) and stop recursion

05AB1E (legacy) ,  4  3 байта

^{Вычеркнуто  4 уже не 4 :)}

η.∊

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

η     # Get the prefixes of the (implicit) input-string
 .∊   # Vertically mirror everything with the last line overlapping
      # (which implicitly joins by newlines in the legacy version of 05AB1E)
      # (and output the result implicitly)

В новой версии 05AB1E »требуется явное указание после η, поэтому я использую устаревшую версию 05AB1E для сохранения байта.

IBM PC DOS, сборка 8088,  44  43

d1ee ad8b d6b4 0948 8af8 8ac8 d0e1 49b3 243a cf7d 024e
4e46 861c cd21 861c 52ba 2901 cd21 5ae2 eac3 0d0a 24

разобранное:

    SHR  SI, 1              ; point SI to DOS PSP at 80H (SI intialized at 100H)
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  DX, SI             ; save start of string pointer
    MOV  AH, 9              ; DOS API display string function
    DEC  AX                 ; remove leading space from string length
    MOV  BH, AL             ; save string len in BH (AL gets mangled by INT 21H,9)
    MOV  CL, AL             ; set up loop counter in CL
    SHL  CL, 1              ; number of lines = 2 * string length - 1
    DEC  CX
    MOV  BL, '$'            ; end of string marker
LINE_LOOP:
    CMP  CL, BH             ; if CL >= string length, ascend
    JGE  ASCEND
    DEC  SI                 ; descend by backing up two places (always increments)
    DEC  SI                 ; (this is fewer bytes than 'SUB SI, 2' or two branches)
ASCEND:
    INC  SI                 ; increment current string position
    XCHG BL, [SI]           ; swap current string byte with end of string delimiter
    INT  21H                ; write substring to console
    XCHG BL, [SI]           ; restore string byte
    PUSH DX                 ; save output string pointer
    MOV  DX, OFFSET CRLF    ; load CRLF string
    INT  21H                ; write to console
    POP  DX                 ; restore output string pointer
    LOOP LINE_LOOP          ; move to next line
    RET
CRLF DB 0DH,0AH,'$'

объяснение

Петля 2 * input length - 1для каждого ряда. Функция отображения строки API DOS ( INT 21H,9) записывает $на экран строку, определяемую окончанием, поэтому каждый раз в цикле символ после последней отображаемой строки заменяется символом конца строки.

Счетчик цикла сравнивается с длиной строки, и, если она больше (имеется в виду восходящая часть вывода), позиция строки / свопа увеличивается, в противном случае она уменьшается (на самом деле это -1-1+1меньше байтов, чем в разветвленной структуре if / else).

Автономная исполняемая программа, принимает входную строку из командной строки.

Выход

Загрузить YT2.COM (43 байта)

• -1 байт благодаря гастропнеру !

Python 2 , 60 52 байта

f=lambda s,n=1:s[n:]and[s[:n]]+f(s,n+1)+[s[:n]]or[s]

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

Python 3.8 (предварительная версия) , 50 байт

f=lambda s,n=1:s>(x:=s[:n])and[x,*f(s,n+1),x]or[s]

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

MATL , 8 байт

nZv"G@:)

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

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

n  % Length of the input string
Zv % Symmetric range ([1 2 ... n ... 1])
"  % For each k in above range
G  % Push input
@: % Push [1 2 ... k]
)  % Index

J 11 байт

Функция анонимного молчаливого префикса. Возвращает заполненную пробелами матрицу символов.

[:(}:,|.)]\

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

]\ список префиксов

[:(... ) применить следующую функцию к этому списку

 |. обратный список

 , с добавлением

 }: свернутый (без последнего элемента) список

Perl 6 , 31 байт

{[\~](@_)[0...@_-1...0]}o*.comb

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

Блок анонимного кода, который принимает строку и возвращает список строк.

Объяснение:

{                      }o*.comb   # Pass the list of characters into the codeblock
 [\~](@_)                 # Triangular reduce by concatenation
                          # e.g. The list [1,2,3,4] turns into [1,12,123,1234]
         [0...@_-1        # Return the elements from 0 to length of string minus 1
                  ...0]   # And back down to 0

Japt -R , 4 байта

å+ ê

Кумулятивное уменьшение по струне.

-1 байт благодаря @Shaggy

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

Japt -R , 9 7 байт

-2 байта благодаря Shaggy

Êõ@¯XÃê

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

Perl 5 ( -p), 26 байт

s,.,$\=$`.$/.$\;"$`$&
",ge

TIO

Haskell, 52 50 44 байта

f x=unlines$init<>reverse$scanr(\_->init)x x

• -2 байта по варианту трюка Орджана Йохансена
• -6 байт, используя в своих интересахinstance Semigroup b => Semigroup (a -> b)

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

R , 79 65 62 58 байт

write(substring(s<-scan(,""),1,c(1:(r=nchar(s)),r-1:r)),1)

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

-14 от превосходного знания функций Джузеппе

-3 с более чистой индексацией

-4 благодаря Ник Кеннеди и Джузеппе переездом в scanиwrite

Избегать петель (и substr) это хорошо.

Желе , 5 4 байта

-1 байт благодаря @JonathanAllan !

¹ƤŒḄ

Попробуйте онлайн! Я думаю, что это мой второй ответ желе? Я не знаю, является ли это оптимальным. Я больше убежден в том, что это оптимально. Возвращает массив строк.

объяснение

¹ƤŒḄ     input: "Hi!"
¹Ƥ       prefixes of the input: [["H"], ["H", "i"], ["H", "i", "!"]]
  ŒḄ     bounce, using each array: [["H"], ["H", "i"], ["H", "i", "!"], ["H", "i"], ["H"]]

Другой подход, предложенный @JonathanAllan, заключается в том ;\ŒḄ, что кумулятивно уменьшает ( \) concatenation ( ;), что является еще одним способом генерирования префиксов.

Python 3.8 (предварительная версия) , 48 байт

lambda s,r='':(l:=[r:=r+c for c in s])+l[-2::-1]

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

Использует выражения присваивания с, :=чтобы накапливать список префиксов, а затем снова, чтобы сохранить результат, чтобы объединить его реверс (без первого символа).

Python 2 , 51 байт

f=lambda s,l=[]:s and f(s[:-1],[s]+l)or l+l[-2::-1]

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

У нас почти есть следующее хорошее 45-байтовое решение, но оно дважды содержит исходную строку, и я не вижу короткого пути, чтобы это исправить.

f=lambda s,l=[]:s and f(s[:-1],[s]+l+[s])or l

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

Древесный уголь , 5 байт

Ｇ^Ｌθθ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение: Ｇрисует заполненный многоугольник, ^указывает, что стороны находятся внизу вправо и вниз влево (многоугольник затем автоматически закрывается сам), Ｌθуказывает длину этих сторон как длину исходного ввода, а финал θзадает строку заливки.

C # (интерактивный компилятор Visual C #) , 123 109 94 84 74 байта

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

a=>new int[a.Length*2-1].Select((b,i)=>a.SkipLast(Math.Abs(a.Length-i-1)))

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

Атташе , 15 байт

Bounce@Prefixes

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

Довольно просто Bounces (добавляет реверс без центра) Prefixesввода.

В качестве альтернативы, 21 байт: Bounce@{_[0..0:~-#_]} повторный префикс.

Brachylog (v2), 6 байт

a₀ᶠ⊆.↔

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

Передача функции, возвращающая массив строк. Свободно, основываясь на ответе @ Fatalize .

объяснение

a₀ᶠ⊆.↔
    .↔  Find a palindrome
   ⊆      that contains, in order,
  ᶠ       all
a₀        prefixes of {the input}

Порядок временного разбиения здесь задается параметром ⊆, который при использовании с этим шаблоном потока предпочитает минимально возможный выходной сигнал, срывая связь, размещая заданные элементы как можно раньше . Кратчайший возможный вывод - это то, что мы хотим здесь (из-за невозможности иметь какие-либо дубликаты префиксов), и размещение данных элементов (то есть префиксов) как можно раньше поместит их в первую половину (с округлением в большую сторону) выход. Учитывая, что мы также требуем, чтобы они были расположены в том же порядке, мы получаем именно тот шаблон, который нам нужен, хотя описание, которое мы дали Brachylog, очень общее; разрывы связей оказываются совершенно правильными, в результате чего Brachylog выбирает нужный нам вывод, а не какой-либо другой вывод, который подчиняется описанию.

PowerShell, 89 87 66 байт

-2 байта благодаря @AdmBorkBork

param($a)0..($d=$a.Length-1)|%{$b+=,-join$a[0..$_]};$b+$b[--$d..0]

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

Это на самом деле не работает, как указано ранее, извините за это! Я отредактировал это и также сумел сбрить некоторые байты.

PowerShell , 46 байт

($l=$args|% t*y|%{($s+=$_);++$i})+$l[$i..0]|gu

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

PowerShell , 42 байта (YouTube особенный, грязный)

Известно, что максимальная длина комментария на YouTube составляет 10000 символов. Хорошо, используйте это как верхний предел.

($l=$args|% t*y|%{($s+=$_)})+$l[1e4..0]|gu

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

APL (Dyalog Unicode) , 9 байтов ^SBCS

Функция анонимного молчаливого префикса. Возвращает список строк.

(⊢,1↓⌽),\

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

,\ список префиксов (горит, накопленная конкатенация)

(… ) Применить к этому списку следующую функцию:

 ⌽ перевернутый список

 1↓ брось первый предмет

 , перед именем

 ⊢ неизмененный список

Рубин , 51 42 40 байт

f=->s,i=1{s[i]?[t=s[0,i],*f[s,i+1],t]:s}

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

Спасибо Doorknob за -2 байта.

JavaScript (Node.js) , 90 байт

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

s=>{a=[];for(c=s.length-1;c--;)a[c]=s.slice(0,c+1);return[...a,s,...a.reverse()].join`\n`}

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

СНОБОЛ4 (CSNOBOL4) , 118 байт

	N =INPUT
	L =1
1	X =LT(X,SIZE(N)) X + 1	:F(D)
O	N ARB . OUTPUT POS(X)	:($L)
D	X =GT(X) X - 1	:F(END)
	L ='D'	:(O)
END

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

Кажется, есть ошибка в этой реализации SNOBOL; попытка заменить ярлык Dна ярлык 2приводит к ошибке, хотя в руководстве для Vanilla SNOBOL это указывается (выделение добавлено)

Если присутствует метка, она должна начинаться с первого символа строки. Метки дают имя для оператора и служат в качестве цели для передачи управления из поля GOTO любого оператора. Метки должны начинаться с буквы или цифры, за которыми может следовать произвольная строка символов. Поле метки завершается символом пробела, табуляции или точки с запятой. Если первый символ строки пустой или табуляция, поле метки отсутствует.

Я предполагаю, что интерпретатор CSNOBOL поддерживает только одну метку, которая начинается с целого числа.

APL + WIN, 31 байт

Запрашивает ввод строки:

 ⊃((⍳n),1↓⌽⍳n)↑¨(¯1+2×n←⍴s)⍴⊂s←⎕

Объяснение:

(¯1+2×n←⍴s)⍴⊂s create a nested vector of the string of length =1+2x length of string

((⍳n),1↓⌽⍳n)↑¨ progressively select elements from each element of the nested vector 
              following the pattern 1  2 ...to n to n-1 ... 1

⊃ convert nested vector into a 2d array.

F # (.NET Core) , 67 61 байт

let l=s.Length
[1..l*2-1]|>Seq.map(fun i->s.[..l-abs(i-l)-1])

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

Вход является, stringа выход являетсяseq<string>

Другое решение может быть let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]для 80-байтовых байтов ... Я не уверен, что это стоит посмотреть.

sed , 31 35 байт

:x
h
s/.\n.*\|.$//
/^$/{x;q}
H
G
bx

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

объяснение

В начале каждой итерации цикла пространство шаблонов представляет собой некоторый «центральный фрагмент» желаемого вывода, и каждый цикл добавляет сокращенную копию вверху и внизу.

:x                 
h                  Copy the current chunk to hold space
s/.\n.*\|.$//      Remove the last letter of the first line, and all other lines (if there are any)
/^$/{x;q}          If pattern space is empty we're done; output hold space
H                  Add the shortened line to the end of hold space
G                  and add the new hold space to pattern space.
bx                 

Python 2 , 131 100 84 байта

Мой первый ответ на Code Golf!

-47 байт в целом благодаря @ SriotchilismO'Zaic

a,b=[],len(x)
for i in range(2*b-1):
 if i<b:a+=x[i]
 else:a=a[:-1]
 print''.join(a)

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

J , 12 байт

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

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

Все еще на 1 байт длиннее, чем у Адама

K (ок) , 12 11 байт

-1 байт благодаря ngn

{x,1_|x}@,\

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