我确实做了一个飞船的花胶！

39

介绍：

受到@MagicOctopusUrn在@Emigna的05AB1E答案中对我的“ 这仅仅是一个错误 ”挑战的评论的启发：

8F9ÝÀNð×ý}».∊我确实做了一个飞船的花胶！我对建议进行12字节的编辑感到非常兴奋。– 魔术章鱼缸 17年7月17日在20:10

这是一个05AB1E（旧版）程序，导致以下结果：

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

在线尝试。

挑战：

输入：非空字符串

输出：从外到内，每行字符之间再增加一个空格，类似于上面的输出，等于length - 1。因此，对于输入1234567890，输出实际上将是以下内容：

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
1         2         3         4         5         6         7         8         9         0
1        2        3        4        5        6        7        8        9        0 
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

为什么？的长度1234567890为10。因此，我们从输出10行开始：第一行不带空格；第二行不带空格。第二个带有一个空格分隔符；第三有二；等等。然后（没有中间length - 1空格重复的行），我们在下降时返回到初始输入。

挑战规则：

  • 输入保证为非空（长度>= 1）。（对于单个字符输入，我们仅输出该字符。）
  • 只要输出本身（在屏幕上的任何位置）都是正确的，任何数量的尾随/前导空格/换行符都是允许的。（也不允许在输出线之间插入空行。）
  • 输入将仅包含可打印的ASCII字符，不包括空格（代码点范围[33, 126]）
  • I / O是灵活的。输入可以作为STDIN，自变量或函数参数。可能是字符的列表/数组/流而不是字符串。输出也可以是字符的列表/数组/流而不是字符串；可以打印到STDOUT；以换行符分隔的字符串返回；等等

一般规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。您的来电。
  • 默认漏洞是禁止的。
  • 如果可能的话，请添加一个带有测试代码的链接。
  • 另外，强烈建议为您的答案添加说明。

测试用例：

Input: @
Output:
@

Input: test
Output:
test
t e s t
t  e  s  t
t   e   s   t
t  e  s  t
t e s t
test

Input: ?!
Output:
?!
? !
?!

Input: Spaceship
Output:
Spaceship
S p a c e s h i p
S  p  a  c  e  s  h  i  p
S   p   a   c   e   s   h   i   p
S    p    a    c    e    s    h    i    p
S     p     a     c     e     s     h     i     p
S      p      a      c      e      s      h      i      p
S       p       a       c       e       s       h       i       p
S        p        a        c        e        s        h        i        p
S       p       a       c       e       s       h       i       p
S      p      a      c      e      s      h      i      p
S     p     a     c     e     s     h     i     p
S    p    a    c    e    s    h    i    p
S   p   a   c   e   s   h   i   p
S  p  a  c  e  s  h  i  p
S p a c e s h i p
Spaceship

Input: 05AB1E
Output:
05AB1E
0 5 A B 1 E
0  5  A  B  1  E
0   5   A   B   1   E
0    5    A    B    1    E
0     5     A     B     1     E
0    5    A    B    1    E
0   5   A   B   1   E
0  5  A  B  1  E
0 5 A B 1 E
05AB1E

Input: )}/\
Output:
)}/\
) } / \
)  }  /  \
)   }   /   \
)  }  /  \
) } / \
)}/\
code-golf  string  ascii-art 
— 凯文·克鲁伊森
source
1
得到所有只是紧张！！！！！
— WallyWest '18
1
我知道我已经知道了输出。我爱这个主意还在继续。
— Carcigenicate's
2
TFW您隐约地认识到一个问题中的模式，ಠ_ಠ然后意识到这是因为您在一年前不小心将其模式化了ಠ⌣ಠ。
— 魔术章鱼缸
1
@MagicOctopusUrn感谢您的灵感。; D
— Kevin Cruijssen
3
@KevinCruijssen感谢您保持愚蠢的报价哈哈！
— 魔术章鱼缸

Answers:

11

Japt，8 6字节

将输入作为字符数组，将输出字符串数组。

£qYçÃê

试试吧

说明

£          :Map each element at (0-based) index Y
 q         :  Join input with
  Yç       :   Space repeated Y times
    Ã      :End Map
     ê     :Palindromise

原始的8个字节

I / O是一个字符串。使用-R标志。每行上都包含尾随空格。

¬£múYÄÃê

试试吧

说明

             :Implicit input of string U
¬            :Split
 £           :Map each character at 0-based index Y
  m          :  Map original U
   ú         :    Right pad with spaces to length ...
    YÄ       :     Y+1
      Ã      :End map
       ê     :Palindromise
             :Implicitly join with newlines
— 毛茸茸
source
S.ç()再次FTW :-)
— ETHproductions '18
1
严重的问题：像这样的难题反复搜索所有1到6字节长的解决方案是否可行？
— filip
2
@filip编号：组合超过256 ** 6 = 281474976710656（至少是幼稚的）。就像猜密码一样。
— Kirill
3
@KirillBulygin，有超过37 万亿种（37,764,717,485,592）可能的方式将Japt中可用的字符组合为1到6个字符的字符串。如果您包括可用于字符串文字或压缩字符串的所有其他1字节字符，则该数字将增长到276万亿以上（276,024,445,697,280）。因此，不行，编写一个自动生成程序的机器人，然后过滤掉有效的Japt程序，然后找到一个可以应对当前挑战的程序（如果有的话）可能是不可行的。此外，让机器人为您打高尔夫球的乐趣何在？！
— 毛茸茸的
6
@Shaggy：“让机器人为您打高尔夫球的乐趣在哪里？！” 如果您真的使机器人很短怎么办？
— 奇怪的想'18
11

R，105 99 85 84 79字节

-6感谢@Kevin Cruissen和@Giuseppe

-14从更改为基于正则表达式的方法

-1感谢@Giuseppe

-5感谢@digEmALl

function(w,n=nchar(w)-1)write(trimws(Map(gsub,"",strrep(" ",n-abs(n:-n)),w)),1)

在线尝试！

— 多伊
source
您可以通过删除处的空格来打高尔夫球1个字节in(r<-。
— 凯文·克鲁伊森
1
并且只使用s一次，因此可以直接将其用作参数write；将您
— Giuseppe
1
应该是a 1而不是""in write吗？我正在研究您的使用Map！
— 朱塞佩
1
— digEmAll
1
我坚信我可以用的collapse论点来击败它，paste但事实并非如此……
— JDL
6

木炭，10字节

Ｅθ⪫θ× κ‖Ｏ↓

在线尝试！链接是详细版本的代码。说明：

Ｅθ          Map over characters of input string
  ⪫θ        Join characters of input string using
    ×       a literal space repeated 
      κ     current index number of times
            Implicitly print each result on its own line
       ‖Ｏ↓  Reflect vertically with overlap
— 尼尔
source
木炭并不反映之类的东西[来]-或者是另一个单独的命令？
— 魔术章鱼缸
@MagicOctopusUrn如果要转换反射，则有单独的命令。例如，请参见codegolf.stackexchange.com/a/127164。
— 尼尔
我以为我以前看过它，但不确定。整齐！
— 魔术章鱼缸
6

Python 2中，72个 70 68 66 65字节

-2个字节归功于Kevin Cruijssen
-3个字节归功于ovs

w=input();c=s=-1
while c:print(' '*~c).join(w);s*=w[:c]>'';c+=s|1

在线尝试！

— 竿
source
c==len(w)-1可以用击打1个字节c+2>len(w)。编辑：在新的70字节版本中，0<c可以为c。
— 凯文·克鲁伊森
6

05AB1E，10 9字节

感谢Adnan，节省了1个字节

εINð×ý}û»

在线尝试！

说明

ε            # apply to each in input
 I           # push the input
  Nð×        # push <index> spaces
     ý       # merge the input on the spaces
      }      # end loop
       û     # palendromize
        »    # join on newlines
— 艾米尼亚
source
您可以删除S。输入是灵活的，因此允许输入为列表。
— 凯文·克鲁伊森
1
@KevinCruijssen：您的第一个版本是旧版的9个字节，»可以省略。
— Emigna
1
如果您删除»循环并将其更改v为地图，则实际上也可以使用9字节来使用旧版文件ε。
— 凯文·克鲁伊森
1
发表答案。目前恐怕Japt用6个字节殴打了我们。还是说05AB1E（Elixir重写）和05AB1E（Python遗留物）中最短？:)
— Kevin Cruijssen
2
难道εINð×ý}û»还工作吗？
— 阿德南'18
4

Japt，9 8字节

@Shaggy的-1个字节

ÊƬqXîÃê

ÊƬqXîÃê        Full program, implicity input U
ÊÆ              Rage from 0 to U length and map
  ¬             split U at ""
   qXîà     join U using " " times range current value
        ê       horizontal mirror

在线尝试！

— 路易斯·费利佩·德·耶稣·穆诺兹
source
荡 看起来您又对我忍了！莱姆知道你是否要我删除我的。
— 粗野的
1
@Shaggy不，保留您的答案，您使用数组作为输入，而我使用字符串，因此它们具有不同的xD
— Luis felipe De jesus Munoz
1
SpX-> Xî保存1个字节。
— 粗野的
4

PowerShell，66 54字节

-12字节感谢mazzy

0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}

在线尝试！

通过展开获取输入，在TIO上，每个字符都显示为单独的命令行参数。

我们首先将其设置$a=$args为输入参数。然后，将其设置为$x等于.count该数组的-1。然后，我们需要遍历字母以构造太空飞船。这是通过构造从0到的范围$x，然后再$x向下扩展到0，然后使用Get-Unique拉出适当的范围来完成的。

每次迭代时，我们都会将输入参数及其-join与相应的空格数一起使用。这些字符串中的每一个都留在管道上，Write-Output当程序完成时，隐式为我们免费提供换行符。

— AdmBorkBork
source
试试这个：0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}
— mazzy
1
@mazzy ... ... Get-Unique在范围内如何工作？太疯狂了！谢谢！
— AdmBorkBork
4

05AB1E（旧版），9 个字节

εINúíJ}û»

输入为字符列表。

在线尝试或验证所有测试用例。

说明：

ε     }    # Map each character in the input to:
 I         #  Take the input
  Nú       #  Prepend each with the 0-indexed amount of spaces
           #   i.e. ["t","e","s","t"] & 3 → ["   t","   e","   s","   t"]
    í      #  Reverse each item
           #   i.e. ["   t","   e","   s","   t"] → ["t   ","e   ","s   ","t   "]
     J     #  Join them together to a single string
           #   i.e. ["t   ","e   ","s   ","t   "] → "t   e   s   t   "
       û»  # Palindromize the list, and join by newlines
           #  i.e. ["test","t e s t ","t  e  s  t  ","t   e   s   t   "]
           #   → "test\nt e s t \nt  e  s  t  \nt   e   s   t   \nt  e  s  t  \nt e s t \ntest"
— 凯文·克鲁伊森
source
1
OOOOOO，也这是无效的，因为反射镜改变的取向/镜像时\，具有相同的[，]和(，)。可能也想添加这些情况来捕获木炭。（将其他评论移至Emigna的答案，因为他是我最初评论的答案）
— Magic Octopus Urn
@MagicOctopusUrn感谢您告诉我。使用û»代替修复了它.∊。
— 凯文·克鲁伊森
4

Haskell，60 59字节

(init<>reverse).(scanl(?)<*>tail)
a?_=do u<-a;u:[' '|' '<u]

在线尝试！

说明

对于字符串（例如"abc"），我们首先应用

scanl (?) <*> tail

这与

\str -> scanl (?) str (tail str)

这会重复应用(?)（在[33 ..]范围内的每个字符上添加一个空格）到，str直到有足够多的字符串str包含以下字符：["abc","a b c ", "a b c "]

现在我们只需要将结果（减去最后一个元素）与其相反的计数器部分连接起来：

init<>reverse
— ბიმო
source
4

MATL，25 22 13字节

zZv"Gtz@he!1e

在线尝试！

感谢路易斯·门多（Luis Mendo）提出了5个字节的高尔夫球，这启发了我再剃掉4个字节！

说明，并带有示例输入'abc'：

         # Implicit input, 'abc'
z        # find number of nonzero elements (length of string)
         # stack: [3]
Zv       # symmetric range
         # stack: [[1 2 3 2 1]]
"        # begin for loop, iterating over [1 2 3 2 1] as the loop indices
G        # push input
         # stack: ['abc']
tz       # dup and push length
         # stack: ['abc', 3]
@        # push loop index, i (for example, 2)
         # stack: ['abc', 3, 2]
h        # horizontally concatenate
         # stack: ['abc', [3, 2]]
e!       # reshape to matrix of 3 rows and i columns, padding with spaces, and transpose
         # stack: [['abc';'   ';'   ']]
1e       # reshape to matrix of 1 row, leaving last value on stack
         # stack: ['a  b  c  ']
         # implicit end of for loop
         # implicit end of program, display stack contents
— 朱塞佩
source
3

果冻，9个字节

jⱮLḶ⁶ẋƲŒḄ

在线尝试！

返回行列表；通过TIO美化了输出。

— 暴民埃里克
source
有点不同9 ：,€⁶$LСŒḄ。其他的，更类似于9的：J’⁶ẋŒḄɓjⱮ和J’⁶ẋŒḄjⱮ@（我一直在寻找更短，但没有喜悦还）
— 乔纳森·艾伦
@JonathanAllan我很确定这是最佳选择，我认为没有任何更短的书写方式LḶ⁶ẋor ŒḄ。但是，如果您设法找到一个保存文件，请对我执行ping操作。:-)
— Erik the Outgolfer
考虑一下，我,€⁶$LСŒḄ可能是无效的，因为它有疯狂的嵌套，所以可能需要Y一个完整的程序。
— 乔纳森·艾伦
@JonathanAllan是的，当然不是。['I', 'f', [[' '], 't', 'h', [['i']], 's'], ' ', 'i', ['s', ' '], 'a', [[' ', 's', 't'], 'r', ['i', 'n', 'g'], ' '], 'w', ['e', ' ', 'a', 'r', 'e'], ' ', 'd', 'o', ['o'], 'm', [[[[['e']]]]], [[[['d']]]], '!']至少我已经超越了05AB1E ...
— Outgolfer的Erik
我说我超越了05AB1E，是吗？ah，不再了。：/
— Erik the Outgolfer
3

Stax，10 个字节

Ç·9ƒù▌╘Ä┘e

运行并调试

每行末尾带有空格的输出。

说明：

%R|pmx{]n(m Full program, unpacked, implicit input
%           Length of input
 R          1-based range
  |p        Palindromize
    m       Map:
     x{   m   Map over characters of input:
       ]        Character -> string
        n(      Right-pad to length given by outer map value
              Implicit flatten and output
— 浪费
source
3

Java（JDK 10），115字节

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf(s.replaceAll(".","%-"+(i<0?l+i:l-i)+"s")+"%n",s.split(""));}

在线尝试！

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
1
l-Math.abs(i)可以打i<0?l+i:l-i-2字节。
— 凯文·克鲁伊森
@KevinCruijssen谢谢！:)
— 奥利维尔·格雷瓜尔
可以l-i<0?-i:i吗？
— Quintec
@ thecoder16您将需要括号：l-(i<0?-i:i)（12个字节）。
— 乔纳森·弗雷希
3

K（oK），25 24字节

解：

,/'(1+a,1_|a:!#x)$\:+,x:

在线尝试！

说明：

我的K4解决方案的端口：

,/'(1+a,1_|a:!#x)$\:+,x: / the solution
                      x: / save input as x
                     ,   / enlist
                    +    / flip
                 $\:     / pad ($) right by each-left (\:)
   (            )        / do this together
              #x         / count length of input,           e.g. 3
             !           / range 0..length,                 e.g. 0 1 2
           a:            / save as a
          |              / reverse it,                      e.g. 2 1 0
        1_               / drop first,                      e.g. 1 0
      a,                 / join to a,                       e.g. 0 1 2 1 0
    1+                   / add 1,                           e.g. 1 2 3 2 1
,/'                      / flatten (,/) each (')

笔记：

  • -1个字节感谢ngn
— 街头小贩
source
1
,:'-> +,
— ngn
2

PHP，88 89字节

for(;++$i<2*$e=count($a=str_split($argn));)echo join(str_pad("",~-$e-abs($i-$e)),$a),"\n";

需要PHP 5或更高版本str_split。与管道一起运行-nR或在线尝试。

— 提图斯
source
恐怕您的在线尝试链接提供了错误的输出。在输出中，所有行也都有前导空格，而不是仅在字符之间（或可选地在结尾）。第一个字符应全部位于输出的同一列中。
— 凯文·克鲁伊森
1
@KevinCruijssen没有足够仔细地查看输出。固定。（尽管imo，我之前的输出看起来更像是一枚火箭）；-)
— 泰特斯（Titus
有点像向我的箭头。：D但是+1现在已经固定。
— 凯文·克鲁伊森
如果您放置实际的换行符而不是\ n，则保存一个字节:)
— Martijn
@Martijn我实际上只为它计算了一个字节……当我在这里粘贴代码时，忘记替换它了。
— 泰特斯（Titus）
2

K4，23个字节

解：

,/'(1+a,1_|a:!#x)$\:$x:

例：

q)k),/'(1+a,1_|a:!#x)$\:$x:"Spaceship"
"Spaceship"
"S p a c e s h i p "
"S  p  a  c  e  s  h  i  p  "
"S   p   a   c   e   s   h   i   p   "
"S    p    a    c    e    s    h    i    p    "
"S     p     a     c     e     s     h     i     p     "
"S      p      a      c      e      s      h      i      p      "
"S       p       a       c       e       s       h       i       p       "
"S        p        a        c        e        s        h        i        p        "
"S       p       a       c       e       s       h       i       p       "
"S      p      a      c      e      s      h      i      p      "
"S     p     a     c     e     s     h     i     p     "
"S    p    a    c    e    s    h    i    p    "
"S   p   a   c   e   s   h   i   p   "
"S  p  a  c  e  s  h  i  p  "
"S p a c e s h i p "
"Spaceship"

说明：

每行上都有尾随空格。

,/'(1+a,1_|a:!#x)$\:$x: / the solution
                     x: / save input as x,                 e.g. "abc"
                    $   / string,                          e.g. (,"a";,"b";,"c")
                 $\:    / pad ($) right by each-left (\:)
   (            )       / do this together
              #x        / count length of input,           e.g. 3
             !          / range 0..length,                 e.g. 0 1 2
           a:           / save as a
          |             / reverse it,                      e.g. 2 1 0
        1_              / drop first,                      e.g. 1 0
      a,                / join to a,                       e.g. 0 1 2 1 0
    1+                  / add 1,                           e.g. 1 2 3 2 1
,/'                     / flatten each
— 街头小贩
source
2

C＃，113个 105 98字节

s=>{for(int l=s.Length,i=-l;++i<l;)WriteLine(Join("",s.Select(c=>$"{c}".PadRight(i<0?l+i:l-i))));}

在线尝试！

— 罗比三世
source
嗨，您好。目前，您的答案是代码段，而不是功能或完整程序。可以通过s=>{在}lambda函数之前和之后添加来廉价地解决此问题。此外，打高尔夫球的一件事是取下环圈的支架。在线尝试。
— 凯文·克鲁伊森
@KevinCruijssen谢谢！在发布之前忘了修复...
— RobIII
2

Scala， 82字节

for(i<-(0 to a.size)union(-a.size to 0))println(a.map(_+" "*Math.abs(i)).mkString)

在线尝试

Scala有很多快捷方式可以在这里帮助我，而且可读性很强！ 试试Scala

— 安德鲁·库列索夫（Andrew Kuleshov）
source
嗨，欢迎来到PPCG！尽管这是一个不错的答案，但恐怕有两件事是不正确的。空格最多的行只能在中间输出一次，而不是两次。目前您从打印0到length的空间量，而不是0要length-1达到的空间。我对Scala不太了解，但是看来您可以像这样解决+4字节（总共86字节）的两个问题：for(i<-(0 to a.size-1)union(-a.size+2 to 0))println(a.map(_+" "*Math.abs(i)).mkString)再次欢迎您，并祝您愉快！:)
— Kevin Cruijssen
2

Oracle SQL，115字节

不是打高尔夫球的语言，而是...

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))FROM t CONNECT BY LEVEL<2*LENGTH(v)

假设该值在v表的列中t：

SQL小提琴

Oracle 11g R2架构设置：

CREATE TABLE t ( v ) AS
  SELECT 'test' FROM DUAL;

查询1：

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))
FROM   t
CONNECT BY LEVEL<2*LENGTH(v)

结果：

（由于某种原因，SQLFiddle将列中的值右对齐打印。没有前导空格）

| TRIM(REGEXP_REPLACE(V,'(.)',LPAD('\1',1+LENGTH(V)-ABS(LEVEL-LENGTH(V))))) |
|---------------------------------------------------------------------------|
|                                                                      test |
|                                                                   t e s t |
|                                                                t  e  s  t |
|                                                             t   e   s   t |
|                                                                t  e  s  t |
|                                                                   t e s t |
|                                                                      test |
— MT0
source
您的SQL Fiddle结果似乎在字符之间只有一个空格？查看此屏幕截图。我认为这是由于SQL Fiddle造成的，并且它在本地工作？顺便说一句，不确定SQL是否使用标准的正则表达式规则，但是可以通过使用而不是像在Java 中那样(.)来.使用？编辑：没关系，那是为了，而不是..（我的意思是Java示例）。\0\1$0\0
— 凯文·克鲁伊森
1
@KevinCruijssen单击“运行SQL”按钮旁边的向下箭头，并将输出更改为“纯文本输出”或“ Markdown输出”，您将看到空格。
— MT0
谢谢。在那种情况下确实看起来不错！
— 凯文·克鲁伊森
2

8086机器代码，56 53字节

00000000  bf 35 01 57 ba 01 00 52  be 82 00 b3 ff ac 59 51  |.5.W...R......YQ|
00000010  aa 3c 0d 74 07 b0 20 e2  f7 43 eb f1 b0 0a aa 59  |.<.t.. ..C.....Y|
00000020  00 d1 e3 08 38 cb d6 08  c2 51 eb dc c6 05 24 5a  |....8....Q....$Z|
00000030  b4 09 cd 21 c3                                    |...!.|
00000035

从组装：

org 0x100
use16
        mov di, buffer
        push di
        mov dx, 1
        push dx
nextl:  mov si, 0x82
        mov bl, -1
nextc:  lodsb
        pop cx
        push cx
stor:   stosb
        cmp al, 0x0d
        je cr
        mov al, ' '
        loop stor
        inc bx
        jmp nextc
cr:     mov al, 0x0a
        stosb
        pop cx
        add cl, dl
        jcxz done
        cmp bl, cl
        salc
        or dl, al
        push cx
        jmp nextl
done:   mov [di], byte '$'
        pop dx
        mov ah, 0x09
        int 0x21
        ret
buffer:

测试用例：

屏幕截图

— 用户名
source
嗨，您好。我猜没有针对8086机器代码的在线编译，但是您能否为其中一个测试用例添加输出的屏幕截图？然后，我可以检查一切是否正确。:)
— Kevin Cruijssen
做完了 还减少了一个字节：)
— user5434231
感谢您的截图！不幸的是，输出中有一个小错误。现在，中间的行有length一定数量的空格，总共有9行，但是中间的行应该有length-1一定数量的空格，而应该总共有7行（对于4个字母的单词“ test”`）。 （我希望修复字节数不会太昂贵？
— Kevin Cruijssen
1
哦，我明白了。现在已解决，我什至减少了一个字节。
— user5434231
2

Haskell，64 60 59字节

(""#)
a#s|l<-(:a)=<<s,w<-' ':a=l:[x|w<(' '<$s),x<-w#s++[l]]

在线尝试！

a#s                         -- take a string of spaces 'a' and the input string 's'
 |l<-(:a)=<<s               -- let 'l' be the current line, i.e. the spaces in 'a'
                            -- appended to each char in 's'
  w<-' ':a                  -- let 'w' be 'a' with an additional space   
 =l                         -- return that 'l'
   :[   |w<(' '<$s)   ]     -- and, if 'w' is shorter than 's',
     x  ,x<-w#s++[l]        -- followed by a recursive call with 'w' 
                            -- and by another copy of 'l'

(""#)                       -- start with an empty 'a'
— 妮米
source
2

击，115，109，105，100，97，96，92， 91，90个字节

-5＆-3感谢Kevin Cruissen 

read s;for((c=f=1;f;c-=2*(f>=${#s}),f+=c))
{ printf '%-'${f}'.c' `grep -o .<<<"$s"`
echo
}

在线尝试！

请注意，由于\是一个shell逸出字符，因此)}/\应在测试用例中输入\以下内容：)}/\\。

— 联合会
source
嗨，您好。是否可以在测试用例中添加TIO链接？另外，我不知道猛砸非常好，但有可能后把空格去掉in，并printf像在Python？
— 凯文·克鲁伊森
1
@KevinCruijssen，谢谢，请参阅修订后的答案。我是TIO-link的新手，并且不确定如何使用多个测试用例，因为此bash代码仅输入一个字符串（即仅一行）。尽管所有测试用例都可以正常工作，但是)}/\ 像这样必须用单引号引起来<<< ')}/\' read s; ...etc. 。in和之后的空格printf是必需的。
— AGC
谢谢。TIO的单个测试用例就可以了。这主要是为了验证一切是否按预期工作，确实如此。向我+1。:)
— Kevin Cruijssen
1
在新版本中，您可以像这样再打5个字节。之后的空格for和do可以被删除。f=1可以更改为c=f=1。并且f=f+c可以f+=c。
— 凯文·克鲁伊森
1
哦，还有一件事要打高尔夫球。不确定是否可以在Bash中使用它，但是显然是这样（TIO链接很方便的另一个原因；））是通过在for循环中更改f!=0为f。就像在JavaScript和Python中一样，它0是false，而在Bash中其他所有正/负整数显然都是真实的。
— 凯文·克鲁伊森
2

Perl 6、43字节

{(0....comb-1...0)>>.&{join ' 'x$^a,.comb}}

在线尝试！

返回行列表。

说明：

 {                                         }  # Anonymous code block
  (0....comb-1...0) # A list from
   0                  # 0
    ...               # to
       .comb-1        # the length of the input string -1
              ...     # back to
                 0    # 0
                   >>.&{                  }  # Map each number to
                        join        ,.comb   # Join the list of characters
                             ' 'x$^a         # With the number of spaces
— 乔·金
source
2

C（GCC） ，131个 129 111字节

i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

在线尝试！

-20字节，感谢ceilingcat！

#import<string.h>
i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

在线尝试！

或者，如果可以接受长度作为参数：

C（gcc），105102字节

-1个字节，感谢ceilingcat！

i;x;f(k,x,j)char*k,*j;{for(i=!x--;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

在线尝试！

— 科纳·奥布莱恩
source
@ceilingcat呵呵！
— 科纳·奥布莱恩
1
在您102字节长的高尔夫球中，我认为全局x阴影被遮蔽了，因此被多余地声明了。
— 乔纳森·弗雷希
2

PHP，148 146 143 141个字节

function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

您可以像这样测试它：

<?php
error_reporting(0);

$s = 1234567890;
function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

输出量

1234567890
1 2 3 4 5 6 7 8 9 0 
1  2  3  4  5  6  7  8  9  0  
1   2   3   4   5   6   7   8   9   0   
1    2    3    4    5    6    7    8    9    0    
1     2     3     4     5     6     7     8     9     0     
1      2      3      4      5      6      7      8      9      0      
1       2       3       4       5       6       7       8       9       0       
1        2        3        4        5        6        7        8        9        0        
1         2         3         4         5         6         7         8         9         0         
1        2        3        4        5        6        7        8        9        0        
1       2       3       4       5       6       7       8       9       0       
1      2      3      4      5      6      7      8      9      0      
1     2     3     4     5     6     7     8     9     0     
1    2    3    4    5    6    7    8    9    0    
1   2   3   4   5   6   7   8   9   0   
1  2  3  4  5  6  7  8  9  0  
1 2 3 4 5 6 7 8 9 0 
1234567890

沙盒

扩展版

 function s($s){
    //loop upwards 0-10
    for(;$i<strlen($s);++$i) f($i,$s);
     //decrement so it's odd, from 9 loop downwards to 0
    for(--$i;--$i>=0;)f($i,$s);
 }
 //2nd function to save space
 function f($i,$s){
     //chunk it, split 1 char, insert $i number of spaces
     echo chunk_split($s,1,str_repeat(' ',$i))."
";}

尝试2，92个字节

看到@Titus回答后，我将我的想法简化为：

for(;++$i<2*$e=strlen($s=$argn);)echo chunk_split($s,1,str_repeat(' ',~-$e-abs($i-$e)))."
";

我试图想出一种使用1循环而不是2循环的方法...信不信由你，我几乎从不使用for“真实”代码中的循环。是~按位不，我想念...

它的门槛稍长一点，92所以我不会感到难过。但是无论如何，我将把它作为第二次尝试。

$argn 是命令行的输入

使用-nR作为管道运行或在线尝试。

沙盒

— 凤凰艺术
source
在我看来，你的第一个版本将是4个字节的短，如果你使用一个命名函数f，而不是分配一个匿名之一$f- function f(在节省2个字节$f=function(每次调用时间，你保存另一个字节f(...)来代替$f(...)。或者，您可以捕获$s，节省2个字节- ($i)use($s)比4个字节长($i,$s)，但是每次调用时都保存3个字节，$f($i)而不是$f($s,$i); 在具有自动捕获功能的语言（例如JS）中，这通常是一种可行的节省方法，因为您无需支付use语句的罚款。
— IMSoP
我非常感谢您的帮助，我是高尔夫编程的新手，但实际上并没有做那么多，不过，对于常规的SO页面确实感到无聊。我确实考虑过使用，use但是感觉更长了，要做到这种感觉$i是动态的，就必须通过引用来传递。因此在通过引用传递之前，必须要定义use(&$i)和$i必须定义$f。这意味着在父函数中或在其他函数之前进行设置。对于函数来说，它可能是function s($s,$i)，只是知道必须与之一起调用，s($s,0) 但是它看起来很丑陋，并且就是这样11 bytes, use(&$i),$i
— ArtisticPhoenix
我们可以使用$s并将更改\n为真实的行返回值。143 从行尾开始将其增加到2，将其从使用中减少到1
— ArtisticPhoenix
是的，我什至没有考虑过使用$ i，因为$ s感觉到了“自然”的捕获，但是计算净节省总是值得的。但是，您仍然可以通过声明一个命名函数f而不是一个闭包来节省2个字节：function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))." ";}根据以下meta帖子，可以允许这样的额外函数：codegolf.meta.stackexchange.com/questions/7614/…–
— IMSoP
更新，保存了一对
— ArtisticPhoenix
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.