La (facile) strada verso il codice

30

Ingresso:

  • Un numero intero n , che è garantito essere ≥3 .
  • Un numero intero d , che è uno di [-1,0,1] .

Produzione:

Una strada di dimensione n , che sarà nella direzione nord-ovest se d=-1 ; una direzione nord se d=0 ; o una direzione nord-est se d=1 . La strada sarà sempre larga tre spazi (o cinque in generale se includessimo i confini esterni). Inoltre, ci sarà una linea di separazione stradale nella parte inferiore, e successivamente si alternerà mentre si sale.

Qualche esempio:

Ingresso: n=7,d=1
Uscita:

      / / /
     /   /
    / / /
   /   /
  / / /
 /   /
/ / /

Ingresso: n=4,d=-1 Uscita:

\   \
 \ \ \
  \   \
   \ \ \

Regole della sfida:

  • Qualsiasi quantità di spazi iniziali / finali e / o newline è accettabile, purché stampi la strada richiesta da qualche parte sullo schermo.
  • Invece delle opzioni [-1,0,1] puoi anche usare le opzioni [0,1,2] o [1,2,3] . Inoltre, puoi scegliere quale delle tre opzioni mappare a quale delle tre direzioni. (Assicurati di menzionare quali opzioni hai usato se differisce dal [-1,0,1][north-west, north, north-east] rispettivamente per quello che viene usato in questa descrizione della sfida!)
  • È accettabile qualsiasi formato di output ragionevole. Il più comune è ovviamente quello di stamparlo su STDOUT, ma anche restituirlo come stringa o elenco di caratteri 2D va bene.

Regole generali:

  • Questo è code-golf , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Sono vietate le scappatoie predefinite .
  • Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
  • Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

I due esempi precedenti e:

Ingresso: n=10,d=0
Uscita:

|   |
| | |
|   |
| | |
|   |
| | |
|   |
| | |
|   |
| | |
code-golf  ascii-art  number 
— Kevin Cruijssen
fonte
3
Titolo alternativo: "Mad Max Code Warrior"
— akozi
1
Il primo esempio non è errato? Ha una striscia centrale su ogni linea dispari invece di ogni linea pari
— moonheart08
2
@ moonheart08 No. Quello in basso avrà sempre una linea di separazione stradale, indipendentemente dal fatto che l'ingresso sia pari o dispari. Dopodiché si alterna mentre si sale. Ho modificato un po 'il testo per renderlo più chiaro.
— Kevin Cruijssen,
Oh, quindi mi sbaglio. Tutto apposto. Grazie per il chiarimento.
— moonheart08

Risposte:

2

Tela , 23 22 byte

B}⁴H‟ｍ↶⁷？／|∙/╋］＼|∙\╋］｝

Provalo qui!

Utilizza gli ingressi di direzione 0, 1 e 2.

Spiegazione:

...‟    push "--¶¶- ¶¶--"
    m   mold the horizontal length to the 1st input - a horizontal road
     ↶  rotate counter-clockwise - so the separator is on the bottom
        also replaces the dashes with bars

⁷?     ]     ]}  switch over the 2nd input:
                 default case (input 2):
  /                pad with spaces to a "/" diagonal
   |∙/╋            replace "|" with "/"
                 case 0:
        \          pad with spaces to a "\" diagonal
         |∙\╋      replace "|" with ""

case 1 is empty, but because of a bug, the trailing "}" is still required
— dzaima
fonte
Ti dispiacerebbe aggiungere una spiegazione? :)
— Kevin Cruijssen il
1
@KevinCruijssen aggiunto.
— dzaima,
16

Python 2 , 79 78 73 72 byte

n,d=input()
c='|\/'[d]
i=n
while i:print' '*(n-i*d)+c,i%2*c or' ',c;i-=1

Provalo online!

Prende [1,0,-1]per[north-west, north, north-east]

-1 byte, grazie a Neil

— TFeld
fonte
3
Accidenti, cosa non darei per un'affettatura simile a Python a Kotlin
— Adam
i%2*c or' 'salva un byte.
— Neil
7

Python 2 , 66 byte

n,d=input()
s=' '+'|\/'[d]
for c in(s*n)[n:]:print' '*n+s,c+s;n+=d

Provalo online!

Utilizza d=-1per NE, d=0per N e d=1per NW. Sfrutta gli spazi iniziali consentiti. La regola secondo cui il segmento inferiore della strada ha un separatore ha reso difficile ottenere la parità giusta; si ottiene affettando (s*n)[n:]la seconda metà delle 2nalternanze tra spazio e carattere stradale.

— XNOR
fonte
6

1. Python 3.5, 122 120 byte

Lo script accetta due parametri: n, d.

d: 0, 1, 2 -> \ | /

tio.run

import sys;(n,d)=[*map(int,sys.argv[1:3])];c="\\|/"[d]
for i in range(n):j=n+~i;print(" "*(i,0,j)[d],c,c*(j%2<1)or" ",c)

produzione:

$ ./script.py 6 2
      /   /
     / / /
    /   /
   / / /
  /   /
 / / /
$ ./script.py 6 1
 |   |
 | | |
 |   |
 | | |
 |   |
 | | |
$ ./script.py 6 0
 \   \
  \ \ \
   \   \
    \ \ \
     \   \
      \ \ \

Spiegazione

# parse input params
(n,d)=[*map(int,sys.argv[1:3])]

# select char for "road"
c="\\|/"[d]

# loop n-times
for i in range(n):

    # complement (how many lines to end)
    j=n+~i

    # print
    #   space i or 0 or j times
    #   road, center of road if j is even else space, road
    print(" "*(i,0,j)[d], c, c*(j%2<1) or " ", c)

modifica: -2 byte grazie a Kevin Cruijssen

— Rene
fonte
3
Bella risposta! :) Due piccole cose da golf: n-1-ipuò essere n+~i( suggerimento rilevante ) e j%2==0può essere j%2<1. Se non li hai ancora visti, Consigli per giocare a golf in Python e Consigli per giocare a golf in <tutte le lingue> potrebbero essere entrambi interessanti da leggere.
— Kevin Cruijssen,
1
Grazie :) Non l'ho n+~iancora visto , ma sembra utile. Grazie anche per l'evidenziazione del codice.
— Rene
Prego! Godetevi il vostro soggiorno e giocando a golf molte risposte. :) Oh, e buon fine settimana.
— Kevin Cruijssen,
j%2*" "or csalva un altro paio di byte.
— Neil
5

PowerShell , 88 82 80 74 71 byte

-8 byte grazie a Mazzy
-6 byte grazie ad AdmBorkBork e Mazzy
-3 byte grazie ad AdmBorkBork

param($n,$d)$n..1|%{' '*($_,($n-$_))[$d]+($y='/\|'[$d])," $y"[$_%2],$y}

Provalo online!

Utilizza [0,1,2] per NW, NE, N. Utilizza ddue volte come indice di elenco per ottenere prima il metodo di spaziatura (Elimina l'elenco quando si utilizza 2 che restituisce 0) e quindi quale carattere utilizzare per disegnare le linee. Aggiunge un elenco alla stringa di spazi (che contiene inavvertitamente spazi tra i membri quando viene aggiunto come tale) che costruisce la strada. Scambia anche tra una corsia aperta o un trattino in base al modulo matematico.

— Veskah
fonte
1
80 byte se utilizza [0,1,2] per [NW, NE, N]
— mazzy
1
@mazzy Smart. Mi ero completamente dimenticato di cadere intenzionalmente da un elenco.
— Veskah
1
Fantastica idea con array.toString di AdmBorkBork! Grazie. 74 byte
— mazzy
3
71 byte indicizzando la parte centrale in una stringa anziché in un array.
— AdmBorkBork
5

Carbone , 33 29 23 byte

↷ＮＮη⊘⊕ηＵＥ¹¦¹Ｆ⟦²±²⟧«Ｊι⁰η

Provalo online! Il collegamento è alla versione dettagliata del codice. Ora che tutti i bug di Charcoal sottostanti sembrano essere stati corretti, posso pubblicizzare il codice ottimale. Spiegazione:

↶Ｎ

Ruota la direzione del cursore in senso antiorario in base al primo input, in modo che 1 diventi nord est, 2 nord e 3 nord ovest.

Ｎη

Inserisci la lunghezza della strada.

⊘⊕ηＵＥ¹¦¹

Stampa metà della lunghezza della strada e poi allungala dando il separatore stradale.

Ｆ⟦²±²⟧«Ｊι⁰η

Stampa i lati della strada.

@KevinCruijssen ha successivamente inviato una versione più difficile di questa domanda che è stata eliminata ma gli utenti con abbastanza rep possono vederla qui: La (difficile) strada per il codice Il trucco che ho usato in questa risposta non è applicabile a quella domanda, quindi invece io ha scritto il seguente programma 47 a 45 byte:

Ｆ³«Ｊ×ι⊘⊕θ⁰≔…⟦¹ ⟧⊕﹪ι²ιＦη«↶§κ⁰Ｆ⊖§κ¹§ιⅉＰ§ιⅉ↑↷§κ⁰

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

Ｆ³«

Passare i lati e il separatore.

Ｊ×ι⊘⊕θ⁰

Salta all'inizio del lato.

≔…⟦¹ ⟧⊕﹪ι²ι

Crea un array contenente a 1e uno spazio, ma rimuovi di nuovo lo spazio se stiamo disegnando i lati anziché il separatore.

Ｆη«

Passa sopra ogni tratto di strada.

↶§κ⁰

Ruota la direzione del cursore di conseguenza.

Ｆ⊖§κ¹

Passa sopra uno in meno della lunghezza della sezione stradale ...

§ιⅉ

... e stampa elementi alternati dell'array. L'alternanza si ottiene indicizzando ciclicamente l'array con la coordinata Y del cursore.

Ｐ§ιⅉ

Stampa l'ultima riga di questa sezione stradale, ma senza spostare il cursore ...

↑

... in modo che il cursore possa essere spostato verso l'alto pronto per la sezione successiva.

↷§κ⁰

Ruota la direzione del cursore indietro pronta per la sezione successiva.

— Neil
fonte
4

Kotlin , 96 92 byte

{n,d->val c="\\|/"[d];(0..n-1).map{println(" ".repeat(n-it*(d-1))+ "$c ${" $c"[it%2]} $c")}}

Accetta [0, 1, 2] anziché [-1, 0, 1]

Funziona in modo simile alle soluzioni in altre lingue, ma sfortunatamente Kotlin non brilla davvero in questo.

val c=“\\|/“; recupera il carattere da utilizzare nella costruzione di strade sfruttando il fatto che Kotlin tratta le stringhe come una matrice di caratteri (come dovrebbe, guardando Java)

Provalo online!

— Adamo
fonte
Ciao, benvenuto in PPCG! C'è un problema minore nel tuo output. Le linee alteranti al centro della strada dovrebbero iniziare con una linea in basso per input uniformi, anziché in alto. Puoi confrontare il tuo output per 4con il mio esempio di 4vedere la differenza che intendo. Non conosco bene Kotlin, ma penso che tu possa risolverlo (e giocare a golf a 4 byte contemporaneamente) cambiando [(it+1)%2]in [it%2]. :) A parte questo è una bella risposta, quindi +1 da parte mia.
— Kevin Cruijssen,
Fantastico, grazie mille per l'accoglienza e l'aiuto! Lo cambierò
— Adam
4

Codice TSQL, 171 117 byte

Mi sono reso conto che questo potrebbe essere scritto molto più breve come codice.

DECLARE @n INT=7,@d INT=0

,@ INT=0a:PRINT
space(@n-@*@d)+stuff(replicate(substring('\|/',@d+2,1)+' ',3),3,@%2,space(@%2))SET
@+=1IF @n>@ GOTO a

Query TSQL, 137 byte

USE master
DECLARE @n INT=6,@ INT=-1

SELECT space(@n-y*@)+z+iif(y%2=1,z,'  ')+z 
FROM(SELECT top(@n)row_number()over(order
by @)y,' '+substring('\|/',@+2,1)z FROM spt_values)x

USE master non è necessario, se il database è già master. Alcuni utenti hanno tuttavia un database predefinito diverso.

Lo script quando lo prova è leggermente diverso. Ho dovuto sostituire lo spazio ascii-32 con ascii-160, gli spazi non sono stati mostrati.

Provalo

Ha apportato alcune modifiche e ha realizzato che avrei potuto sostituire

ordina per 1/0

con

ordinato da @

— t-clausen.dk
fonte
2
Come order by 1/0mai non provoca una divisione per zero errore?
— HoneyBadger
perché 1/0 non viene calcolato. dove esiste (selezionare 1/0) avrà lo stesso effetto
— t-clausen.dk
— Sposta la
3

JavaScript (ES8),  90 87  85 byte

(direction)(length)012

d=>g=(n,w=n)=>n?(c='/|\\'[d]).padStart([n--,,w-n][d])+` ${n&1?' ':c} ${c}
`+g(n,w):''

Provalo online!

JavaScript (ES6), 90 byte

Questo disegna l'output carattere per carattere con un po 'più di matematica invece di .padStart() metodo.

(direction)(length)123

d=>n=>(g=x=>y?` /|\\
`[x+5?17+y%2*4>>--x+5-[,n+1-y,n,y][d]&1&&d:(x=n,y--,4)]+g(x):'')(y=n)

Provalo online!

— Arnauld
fonte
3

Gelatina ,  31  30 byte

⁶ẋẋƤḂ};€ị“\/|”ẋ3KƊ}Ṛ⁹¡⁶-2¦€ÐeṚ

Un collegamento diadico che accetta la lunghezza a sinistra e la direzione negata * a destra che produce una seconda serie di caratteri.
*[north-west, north, north-east]=[1, 0, -1]

Provalo online! (il piè di pagina chiama il collegamento, si unisce ai caratteri di nuova riga e stampa il risultato)

Come?

⁶ẋẋƤḂ};€ị“\/|”ẋ3KƊ}Ṛ⁹¡⁶-2¦€ÐeṚ - Link: integer, L; integer, D
⁶                              - space character
 ẋ                             - repeat L times
     }                         - using the right argument (D):
    Ḃ                          -   mod 2 (0 if D = 0, 1 otherwise ...A would work too)
   Ƥ                           - for each prefix (of the list of spaces):
  ẋ                            -   repeat (D mod 2 times)
                  }            - using the right argument (D):
                 Ɗ             -   last three links as a monad:
        ị“\/|”                 -     index into "\/|" (1-indexed & modular)
              ẋ3               -     repeat three times - e.g. "\\\"
                K              -     join with spaces          "\ \ \"
      ;€                       - concatenate €ach (altered prefix with that list)
                     ¡         - repeat action...
                    ⁹          - ...number of times: right argument (-1 repeats 0 times)
                   Ṛ           - ...action: reverse (i.e. reverse if north-west)
                           Ðe  - for even indexes:
                         ¦€    -   sparse application for €ach...
                       -2      -   ...to indices: [-2] (the middle of the road)
                      ⁶        -   ...action: a space character
                             Ṛ - reverse
— Jonathan Allan
fonte
2

Python 2, 127 byte

n,d=input()
c='|/\\'[d]
for i in range(n):t=0if d==0else(i if d<0else n-i);print(' '*t+'{} {} {}'.format(c,' 'if i%2==0else c,c))

Provalo online!

Prime due righe tratte da @TFeld.

— Henry T
fonte
1
Ciao, benvenuto in PPCG! Temo che gli invii debbano essere una funzione che accetta parametri o un programma completo che accetta argomenti o input da STDIN. Snippet come stai usando in questo momento non sono ammessi, temo. È possibile aggiungere un lead D,N=input()(e utilizzare Python 2 anziché 3) per risolvere il problema. Oppure puoi cambiarlo in una funzione lambda prendendo questi due parametri.
— Kevin Cruijssen,
1
Bella soluzione. Sono arrivato a 122 usando " ".join(..)piuttosto ran.format
— akozi il
1
i%2*c or' 'salva qualche byte in più, anche se ho notato che il separatore è sbagliato per strade di lunghezza dispari.
— Neil
2

Python 2 , 93 byte

n,d=input();p=''
while n:g='|/\\'[d];n-=1;print['',' '*n,p][d]+g+' %s '%(g,' ')[n%2]+g;p+=' '

Provalo online!

— OVS
fonte
Cambiare +' %s '+per ,'%s',risparmiare 2 byte
— TFeld
@TFeld In tal caso, potresti anche rimuovere '%s'%completamente.
— Neil
2

J , 64 byte

' \|/'{~(_2&|*[:i.[*1 _1{~3=])|."_1((5+[){."1(5,~[)|.@$]*#:@689)

Provalo online!

  • 1 nord-ovest
  • 2 nord
  • 3 nord-est

Proverò a giocare a golf più tardi

— Galen Ivanov
fonte
1

Rosso , 157 byte

func[s d][p: pick"\|/"d set[a b]reduce pick[[4 1]0[5 + s -1]]d 
repeat n s[print pad/left form reduce pick[[p" "p][p p p]]odd?(n + pick[1 0]odd? s)a: a + b]]

Provalo online!

  • 1 nord-ovest
  • 2 nord
  • 3 nord-est
— Galen Ivanov
fonte
1

Swift 4.2 , 112 108 byte

-4 byte grazie allo Sriotchilism O'Zaic

let c=["\\","|","/"][d];(0..<n).map{print((0..<n-$0*(d-1)).map{_ in" "}.joined()+c+" \($0%2==0 ?c:" ") "+c)}

[0,1,2] invece di [-1,0,1].

Provalo online!

Spiegazione

let c=["\\","|","/"][d]

Determina il segnale stradale da utilizzare. (Scommetto che questo può essere abbreviato in qualche modo)

(0..<n).map{

Scorre la lunghezza della strada.

(0..<n-$0*(d-1)).map{_ in" "}.joined()

Aggiunge gli spazi davanti alla strada.

\($0%2==0 ?c:" ")"

Aggiunge il segno centrale a ogni altra riga.

Il mio primissimo ☝️, sono contento di eventuali consigli di ottimizzazione. Imparato principalmente da quel thread: Suggerimenti per giocare a golf in Swift .

— palme
fonte
1
Benvenuti nel sito! Sembra che tu abbia dimenticato di rimuovere lo spazio tra ine " "nel tuo codice anche se lo hai rimosso nei tuoi esempi.
— Wheat Wizard
1
Non conosco veloce ma sembra per le tue interpolazioni alle estremità delle stringhe ( \(c)in entrambi i casi). Risparmieresti byte semplicemente concatenando cla stringa. Provalo online!
— Wheat Wizard
1
Grazie hai ragione! ci ha salvato 3 byte 🚀
— palme
1

Perl 6 , 66 byte

->\n,\d{{(' 'x--$ *d%-+^n~(' ',<\ | />[d+1])[1,(n+$++)%2,1])xx n}}

Provalo online!

Restituisce un elenco di righe.

Spiegazione

->\n,\d{                                                         }  # Block taking n, d
        {                                                       }   # Reset $ variables
         (                                                 )xx n    # Repeat n times
          ' 'x  # Space times
              --$ *d  # (-1,-2,-3,...) if d=1
                      # (0,0,0,...) if d=0
                      # (1,2,3,...) if d=-1
                    %-+^n  # modulo -~n = n+1
                         ~  # Concat
                          (' ',<\ | />[d+1])  # Space or line
                                            [1,(n+$++)%2,1]  # Alternate middle char
— nwellnhof
fonte
1

Rubino , 90 byte

n,a=*$*.map{|i|-i.to_i}
c='|\/'[a]
n.upto(-1){|i|puts' '*(i*a-n)+c+' '+[' ',c][i%2]+' '+c}

Provalo online!

AGGIORNAMENTO: Grazie, Kevin, per aver sottolineato che nella mia presentazione originale mancavano spazi tra i bordi della strada e gli indicatori (cioè strade a 3 larghezze anziché a 5). Detto questo, potrebbe esserci una soluzione più breve per quella di c+' '+...+' '+c .

Informazioni direzionali: -1, 0, 1mappe per{ north-west, north, north-east }

Argomenti: legge argomenti della riga di comando come 4 -1(una strada a quattro file, inclinata a nord-ovest).

Nota aggiuntiva: è stato testato localmente con Ruby v2.6.1 e sembra che Try It Online utilizzi Ruby v2.5.3. Non ho motivo di pensare che non funzionerebbe con tutte le altre versioni di Ruby.

— Spencer D
fonte
Ciao, benvenuto in PPCG! Le indicazioni e l'alterazione delle strade sono corrette nel tuo output, quindi ben fatto. C'è solo un piccolo errore nell'output corrente: la strada dovrebbe essere larga tre spazi anziché 1. Attualmente la tua strada è |||o |<sp>|, ma dovrebbe essere |<sp>|<sp>|o |<sp><sp><sp>|(dove <sp>è uno spazio). Non conosco Ruby, ma sembra che tu possa risolverlo cambiando c+[' ',c][i%2]+cin c+' '+[' ',c][i%2]+' '+c. :)
— Kevin Cruijssen il
Ah buona cattura! Grazie per averlo sottolineato, @KevinCruijssen.
— Spencer D
1

Japt -R , 40 byte

Æ=Vg"|\\/";²i1S+iX%2?S:U)iSp[TZÊ-YY]gVÃw

Provalo online!

Spiegazione:

Æ=Vg"|\\/";²i1S+iX%2?S:U)iSp[TZÊ-YY]gVÃw
                                            // U = road size
                                            // V = direction
Æ                                     Ã     // Loop X through [0...U]
 =        ;                                 //   Set U to:
    "|\\/"                                  //       "|\/"
  Vg                                        //            [V]
           ²                                //  Double U
            i1          )                   //  Insert at index 1:
              S+                            //    " " +
                 X%2?S:U                    //         X%2?" ":U
                i                           //                  + " "
                         i                  //  Insert at index 0:
                          Sp                //    " " repeated this many times:
                            [TZÊ-YY]        //      [0,U.length - X,X]
                                    gV      //                        [V]
                                        w   // Reverse output
— Oliver
fonte
Sembra esserci un piccolo errore nell'output. Attualmente il separatore stradale per gli ingressi pari inizia in alto invece che in basso. Tutto il resto sembra ok, quindi spero che non sia troppo difficile da risolvere.
— Kevin Cruijssen,
@KevinCruijssen Ah, grazie per averlo scoperto. Prima di aggiornare la mia risposta, puoi confermare che questa soluzione va bene?
— Oliver
Sì, sembra completamente corretto. :)
— Kevin Cruijssen il
1
@KevinCruijssen Aggiunta una spiegazione poiché so che ti piacciono quelli: P
— Oliver
Grazie, apprezzato :) Mi piace sempre avere una spiegazione per le lingue del golf. A volte ho già problemi a comprendere le risposte JavaScript, per non parlare della lingua giocata a golf di JS. ;)
— Kevin Cruijssen il
1

Stax , 23 byte

ù╒←∩♂2Ωⁿ¡├∩22♀Ç○=÷â╧δÖ↑

Esegui ed esegui il debug

L'input è due numeri interi separati da uno spazio.
Il primo è d. -1 specifica nord-est. 0 per il nord. 1 per nord-ovest. Il secondo parametro è n. Questi due valori verranno implicitamente analizzati dall'input e posizionati nello stack di input con nin cima. Inoltre dsarà accessibile dagli Staxx poiché è il primo valore implicitamente analizzato.

Ad esempio, inserire "1 7"

            Main stack      Explanation
            ----------      -----------
;           [7]             peek from input stack
m                           map over integers [1..n] using the rest of the program
                            output each produced value implicitly
  ;         [1 7]           peek from input stack
  +         [8]             add
  .*"       [8 [42 34]]     2 character string literal with codepoints 42 and 34
  @         [42]            get the element at the specified modular index (8)
  0         [42 0]          literal zero
  "|\/"x@   [42 0 92]       get codepoint from string literal at input d (from x register)
  \         [42 [0 92]]     make pair
  :B        ['\ \ \ ']      encode in custom base; it's binary with custom codepoints
  _x*       ['\ \ \ ' 1]    (loop variable) * (input d)
  ;^        ['\ \ \ ' 1 8]  peek from input stack and increment
  %         ['\ \ \ ' 1]    modulus
  6+        ['\ \ \ ' 7]    add 6
  )         [' \ \ \ ']     left-pad to length

Esegui questo

— ricorsivo
fonte
Ti dispiacerebbe aggiungere una spiegazione? :)
— Kevin Cruijssen
1
@KevinCruijssen: Niente affatto.
— ricorsivo
0

perl -M5.010 -Mfeature = firme, 97 byte

sub f($n,$d){$x=qw[| / \\][$d];say" "x($d<1?$_*-$d:$n-$_),$x,$",($n-$_)%2?$":$x,$",$x for 1..$n;}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.