ASCII Art of the Day # 1 - Double Knot


47

Scrivi un programma completo o una funzione che accetta un numero intero positivo Ncome input tramite STDIN / riga comandi / ARGV o argomenti di funzione e stampa un doppio nodo ASCII corrispondente Na STDOUT.

Il doppio nodo ASCII è simile al seguente:

  __  __  __  __  __  __
 /  \/  \/  \/  \/  \/  \
| /\/ /\/ /\/ /\/ /\/ /\ |
| \/ /\/ /\/ /\/ /\/ /\/ |
 \ \/\ \/\ \/\ \/\ \/\ \/
 /\ \/\ \/\ \/\ \/\ \/\ \
| /\/ /\/ /\/ /\/ /\/ /\ |
| \/ /\/ /\/ /\/ /\/ /\/ |
 \__/\__/\__/\__/\__/\__/

Quanto sopra è per N = 6

Ecco qualche altro doppio nodo per altri valori di N:

Se N = 1, il doppio nodo di output appare come:

  __
 /  \
| /\ |
| \/ |
 \ \/
 /\ \
| /\ |
| \/ |
 \__/

Per N = 2, è

  __  __ 
 /  \/  \
| /\/ /\ |
| \/ /\/ |
 \ \/\ \/
 /\ \/\ \
| /\/ /\ |
| \/ /\/ |
 \__/\__/

Per N = 3, è

  __  __  __ 
 /  \/  \/  \
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \ \/\ \/\ \/
 /\ \/\ \/\ \
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \__/\__/\__/

e allo stesso modo, il modello continua e qualsiasi valore maggiore di N.

Dettagli :

  • L'input è sempre un numero intero positivo maggiore di 0.
  • Il trascinamento di newline è facoltativo
  • Non ci dovrebbero essere spazi finali in ogni riga o spazi finali sufficienti in modo che la lunghezza di ogni riga sia 4*N + 2.
  • Non dovrebbe mai esserci spazio iniziale che non faccia parte del modello specificato.

Questo è , quindi vince il codice più breve in byte.


Classifica serie

Sto convertendo questo in una serie di sfide artistiche ASCII e aggiungendo così una classifica per la serie (frammento di Martin). Per assicurarti che le tue risposte vengano visualizzate, inizia ogni risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dove N è la dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes


Serie finora

1. Doppio nodo

2. Serpenti di flusso

3. Santuari cinesi

4. Segni zodiacali

5. Diamanti casuali del diamante


1
Perché il bordo destro è diverso per N = 3?
aditsu,

@aditsu Haha. 4 giorni, 3K visualizzazioni, 11 risposte e sei la prima persona a notarlo: D. Fisso!
Ottimizzatore

Risposte:


12

CJam, 55 byte

Sono stato preso da un secchione piuttosto male da questo ... comunque, ho finalmente trovato 55 byte di ISO 8859-1:

"²îå<63Åhbغ¢dräOä[æTZ"246b5b"|_ \/"f=9/4/~2/\ri*2>*zN*

o questa alternativa :

"ô/Ht]õDz1M;í,D¯Tmä$:r"246b5b"_/\ |"f=9/2/~+ri*2>\++zN*

Inizialmente ho provato a farlo in semplice ASCII, ma ho ottenuto solo 58 byte :

"C]VA~`+-WIt*n_I?FanSEo*b"128b5b"_/|\ "f=9/4/~2/\ri*2>*zN*

e ancora, un'alternativa :

"1,*Ap7c?UvI$yQHqHqs~=}n"153b5b"_ /|\\"f=9/2/~+ri*2>\++zN*

Spiegazione:

L'idea è di codificare le parti uniche (bordo sinistro, bordo destro e motivo centrale) in modo conveniente, ripetere la parte centrale secondo necessità e metterle insieme. Il codice finì per essere simile in molti modi alla risposta di Dennis; Non ho provato a copiarlo, ma ho provato molti approcci diversi (compreso lo sfruttamento di più simmetrie e ripetizioni) e questo è ciò che ha funzionato meglio.

Ho unito i bordi sinistro e destro in questo modo:

    
 /\ 
|  |
|  |
 \/ 
 /\ 
|  |
|  |
 \/ 

Il modello centrale ha 4 colonne, ma vengono ripetute N-0,5 volte, ovvero una ripetizione viene tagliata a metà. Per comodità, ho usato questo modello:

  __
\/  
/ /\
 /\/
/\ \
\/\ 
/ /\
 /\/
/\__

e rimosso la prima metà della prima ripetizione.

Quindi ho unito le parti e le ho codificate in forma trasposta, poiché è più facile lavorare con esse in quel modo. Il primo e il terzo programma codificano questa stringa:

 \/ /\/ /
 / /\/ /\
_ /\ \/\_
_ \/\ \/_
  ||  || 
 /  \/  \
 \  /\  /
  ||  || 

(senza newline), che è la trasposizione del centro + bordi. Il secondo e il quarto programma (le "alternative") codificano questa stringa:

  ||  || 
 /  \/  \
 \  /\  /
  ||  || 
 \/ /\/ /
 / /\/ /\
_ /\ \/\_
_ \/\ \/_

di nuovo, senza newline, e questa è la trasposizione dei bordi + al centro.

Ecco come funziona questa parte comune del codice:

"…"        encoded string (constructed via the reverse process,
           using a suitable base that gives valid characters)
246b       convert the string to an integer, treating each character as a digit
           in base 246 (or other bases in the ASCII versions)
5b         convert the number to base 5, obtaining 72 digits from 0 to 4,
           representing the 5 different characters we have
"|_ \/"f=  convert the digits to their corresponding characters
           (each program uses a different assignment order)
9/         split the resulting strings into 8 strings of 9 characters
           if viewed as lines, they look exactly like the 2 patterns shown above

Successivamente, l'implementazione differisce leggermente. Nel primo e terzo programma abbiamo:

4/     split the lines into groups of 4 - the middle part and the edges
~      dump the two 4-line parts onto the stack
2/     split the second part (the edges) into 2 groups of 2 lines
       (left edge and right edge)
\      swap the edges with the middle part
ri*    read the input, convert to integer (N) and repeat the middle part N times
2>     remove the first 2 lines (first half of first repetition)
*      join the 2 edges using the repeated middle part as a separator
z      transpose the result back to the desired form
N*     join with newlines

Nel secondo e quarto programma (alternativo) abbiamo:

2/     split the lines into groups of 2
       (left edge, right edge, middle first half, middle 2nd half)
~      dump all the groups onto the stack
+      join the two middle halves into a single middle group of 4 lines
ri*    read the input, convert to integer (N) and repeat the middle part N times
2>     remove the first 2 lines (first half of first repetition)
\      swap the repeated middle with the right edge
+      concatenate the middle with the right edge
+      concatenate the left edge with the rest
z      transpose the result back to the desired form
N*     join with newlines

Non sono sicuro di quanto tempo ho cercato di 1>W<abbreviare. Si scopre che dovevo solo ruotare l'array prima di codificarlo e utilizzare 2>...
Dennis

23

CJam, 103 92 83 69 66 57 byte

"O5àäªÞáKZò,_÷%SJ«Ò"248b5b"/ \_|"f=9/4/~ri*1>W<+2m<zN*

Provalo online nell'interprete CJam .

Idea

Il modello diventa molto più evidente quando trasponiamo le righe con colonne (imbottite a destra con spazi).

Per l'ingresso 3 , ad esempio, questo dà:

  ||  || 
 /  \/  \
_ /\ \/\_
_ \/\ \/_
 \/ /\/ /
 / /\/ /\
_ /\ \/\_
_ \/\ \/_
 \/ /\/ /
 / /\/ /\
_ /\ \/\_
_ \/\ \/_
 \  /\  /
  ||  || 

Le prime due e le ultime due righe sono speciali, ma le altre ripetono ripetutamente lo stesso schema.

Pertanto, per l'ingresso N , tutto ciò che dobbiamo fare è ripetere

 / /\/ /\
_ /\ \/\_
_ \/\ \/_
 \/ /\/ /

N volte, sostituisci la prima riga con

  ||  || 
 /  \/  \

l'ultima riga con

 \  /\  /
  ||  || 

e, infine, trasporre le righe con le colonne.

Codice

"O5àäªÞáKZò,_÷%SJ«Ò"

248b  e# Convert the string (array of code points in base 248) to an integer.
5b    e# Convert the integer to the array of its digits in base 5.

      e# This pushes the following array:

      e# [ 1 2 1 1 0 2 1 1 0 1 1 4 4 1 1 4 4 1 1 1 4 4 1 1
      e#   4 4 1 1 0 1 1 2 0 1 1 2 1 0 1 0 2 0 1 0 2 3 1 0
      e#   2 1 2 0 2 3 3 1 2 0 2 1 2 0 3 1 2 0 1 0 2 0 1 0 ]

"/ \_"

f=    e# Retrieve the chars that correspond to the indexes in the array.

      e# This pushes the following string:

      e# " \  /\  /  ||  ||   ||  ||  /  \/  \ / /\/ /\_ /\ \/\__ \/\ \/_ \/ /\/ /"

9/4/~ e# Divide into groups of 4 strings of length 9.

      e# This pushes the following arrays:

      e# [ " \  /\  /"   "  ||  || "   "  ||  || "   " /  \/  \" ]
      e# [ " / /\/ /\"   "_ /\ \/\_"   "_ \/\ \/_"   " \/ /\/ /" ]

ri    e# Read an integer from STDIN.
*     e# Repeat the last array that many times.
1>W<  e# Remove the first and last string from the array.
+     e# Concatenate both arrays.
2m<   e# Rotate the concatenated arrays two elements to the left.
z     e# Zip the array of strings (transpose rows with columns).
N*    e# Join the strings of the array, separating by linefeeds.

12

Javascript ( ES7 Draft ), 169 163 160 158 byte

Modifica: -6 usando una stringa modello per eliminare alcune ripetizioni dalla stringa modello.

Modifica: -3 passando da slice(0,-2)a slice(2)riordinando la stringa del modello.

Modifica: -2 eseguendo il ciclo binvece di ae riducendo la astringa a 4 con un modulo.

F=N=>[(a='  ||'[i%4])+b[i]+`  __0\\/ ${c=' 0/ /\\0 /\\/0/\\'} \\0\\/\\${c}__`.split(0)[i].repeat(N).slice(2)+(b+b)[9-i]+a for(i in b=' /  \\/  \\')].join(`
`)
<input id="stdin" value="4" />
<button onclick="stdout.innerHTML=F(stdin.value)">Run</button><br />
<pre id="stdout"></pre>

ha commentato:

F=N=>[ // define function F, start array comprehension to generate each line
    (a = '  ||'[i % 4]) + // first character of the line, store copy in a
    b[i] + // second character of each line
        `  __0\\/ ${c=' 0/ /\\0 /\\/0/\\'} \\0\\/\\${c}__`. 
        // list of patterns for each line delimited by 0's
        // results in string: '  __0\/  0/ /\0 /\/0/\ \0\/\ 0/ /\0 /\/0/\__'
        split(0)[i]. // split by 0, get index at i
        repeat(N). // repeat N times
        slice(2) + // chop off the first 2 characters
    (b + b)[9 - i] + // get opposite of second character, b+b to get a space at index 9
    a // repeat first character (a)
    for(i in b = ' /  \\/  \\') // runs for each index in character map b
].join(` // join resulting array with newlines
`)

Penso che puoi sostituire la stringa prima .split(0)con ('__ 0 '+(r='\\/0/\\/ 0\\/ /0 ')+r+'0\\/ /0__/\\').
flawr

@flawr Sono stato in grado di ridurlo ulteriormente usando un metodo simile :)
nderscore

Se lo passi 0, vedrai un 8.
Ismael Miguel,

Che cosa fanno quelli `` e ${...}fare esattamente?
flawr

@flawr La sintassi backtick `dichiara una stringa di modello . Qualsiasi cosa all'interno ${}viene valutata come espressione javascript.
nderscore,

9

Perl, 134 129

print s/...\K.{4}/$&x~-"@ARGV"/er=~y!iolp!| /\\!r,$/for
map/i/?$_.oi:"o$_$_".o,o__o,loop,@x=(iolplolp,ioplolpl),popl,lpop,@x,p__l

Accetta un parametro della riga di comando:

$ perl ~/knot.pl 3
  __  __  __  
 /  \/  \/  \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \ \/\ \/\ \/ 
 /\ \/\ \/\ \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \__/\__/\__/ 

8

JavaScript ( ES6 ), 165 166

Elementi del nodo:

  • 2 righe superiori, basate su '__' e '/ \' ripetute
  • 2 righe esterne, basate su '/ \ /' ripetute e racchiuse tra '| ... | '
  • 2 righe interne, basate su '\ / \' ripetute e racchiuse tra '... /' e '/ ... \'
  • le stesse 2 file esterne sopra
  • 1 riga inferiore basata su '\ __ /' ripetuta

Ungolfed

K=r=>
{
  R = x => x.repeat(r);
  S = d => R(elem).slice(d,d-2); // use global 'elem' that must be assigned before the call
  elem = '/\\/ '
  outer = '\n| ' + S(0) + ' |\n| ' + S(1) + ' |\n '
  elem = '\\ \\/'
  inner = '\\' + S(1) + '/\n /' + S(0) + '\\'
  return R('  __') + '\n ' + R('/  \\') + outer
  + inner + outer + R('\\__/')
}

golfed

K=r=>(S=d=>(R=e=>e.repeat(r))(e).slice(d,d-2),o=`
| ${S(0,e='/\\/ ')} |
| ${S(1)} |
 `,R('  __')+`
 ${R('/  \\')+o}\\${S(1,e='\\ \\/')}/
 /${S(0)}\\${o}`+R('\\__/'))

// TEST

function go() {
  O.innerHTML=K(I.value)
}

go()
<input id=I value=5><button onclick='go()'>-></button><br>
<pre id=O></pre>


2
Prova 0a passarci e otterrai un ragno a 4 zampe.
Ismael Miguel,

8

C ++, 1530 639 479

Sembrava una sfida divertente che ho leggermente discostato dal riassunto.

#include "stdafx.h"
#include <iostream>
#include <sstream>
using namespace std;
string a=" __ ",b="/  \\",c=" /\\",d="/\\/ ",f="\\ \\/",g="/\\\ \\",r="\\__/",o="",e=o,j="|";
string q(int n,string r,string x="",string m=" ",string t=" "){string z=o;for(int i=0;i<n;i++){z+=r;if(i!=n-1)z+=x;}return m+z+t+"\n";}
int main(){int x,y;cin>>x;cin>>y;e+=q(x,a)+q(x,b);for(int i=0;i<y;i++){e+=q(x,c,"/",j," |")+q(x-1,d,o,"| \\/ ",j);if(i!=y-1){e+=q(x,f)+q(x,g);}}e+=q(x,r);cout<<e;}

Non sono sicuro di come misurare i byte della dimensione della mia applicazione, ma proverò a capirlo e ad aggiornare la mia risposta.

La mia app potrebbe essere più piccola ma si muove sia in xe in ye mi piace un po 'così: D


1
Benvenuti in PPCG! Il tuo punteggio è la dimensione del tuo codice sorgente, che è 1530 byte così com'è. È possibile iniziare a salvare byte rimuovendo commenti e spazi bianchi e abbreviando i nomi di variabili e funzioni.
Dennis,

Wowzor è più grande del resto ahah lavorerò per farlo scendere: D
Spaceman

6

Python 2, 156 151 147 141 139

modifica 1: modificata per utilizzare input () anziché una funzione.

modifica 2: usato str.join e aggiunto a var c per rimuovere alcuni caratteri ridondanti.

modifica 3: rimosse alcune sequenze di escape stringa non necessarie.

modifica 4: usato ~ -n invece di a = n-1

È stato molto divertente programmare, il mio primo codice golf!

n=input()
a='/\/ '*~-n
b='\ '+'\/\ '*~-n+'\\'
c='\n| '+a+'/\ |\n| \/ '+a+'|'
print'\n '.join(('  __'*n,'/  \\'*n+c,b+'/','/'+b+c,'\__/'*n))

salvarlo in un editor di testo esterno come n.py per rimuovere l'ultimo carattere di nuova riga per ridurre le dimensioni del file di 1 byte, eseguire il modulo e inserire il numero.


Se permetti di inserire il numero subito dopo la dichiarazione di esecuzione dei programmi, allora posso ulteriormente
ridurlo

Di solito input ()è considerato ok quando si legge da STDIN.
Seequ,

Vedo che hai salvato a=n-1per risparmiare *(n-1)due volte sulla scrittura , ma lo fai*~-n .
xnor

comunque la stessa quantità di caratteri in entrambi i casi, perché uso il valore due volte, ma un buon consiglio.
micsthepick,

Puoi salvare alcuni byte nel modo in cui Python gestisce le barre rovesciate nelle stringhe, non è sempre necessario codificarle. Vedi stackoverflow.com/a/16973452/3351622
Matty,

5

Python 2, 139 133 129 byte

n=input()
for i in range(9):w=' ?|'[i&2];s=' / /\/ /\_ /\ \/\__ \/\ \/_ \/ /\/ /'[i::9]*n;s=(s,' %s '%s[1:-1])[i%4>1];print w+s+w

Questo crea e stampa solo riga per riga.

Ecco il codice in forma non golfata:

n=int(input())
# The list with all the knot pieces
l= [' __ ',
    '/  \\',
    ' /\/',
    '/\/ ',
    '\ \/',
    '/\ \\',
    ' /\/',
    '/\/ ',
    '\__/']
# The first and last columns
w = '  ||  || '
# Loop for each row
for i in range(9):
    # Exception for the first and last character in the knot (in some rows)
    s = l[i]*n
    if i % 4 > 1:
        s = ' ' + s[1:-1] + ' '
    # Print the knot for this row
    print(w[i] + s + w[i])

Modifica: ho cambiato la lingua in python 2, per essere compatibile con la mia risposta per # 3 (e salva anche altri 6 byte)


Credo w=(3*' ||')[i] -> w=' |'[i&2]e ' '+s[1:-1]+' ' -> ' %s '%s[1:-1]lavoro (il primo è una stringa con due spazi, quindi una pipe, ma SE agisce in alto)
Sp3000,

@ Grazie Sp3000! Quello primo è piuttosto intelligente. Avrei dovuto pensarci ' ||'[i%4], ma questo è ancora più breve (anche con due spazi).
Matty,

3

C, 159 byte

j,k;f(n){char*t="7>771I;M6CMI93;IIB;;MI1M;M6CMI93;IIB;>MI";for(n*=4;t[j/2];++k,k%=n+3,j+=k-n?k%n<3||k%4-2?1:-3:3)putchar("\n _|/\\"[(t[j/2]-48)/(j%2?1:6)%6]);}

Con spazi bianchi e alcuni altri miglioramenti della leggibilità:

#include <stdio.h>

int j, k;

void f(int n) {
    char *t = "7>771I;M6CMI93;IIB;;MI1M;M6CMI93;IIB;>MI", *m = "\n _|/\\";
    for (n *= 4; t[j / 2];
         ++k,
         k %= n + 3,
         j += k - n ? k % n < 3 || k % 4 - 2 ? 1 : -3 : 3)
        putchar(m[(t[j / 2] - 48) / (j % 2 ? 1 : 6 ) % 6]);
}

Questo è principalmente basato su template. Il modello tcontiene tutte e 9 le possibili colonne dell'output, il che significa che codifica 9 * 9 = 81 caratteri o 80 senza la nuova riga finale.

Dato che ci sono solo 6 caratteri diversi nel modello (inclusi i caratteri di nuova riga), ne ho impacchettati coppie in un carattere modello, il che significa che il modello può essere memorizzato in 40 caratteri. Vi sono quindi 6 * 6 = 36 possibili coppie di caratteri, che sono codificati come caratteri ASCII da 48 a 73. La traduzione al carattere originale è data dalla piccola tabella di ricerca m.

Il resto della logica è principalmente quello di ripetere i ntempi del modello , il che significa saltare indietro di 4 caratteri nel modello, emettendo correttamente le parti di inizio e fine di ogni riga.


2

PHP 5.5.3, 488 , 466

<?php 
function k($n){$r=array_fill(0,9,'');for($i=0;$i<$n;$i++){$r[0].=($i==0)?"  __ ":" __ ";$r[1].=($i==0)?" /  \\":"/  \\";$r[2].=($i==0)?"| /\\/":(($i==$n-1)?" /\\ |":" /\\/");$r[3].=($i==0)?"| \/ ":(($i==$n-1)?"/\/ |":"/\/ ");$r[4].=($i==0)?" \\ ":(($i==$n-1)?"\\/\\ \\/":"\\/\\ ");$r[5].=($i==0)?" /\\ ":(($i==$n-1)?"\\/\\ \\":"\\/\\ ");$r[6]=$r[2];$r[7]=$r[3];$r[8].=($i==0)? " \__/":"\__/";}foreach($r as $o){if(strlen($o)-2 !== 4*$n)$o.=" ";echo $o."\n";}}

È possibile salvare alcuni caratteri rimuovendo alcuni spazi bianchi non necessari attorno agli operatori, ad esempio attorno a =e .=.
ProgramFOX,

Grazie ho modificato la risposta
Med

2

Prolog (SWI), 285 byte

a(N):-b(N,"  ||  || "," /  \\/  \\","_ /\\ \\/\\_","_ \\/\\ \\/_"," \\/ /\\/ /"," / /\\/ /\\"," \\  /\\  /"). b(N,[A|G],[B|H],[C|I],[D|J],[E|K],[F|L],[Y|Z]):-c(N,[Y,A],[E,F,C,D],T),writef([A,B,C,D|T]),nl,b(N,G,H,I,J,K,L,Z). c(1,L,_,L):-!. c(N,L,X,O):-M is N-1,c(M,L,X,T),append(X,T,O).

(Con spazi bianchi):

a(N):-
    b(N,
    "  ||  || ", 
    " /  \\/  \\", 
    "_ /\\ \\/\\_", 
    "_ \\/\\ \\/_", 
    " \\/ /\\/ /", 
    " / /\\/ /\\", 
    " \\  /\\  /").

b(N,[A|G],[B|H],[C|I],[D|J],[E|K],[F|L],[Y|Z]):-
    c(N,[Y,A],[E,F,C,D],T),
    writef([A,B,C,D|T]),
    nl,
    b(N,G,H,I,J,K,L,Z).

c(1,L,_,L):-!.
c(N,L,X,O):-
    M is N - 1,
    c(M,L,X,T),
    append(X,T,O).

Ho provato alcuni modi per tagliare le corde, ma nessuno sembrava battere questo ingenuo metodo delle colonne.


2

JavaScript (ES6), 158 154 148 137 byte

n=>`    __
 /\\/ - \\/
 /\\/\\-__/`.replace(/-/g,` \\
| / /\\ |
|  /\\/ |
 \\/\\`).replace(/(..)(....)/g,(_,l,m)=>l+m.repeat(n).slice(2))

Modifica: salvato 11 byte grazie a @ Bálint.


@ Bálint Ma ha /(..)(.{4})/g13 byte, lo stesso di /(..)(....)/g...
Neil,

@Bálint In realtà mi sono reso conto che il mio precedente salvataggio a 4 byte mi aveva permesso di farlo, ma in quel momento ero lontano dal computer.
Neil,

@ Bálint Nice! Avevo cercato di evitare il segmento \\ / \\ ripetuto ma non avevo pensato di verificare una sottostringa ripetuta più a lungo.
Neil,

1

Java, 339 330 byte

class D{int n,i;public static void main(String[]a){new D(new Integer(a[0]));}D(int k){n=k;r("  __");p("\n ");r("/  \\");c();r("\\ \\/");p("\n ");r("/\\ \\");c();r("\\__/");}void c(){p("\n|");--n;r(" /\\/");p(" /\\ |\n| \\/");r(" /\\/");++n;p(" |\n ");}void p(String s){System.out.print(s);}void r(String s){for(i=n;i>0;--i)p(s);}}

La mia prima soluzione conteneva così tante parole chiave "statiche" che era più breve rendere i metodi e gli attributi non statici ed eseguire il codice nel costruttore.


1

PowerShell, 228 207 181 133 byte

%{"  "+"__  "*$_;" "+"/  \"*$_;$b="|"+" /\/"*$_+"`b |";$b;$c="| "+"\/ /"*$_+"`b|";$c;" "+"\ \/"*$_;" "+"/\ \"*$_;$b;$c;" "+"\__/"*$_}

Promemoria: PowerShell non attende automaticamente lo stdin. Devi convogliare qualcosa, ad es3|%{...}


0

SmileBASIC, 149 byte

INPUT N?"  __"*N
A$="| / /\ |
B$="|  /\/ |
K" /\/  \
K A$K B$K" \/\ \/
K" /\/\ \
K A$K B$K" \/\__/
DEF K A?SUBST$(A,2,4,MID$(MID$(A,2,4)*N,2,N*9))END

Ogni stringa contiene il motivo AACCBBDDche viene espanso per formare AABB(CCBB)*DDLa CCBBparte viene ripetuta N volte, quindi i primi 2 caratteri vengono rimossi. (È stato più breve rimuovere i caratteri dall'inizio che dalla fine)

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.