Dessinez une chaîne en S

27

Contexte

Quand j'étais plus jeune, on m'a enseigné une méthode pour dessiner une étrange forme de "S", que j'ai (avec mes camarades de classe) trouvé fascinante. Aujourd'hui, je l'ai redécouvert, et en raison de son approche formelle pour le dessiner, j'ai pensé que cela pourrait conduire à un défi intéressant: P

Dessiner le "S"

Le S peut être dessiné en suivant ces étapes simples:

Tout d'abord, dessinez 2 rangées de trois lignes verticales comme ceci

| | |

| | |

Ensuite, connectez la ligne en haut à gauche avec la ligne du milieu en bas et le milieu en haut avec la ligne en bas à droite pour produire

| | |
 \ \
| | |

Enfin, dessinez un haut et un bas sur l'image actuellement dessinée afin qu'elle finisse par ressembler à

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

Comme vous pouvez le voir, cela se traduit par une forme en "S". Cependant, lorsqu'il est étendu (en le dessinant avec plus de 2 lignes), il produit un motif très intéressant. Votre tâche est de reproduire ce modèle intéressant.

Tâche

Étant donné un entier où n >= 2, sortez le S avec des nlignes à en faire. La sortie peut être renvoyée par une fonction et l'entrée peut être prise selon des méthodes standard. Les espaces de fin / de début pour l'image globale, ainsi que pour chaque ligne, conviennent parfaitement. Cependant, les espaces de ligne de tête doivent être cohérents afin que le «ne soit pas rompu.

Cas de test

input
output
---

2

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

---

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

---

10

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

C'est un code-golf donc le code le plus court gagne! Bonne chance,

code-golf string ascii-art caird coinheringaahing
la source
13
Wikipédia appelle Sle froid S , et appelle une version infinie du unS Chain
Stephen
Pouvons-nous produire une liste de lignes?
M. Xcoder
@ Mr.Xcoder vous pouvez
caird coinheringaahing
@Stephen 10 minutes googler et cela ne s'est pas produit. Je vais modifier le nom de la question
caird coinheringaahing
@cairdcoinheringaahing J'ai recherché des images, ça aurait pu être ça: P
Stephen

Réponses:

10

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

Deux octets de moins et une apparence de type perl grâce à Barodus. Vous n'avez pas pensé à utiliser int? pour null. 

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

Essayez-le en ligne!

mon pronom est monicareinstate
la source
1
Si c'était un golf de la réponse C # existante, je n'aurais jamais pu le dire. Bravo :-)
ETHproductions
Pouvez-vous expliquer ce que cela new string[n+1]fait? Je ne l'ai jamais vu auparavant.
Ian H.
Crée un tableau de chaînes vides AFAIK. J'ai utilisé un hack avec string.Join, aka join {"", "", "", ""} with separator "\ \ n | | | \ n \"
mon pronom est monicareinstate
@quelqu'un Woah, je n'avais jamais reconnu cette astuce avant. Vraiment cool! (Aussi ma mauvaise, je pensais que new string[n+1]c'était une sorte de constructeur de chaînes délicat et pas une déclaration de tableau -.-)
Ian H.
6

Python 3 , 48  56 59 61  octets

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

Essayez-le en ligne!

M. Xcoder
la source
Vous pouvez enregistrer 2 octets en évitant les seules barres obliques inverses.
L3viathan
@ L3viathan Mise à jour aussi
M. Xcoder
56 octets; Je ne sais pas si c'est un jeu équitable ; ne fonctionne pas sur TIO
L3viathan
@ L3viathan Ce n'est pas correct. Extra \ \.
M. Xcoder
Sur TIO: oui. Dans mon terminal: non.
L3viathan
6

05AB1E , 27 26 octets

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

Essayez-le en ligne!

Version alternative de 27 octets

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

Essayez-le en ligne!

Explication

'^                             # 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
la source
5
Votre code me ressemble un peu à un éléphant :)
Wojowu
C'est littéralement effrayant à quel point ma réponse était proche de la vôtre: '^…/ \©IF„| ûû„\ û}\®R'v).Csans regarder.
Magic Octopus Urn
6

Japt , 34 25 23 octets

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

Testez-le en ligne! Sorties sous forme de tableau de lignes; -Rdrapeau ajouté pour rejoindre les nouvelles lignes. (Merci @Shaggy)

Première Deuxième tentative, pourrait être améliorable ...

Comment ça marche

" ^ /{ ç'\²  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
la source
Battre le charbon de bois et attacher SOGL? Excellent travail!
Shaggy
Soit dit en passant, vous pouvez sortir un tableau de lignes, vous pouvez donc abandonner les 2 derniers caractères.
Shaggy
@Shaggy C'est super, maintenant nous gagnons!
ETHproductions
Nous nous en sortons bien ces derniers temps :)
Shaggy
6

SOGL V0.12 , 26 25 18 octets

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

Essayez-le ici!

Utilise la même stratégie que la réponse Japt d'ETHproductions

Explication:

..‘           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
la source
2
push "|" and " "qu'est-ce que c'est que ça
Steven H.
1
@StevenHewitt, ce sont en fait deux éléments intégrés, mais je les ai réunis (comme je le fais avec d'autres choses) parce que je ne pense pas qu'il ne soit pas nécessaire de séparer les choses qui
seront
5

JavaScript (ES6), 60 octets

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

Extrait de test

Afficher l'extrait de code

Justin Mariner
la source
1
57: n=>' ^\n /${' \\ \\\n| | |\n'.repeat(n).slice(2)} \\ /\n v'(en utilisant des backticks et des retours à la ligne littéraux)
edc65
5

Fusain , 27 26 25 octets

-1 octet merci à Carlos Alejo. -1 octet grâce à ASCII uniquement.

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

Essayez-le en ligne! Le lien est vers la version détaillée. # charcoal-verbose-obfucation

totalement humain
la source
1
Vous pouvez enregistrer 1 octet en appelant simplement Print (au lieu d'ajouter les chaînes) et en utilisant \r: `^ ⸿ / × \ ⸿ | | | ⸿ \ Ｉθ / ⸿ v`. Version verbeuse .
Charlie
Ah ... je vais devoir me souvenir \rcomme le moyen d'obtenir des nouvelles lignes de la manière saine. Merci!
2017 totalement humain
25 octets
ASCII uniquement
@ ASCII uniquement: P -
2017 totalement humain à 12h54
4

Perl 5 , 39 37 octets

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

Essayez-le en ligne!

Rasé deux octets avec la suggestion de @DomHastings

Xcali
la source
Si vous utilisez des guillemets simples, vous n'avez pas besoin d'échapper aux barres obliques inverses pour -2! :)
Dom Hastings
3

En fait , 49 octets

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

Essayez-le en ligne!

Explication:

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

05AB1E , 38 octets

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

Essayez-le en ligne!

…| |                         # 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
la source
3

C (gcc) , 82 octets

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

Essayez-le en ligne!

cleblanc
la source
3

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

24 octets enregistrés grâce à i cri everytim !
4 octets enregistrés grâce à Kevin Cruijssen !

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

Essayez-le en ligne!

Comme d'habitude, la répétition de chaîne en C # est une douleur.

Ian H.
la source
77 octets.
2017 totalement humain
@icrieverytim Ahhh, bien sûr, c'est bien mieux.
Ian H.
Vous pouvez changer --n>=0à n-->0et s+="/\n v";return s;pour return s+"/\n v";sauver quelques octets.
Kevin Cruijssen
1
@KevinCruijssen Merci, corrigé!
Ian H.
3

Rétine , 38 octets

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

Essayez-le en ligne!

Imprime une colonne d'espaces de début et d'espace de fin sur chaque ligne.

Explication

Les principales économies d'octets proviennent de l'omission des espaces dans toutes les parties littérales et de leur insertion à la fin. La figure est structurée de manière à ce qu'il n'y ait jamais deux non-espaces côte à côte, donc si nous les supprimons tous, nous pouvons presque corriger la forme en insérant un espace à chaque position à la fin:

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

devient:

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

C'est presque correct, sauf pour l'indentation. Les ^et vmanquent deux espaces. C'est en fait plus facile à corriger, car si nous insérons simplement un espace explicite devant chacun d'eux, cela se traduira par deux espaces supplémentaires à la fin. Les lignes avec les barres obliques sont plus délicates car elles nécessitent un seul espace supplémentaire. Pour résoudre ce problème, nous y insérons un caractère d'espace réservé ( x). Lorsque nous insérons les espaces à la fin, nous ne les insérons pas uniquement pour chaque correspondance vide, mais nous faisons éventuellement correspondre cela x. Cela signifie qu'au lieu d'insérer un espace devant le x, le xlui - même est remplacé. Et puis il y aura toujours un match vide juste après le x. Cela signifie que chaquexajoute exactement un espace sans rien changer d'autre. Donc, ce que nous voulons mettre en place, c'est ceci:

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

ce qui nous donnera le résultat souhaité. Voici donc le code:

.+
$*

Convertissez l'entrée en unaire.

1
¶|||¶x\\

Convertissez chacune 1en deux lignes avec |||et x\\(et un saut de ligne de tête).

^
 ^¶x/\

Insérez les deux premières lignes avec ^et x/\.

.$
/¶ v

Fixez la finale x\\en transformant la dernière \en /et en ajoutant une ligne avec le v.

x?

Remplacez chaque correspondance xou vide par un espace.

Martin Ender
la source
Approche soignée. J'essayais de trouver un moyen d'utiliser la jointure sur des espaces pour ma solution Pip, mais cela ne fonctionnait pas tout à fait en raison du nombre différent d'espaces de tête sur différentes lignes.
DLosc
2

Pyth, 46 octets

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

Suite de tests.

Steven H.
la source
36 octets:%" ^\n / %s/\n v"*Q"\\\n| | |\n \
M. Xcoder
31 octets .
M. Xcoder
2

Pyth, 40 octets

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

Assez similaire à Steven Hewitt, mais développé indépendamment.

Essayez-le en ligne

Explication

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.

la source
2

Rétine , 45 octets

Ceci est une solution assez simple.

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

Essayez-le en ligne

Si l'art pouvait être indexé à la place, il serait un peu plus court (44 octets):

.+
  ^¶ /x$0$*1
$
 \ /¶  v
1
 \x
x
 \¶| | |¶
mbomb007
la source
2

Pip , 45 42 33 octets

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

Essayez-le en ligne!

Explication

Le code est vraiment simple, bien que les nouvelles lignes le rendent plus difficile à lire. Voici une meilleure façon de voir la structure:

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

L'élément répété dans la chaîne S est

   \
| | |
 \

Prenez cela comme une chaîne littérale et répétez-le afois (où aest le premier argument de ligne de commande). Ajoutez ensuite le préfixe:

  ^
 /

et ajoutez le suffixe:

   /
  v

et imprimer.

(J'aime comment cela a fini par ressembler à un programme> <>.)

DLosc
la source
Cela ressemble à Lumpy Space Princess de Adventure Time :)
YSC
2

MATL , 47 44 43 octets

-3 octets grâce à Giuseppe

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

Essayez-le en ligne!

Cinaski
la source
' ^' ' / \ 'XK'| | |'XJ`' \ \'JGq@-]KP' v'est de 44 octets.
Giuseppe
1

Excel, 60 octets

="  ^
 / \
"&REPT("| | |
 \ \
",A1-1)&"| | |
 \ /
  v"
Wernisch
la source
Vous devriez envisager de vérifier s'il s'agit d'un polyglotte avec Google Sheets
Taylor Scott
1

PowerShell , 83 , 57 octets

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

Essayez-le en ligne!

Selon les suggestions de @ AdmBorkBork,

  • Simplifié foren utilisant une plage de nombres.
  • Chaînes remplacées ;et combinées.
  • Suppression d'une définition de variable inutile.
racine
la source
Vous pouvez jouer forbeaucoup à votre boucle en utilisant 1..--$args[0]|%{ }.
AdmBorkBork
En outre, vous pouvez utiliser des sauts de ligne littéraux entre les chaînes adjacentes pour économiser ";"et il est moins coûteux de s'en débarrasser $sentièrement. 57 octets
AdmBorkBork
Nappe. J'aime la sauvegarde de la nouvelle ligne. C'est drôle que j'ai raté l' 1..$argsoccasion. Je ne sais pas quelle est la bonne étiquette sur ce site. Dois-je apporter des modifications à ma réponse et vous créditer, ou affichez-vous votre solution en tant que réponse distincte?
root
Modifier les modifications et attribuer un crédit est la bonne étiquette. Bienvenue chez PPCG.
AdmBorkBork
1

Gelée , 32 octets

Port ennuyeux de la solution Python de Lynn .

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

Essayez-le en ligne!

Explication:

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  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
Camarade SparklePony
la source
1

En fait , 30 octets

Cela fonctionne sur le même principe que la réponse Japt d'ETHproductions , où des espaces supplémentaires sont ajoutés plus tard, et la chaîne entière est divisée en lignes de 5 pour une impression implicite. Essayez-le en ligne!

"\|||\"*" ^ /"+"/ 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
la source
Beau travail surpassant Mego dans sa propre langue!
caird coinheringaahing
1

Gelée , 25 23 octets

Cela fonctionne sur le même principe que la réponse Japt d'ETHproductions , où des espaces supplémentaires sont ajoutés plus tard, et la chaîne entière est divisée en chaînes de longueur 5 avant l'impression. Essayez-le en ligne!

Edit: je savais qu'il y avait un moyen de joindre le haut et le bas de la chaîne S de manière golfique. Merci à Erik l'Outgolfer pour -2 octets.

“\|||\”ẋ“ ^ /“/ 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
la source
“\|||\”ẋ“ ^ /“/ v”jKs5Y
Erik the Outgolfer
1

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code.

Neil
la source
C'est amusant de voir comment l' autre réponse Charcoal est le même nombre d'octets en utilisant une approche complètement différente. Mais j'aime mieux le vôtre. L'autre est presque codé en dur, mais le vôtre utilise en fait la force de Charcoal.
Kevin Cruijssen
@KevinCruijssen Vous dites force, mais cela devrait vraiment être imprimé en diagonale; malheureusement, le mieux que j'ai pu faire était de 29 octets:↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v
Neil
0

Java 8, 93 76 octets

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

Port de @IanH. est la réponse C # .NET après avoir joué un peu plus au golf.

Essayez-le ici.

Kevin Cruijssen
la source
C'est drôle comme c'est presque exactement la même chose pour la partie stringvs. var
Ian H.
@IanH. Et le n->vs n=>;)
Kevin Cruijssen