fundo

Quando eu era mais jovem, aprendi um método de desenhar uma forma estranha de "S", que eu (junto com meus colegas de classe) achei fascinante. Hoje, eu o redescobri e, devido à sua abordagem fórmula para desenhá-lo, pensei que poderia levar a um desafio interessante: P

Desenhando o "S"

OS pode ser desenhado seguindo estas etapas simples:

Primeiro, desenhe 2 linhas de três linhas verticais da seguinte maneira

| | |

| | |

Em seguida, conecte a linha superior esquerda com a linha do meio inferior e o meio superior com a linha de baixo direita para produzir

| | |
 \ \
| | |

Por fim, desenhe uma parte superior e inferior da imagem atualmente desenhada, para que ela pareça

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

Como você pode ver, isso resulta em uma forma "S". No entanto, quando estendido (desenhando-o com mais de 2 linhas), produz um padrão muito interessante. Sua tarefa é reproduzir esse padrão interessante.

Tarefa

Dado um número inteiro onde n >= 2, imprima O S com nlinhas a serem feitas a partir dele. A saída pode ser retornada de uma função e a entrada pode ser obtida em métodos padrão. O espaço em branco à direita / à direita para a imagem geral e para cada linha é bom. No entanto, os espaços de linha à esquerda devem ser consistentes para que o "não seja quebrado. Você pode exibir como uma lista de linhas.

Casos de teste

input
output
---

2

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

---

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

---

10

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

Este é um código de golfe, então o código mais curto vence! Boa sorte,

Python 2 , 47 bytes

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

Experimente online!

C # (.NET Core) , 73 69 66 64 62 bytes

Dois bytes a menos e aparência perl, graças ao Barodus. Não pensou em usar int? para nulos.

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

Experimente online!

Python 3 , 48  56 59 61  bytes

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

Experimente online!

05AB1E , 27 26 bytes

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

Experimente online!

Versão alternativa de 27 bytes

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

Experimente online!

Explicação

'^                             # 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

Japonês , 34 25 23 bytes

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

Teste online! Saídas como uma matriz de linhas; -Rsinalizador adicionado para participar de novas linhas. (Obrigado @Shaggy)

Primeira tentativa, pode ser improvável ...

Como funciona

" ^ /{ ç'\²  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"

SOGL V0.12 , 26 25 18 bytes

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

Experimente aqui!

Usa a mesma estratégia que a resposta Japt da ETHproductions

Explicação:

..‘           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

JavaScript (ES6), 60 bytes

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

Snippet de teste

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>

Carvão , 27 26 25 bytes

-1 byte graças a Carlos Alejo. -1 byte graças ao ASCII-only.

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

Experimente online! Link é a versão detalhada. # charcoal-verbose-obfucation

Perl 5 , 39 37 bytes

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

Experimente online!

Raspou dois bytes com a sugestão de @DomHastings

Na verdade , 49 bytes

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

Experimente online!

Explicação:

"| | |"@α;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

05AB1E , 38 bytes

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

Experimente online!

…| |                         # 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

C (gcc) , 82 bytes

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

Experimente online!

C # (.NET Core) , 101 77 73 bytes

_{Economizou 24 bytes graças a i cri everytim !
Guardado 4 bytes graças a Kevin Cruijssen !}

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

Experimente online!

Como de costume, repetir seqüências em C # é uma dor.

Retina , 38 bytes

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

Experimente online!

Imprime uma coluna de espaços à esquerda e à direita em cada linha.

Explicação

A principal economia de bytes vem da omissão dos espaços em todas as partes literais e da inserção deles no final. A figura é estruturada de forma que nunca haja dois não espaços próximos um do outro, portanto, se apenas removemos todos eles, podemos quase consertar a forma inserindo um espaço em todas as posições no final:

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

torna-se:

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

Isso está quase correto, exceto pelo recuo. O ^e vestão faltando dois espaços. Na verdade, é mais fácil de corrigir, porque se inserirmos um espaço explícito na frente de cada um deles, isso resultará em dois espaços adicionais no final. As linhas com as barras são mais complicadas porque exigem apenas um espaço adicional. Para corrigir isso, inserimos um caractere de espaço reservado lá ( x). Quando inserimos os espaços no final, não apenas os inserimos para todas as correspondências vazias, mas opcionalmente correspondemos a isso x. Isso significa que, em vez de inserir um espaço na frente do x, o xpróprio é substituído. E ainda haverá uma partida vazia logo após o x. Isso significa que todoxadiciona exatamente um espaço sem alterar mais nada. Então, o que queremos configurar é o seguinte:

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

o que nos dará o resultado desejado. Então aqui está o código:

.+
$*

Converta a entrada para unário.

1
¶|||¶x\\

Converta cada uma 1em duas linhas com |||e x\\(e um avanço de linha inicial).

^
 ^¶x/\

Insira as duas primeiras linhas com ^e x/\.

.$
/¶ v

Corrija a final x\\transformando a última \em /e acrescentando uma linha ao v.

x?
 

Substitua cada xcorrespondência vazia por um espaço.

Pitão, 46 ​​bytes

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

Suíte de teste.

Pitão, 40 bytes

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

Bastante semelhante ao de Steven Hewitt, mas desenvolvido de forma independente.

Experimente Online

Explicação

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.

Pitão, 33 32 31 bytes

Obrigado Sr. Xcoder por um byte.

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

Experimente on-line: Demonstration or Test Suite

Retina , 45 bytes

Esta é uma solução bastante simples.

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

Experimente online

Se a arte pudesse ser indexada em 1, seria um pouco menor (44 bytes):

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

Pip , 45 42 33 bytes

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

Experimente online!

Explicação

O código é realmente simples, embora as novas linhas tornem mais difícil a leitura. Aqui está uma maneira melhor de ver a estrutura:

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

O elemento repetido na cadeia S é

   \
| | |
 \

Tome isso como uma string literal e repita-a avezes (onde aé o primeiro argumento da linha de comando). Em seguida, acrescente o prefixo:

  ^
 /

e acrescente o sufixo:

   /
  v

e imprima.

(Eu gosto de como isso acabou parecendo um programa> <>.)

MATL , 47 44 43 bytes

-3 bytes graças a Giuseppe

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

Experimente online!

Haskell, 53 bytes

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

Experimente online!

Excel, 60 bytes

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

PowerShell , 83 , 57 bytes

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

Experimente online!

De acordo com as sugestões do @ AdmBorkBork,

• Simplificado forusando um intervalo numérico.
• ;Cordas substituídas e combinadas.
• Removida uma definição de variável desnecessária.

AsciiDots , 88 bytes

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

Experimente online!

Geléia , 32 bytes

Porta chata da solução Python de Lynn .

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

Experimente online!

Explicação:

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  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

Na verdade , 30 bytes

Isso funciona com o mesmo princípio da resposta Japt da ETHproductions , onde espaços extras são adicionados posteriormente, e toda a cadeia é dividida em linhas de 5 para impressão implícita. Experimente online!

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

Ungolfing

            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.

Geléia , 25 23 bytes

Isso funciona com o mesmo princípio que a resposta Japt da ETHproductions , onde espaços extras são adicionados posteriormente e toda a cadeia é dividida em cadeias de comprimento 5 antes da impressão. Experimente online!

Edit: Eu sabia que havia uma maneira de se juntar à parte superior e inferior da cadeia S de uma maneira mais golfista. Graças a Erik, o Outgolfer, por -2 bytes.

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

Ungolfing

                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.

Carvão , 25 bytes

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

Experimente online! Link é a versão detalhada do código.

bash, 67 bytes

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

Experimente online

Java 8, 93 76 bytes

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

Porto de @IanH. Resposta C # .NET do depois que eu joguei um pouco mais.

Experimente aqui.