Fondo

Cuando era más joven, me enseñaron un método para dibujar una extraña forma de "S", que (junto con mis compañeros de clase) me pareció fascinante. Hoy, lo redescubrí y, debido a su enfoque formulado para dibujarlo, pensé que podría conducir a un desafío interesante: P

Dibujando la "S"

La S se puede dibujar siguiendo estos simples pasos:

Primero, dibuja 2 filas de tres líneas verticales como esta

| | |

| | |

Luego, conecte la línea superior izquierda con la línea media inferior y la parte superior central con la línea inferior derecha para producir

| | |
 \ \
| | |

Finalmente, dibuje una parte superior e inferior en la imagen dibujada actualmente para que parezca

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

Como puede ver, esto da como resultado una forma de "S". Sin embargo, cuando se extiende (dibujándolo con más de 2 filas), produce un patrón muy interesante. Su tarea es reproducir este patrón interesante.

Tarea

Dado un número entero donde n >= 2, la salida de la S con nfilas para hacer de ella. La salida puede ser devuelta desde una función, y la entrada puede ser tomada en métodos estándar. El espacio en blanco final / inicial para la imagen general, así como para cada línea, está bien. Sin embargo, los espacios de línea iniciales deben ser consistentes para que el "no esté roto. Puede generar una lista de líneas.

Casos de prueba

input
output
---

2

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

---

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

---

10

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

Este es un código de golf, ¡el código más corto gana! Buena suerte,

code-golf string ascii-art

— caird coinheringaahing
fuente

13

Wikipedia llama a la Sdel frío S , y llama a una versión infinita de la unaS Chain

— Stephen

¿Podemos generar una lista de líneas?

— Sr. Xcoder

@ Mr.Xcoder puedes

— caird coinheringaahing

@Stephen 10 minutos buscando en Google y esto no surgió.

— Editaré

@cairdcoinheringaahing Busqué imágenes, eso podría haber sido: P

— Stephen

15

Python 2 , 47 bytes

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

Pruébalo en línea!

— Lynn
fuente

10

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

Dos bytes menos y apariencia perl gracias a Barodus. No pensé en usar int? para nulos.

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

Pruébalo en línea!

— mi pronombre es monicareinstate
fuente

1

Si este fuera un campo de golf de la respuesta C # existente, nunca hubiera podido decirlo. Bien hecho :-)

— ETHproductions

¿Puedes explicar qué new string[n+1]hace? No lo había visto antes.

— Ian H.

Crea una matriz de cadenas vacías AFAIK. He usado un hack con string.Join, también conocido como {"", "", "", ""} con separador "\ \ n | | | \ n \"

— mi pronombre es monicareinstate el

@ alguien Woah, nunca antes reconocí este truco. ¡Realmente genial! (También es malo, pensé que new string[n+1]era una especie de constructor de cadenas complicado y no una declaración de matriz -.-)

— Ian H.

6

Python 3 , 48 56 59 61 bytes

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

Pruébalo en línea!

— Sr. Xcoder
fuente

Puede guardar 2 bytes quitando las barras invertidas solitarias.

— L3viathan

@ L3viathan También actualizando también

— Sr. Xcoder

56 bytes; no estoy seguro si este es un juego justo ; no funciona en TIO

— L3viathan

@ L3viathan Eso no es correcto. Extra \ \.

— Sr. Xcoder

En TIO: sí. En mi terminal: no.

— L3viathan

6

05AB1E , 27 26 bytes

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

Pruébalo en línea!

Versión alternativa de 27 bytes

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

Pruébalo en línea!

Explicación

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

55

Tu código me parece un elefante :)

— Wojowu

Literalmente da miedo lo cerca que estaba mi respuesta a la tuya: '^…/ \©IF„| ûû„\ û}\®R'v).Csin mirar.

— Urna de pulpo mágico

6

Japt , 34 25 23 bytes

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

¡Pruébalo en línea! Salidas como un conjunto de líneas; -Rbandera agregada para unirse en nuevas líneas. (Gracias @Shaggy)

~~Primer~~ segundo intento, podría ser mejorable ...

Cómo 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"

— ETHproducciones
fuente

¿Golpear el carbón y atar el SOGL? ¡Excelente trabajo!

— Shaggy

Puede generar una serie de líneas, por cierto, para que pueda deshacerse de los últimos 2 caracteres.

— Shaggy

@ Shaggy Eso es genial, ¡ahora estamos ganando!

— ETHproductions

Hemos estado bien últimamente :)

— Shaggy

6

SOGL V0.12 , 26 25 18 bytes

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

Pruébalo aquí!

Utiliza la misma estrategia que la respuesta Japt de ETHproductions

Explicación:

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

2

push "|" and " "qué diablos es eso incorporado

— Steven H.

1

@StevenHewitt esos son en realidad dos incorporados, pero los uní (como hago con otras cosas) porque no creo que sea necesario separar las cosas que se usan juntas pronto

— dzaima

5

JavaScript (ES6), 60 bytes

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

Fragmento de prueba

Mostrar fragmento 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>

Expand snippet

— Justin Mariner
fuente

1

57: n=>' ^\n /${' \\ \\\n| | |\n'.repeat(n).slice(2)} \\ /\n v'(utilizando backticks y nuevas líneas literales)

— edc65

5

Carbón , 27 26 25 bytes

-1 byte gracias a Carlos Alejo. -1 byte gracias a ASCII-only.

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

Pruébalo en línea! El enlace es a la versión detallada. # carbón-verbose-obfucation

— totalmente humano
fuente

1

Puede guardar 1 byte simplemente llamando a Imprimir (en lugar de agregar las cadenas) y usando \r: `^ ⸿ / × \ ⸿ | El | | ⸿ \ Ｉθ / ⸿ v`. Versión detallada .

— Charlie

Ah ... tendré que recordar \rcomo la forma de obtener nuevas líneas de la manera más sensata. ¡Gracias!

— totalmente humano

25 bytes

— solo ASCII el

@ Solo ASCII: P -

— totalmente humano

4

Perl 5 , 39 37 bytes

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

Pruébalo en línea!

Afeitó dos bytes con la sugerencia de @DomHastings

— Xcali
fuente

Si usa comillas simples, ¡no necesita escapar de las barras invertidas para -2! :)

— Dom Hastings

3

En realidad , 49 bytes

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

Pruébalo en línea!

Explicación:

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

3

05AB1E , 38 bytes

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

Pruébalo en línea!

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

3

C (gcc) , 82 bytes

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

Pruébalo en línea!

— cleblanc
fuente

3

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

_{¡Ahorré 24 bytes gracias a i cri everytim !}
_{¡Guardado 4 bytes gracias a Kevin Cruijssen !}

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

Pruébalo en línea!

Como de costumbre, la cadena que se repite en C # es un dolor.

— Ian H.
fuente

77 bytes.

— totalmente humano

@icrieverytim Ahhh, por supuesto, eso es mucho mejor.

— Ian H.

Puede cambiar --n>=0a n-->0y s+="/\n v";return s;a return s+"/\n v";salvar algunos bytes.

— Kevin Cruijssen

1

@KevinCruijssen Gracias, arreglado!

— Ian H.

3

Retina , 38 bytes

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

Pruébalo en línea!

Imprime una columna de espacios iniciales y en espacios finales en cada línea.

Explicación

El principal ahorro de bytes proviene de omitir los espacios en todas las partes literales e insertarlos al final. La figura está estructurada de tal manera que nunca hay dos no espacios uno al lado del otro, por lo que si solo los eliminamos, casi podemos arreglar la forma insertando un espacio en cada posición al final:

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

se convierte en:

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

Eso es casi correcto, excepto por la sangría. los^ y vfaltan dos espacios. En realidad, eso es más fácil de solucionar, porque si solo insertamos un espacio explícito frente a cada uno de ellos, se obtendrán dos espacios adicionales al final. Las líneas con las barras son más complicadas porque requieren solo un espacio adicional. Para solucionar esto, insertamos un carácter de marcador de posición allí ( x). Cuando insertamos los espacios al final, no solo los insertamos para cada coincidencia vacía, sino que opcionalmente lo hacemos x. Eso significa que, en lugar de insertar un espacio en frente, agrega exactamente un espacio sin cambiar nada más. Entonces, lo que queremos configurar es esto:x , el xmismo se reemplaza. Y luego todavía habrá una coincidencia vacía justo después del x. Eso significa que cadax

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

lo que nos dará el resultado deseado. Así que aquí está el código:

.+
$*

Convierta la entrada a unario.

1
¶|||¶x\\

Convierta cada uno 1en dos líneas con |||y x\\(y un salto de línea inicial).

^
 ^¶x/\

Inserte las dos primeras líneas con ^y x/\.

.$
/¶ v

Arregle el final x\\convirtiendo el último \en /y agregando una línea con el v.

x?

Reemplace cada xpartido o vacío con un espacio.

— Martin Ender
fuente

Enfoque aseado. Estaba tratando de encontrar una manera de usar join-on-spaces para mi solución Pip, pero no funcionó debido a los diferentes números de espacios iniciales en diferentes filas.

— DLosc

2

Pyth, 46 bytes

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

Banco de pruebas.

— Steven H.
fuente

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

— Sr. Xcoder

31 bytes .

— Sr. Xcoder

2

Pyth, 40 bytes

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

Bastante similar al de Steven Hewitt, pero desarrollado independientemente.

Pruébalo en línea

Explicación

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 bytes

Gracias Sr. Xcoder por un byte.

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

Pruébelo en línea: Demostración o conjunto de pruebas

— Jakube
fuente

Muy buena respuesta! Puede reducirlo a 32 bytes .

— Sr. Xcoder

2

31 bytes , de hecho.

— Sr. Xcoder

2

Retina , 45 bytes

Esta es una solución bastante simple.

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

Pruébalo en línea

Si el arte pudiera ser indexado en su lugar, sería un poco más corto (44 bytes):

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

— mbomb007
fuente

2

Pip , 45 42 33 bytes

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

Pruébalo en línea!

Explicación

El código es realmente simple, aunque las nuevas líneas hacen que sea más difícil de leer. Aquí hay una mejor manera de ver la estructura:

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

El elemento repetido en la cadena S es

   \
| | |
 \

Tome esto como una cadena literal y repítalo aveces (donde aestá el primer argumento de la línea de comandos). Luego anteponga el prefijo:

  ^
 /

y agregue el sufijo:

   /
  v

e imprimir.

(Me gusta cómo terminó pareciéndose a un programa> <>).

— DLosc
fuente

Esto se parece a Lumpy Space Princess de Adventure Time :)

— YSC

2

MATL , 47 44 43 bytes

-3 bytes gracias a Giuseppe

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

Pruébalo en línea!

— Cinaski
fuente

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

— Giuseppe

1

Haskell, 53 bytes

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

Pruébalo en línea!

— nimi
fuente

1

Excel, 60 bytes

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

— Wernisch
fuente

Debería considerar verificar si se trata de un políglota con las Hojas de cálculo de Google

— Taylor Scott el

1

PowerShell , 83 , 57 bytes

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

Pruébalo en línea!

Según las sugerencias de @ AdmBorkBork,

Simplificado for mediante el uso de un rango de números.
Reemplazado ; y cadenas combinadas.
Se eliminó una definición variable innecesaria.

— raíz
fuente

Puedes jugar formucho al golf usando 1..--$args[0]|%{ }.

— AdmBorkBork

Además, puede usar nuevas líneas literales entre las cadenas adyacentes para ahorrar ";"y es más barato deshacerse de ellas por $scompleto. 57 bytes

— AdmBorkBork

Mancha. Me gusta la línea nueva guardar. Es curioso que perdí la 1..$argsoportunidad. No estoy seguro de cuál es la etiqueta correcta en este sitio. ¿Realizo cambios en mi respuesta y le doy crédito, o publico su solución como una respuesta separada?

— raíz

Editar los cambios y dar crédito es la etiqueta adecuada. Bienvenido a PPCG.

— AdmBorkBork

1

AsciiDots , 88 bytes

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

Pruébalo en línea!

— usuario31415
fuente

1

Jalea , 32 bytes

Puerto aburrido de la solución Python de Lynn .

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

Pruébalo en línea!

Explicación:

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

1

Actualmente , 30 bytes

Esto funciona según el mismo principio que la respuesta Japt de ETHproductions , donde se agregan espacios adicionales más adelante, y toda la cadena se divide en filas de 5 para la impresión implícita. Pruébalo en línea!

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

No golfista

            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
fuente

¡Buen trabajo superando a Mego en su propio idioma!

— caird coinheringaahing

1

Gelatina , 25 23 bytes

Esto funciona según el mismo principio que la respuesta Japt de ETHproductions , donde se agregan espacios adicionales más adelante, y toda la cadena se divide en cadenas de longitud 5 antes de imprimir. Pruébalo en línea!

Editar: Sabía que había una manera de unir la parte superior e inferior de la cadena S de una manera más golfista. Gracias a Erik the Outgolfer por -2 bytes.

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

No golfista

                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
fuente

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

— Erik the Outgolfer

1

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código.

— Neil
fuente

Es curioso cómo la otra respuesta de Carbón es el mismo número de bytes utilizando un enfoque completamente diferente. Sin embargo, me gustan más los tuyos. El otro está casi codificado, pero el tuyo está usando la fuerza del carbón.

— Kevin Cruijssen

@KevinCruijssen Dices fuerza, pero eso realmente debería imprimirse en diagonal; Lamentablemente, lo mejor que pude hacer fue 29 bytes:↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v

— Neil

1

bash, 67 bytes

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

Pruébalo en línea

— Nahuel Fouilleul
fuente

0

Java 8, 93 76 bytes

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

Puerto de @IanH. La respuesta de C # .NET después de jugar un poco más.

Pruébalo aquí

— Kevin Cruijssen
fuente

Es curioso cómo esto es casi exactamente idéntico esperar para la parte stringvs. var

— Ian H.

@IanH. And the n->vs n=>;)

— Kevin Cruijssen

Dibuja una cadena en S

Fondo

Dibujando la "S"

Tarea

Casos de prueba

Python 2 , 47 bytes

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

Python 3 , 48 56 59 61 bytes

05AB1E , 27 26 bytes

Japt , 34 25 23 bytes

Cómo funciona

SOGL V0.12 , 26 25 18 bytes

JavaScript (ES6), 60 bytes

Fragmento de prueba

Carbón , 27 26 25 bytes

Perl 5 , 39 37 bytes

En realidad , 49 bytes

05AB1E , 38 bytes

C (gcc) , 82 bytes

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

Retina , 38 bytes

Explicación

Pyth, 46 bytes

Pyth, 40 bytes

Explicación

Pyth, 33 32 31 bytes

Retina , 45 bytes

Pip , 45 42 33 bytes

Explicación

MATL , 47 44 43 bytes

Haskell, 53 bytes

Excel, 60 bytes

PowerShell , 83 , 57 bytes

AsciiDots , 88 bytes

Jalea , 32 bytes

Actualmente , 30 bytes

Gelatina , 25 23 bytes

Carbón de leña , 25 bytes

bash, 67 bytes

Java 8, 93 76 bytes