sfondo

Quando ero più giovane, mi hanno insegnato un metodo per disegnare una strana forma a "S", che io (insieme ai miei compagni di classe) ho trovato affascinante. Oggi l'ho riscoperto e, grazie al suo approccio formulaico al disegno, ho pensato che potesse portare a una sfida interessante: P

Disegnando la "S"

La S può essere disegnata seguendo questi semplici passaggi:

Innanzitutto, disegna 2 file di tre linee verticali in questo modo

| | |

| | |

Quindi, collega la linea in alto a sinistra con la linea centrale in basso e la parte centrale in alto con la linea in basso a destra per produrre

| | |
 \ \
| | |

Infine, disegna una parte superiore e inferiore sull'immagine attualmente disegnata in modo che finisca per apparire

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

Come puoi vedere, questo si traduce in una forma a "S". Tuttavia, se esteso (disegnandolo con più di 2 righe), produce uno schema molto interessante. Il tuo compito è riprodurre questo modello interessante.

Compito

Dato un numero intero dove n >= 2, l'output della S con le nrighe da cui ricavare. L'output può essere restituito da una funzione e l'input può essere preso in metodi standard. Lo spazio bianco finale / iniziale sia per l'immagine complessiva, sia per ogni riga, va bene. Tuttavia, gli spazi delle righe iniziali devono essere coerenti in modo che "non sia interrotto. È possibile generare un elenco di righe.

Casi test

input
output
---

2

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

---

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

---

10

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

Questo è un code-golf quindi vince il codice più corto! In bocca al lupo,

code-golf string ascii-art

— caird coinheringaahing
fonte

13

Wikipedia definisce il Sil fresco S e chiede una versione infinita di unS Chain

— Stephen

Possiamo produrre un elenco di righe?

— Mr. Xcoder,

@ Mr.Xcoder potresti

— caird coinheringaahing il

@Stephen 10 minuti su Google e questo non è emerso.

— Modificherò

@cairdcoinheringaahing Ho cercato immagini, che potrebbero essere state: P

— Stephen,

15

Python 2 , 47 byte

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

Provalo online!

— Lynn
fonte

10

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

Due byte in meno e aspetto simile al perl grazie a Barodus. Non hai pensato di usare int? per null.

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

Provalo online!

— il mio pronome è monicareinstate
fonte

1

Se questo fosse un golf della risposta C # esistente, non sarei mai stato in grado di dirlo. Ben fatto :-)

— ETHproductions

Puoi spiegare cosa new string[n+1]fa? Non l'ho mai visto prima.

— Ian H.,

Crea una matrice di stringhe vuote AFAIK. Ho usato un hack con string.Join, aka join {"", "", "", ""} con il separatore "\ \ n | | | \ n \"

— mio pronome è monicareinstate il

@ qualcuno Woah, non ho mai riconosciuto questo trucco prima. Veramente cool! (Anche il mio male, ho pensato che new string[n+1]fosse una specie di costruttore di stringhe complicato e non una dichiarazione di matrice -.-)

— Ian H.

6

Python 3 , 48 56 59 61 byte

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

Provalo online!

— Mr. Xcoder
fonte

È possibile salvare 2 byte eliminando il backslash solitario.

— L3viathan,

@ L3viathan Anche solo l'aggiornamento

— Mr. Xcoder,

56 byte; non sono sicuro se questo è un gioco equo ; non funziona su TIO

— L3viathan,

@ L3viathan Non è corretto. Extra\ \ .

— Mr. Xcoder,

Su TIO: sì. Nel mio terminale: no.

— L3viathan,

6

05AB1E , 27 26 byte

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

Provalo online!

Versione alternativa a 27 byte

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

Provalo online!

Spiegazione

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

Il tuo codice mi sembra un po 'un elefante :)

— Wojowu,

È letteralmente spaventoso quanto la mia risposta fosse vicina alla tua: '^…/ \©IF„| ûû„\ û}\®R'v).Csenza guardare.

— Magic Octopus Urn,

6

Japt , 34 25 23 byte

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

Provalo online!Output come una matrice di linee; -Rbandiera aggiunta per unirsi su newline. (Grazie @Shaggy)

~~Primo~~ secondo tentativo, potrebbe essere migliorabile ...

Come funziona

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

Battere carbone e legare SOGL? Lavoro eccellente!

— Shaggy,

A proposito, puoi generare una serie di linee, in modo da poter abbandonare gli ultimi 2 caratteri.

— Shaggy,

@Shaggy Fantastico, ora stiamo vincendo!

— ETHproductions,

Ultimamente stiamo andando bene :)

— Shaggy,

6

SOGL V0.12 , 26 25 18 byte

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

Provalo qui!

Utilizza la stessa strategia della risposta Japt di ETHproductions

Spiegazione:

..‘           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 " "che diamine è quello incorporato

— Steven H.

1

@StevenHewitt in realtà sono due built-in, ma li ho uniti insieme (come faccio con altre cose) perché non penso che non sia necessario separare le cose che

— verranno

5

JavaScript (ES6), 60 byte

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

Test dello snippet

Mostra snippet di codice

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>

Espandi frammento

— Justin Mariner
fonte

1

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

— newline

5

Carbone , 27 26 25 byte

-1 byte grazie a Carlos Alejo. -1 byte grazie solo a ASCII.

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

Provalo online! Il collegamento è alla versione dettagliata. # carbone-verbose-obfucation

— totallyhuman
fonte

1

Puoi salvare 1 byte chiamando semplicemente Print (invece di aggiungere le stringhe) e usando \r: `^ ⸿ / × \ ⸿ | | | ⸿ \ Ｉθ / ⸿ v`. Versione dettagliata .

— Charlie

Ah ... dovrò ricordare \rcome il modo di ottenere le nuove linee in modo sano. Grazie!

— totalmente umano

25 byte

— solo ASCII

@ Solo ASCII: P -

— totalmente umano il

4

Perl 5 , 39 37 byte

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

Provalo online!

Rasato due byte con il suggerimento di @DomHastings

— Xcali
fonte

Se usi virgolette singole, non è necessario sfuggire alle barre rovesciate per -2! :)

— Dom Hastings,

3

In realtà , 49 byte

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

Provalo online!

Spiegazione:

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

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

Provalo 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 byte

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

Provalo online!

— cleblanc
fonte

3

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

_{24 byte salvati grazie a cri everytim !}
_{Salvato 4 byte grazie a Kevin Cruijssen !}

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

Provalo online!

Come al solito, ripetere le stringhe in C # è un dolore.

— Ian H.
fonte

77 byte.

— totalmente umano il

@icrieverytim Ahhh, ovviamente, è molto meglio.

— Ian H.,

È possibile modificare --n>=0a n-->0ed s+="/\n v";return s;a return s+"/\n v";salvare alcuni byte.

— Kevin Cruijssen,

1

@KevinCruijssen Grazie, risolto!

— Ian H.,

3

Retina , 38 byte

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

Provalo online!

Stampa una colonna di spazi iniziali e su spazio finale su ogni riga.

Spiegazione

Il principale risparmio di byte deriva dall'omissione degli spazi in tutte le parti letterali e dall'inserimento alla fine. La figura è strutturata in modo tale che non ci siano mai due non spazi uno accanto all'altro, quindi se li rimuoviamo tutti, possiamo quasi fissare la forma inserendo uno spazio in ogni posizione alla fine:

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

diventa:

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

È quasi corretto, fatta eccezione per il rientro. L' ^e vmancano due spazi. In realtà è più facile da risolvere, perché se si inserisce semplicemente uno spazio esplicito davanti a ciascuno di essi, si otterranno due spazi aggiuntivi alla fine. Le linee con le barre sono più complicate perché richiedono solo uno spazio aggiuntivo. Per risolvere questo problema, inseriamo un carattere segnaposto ( x). Quando inseriamo gli spazi alla fine, non li inseriamo solo per ogni corrispondenza vuota, ma opzionalmente abbiniamo quello x. Ciò significa che invece di inserire uno spazio davanti a x, lo xstesso viene sostituito. E poi ci sarà ancora una partita vuota subito dopo x. Ciò significa che ognixaggiunge esattamente uno spazio senza cambiare nient'altro. Quindi quello che vogliamo impostare è questo:

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

che ci darà il risultato desiderato. Quindi ecco il codice:

.+
$*

Converti l'input in unario.

1
¶|||¶x\\

Converti ciascuna 1in due righe con |||e x\\(e un avanzamento riga iniziale).

^
 ^¶x/\

Inserire le prime due righe con ^e x/\.

.$
/¶ v

Risolvi il finale x\\trasformando l'ultimo \in /e aggiungendo una riga con il v.

x?

Sostituisci ogni xpartita vuota con uno spazio.

— Martin Ender
fonte

Approccio pulito. Stavo cercando di trovare un modo per utilizzare join-on-space per la mia soluzione Pip, ma non ha funzionato del tutto a causa del diverso numero di spazi iniziali su righe diverse.

— DLosc

2

Pyth, 46 byte

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

Suite di test.

— Steven H.
fonte

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

— Mr. Xcoder,

31 byte .

— Mr. Xcoder,

2

Pyth, 40 byte

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

Abbastanza simile a quello di Steven Hewitt, ma sviluppato indipendentemente.

Provalo online

Spiegazione

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 byte

Grazie Mr. Xcoder per un byte.

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

Provalo online: dimostrazione o suite di test

— Jakube
fonte

Risposta molto bella! È possibile ridurlo a 32 byte .

— Mr. Xcoder,

2

31 byte , infatti.

— Mr. Xcoder,

2

Retina , 45 byte

Questa è una soluzione piuttosto semplice.

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

Provalo online

Se invece l'arte potesse essere indicizzata 1, sarebbe un po 'più breve (44 byte):

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

— mbomb007
fonte

2

Pip , 45 42 33 byte

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

Provalo online!

Spiegazione

Il codice è davvero semplice, anche se le nuove righe rendono più difficile la lettura. Ecco un modo migliore per vedere la struttura:

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

L'elemento ripetuto nella catena a S è

   \
| | |
 \

Prendi questo come una stringa letterale e ripeterlo avolte (dov'è ail primo argomento della riga di comando). Quindi anteporre il prefisso:

  ^
 /

e aggiungi il suffisso:

   /
  v

e stampa.

(Mi piace come sia finito un po 'come un programma> <>.)

— DLosc
fonte

Sembra Lumpy Space Princess di Adventure Time :)

— YSC

2

MATL , 47 44 43 byte

-3 byte grazie a Giuseppe

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

Provalo online!

— Cinaski
fonte

' ^' ' / \ 'XK'| | |'XJ`' \ \'JGq@-]KP' v'è di 44 byte.

— Giuseppe,

1

Haskell, 53 byte

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

Provalo online!

— Nome del modello
fonte

1

Excel, 60 byte

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

— Wernisch
fonte

Dovresti considerare di verificare se si tratta di un poliglotta con Fogli Google

— Taylor Scott,

1

PowerShell , 83 , 57 byte

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

Provalo online!

I suggerimenti di Per @ AdmBorkBork,

Semplificato forutilizzando un intervallo di numeri.
Sostituite ;le stringhe combinate.
Rimossa una definizione variabile non necessaria.

— radice
fonte

Puoi giocare a golf il tuo forloop molto usando 1..--$args[0]|%{ }.

— AdmBorkBork,

Inoltre, puoi usare letteralmente newline tra le stringhe adiacenti per risparmiare ";"ed è più economico sbarazzartene $scompletamente. 57 byte

— AdmBorkBork,

Slick. Mi piace il salvataggio di newline. Divertente che ho perso l' 1..$argsoccasione. Non sono sicuro di quale sia l'etichetta corretta su questo sito. Apporto delle modifiche alla mia risposta e mi accredito o inserisco la soluzione come risposta separata?

— root

Modificare le modifiche e dare credito è l'etichetta corretta. Benvenuti in PPCG.

— AdmBorkBork,

1

AsciiDots , 88 byte

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

Provalo online!

— user31415
fonte

1

Gelatina , 32 byte

Porta noiosa della soluzione Python di Lynn .

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

Provalo online!

Spiegazione:

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

— Compagno SparklePony
fonte

1

In realtà , 30 byte

Funziona con lo stesso principio della risposta Japt di ETHproductions , in cui gli spazi aggiuntivi vengono aggiunti in seguito e l'intera stringa viene suddivisa in righe di 5 per la stampa implicita. Provalo 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

Bel lavoro superando Mego nella sua lingua!

— caird coinheringaahing

1

Gelatina , 25 23 byte

Questo funziona secondo lo stesso principio di della risposta Japt di ETHproductions , in cui gli spazi aggiuntivi vengono aggiunti in seguito e l'intera stringa viene suddivisa in stringhe di lunghezza 5 prima della stampa. Provalo online!

Modificare: sapevo che c'era un modo per unire la parte superiore e inferiore della catena a S in un modo più golfistico. Grazie a Erik the Outgolfer per -2 byte.

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

Carbone , 25 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

— Neil
fonte

Divertente come l' altra risposta al carbone sia lo stesso numero di byte usando un approccio completamente diverso. Mi piacciono di più i tuoi, però. L'altro è quasi codificato, ma il tuo sta effettivamente usando la forza del carbone.

— Kevin Cruijssen,

@KevinCruijssen Dici forza, ma dovrebbe davvero essere stampato in diagonale; purtroppo il meglio che potei fare ci furono 29 byte:↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v

— Neil,

1

bash, 67 byte

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

Provalo online

— Nahuel Fouilleul
fonte

0

Java 8, 93 76 byte

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

Porto di @IanH. La risposta di C # .NET dopo averla giocata un po 'di più.

Provalo qui.

— Kevin Cruijssen
fonte

È divertente come questo sia quasi identico aspettarsi dalla parte stringvs. var

— Ian H.,

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

— Kevin Cruijssen il

Disegna una S-Chain

sfondo

Disegnando la "S"

Compito

Casi test

Python 2 , 47 byte

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

Python 3 , 48 56 59 61 byte

05AB1E , 27 26 byte

Japt , 34 25 23 byte

Come funziona

SOGL V0.12 , 26 25 18 byte

JavaScript (ES6), 60 byte

Test dello snippet

Carbone , 27 26 25 byte

Perl 5 , 39 37 byte

In realtà , 49 byte

05AB1E , 38 byte

C (gcc) , 82 byte

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

Retina , 38 byte

Spiegazione

Pyth, 46 byte

Pyth, 40 byte

Spiegazione

Pyth, 33 32 31 byte

Retina , 45 byte

Pip , 45 42 33 byte

Spiegazione

MATL , 47 44 43 byte

Haskell, 53 byte

Excel, 60 byte

PowerShell , 83 , 57 byte

AsciiDots , 88 byte

Gelatina , 32 byte

In realtà , 30 byte

Gelatina , 25 23 byte

Carbone , 25 byte

bash, 67 byte

Java 8, 93 76 byte