Arte ASCII del día # 1 - Nudo doble

47

Escriba un programa completo o una función que tome un entero positivo Ncomo entrada a través de STDIN / línea de comando / ARGV o argumentos de función e imprima un nudo doble ASCII correspondiente Na STDOUT.

El nudo doble ASCII se ve así:

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

Lo anterior es para N = 6

Aquí hay algunos nudos dobles más para otros valores de N:

Si N = 1, el nudo doble de salida se ve así:

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

Para N = 2su

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

Para N = 3su

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

y de manera similar, el patrón continúa y cualquier valor mayor de N.

Detalles :

  • La entrada siempre es un entero positivo mayor que 0.
  • La nueva línea final es opcional
  • No debe haber espacios finales en cada línea, o suficientes espacios finales de manera que la longitud de cada fila sea 4*N + 2.
  • Nunca debería haber ningún espacio inicial que no sea parte del patrón especificado.

Este es el código de golf , por lo que gana el código más corto en bytes.

Tabla de clasificación de la serie

Estoy convirtiendo esto en una serie de desafíos de arte ASCII y, por lo tanto, agrego una tabla de líderes para la serie (fragmento de Martin). Para asegurarse de que sus respuestas aparezcan, comience cada respuesta con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

donde N es el tamaño de su envío. Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Mostrar fragmento de código

Serie hasta ahora

1. Doble nudo

2. Serpientes de flujo

3. Santuarios chinos

4. Signos del zodiaco

5. Revestimientos aleatorios de diamantes

code-golf ascii-art kolmogorov-complexity Optimizador
fuente
1
¿Por qué el borde derecho es diferente para N = 3?
aditsu
@aditsu Jaja. 4 días, 3K vistas, 11 respuestas y usted es la primera persona en notarlo: D. ¡Fijo!
Optimizador

Respuestas:

12

CJam, 55 bytes

Me sorprendió bastante el nerd por esto ... de todos modos, finalmente obtuve 55 bytes de ISO 8859-1:

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

o esta alternativa :

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

Inicialmente intenté hacerlo en ASCII simple, pero solo lo reduje a 58 bytes :

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

y nuevamente, una alternativa :

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

Explicación:

La idea es codificar las partes únicas (borde izquierdo, borde derecho y patrón del medio) de una manera conveniente, repetir la parte del medio según sea necesario y juntarlas. El código terminó siendo similar en muchos aspectos a la respuesta de Dennis; No intenté copiarlo, pero probé muchos enfoques diferentes (incluida la explotación de más simetrías y repeticiones) y esto es lo que funcionó mejor.

Puse los bordes izquierdo y derecho juntos de esta manera:

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

El patrón del medio tiene 4 columnas, pero se repiten N-0.5 veces, es decir, una repetición se reduce a la mitad. Por conveniencia, utilicé este patrón:

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

y eliminó la primera mitad de la primera repetición.

Así que uní las partes y las codifiqué en forma transpuesta, ya que es más fácil trabajar con ellas de esa manera. El primer y tercer programa codifican esta cadena:

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

(sin líneas nuevas), que es la transposición de los bordes + medios. El segundo y cuarto programa (las "alternativas") codifican esta cadena:

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

de nuevo, sin nuevas líneas, y esta es la transposición de bordes + centro.

Así es como funciona esta parte común del código:

"…"        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

Después de esto, la implementación difiere ligeramente. En el primer y tercer programa tenemos:

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

En el segundo y cuarto programas (alternativos), tenemos:

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
aditsu
fuente
No estoy seguro de cuánto tiempo intenté hacer el 1>W<más corto. Resulta que solo tuve que rotar la matriz antes de codificarla y usar 2>...
Dennis
23

CJam, 103 92 83 69 66 57 bytes

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

Pruébelo en línea en el intérprete de CJam .

Idea

El patrón se vuelve mucho más obvio una vez que transponemos filas con columnas (rellenadas a la derecha con espacios).

Para la entrada 3 , por ejemplo, esto da:

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

Las primeras dos y las últimas dos filas son especiales, pero las otras repiten el mismo patrón una y otra vez.

Por lo tanto, para la entrada N , todo lo que tenemos que hacer es repetir

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

N veces, reemplace la primera fila con

  ||  || 
 /  \/  \

la última fila con

 \  /\  /
  ||  ||

y, finalmente, transponer filas con columnas.

Código

"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.
Dennis
fuente
12

Javascript ( ES7 Draft ), 169 163 160 158 bytes

Editar: -6 usando una cadena de plantilla para eliminar algunas repeticiones de la cadena de patrón.

Editar: -3 cambiando de slice(0,-2)a slice(2)reorganizando la cadena de patrón.

Editar: -2 al recorrer en blugar de ay reducir la acadena a 4 con un módulo.

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

Comentado:

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
`)
nderscore
fuente
Creo que puedes reemplazar la cadena antes .split(0)con ('__ 0 '+(r='\\/0/\\/ 0\\/ /0 ')+r+'0\\/ /0__/\\').
falla
@flawr Pude condensarlo aún más usando un método similar :)
nderscore
Si lo pasa 0, verá un 8.
Ismael Miguel
¿Qué hacen esos `` y ${...}exactamente?
falla
@flawr La sintaxis de retroceso `declara una cadena de plantilla . Cualquier cosa dentro ${}se evalúa como una expresión 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

Toma un parámetro de línea de comando:

$ perl ~/knot.pl 3
  __  __  __  
 /  \/  \/  \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \ \/\ \/\ \/ 
 /\ \/\ \/\ \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \__/\__/\__/
nutki
fuente
8

JavaScript ( ES6 ), 165166

Elementos del nudo:

  • 2 filas superiores, basadas en '__' y '/ \' repetidas
  • 2 filas externas, basadas en '/ \ /' repetidas y encerradas en '| ... |
  • 2 filas internas, basadas en '\ / \' repetidas y encerradas en '... /' y '/ ... \'
  • las mismas 2 filas exteriores arriba
  • 1 fila inferior basada en '\ __ /' repetida

Sin golf

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

edc65
fuente
2
Intenta pasar 0y obtendrás una araña de 4 patas.
Ismael Miguel
8

C ++, 1530 639 479

Esto parecía un desafío divertido que me desvió un poco del informe.

#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;}

No estoy seguro de cómo medir los bytes del tamaño de mi aplicación, pero intentaré averiguarlo y actualizar mi respuesta.

Mi aplicación podría ser más pequeña pero se repite tanto en x como en y, y me gusta un poco así: D

Astronauta
fuente
1
Bienvenido a PPCG! Su puntaje es el tamaño de su código fuente, que es de 1530 bytes. Puede comenzar a guardar bytes eliminando comentarios y espacios en blanco, y acortar nombres de variables y funciones.
Dennis
Wowzor es más grande que el resto jaja Trabajaré para lograrlo: D
Spaceman
6

Python 2, 156 151 147 141 139

editar 1: editado para usar input () en lugar de una función.

edit 2: usó str.join y se agregó a var c para eliminar algunos caracteres redundantes.

edición 3: eliminó algunas secuencias de escape de cadena innecesarias.

edit 4: utilizado ~ -n en lugar de a = n-1

Fue muy divertido programarlo, ¡mi primer código de golf!

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

guárdelo en un editor de texto externo como n.py para eliminar el último carácter de nueva línea para reducir el tamaño del archivo en 1 byte, ejecute el módulo e ingrese su número.

micsthepick
fuente
Si usted permite para introducir el número justo después de la declaración de los programas de ejecución, entonces puedo despojar aún más hacia abajo a 151 bytes
micsthepick
Por input ()lo general, se considera correcto cuando se lee desde STDIN.
seequ
Veo que has ahorrado a=n-1para ahorrar al escribir *(n-1)dos veces, pero lo haces*~-n .
xnor
sigue siendo la misma cantidad de caracteres en ambos sentidos, porque uso el valor dos veces, pero buen consejo.
micsthepick
Puede guardar algunos bytes en la forma en que Python maneja las barras invertidas en cadenas, no siempre necesita codificarlos. Ver stackoverflow.com/a/16973452/3351622
Matty
5

Python 2, 139 133 129 bytes

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

Este solo construye e imprime línea por línea.

Aquí está el código en forma no golfizada:

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])

Editar: cambié el idioma a python 2, para que sea compatible con mi respuesta para el n. ° 3 (y también ahorra 6 bytes más)

Matty
fuente
Creo w=(3*' ||')[i] -> w=' |'[i&2]y ' '+s[1:-1]+' ' -> ' %s '%s[1:-1]trabajo (el primero es una cadena con dos espacios, luego una tubería, pero SE está actuando)
Sp3000
@ Sp3000 Gracias! El primero es bastante inteligente. Debería haber pensado ' ||'[i%4], pero esto es aún más corto (también con dos espacios).
Matty
3

C, 159 bytes

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 espacios en blanco y algunas otras mejoras de legibilidad:

#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]);
}

Esto se basa principalmente en plantillas. La plantilla tcontiene las 9 columnas posibles de la salida, lo que significa que codifica 9 * 9 = 81 caracteres, u 80 sin la nueva línea final.

Como solo hay 6 caracteres diferentes en el patrón (incluidos los caracteres de nueva línea), empaqueté pares de ellos en un carácter de plantilla, lo que significa que la plantilla se puede almacenar en 40 caracteres. Hay entonces 6 * 6 = 36 posibles pares de caracteres, que se codifican como caracteres ASCII 48 a 73. La traducción de vuelta al carácter original viene dada por la pequeña tabla de búsqueda m.

El resto de la lógica consiste principalmente en repetir los ntiempos del patrón , lo que significa retroceder 4 caracteres en la plantilla, mientras se emiten correctamente las partes inicial y final de cada fila.

Reto Koradi
fuente
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";}}
Medicina
fuente
Puede guardar algunos caracteres eliminando algunos espacios en blanco innecesarios alrededor de los operadores, por ejemplo, alrededor de los =y .=unos.
ProgramFOX
Thx he editado la respuesta
Med
2

Prólogo (SWI), 285 bytes

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 espacios en blanco):

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).

Intenté algunas formas de cortar las cuerdas, pero ninguna parecía superar este ingenuo método de columnas.

Carnicero paul
fuente
2

JavaScript (ES6), 158 154 148 137 bytes

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

Editar: Guardado 11 bytes gracias a @ Bálint.

Neil
fuente
@ Bálint Pero /(..)(.{4})/gtiene 13 bytes, lo mismo que /(..)(....)/g...
Neil
@ Bálint Realmente me di cuenta de que mi anterior ahorro de 4 bytes me permitió hacer eso, pero estaba lejos de la computadora en ese momento.
Neil
@ Bálint Nice! Había tratado de evitar el segmento \\ / \\ repetido pero no había pensado en buscar una subcadena repetida más larga.
Neil
1

Java, 339 330 bytes

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);}}

Mi primera solución tenía tantas palabras clave "estáticas" que era más corto hacer que los métodos y atributos no fueran estáticos y ejecutar el código en el constructor.

ECS
fuente
1

PowerShell, 228 207 181 133 bytes

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

Recordatorio: PowerShell no espera la entrada estándar automáticamente. Tienes que canalizar algo, p. Ej.3|%{...}

Nacht - Restablece a Monica
fuente
0

SmileBASIC, 149 bytes

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

Cada cadena contiene el patrón AACCBBDDque se expande para formar AABB(CCBB)*DDLa CCBBparte se repite N veces, luego se eliminan los primeros 2 caracteres. (Fue más corto eliminar caracteres desde el principio que desde el final)

12Me21
fuente