Seni ASCII Hari Ini # 1 - Simpul Ganda

47

Tulis program lengkap atau fungsi yang mengambil bilangan bulat positif Nsebagai input melalui STDIN / baris perintah / ARGV atau argumen fungsi dan mencetak simpul ganda ASCII yang sesuai dengan Nke STDOUT.

Simpul ganda ASCII terlihat seperti ini:

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

Di atas adalah untuk N = 6

Berikut adalah beberapa simpul ganda untuk nilai lain dari N:

Jika N = 1, simpul ganda keluaran terlihat seperti:

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

Untuk N = 2itu

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

Untuk N = 3itu

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

dan demikian pula, pola berlanjut dan nilai yang lebih besar dari N.

Detail :

  • Input selalu bilangan bulat positif lebih besar dari 0.
  • Mengejar baris baru adalah opsional
  • Seharusnya tidak ada spasi tambahan di setiap baris, atau spasi tambahan yang cukup sehingga panjang setiap baris 4*N + 2.
  • Seharusnya tidak pernah ada ruang utama yang bukan bagian dari pola yang ditentukan.

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Papan Peringkat Seri

Saya mengubah ini menjadi serangkaian tantangan seni ASCII dan dengan demikian menambahkan papan pemimpin untuk seri (cuplikan oleh Martin). Untuk memastikan jawaban Anda muncul, mulailah setiap jawaban dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana N adalah ukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Misalnya:

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

Tampilkan cuplikan kode

Seri sejauh ini

1. Simpul Ganda

2. Aliran Ular

3. Kuil Cina

4. Tanda Zodiak

5. Memiringkan Berlian Secara Acak

code-golf ascii-art kolmogorov-complexity Pengoptimal
sumber
1
Mengapa tepi kanan berbeda untuk N = 3?
aditsu
@aditsu Haha. 4 hari, pandangan 3K, 11 jawaban dan Anda adalah orang pertama yang memperhatikannya: D. Tetap!
Pengoptimal

Jawaban:

12

CJam, 55 byte

Saya mendapatkan kutu buku yang cukup buruk dengan ini ... lagi pula, saya akhirnya menghasilkan 55 byte ISO 8859-1:

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

atau alternatif ini :

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

Awalnya saya mencoba melakukannya di ASCII biasa, tetapi hanya turun menjadi 58 byte :

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

dan sekali lagi, sebuah alternatif :

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

Penjelasan:

Idenya adalah untuk menyandikan bagian-bagian unik (tepi kiri, tepi kanan dan pola tengah) dengan cara yang nyaman, ulangi bagian tengah sesuai kebutuhan, dan satukan. Kode akhirnya menjadi serupa dalam banyak hal dengan jawaban Dennis; Saya tidak mencoba menyalinnya, tetapi saya mencoba banyak pendekatan berbeda (termasuk mengeksploitasi lebih banyak simetri dan pengulangan) dan inilah yang paling berhasil.

Saya menempatkan tepi kiri dan kanan bersamaan seperti ini:

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

Pola tengah memiliki 4 kolom, tetapi mereka diulang N-0,5 kali, yaitu satu pengulangan dipotong setengah. Untuk kenyamanan, saya menggunakan pola ini:

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

dan menghapus paruh pertama dari pengulangan pertama.

Jadi saya bergabung dengan bagian-bagian itu dan menyandikannya dalam bentuk transparan, karena lebih mudah untuk bekerja dengan mereka seperti itu. Program pertama dan ketiga menyandikan string ini:

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

(tanpa baris baru), yang merupakan transposisi dari tepi + tengah. Program kedua dan keempat ("alternatif") menyandikan string ini:

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

lagi, tanpa baris baru, dan ini adalah transposisi tepi + tengah.

Inilah cara kerja bagian umum kode ini:

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

Setelah ini, implementasinya sedikit berbeda. Dalam program pertama dan ketiga kami memiliki:

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

Dalam program (alternatif) kedua dan keempat, kami memiliki:

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
sumber
Saya tidak yakin berapa lama saya mencoba membuatnya 1>W<lebih pendek. Ternyata saya hanya perlu memutar array sebelum menyandikannya dan menggunakan 2>...
Dennis
23

CJam, 103 92 83 69 66 57 byte

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

Cobalah online di juru bahasa CJam .

Ide

Polanya menjadi jauh lebih jelas setelah kita memindahkan baris dengan kolom (empuk ke kanan dengan spasi).

Untuk input 3 , misalnya, ini memberi:

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

Dua baris pertama dan dua terakhir adalah khusus, tetapi yang lain mengulangi pola yang sama berulang kali.

Jadi, untuk input N , yang harus kita lakukan adalah mengulang

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

N kali, ganti baris pertama dengan

  ||  || 
 /  \/  \

baris terakhir dengan

 \  /\  /
  ||  ||

dan, akhirnya, transpos baris dengan kolom.

Kode

"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
sumber
12

Javascript ( ES7 Draft ), 169 163 160 158 byte

Edit: -6 dengan menggunakan string template untuk menghilangkan beberapa pengulangan dari string pola.

Edit: -3 dengan beralih dari slice(0,-2)ke slice(2)dengan mengatur ulang string pola.

Sunting: -2 dengan mengulangi balih-alih adan mengurangi astring menjadi 4 dengan 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>
Luaskan cuplikan

Berkomentar:

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
sumber
Saya pikir Anda dapat mengganti string sebelumnya .split(0)dengan ('__ 0 '+(r='\\/0/\\/ 0\\/ /0 ')+r+'0\\/ /0__/\\').
flawr
@ flawr Saya bisa memadatkannya lebih jauh menggunakan metode serupa :)
nderscore
Jika Anda meneruskannya 0, Anda akan melihat 8.
Ismael Miguel
Apa yang mereka lakukan `` dan apa yang ${...}sebenarnya dilakukan?
flawr
@ flawr Sintaks backtick `menyatakan string template . Apa pun di dalamnya ${}dievaluasi sebagai ekspresi 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

Mengambil parameter baris perintah:

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

JavaScript ( ES6 ), 165 166

Elemen simpul:

  • 2 baris teratas, berdasarkan '__' dan '/ \' diulangi
  • 2 baris luar, berdasarkan pada '/ \ /' yang diulang dan dilampirkan dalam '| ... | '
  • 2 baris dalam, berdasarkan '\ / \' yang diulang dan diapit dalam '... /' dan '/ ... \'
  • 2 baris luar yang sama di atas
  • 1 baris bawah berdasarkan '\ __ /' diulangi

Tidak disatukan

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('\\__/')
}

Golf 

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>
Luaskan cuplikan

edc65
sumber
2
Coba lewati 0dan Anda akan mendapatkan laba-laba berkaki 4.
Ismael Miguel
8

C ++, 1530 639 479

Ini tampak seperti tantangan yang menyenangkan, saya sedikit menyimpang dari brief.

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

Saya tidak yakin bagaimana mengukur byte dari ukuran aplikasi saya, tetapi saya akan mencoba mencari tahu dan memperbarui jawaban saya.

Aplikasi saya bisa lebih kecil tetapi loop di kedua x dan y, dan saya agak suka itu: D

Angkasawan
sumber
1
Selamat datang di PPCG! Skor Anda adalah ukuran kode sumber Anda, yaitu 1530 byte. Anda dapat mulai menyimpan byte dengan menghapus komentar dan spasi, dan mempersingkat nama variabel dan fungsi.
Dennis
Wowzor itu lebih besar daripada yang lain haha ​​saya akan bekerja untuk mendapatkannya: D
Spaceman
6

Python 2, 156 151 147 141 139

sunting 1: diedit untuk menggunakan input () alih-alih suatu fungsi.

sunting 2: menggunakan str.join dan ditambahkan ke var c untuk menghapus beberapa karakter yang berlebihan.

sunting 3: menghapus beberapa urutan pelarian string yang tidak perlu.

sunting 4: digunakan ~ -n alih-alih a = n-1

Ini program yang menyenangkan, golf kode pertama saya!

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

simpan di editor teks eksternal sebagai n.py untuk menghapus karakter baris baru terakhir untuk mengurangi ukuran file sebesar 1 byte, jalankan modul, dan masukkan nomor Anda.

micsthepick
sumber
Jika Anda mengizinkan untuk memasukkan nomor tepat setelah pernyataan eksekusi program, maka saya dapat menguranginya hingga 151 byte
micsthepick
Biasanya input ()dianggap oke ketika membaca dari STDIN.
seequ
Saya melihat Anda telah menyimpan a=n-1untuk menghemat menulis *(n-1)dua kali, tetapi Anda melakukannya*~-n .
xnor
masih jumlah karakter yang sama pula, karena saya menggunakan nilai dua kali, tapi tip yang baik.
micsthepick
Anda dapat menyimpan beberapa byte pada cara python menangani backslash dalam string, Anda tidak selalu perlu menyandikannya. Lihat 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

Yang ini hanya membangun dan mencetak baris demi baris.

Berikut kode dalam bentuk ungolfed:

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

Sunting: Saya mengubah bahasa menjadi python 2, agar kompatibel dengan jawaban saya untuk # 3 (dan juga menghemat 6 byte lebih banyak)

Matty
sumber
Saya percaya w=(3*' ||')[i] -> w=' |'[i&2]dan ' '+s[1:-1]+' ' -> ' %s '%s[1:-1]bekerja (yang pertama adalah string dengan dua spasi kemudian pipa, tapi SE bertindak)
Sp3000
@ Sp3000 Terima kasih! Yang pertama cukup cerdas. Saya seharusnya memikirkannya ' ||'[i%4], tetapi ini bahkan lebih pendek (juga dengan dua spasi).
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]);}

Dengan spasi putih, dan beberapa peningkatan keterbacaan lainnya:

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

Ini terutama berbasis template. Template tberisi semua 9 kolom yang mungkin dari output, yang berarti bahwa itu mengkodekan 9 * 9 = 81 karakter, atau 80 tanpa baris baru.

Karena hanya ada 6 karakter yang berbeda dalam pola (termasuk karakter baris baru), saya mengemas pasangan mereka menjadi satu karakter templat, yang berarti bahwa templat dapat disimpan dalam 40 karakter. Kemudian ada 6 * 6 = 36 pasangan karakter yang memungkinkan, yang dikodekan sebagai karakter ASCII 48 hingga 73. Terjemahan kembali ke karakter asli diberikan oleh tabel pencarian kecil m.

Logika lainnya adalah untuk mengulangi pola nkali, yang berarti melompat kembali 4 karakter dalam template, sambil memancarkan bagian awal dan akhir dari setiap baris dengan benar.

Reto Koradi
sumber
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";}}
Med
sumber
Anda dapat menyimpan beberapa karakter dengan menghapus beberapa spasi putih yang tidak perlu di sekitar operator, misalnya di sekitar =dan .=yang.
ProgramFOX
Terima kasih sudah diedit jawabannya
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).

(Dengan spasi putih):

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

Saya mencoba beberapa cara untuk memotong string, tetapi tampaknya tidak ada yang mengalahkan metode kolom naif ini.

Paul Butcher
sumber
2

JavaScript (ES6), 158 154 148 137 byte

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

Sunting: Disimpan 11 byte berkat @ Bálint.

Neil
sumber
@ Bálint But /(..)(.{4})/gadalah 13 byte, sama dengan /(..)(....)/g...
Neil
@ Bálint Saya benar-benar menyadari bahwa penghematan 4-byte saya sebelumnya memungkinkan saya untuk melakukan itu, tetapi saya jauh dari komputer pada saat itu.
Neil
@ Bálint Bagus! Saya telah melihat ke dalam menghindari segmen \\ / \\ berulang tapi saya tidak berpikir untuk memeriksa substring yang lebih lama diulang.
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);}}

Solusi pertama saya memiliki begitu banyak kata kunci "statis" di dalamnya sehingga lebih pendek untuk membuat metode dan atribut non-statis dan menjalankan kode dalam konstruktor.

ECS
sumber
1

PowerShell, 228 207 181 133 byte

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

Pengingat - PowerShell tidak menunggu stdin secara otomatis. Anda harus menyalurkan sesuatu, misalnya3|%{...}

Nacht - Pasang kembali Monica
sumber
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

Setiap string berisi pola AACCBBDDyang diperluas untuk membentuk AABB(CCBB)*DDBagian CCBBdiulang N kali, kemudian 2 karakter pertama dihapus. (Itu lebih pendek untuk menghapus karakter dari awal daripada dari akhir)

12Me21
sumber