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,

code-golf string ascii-art

— caird coinheringaahing
fonte

13

Wikipedia chama Sdo fresco S , e chama uma versão infinita do umS Chain

— Stephen

Podemos imprimir como uma lista de linhas?

— Sr. Xcoder

@ Mr.Xcoder você pode

— caird coinheringaahing

@ Stephen 10 minutos pesquisando no Google e isso não apareceu. Vou editar o nome da questão

— caird coinheringaahing

@cairdcoinheringaahing Procurei imagens, que poderiam ter sido essas: P

— Stephen

15

Python 2 , 47 bytes

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

Experimente online!

— Lynn
fonte

10

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!

— meu pronome é monicareinstate
fonte

1

Se este fosse um golfe da resposta C # existente, eu nunca seria capaz de dizer. Bem feito :-)

— ETHproductions

Você pode explicar o que new string[n+1]faz? Eu nunca vi isso antes.

— Ian H.

Cria uma matriz de cadeias vazias AFAIK. Eu usei um truque com String.Join, aka juntar { "", "", "", ""} com separador "\ \ n | | | \ n \"

— o meu pronome é monicareinstate

@ alguém Woah, eu nunca reconheci esse truque antes. Realmente legal! (Também o meu mau, eu que o new string[n+1]foi algum tipo de construtor seqüência complicada e não uma declaração de matriz -.-)

— Ian H.

6

Python 3 , 48 56 59 61 bytes

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

Experimente online!

— Mr. Xcoder
fonte

Você pode salvar 2 bytes desmarcando as barras invertidas solitárias.

— L3viathan

@ L3viathan Apenas atualização também

— Mr. Xcoder

56 bytes; não tenho certeza se este é um jogo justo ; não funciona no TIO

— L3viathan

@ L3viathan Isso não está correto. Extra \ \.

— Sr. Xcoder

No TIO: sim. No meu terminal: não.

— L3viathan

6

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

— Emigna
fonte

5

Seu código parece um pouco com um elefante para me :)

— Wojowu

É literalmente assustador o quão perto minha resposta foi da sua: '^…/ \©IF„| ûû„\ û}\®R'v).Csem olhar.

— Magic Octopus Urn

6

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"

— ETHproductions
fonte

Bater carvão e amarrar SOGL? Excelente trabalho!

— Shaggy

A propósito, você pode produzir uma matriz de linhas, para abandonar os últimos 2 caracteres.

— Shaggy,

@ Shaggy Isso é ótimo, agora estamos vencendo!

— ETHproductions

Ultimamente, estamos indo bem :)

— Shaggy

6

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

— dzaima
fonte

2

push "|" and " "o que diabos é que builtin

— Steven H.

1

@StevenHewitt esses são na verdade dois built-ins, mas me juntei a eles juntos (como eu faço com outras coisas) porque eu não acho que não é necessário o material separado que é usado em conjunto em breve

— dzaima

5

JavaScript (ES6), 60 bytes

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

Snippet de teste

Mostrar snippet de código

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>

Expandir snippet

— Justin Mariner
fonte

1

57: n=>' ^\n /${' \\ \\\n| | |\n'.repeat(n).slice(2)} \\ /\n v'(usando crase e novas linhas literais)

— edc65

5

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

— totalmente humano
fonte

1

Você pode economizar 1 byte, chamando Print (em vez de adicionar as strings) e usando \r: `^ ⸿ / × \ ⸿ | | | ⸿ \ Ｉθ / ⸿ v`. Versão detalhada .

— Charlie

Ah ... eu vou ter que lembrar \rcomo o caminho para obter novas linhas do jeito são. Obrigado!

— totallyhuman

25 bytes

— somente ASCII

@ Somente ASCII: P -

— totallyhuman 4/17

4

Perl 5 , 39 37 bytes

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

Experimente online!

Raspou dois bytes com a sugestão de @DomHastings

— Xcali
fonte

Se você usar aspas simples, não precisará escapar das barras invertidas para -2! :)

— Dom Hastings

3

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

— Mego
fonte

3

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

— Riley
fonte

3

C (gcc) , 82 bytes

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

Experimente online!

— cleblanc
fonte

3

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.

— Ian H.
fonte

77 bytes.

— totallyhuman

@icrieverytim Ahhh, é claro, isso é muito melhor.

— Ian H.

Você pode mudar --n>=0para n-->0e s+="/\n v";return s;para return s+"/\n v";salvar alguns bytes.

— Kevin Cruijssen

1

@KevinCruijssen Thanks, fixed!

— 21817 Ian H.

3

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.

— Martin Ender
fonte

Abordagem pura. Eu estava tentando descobrir uma maneira de usar junção de espaços para minha solução Pip, mas não funcionou devido aos diferentes números de espaços à esquerda em linhas diferentes.

— DLosc 21/09

2

Pitão, 46 bytes

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

Suíte de teste.

— Steven H.
fonte

36 bytes:%" ^\n / %s/\n v"*Q"\\\n| | |\n \

— Sr. Xcoder

31 bytes .

— Sr. Xcoder

2

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.

2

Pitão, 33 32 31 bytes

Obrigado Sr. Xcoder por um byte.

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

Experimente on-line: Demonstration or Test Suite

— Jakube
fonte

Resposta muito boa! Você pode reduzi-lo para 32 bytes .

— Sr. Xcoder

2

31 bytes , de fato.

— Sr. Xcoder

2

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
 \¶| | |¶

— mbomb007
fonte

2

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

— DLosc
fonte

Parece o Lumpy Space Princess de Adventure Time :)

— YSC

2

MATL , 47 44 43 bytes

-3 bytes graças a Giuseppe

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

Experimente online!

— Cinaski
fonte

' ^' ' / \ 'XK'| | |'XJ`' \ \'JGq@-]KP' v'é 44 bytes.

— Giuseppe

1

Haskell, 53 bytes

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

Experimente online!

— nimi
fonte

1

Excel, 60 bytes

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

— Wernisch
fonte

Você deve verificar se é um poliglota com o Planilhas Google

— Taylor Scott

1

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.

— raiz
fonte

Você pode jogar muito seu forloop usando 1..--$args[0]|%{ }.

— AdmBorkBork

Além disso, você pode usar novas linhas literais entre as seqüências adjacentes para economizar ";"e é mais barato se livrar $scompletamente. 57 bytes

— AdmBorkBork 21/09

Liso. Eu gosto da nova linha salvar. Engraçado que eu perdi a 1..$argsoportunidade. Não sei ao certo qual é a etiqueta correta neste site. Eu faço alterações na minha resposta e credito a você ou você publica sua solução como uma resposta separada?

— root

Editar as alterações e dar crédito é a etiqueta adequada. Bem-vindo ao PPCG.

— AdmBorkBork 21/09

1

AsciiDots , 88 bytes

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

Experimente online!

— user31415
fonte

1

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

— Camarada SparklePony
fonte

1

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.

— Sherlock9
fonte

Bom trabalho superando Mego em seu próprio idioma!

— caird coinheringaahing

1

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.

— Sherlock9
fonte

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

— Erik the Outgolfer

1

Carvão , 25 bytes

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

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

— Neil
fonte

Engraçado como a outra resposta do carvão vegetal é a mesma contagem de bytes, usando uma abordagem completamente diferente. Eu gosto mais do seu, no entanto. O outro é quase codificado, mas o seu está realmente usando a força do carvão vegetal.

— Kevin Cruijssen 27/10

@KevinCruijssen Você diz força, mas isso deve realmente ser impresso na diagonal; infelizmente o melhor que pude fazer foi 29 bytes:↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v

— Neil

1

bash, 67 bytes

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

Experimente online

— Nahuel Fouilleul
fonte

0

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.

— Kevin Cruijssen
fonte

É engraçado como isso é exatamente exatamente o mesmo esperado para a parte stringvs. var

— 21817 Ian H.

@IanH. E o n->vs n=>;)

— Kevin Cruijssen

Desenhe uma cadeia S

fundo

Desenhando o "S"

Tarefa

Casos de teste

Python 2 , 47 bytes

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

Python 3 , 48 56 59 61 bytes

05AB1E , 27 26 bytes

Japonês , 34 25 23 bytes

Como funciona

SOGL V0.12 , 26 25 18 bytes

JavaScript (ES6), 60 bytes

Snippet de teste

Carvão , 27 26 25 bytes

Perl 5 , 39 37 bytes

Na verdade , 49 bytes

05AB1E , 38 bytes

C (gcc) , 82 bytes

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

Retina , 38 bytes

Explicação

Pitão, 46 ​​bytes

Pitão, 40 bytes

Explicação

Pitão, 33 32 31 bytes

Retina , 45 bytes

Pip , 45 42 33 bytes

Explicação

MATL , 47 44 43 bytes

Haskell, 53 bytes

Excel, 60 bytes

PowerShell , 83 , 57 bytes

AsciiDots , 88 bytes

Geléia , 32 bytes

Na verdade , 30 bytes

Geléia , 25 23 bytes

Carvão , 25 bytes

bash, 67 bytes

Java 8, 93 76 bytes

Pitão, 46 bytes