背景

小时候，我被教导一种绘制奇怪的“ S”形的方法，使我（和同学们）着迷。今天，我重新发现了它，并且由于它采用公式化的方式绘制它，因此认为它可能会引发一个有趣的挑战：P

画“ S”

可以通过以下简单步骤绘制S：

首先，像这样绘制2行，每条垂直的三个直线

| | |

| | |

接下来，将左上方的线与底部的中线连接，并将上方的中线与右下方的线连接以产生

| | |
 \ \
| | |

最后，在当前绘制的图像上绘制顶部和底部，使其最终看起来像

  ^
 / \
| | |
 \ \
| | |
 \ /
  v

如您所见，这将导致“ S”形。但是，当扩展时（绘制超过2行），它会产生一个非常有趣的图案。您的任务是重现此有趣的模式。

任务

给定一个整数where n >= 2，输出S及其n要制成的行。输出可以从函数返回，输入可以采用标准方法。整个图像以及每行的尾随/前导空格都很好。但是，前导空格必须保持一致，以免破折号。您可以输出为行列表。

测试用例

input
output
---

2

  ^
 / \
| | |
 \ \
| | |
 \ /
  v

---

8
  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

---

10

  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

这是一个代码高尔夫球，所以最短的代码胜出！祝好运，

code-golf string ascii-art

— 开斋节
source

13

维基百科S将Cool S称为，并称其为无限版本S Chain

— Stephen Stephen

我们可以输出为行列表吗？

— Xcoder先生17年

@ Mr.Xcoder您可以

— caird coinheringaahing

@斯蒂芬十分钟谷歌搜索，这没有出现。我将编辑问题的名称

— Caird coinheringaahing

@cairdcoinheringaahing我搜索了图像，可能就是它了：P

— Stephen

15

Python 2，47个字节

lambda k:'  ^\n / '+'\\\n| | |\n \ '*k+'/\n  v'

在线尝试！

— 林恩
source

10

C＃（.NET Core），73 69 66 64 62字节

多亏了Barodus，少了两个字节，而且外观像Perl。没想到要使用int吗？为空。

n=>$@"  ^
 / {string.Join(@"\
| | |
 \ ",new int?[++n])}/
  v"

在线尝试！

— 我的代词是莫尼卡
source

1

如果这是对现有C＃答案的肯定，那么我将永远无法分辨。做得好:-)

— ETHproductions's

你能解释一下new string[n+1]吗？我从未见过。

— 伊恩·

创建一个空字符串数组AFAIK。我使用过带string的hack。加入，也称为连接{“”，“”，“，”“}，使用分隔符” \ \ n | | | | \ n \“

— 我的代词是monicareinstate

@someone哇，我以前从未承认过这个技巧。真酷！（同样糟糕的是，尽管我 new string[n+1]是某种棘手的字符串构造函数，而不是数组声明-.-）

— Ian H.

6

Python 3，48 56 59 61 字节

lambda k:'  ^\n / %s/\n  v'%('\\\n| | |\n \ '*k)

在线尝试！

— Xcoder先生
source

您可以通过转义单独的反斜杠来节省2个字节。

— L3viathan

@ L3viathan也更新了

— Xcoder先生17年

56个字节; 不确定这是否公平 ; 在TIO上不起作用

— L3viathan

@ L3viathan这是不正确的。额外的\ \。

— Xcoder先生17年

关于TIO：是的。在我的终端机中：不。

— L3viathan

6

05AB1E，27 26字节

…^
/ð"\
| | |
\ "I×…/
vJ.c

在线尝试！

备用27字节版本

'^…/ \©IF…| |û…\ \}\®R'v».c

在线尝试！

说明

'^                             # push "^"
  …/ \©                        # push "/ \" and store a copy in register
       IF                      # input times do:
         …| |û                 # push "| | |"
              …\ \             # push "\ \"
                  }            # end loop
                   \           # discard top of stack (the extra "\ \")
                    ®R         # push "/ \" reversed = "\ /"
                      'v       # push "v"
                        »      # join stack on newlines
                         .c    # center each row

— 艾米尼亚
source

5

在我看来，您的代码有点像大象:)

— Wojowu

从字面上看，这是SCARY，我的答案与您的答案有多接近：'^…/ \©IF„| ûû„\ û}\®R'v).C不看。

— 魔术章鱼缸

6

Japt，34 25 23字节

" ^ /{ç'\²i|³1}/ v"¬¸ò5

在线测试！输出为线阵列；-R标志添加到换行符上。（感谢@Shaggy）

第一次第二次尝试，可能是可改进的...

怎么运行的

" ^ /{ ç'\²  i |³  1}/ v"¬ ¸  ò5
" ^ /{Uç'\p2 i'|p3 1}/ v"q qS ò5   Ungolfed
                                   Implicit: U = input number
        '\p2                       Repeat a backslash twice, giving "\\".
             i     1               Insert at index 1
              '|p3                   3 vertical bars. This gives "\|||\".
      Uç                           Make U copies of this string. U = 2: "\|||\\|||\"
" ^ /{              }/ v"          Insert this into this string.    " ^ /\|||\\|||\/ v"
                         q qS      Split into chars; join on spaces."  ^   / \ | | | \ \ | | | \ /   v"
                              ò5   Split into rows of length 5.    ["  ^  "," / \ ","| | |"," \ \ ","| | |"," \ / ","  v"]
                                   Joining on newlines gives "  ^  
                                                               / \ 
                                                              | | |
                                                               \ \
                                                              | | |
                                                               \ /
                                                                v"

— ETH生产
source

打木炭并绑SOGL？优秀作品！

— 毛茸茸的

顺便说一下，您可以输出一个行数组，因此可以删除最后两个字符。

— 毛茸茸的

@Shaggy太好了，现在我们赢了！

— ETHproductions

我们最近过得不错：)

— Shaggy

6

SOGL V0.12，26个 25 18 字节

°I-‘*"∑ūCƨΩ)¹‘@∑5n

在这里尝试！

使用与ETHproductions的Japt答案相同的策略

说明：

..‘           push "\|||\"
   *          repeat input times
    "..‘      push " ^ /ŗ/ v ", with ŗ replaced with POP. The reason why there's a trailing
              space is because otherwise it didn't have enough repeating characters to compress
        @∑    join with spaces
          5n  split to line lengths of 5

— 宰马
source

2

push "|" and " "内建的东西到底是什么

— Steven H.

1

@StevenHewitt实际上是两个内置组件，但是我将它们结合在一起（就像我对其他东西所做的那样），因为我认为没有必要分离很快会一起使用的东西

— dzaima

5

JavaScript（ES6），60个字节

n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`

测试片段

显示代码段

let f=
n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`
;(I.oninput=_=>O.innerHTML=I.value+"\n"+f(+I.value))()

<input id=I type=range min=2 max=15 value=2><pre id=O></pre>

展开摘要

— 贾斯汀·马里纳（Justin Mariner）
source

1

57 ：（n=>' ^\n /${' \\ \\\n| | |\n'.repeat(n).slice(2)} \\ /\n v'使用反引号和原义换行符）

— edc65

5

木炭，27 26 25字节

-1个字节感谢Carlos Alejo。-1字节（仅使用ASCII）。

  ^⸿ / ×\⸿| | |⸿ \ Ｎ/⸿  v

在线尝试！链接是详细版本。＃木炭-冗长-混淆

— 全人类
source

1

您可以通过仅调用Print（而不是添加字符串）并使用\r以下命令来节省1个字节：`^⸿/×\⸿| | |⸿\ Ｉθ /⸿v`。详细版本。

— 查理

啊...我必须记住\r，这是理智地换行的方法。谢谢！

— –totalhuman

25个字节

— 仅使用ASCII

@ ASCII只：P -

— totallyhuman

4

Perl 5中，39 37个字节

say"  ^
 / ".'\
| | |
 \ 'x<>."/
  v"

在线尝试！

使用@DomHastings的建议将两个字节剃光

— Xcali
source

如果使用单引号，则无需对-2进行反斜杠转义！:)

— Dom Hastings

3

其实 49字节

"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"

在线尝试！

说明：

"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"
"| | |"@α                                          push a list containing n copies of the vertical lines
         ;lD" \ \"@α                               push a list containing n-1 copies of the diagonal connections
                    @Z♂i                           interleave
                        i                          flatten
                         "  v"" \ /"))             make the bottom
                                      " / \""  ^"  make the top

— 梅果
source

3

05AB1E，38个字节

…| |ûU"  ^
 / \"XI<F„ \2×X}" \ /
  v"»

在线尝试！

…| |                         # Push "| |"
    û                        # Palindromize
     U                       # Store in X
      "..."X                 # Push the top three rows
            I<F      }       # One less than input times do:
               „ \           #   Push " \"
                  2×         #   Concatenate that with itself
                    X        #   Push "| | |"
                      "..."  # Push the last two rows
                           » # Join stack with newlines

— 莱利
source

3

C（gcc），82字节

f(n){for(puts("  ^\n / \\");--n;puts("| | |\n \\ \\"));puts("| | |\n \\ /\n  v");}

在线尝试！

— 克莱布朗
source

3

C＃（.NET Core），101 77 73字节

_{多亏了我cri每个人，节省了24个字节！}
_{感谢Kevin Cruijssen保存了4个字节！}

n=>{var s="  ^\n / ";for(;n-->0;s+="\\\n| | |\n \\ ");return s+"/\n  v";}

在线尝试！

像往常一样，在C＃中重复字符串很麻烦。

— 伊恩·H。
source

77个字节。

— –totalhuman

@icrieverytim Ahhh，那当然更好。

— 伊恩·

您可以更改--n>=0到n-->0并s+="/\n v";return s;以return s+"/\n v";节省一些字节。

— 凯文·克鲁伊森

1

@KevinCruijssen谢谢，固定！

— 伊恩·

3

视网膜，38字节

.+
$*
1
¶|||¶x\\
^
 ^¶x/\
.$
/¶ v
x?

在线尝试！

在每行上打印一列前导空格和尾随空格。

说明

节省主要字节的原因是，省略了所有文字部分的空格并将其插入末尾。该图的结构使得彼此之间永远不会有两个非空格，因此，如果我们全部删除它们，我们几乎可以通过在结尾处的每个位置插入一个空格来固定形状：

^
/\
|||
\\
|||
\/
v

变成：

 ^ 
 / \ 
 | | | 
 \ \ 
 | | | 
 \ / 
 v

除了缩进，这几乎是正确的。在^与v缺少两个空格。实际上，这更容易解决，因为如果我们在每个位置前面都插入一个明确的空格，则会在最后增加两个空格。带斜线的行比较棘手，因为它们仅需要一个额外的空间。为了解决这个问题，我们在（x）处插入一个占位符。当我们在末尾插入空格时，我们不仅会为每个空匹配项都插入空格，还可以有选择地匹配x。这意味着，无需替换本身的空格x，x而是可以替换本身。然后在之后将仍然有一个空匹配x。也就是说，每个x仅添加一个空间而不更改其他任何内容。因此，我们要设置的是：

 ^
x/\
|||
x\\
|||
x\/
 v

这将给我们理想的结果。所以这是代码：

.+
$*

将输入转换为一元。

1
¶|||¶x\\

1使用|||和将其转换为两行x\\（以及换行符）。

^
 ^¶x/\

用^和插入前两行x/\。

.$
/¶ v

固定决赛，方法x\\是将最后一个\变成，/并在后面加上一行v。

x?

用x空格替换每个或空的匹配项。

— 马丁·恩德
source

整洁的方法。我试图找到一种将空间连接用于我的Pip解决方案的方法，但是由于不同行上的前导空间数量不同，因此无法正常工作。

— DLosc

2

Pyth，46个字节

"  ^
 / \\"
+*j[jd*\|3" \ \\"k))Q" \ /
  v

测试套件。

— 史蒂文·H
source

36个字节：%" ^\n / %s/\n v"*Q"\\\n| | |\n \

— Xcoder先生17年

31个字节。

— Xcoder先生17年

2

Pyth，40个字节

K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v

完全类似于史蒂文·休伊特（Steven Hewitt）的作品，但独立开发。

在线尝试

说明

K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v
K" / \ ""                                 Set K = " / \ "
        "  ^"                       "  v  Draw the end points.
             K                    _K      Draw the slants.
                         *Q]*3"| "        Draw the vertical bars...
              j+b+*2+d\\b                 ... interspersed with slants.

2

Pyth，33 32 31字节

感谢Xcoder先生一个字节。

%"  ^
 / %s/
  v"*tj\|_B" \\
|

在线尝试：演示或测试套件

— 雅库比
source

很好的答案！您可以将其减少到32个字节。

— Xcoder先生17年

2

实际上是31个字节。

— Xcoder先生17年

2

视网膜，45字节

这是一个非常简单的解决方案。

.+
$*
^1
  ^¶ /x
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

在线尝试

如果可以将艺术标为1索引，它会短一些（44字节）：

.+
  ^¶ /x$0$*1
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

— mbomb007
source

2

点，45 42 33字节

"  ^
 / "."\
| | |
 \ "Xa."/
  v"

在线尝试！

说明

该代码确实很简单，尽管换行符使其更难阅读。这是查看结构的更好方法：

"prefix" . "repeated" X a . "suffix"

S链中的重复元素是

   \
| | |
 \

将此作为文字字符串并重复执行a一次（a第一个命令行参数在哪里）。然后添加前缀：

  ^
 /

并附加后缀：

   /
  v

并打印。

（我喜欢这最终看起来有点像> <>程序。）

— DLosc
source

这看起来像《冒险时光》中的块状太空公主：）

— YSC

2

MATL，47 44 43字节

-3个字节，感谢Giuseppe

'  ^' ' / \ 'XK'| | |'XJGq:"' \'thJ]KP'  v'

在线尝试！

— 西纳斯基
source

' ^' ' / \ 'XK'| | |'XJ`' \ \'JGq@-]KP' v'是44个字节。

— 朱塞佩

1

Haskell，53个字节

f n="  ^\n /"++([1..n]>>" \\\n| | |\n \\")++" /\n  v"

在线尝试！

— 妮米
source

1

Excel，60个字节

="  ^
 / \
"&REPT("| | |
 \ \
",A1-1)&"| | |
 \ /
  v"

— 韦尼施
source

您应该考虑检查一下是否与Google表格通晓

— Taylor Scott

1

PowerShell，83，57字节

"  ^
 / \"
1..--$args[0]|%{"| | |
 \ \"}
"| | |
 \ /
  v"

在线尝试！

根据@AdmBorkBork的建议，

for通过使用数字范围进行简化。
替换了;和组合的字符串。
删除了不必要的变量定义。

— 根
source

您可以for使用进行很多循环运动1..--$args[0]|%{ }。

— AdmBorkBork

同样，您可以在相邻字符串之间使用文字换行符进行保存，";"并且$s完全删除它更便宜。57字节

— AdmBorkBork

光滑我喜欢换行保存。有趣的是我错过了这个1..$args机会。我不确定此网站上的正确礼节是什么。我会更改答案并给您以信誉，还是将解决方案作为单独的答案发布？

— 根

编辑变更并给予赞赏是适当的礼节。欢迎来到PPCG。

— AdmBorkBork

1

AsciiDots，88字节

.*$"  ^"$" / \"
/>#?)--*$"| | |"$" \ \"
*#1\ /-~$"| | |"$" \ /"$"  v"
*-{-}*[<]
\#0----/

在线尝试！

— 用户名
source

1

果冻，32字节

Lynn的Python解决方案的乏味端口。

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”

在线尝试！

说明：

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”    Example input: 5
“\¶| | |¶ \ ”                       Literal string "\¶| | |¶ \ " (¶ = newline). Result: "\¶| | |¶ \ "
             ẋ                      Repeat as many times as the (implicit) input. Result: "\¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
              ṭ                     Tack that on the end of...
               “  ^¶ / ”            ...the string "  ^¶ / ". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
                        ;           Append...
                         “/¶  v”    The string "/¶  v". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ /¶  v"
                                    Implicit print

— 小马同志
source

1

其实是30个位元组

它的工作原理与ETHproductions的Japt答案相同，后者稍后会添加额外的空格，并将整个字符串分成5行以进行隐式打印。在线尝试！

"\|||\"*" ^ /"+"/ v"@+#' j5@╪i

开球

            Implicit input.
"\|||\"*    Add the middle portion and multiply that by the input.
" ^ /"+     Append the top.
"/ v"@+     Append the bottom.
#           Convert into a list of strings
' j         Join with spaces.
5@╪         Split into a list of length-5 strings.
i           Flatten list onto the stack for implicit printing with newlines.

— 神探洛克9
source

用自己的语言胜过Mego，做得很好！

— Caird coinheringaahing

1

果冻，25 23字节

它的工作原理与ETHproductions的Japt答案相同，后者稍后会添加额外的空格，并且在打印之前将整个字符串分成长度为5的字符串。在线尝试！

编辑：我知道有一种方法可以使高尔夫球手更容易地连接S链的顶部和底部。多亏了Erik the Outgolfer占用了-2个字节。

“\|||\”ẋ“ ^ /“/ v”jKs5Y

开球

                Left argument: n
“\|||\”ẋ        Repeat the middle portion n times.
“ ^ /“/ v”j     Append the top and bottom.
K               Join with spaces.
s5              Split into a list of length-5 strings.
Y               Print the strings with linefeeds.

— 神探洛克9
source

“\|||\”ẋ“ ^ /“/ v”jKs5Y

— Erik the Outgolfer '17

1

木炭，25字节

↘^\¶/¶Ｇ→⁵↓⊕⊗Ｎ←⁵|¶ \↗¶\¶v/

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

— 尼尔
source

通过使用完全不同的方法，另一个木炭答案是相同的字节数，这很有趣。不过，我更喜欢您的。另一个接近硬编码，但您实际上是在使用木炭的强度。

— 凯文·克鲁伊森

@KevinCruijssen你说的是力量，但这确实应该是对角印刷的。可悲的是，我能做的最好的是29个字节：↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v

— 尼尔（Neil）

1

bash，67个字节

printf -v a %\*s $1 \ ;echo '  ^
 / '"${a// /\\
| | |
 \\ }"'/
  v'

在线尝试

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

0

Java 8，93 76字节

n->{String r="  ^\n / ";for(;n-->0;r+="\\\n| | |\n \\ ");return r+"/\n  v";}

@IanH的端口。在打完高尔夫球之后，C＃.NET的答案是什么。

在这里尝试。

— 凯文·克鲁伊森
source

有趣的是，这string与vs var部分的期望几乎完全相同。

— 伊恩·

@IanH。和n->vs n=>;）

— 凯文·克鲁伊森

画一个S链

背景

画“ S”

任务

测试用例

Python 2，47个字节

C＃（.NET Core），73 69 66 64 62字节

Python 3，48 56 59 61 字节

05AB1E，27 26字节

Japt，34 25 23字节

怎么运行的

SOGL V0.12，26个 25 18 字节

JavaScript（ES6），60个字节

测试片段

木炭，27 26 25字节

Perl 5中，39 37个字节

其实 49字节

05AB1E，38个字节

C（gcc），82字节

C＃（.NET Core），101 77 73字节

视网膜，38字节

说明

Pyth，46个字节

Pyth，40个字节

说明

Pyth，33 32 31字节

视网膜，45字节

点，45 42 33字节

说明

MATL，47 44 43字节

Haskell，53个字节

Excel，60个字节

PowerShell，83，57字节

AsciiDots，88字节

果冻，32字节

其实是30个位元组

果冻，25 23字节

木炭，25字节

bash，67个字节

Java 8，93 76字节