等等.....这不是拖钓。

背景

如今，在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或某种东西，并且OP通常会成功聚集许多喜欢的对象。

任务

尽管您凭借出色的高尔夫技巧在PPCG上积累了丰富的才能，但您绝对不是在YouTube评论部分发表机智的言论或引用模因的最佳选择。因此，您在YouTube上经过深思熟虑而提出的建设性评论几乎没有“喜欢”。您想要改变。因此，您可以采用上述陈词滥调的模式来实现自己的最终目标，而又不浪费任何时间手动编写它们。

简而言之，您的任务是获取一个字符串，例如s，并输出的2*s.length - 1子字符串s，以换行符分隔，以符合以下模式：

（用于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（旧版）， 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每一行。DOS API的字符串显示函数（INT 21H,9）将一个- $终止的字符串写入屏幕，因此，每次循环时，最后一个要显示的字符将与字符串结尾终止符交换。

将循环计数器与字符串长度进行比较，如果长度更大（表示输出的升序部分），则字符串/交换位置递增，否则递减（实际上，-1-1+1字节数比if / else分支结构少）。

独立的可执行程序，从命令行获取输入字符串。

输出量

下载YT2.COM（43字节）

• -1个字节感谢gastropner！

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

蒂奥

哈斯克尔， 52 50 44个字节

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

• -2字节，由ØrjanJohansen的技巧变体
• 通过-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感谢尼克·肯尼迪和Giuseppe的举动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提出的另一种方法是;\ŒḄ，该方法可累计减少（\）级联（;），这是生成前缀的另一种方法。

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字节

Ｇ^Ｌθθ

在线尝试！链接是详细版本的代码。说明：Ｇ绘制一个填充的多边形，^指定边在右下和左下（然后多边形自动关闭），Ｌθ将这些边的长度θ指定为原始输入的长度，而final 指定填充字符串。

C＃（Visual C＃中交互式编译器），123个 109 94 84 74字节

假设我们可以返回一个char数组数组（我相信可以，因为char数组是字符串的有效表示形式，而string数组是多行的有效表示形式）

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上评论的最大长度为10,000个字符。好的，将其用作上限。

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

在线尝试！

感谢-2个字节的Doorknob。

JavaScript（Node.js），90字节

这可能可以打更多次，Arnauld已经有一个短一点的方法，但是我至少乐在其中！

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

在线尝试！

SNOBOL4（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导致错误，尽管对于香草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])

在线尝试！

输入是a string，输出是aseq<string>

另一个解决方案可能是let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]80ish字节...我不确定是否值得研究。

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的第一个答案！

由于@ SriotchilismO'Zaic，整体-47字节

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个字节

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

在线尝试！

比Adám还长1个字节

K（oK），12 11字节

-1个字节感谢ngn

{x,1_|x}@,\

在线尝试！