Viết chương trình đầy đủ hoặc một hàm lấy số nguyên dương Nlàm đầu vào thông qua STDIN / dòng lệnh / ARGV hoặc đối số hàm và in một nút kép ASCII tương ứng Nvới STDOUT.

Nút thắt đôi ASCII trông như thế này:

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

Trên đây là cho N = 6

Dưới đây là một vài nút thắt đôi cho các giá trị khác của N:

Nếu N = 1, nút thắt đầu ra trông như sau:

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

Cho N = 2, nó

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

Cho N = 3, nó

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

và tương tự, mô hình tiếp tục và bất kỳ giá trị lớn hơn của N.

Chi tiết :

• Đầu vào luôn là một số nguyên dương lớn hơn 0.
• Trailing newline là tùy chọn
• Không nên có khoảng trắng ở mỗi dòng hoặc đủ khoảng trắng ở cuối mỗi hàng 4*N + 2.
• Không bao giờ nên có bất kỳ không gian hàng đầu nào không phải là một phần của mẫu được chỉ định.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Bảng xếp hạng

Tôi đang chuyển đổi điều này thành một loạt các thách thức nghệ thuật ASCII và do đó thêm một ban lãnh đạo cho loạt bài (đoạn trích của Martin). Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu mọi câu trả lời bằng tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

Trong đó N là kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

/* Configuration */

var QUESTION_IDs = [50484, 50521, 50625, 51123, 51222]; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!.FjwQBrX2KXuFkv6p2lChi_RjzM19";

/* App */

var answers = [], page = 1, currentQ = -1;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_IDs.join(";") + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}


function getAnswers() {
  $.ajax({
    url: answersUrl(page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SIZE_REG = /\d+(?=[^\d&]*(?:<(?:s>((?!>).)*<\/s>|((?!>).)+>)[^\d&]*)*$)/;
var NUMBER_REG = /\d+/;
var LANGUAGE_REG = /^#*\s*([^\n,]+)(?=,)/;//

function shouldHaveHeading(a) {
  var pass = false;
  var lines = a.body_markdown.split("\n");
  try {
    pass |= /^#/.test(a.body_markdown);
    pass |= ["-", "="]
              .indexOf(lines[1][0]) > -1;
    pass &= LANGUAGE_REG.test(a.body_markdown);
  } catch (ex) {}
  return pass;
}

function shouldHaveScore(a) {
  var pass = false;
  try {
    pass |= SIZE_REG.test(a.body_markdown.split("\n")[0]);
  } catch (ex) {}
  if (!pass) console.log(a);
  return pass;
}

function getAuthorName(a) {
  return a.owner.display_name;
}

function getAuthorId(a) {
  return a.owner.user_id;
}

function process() {
  answers = answers.filter(shouldHaveScore)
                   .filter(shouldHaveHeading);
  answers.sort(function (a, b) {
    var aB = +(a.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0],
        bB = +(b.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0];
    return aB - bB
  });

  var users = {};
  answers.forEach(function (a) {
    var headline = a.body_markdown.split("\n")[0];
    var question = QUESTION_IDs.indexOf(a.question_id);
    var size = parseInt((headline.match(SIZE_REG)||[0])[0]);
    var language = headline.match(LANGUAGE_REG)[1];
    var user = getAuthorName(a);
    var userId = getAuthorId(a);
    if (!users[userId]) users[userId] = {name: user, nAnswer: 0, answers: []};
    if (!users[userId].answers[question]) {
      users[userId].answers[question] = {size: Infinity};
      users[userId].nAnswer++;
    }
    if (users[userId].answers[question].size > size) {
      users[userId].answers[question] = {size: size, link: a.share_link}
    }
  });
  
  
  var sortedUsers = [];
  for (var userId in users)
    if (users.hasOwnProperty(userId)) {
      var user = users[userId];
      user.score = 0;
      user.completedAll = true;
      for (var i = 0; i < QUESTION_IDs.length; ++i) {
        if (user.answers[i])
          user.score += user.answers[i].size;
        else
          user.completedAll = false;
      }
      sortedUsers.push(user);
    }  
  
  sortedUsers.sort(function (a, b) {
    if (a.nAnswer > b.nAnswer) return -1;
    if (b.nAnswer > a.nAnswer) return 1;
    return a.score - b.score;
  });
  
  var place = 1;
  for (var i = 0; i < sortedUsers.length; ++i) {
    var user = sortedUsers[i];
    var row = '<tr><td>'+ place++ +'.</td><td>'+user.name+'</td>';
    for (var j = 0; j < QUESTION_IDs.length; ++j) {
      var answer = user.answers[j];
      if (answer)
        row += '<td><a href="'+answer.link+'">'+answer.size+'</a></td>';
      else
        row += '<td class="missing"></td>';
    }
    row += '<td></td>';
    if (user.completedAll)
      row += '<td class="total">'+user.score+'</td>';
    else
      row += '<td class="total missing">'+user.score+'</td>';
    row += '</tr>';
    $("#users").append(row);
  }
}

body { text-align: left !important}

#leaderboard {
  width: 500px; 
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

td.total {
  font-weight: bold;
  text-align: right;
}

td.missing {
  background: #bbbbbb;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="leaderboard">
  <h2>Leaderboard</h2>
  <p>
    Missing scores are shown as grey cells. A grey total indicates that the user has not participated in all challenges and is not eligible for the overall victory yet.
  </p>
  <table class="_user-list">
    <thead>
      <tr><td></td><td>User</td>
        <td><a href="https://codegolf.stackexchange.com/q/50484/31414">#1</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/50521/31414">#2</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/50625/31414">#3</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/51123/31414">#4</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/51222/31414">#5</a></td>
        <td></td><td>Total</td>
      </tr>
    </thead>
    <tbody id="users">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Loạt cho đến nay

1. Nút thắt đôi

2. Rắn chảy

3. Đền thờ Trung Quốc

4. Cung hoàng đạo

5. Ốp kim cương ngẫu nhiên

CJam, 55 byte

Tôi đã bị mọt sách khá tệ bởi điều này ... dù sao đi nữa, cuối cùng tôi đã tìm ra 55 byte ISO 8859-1:

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

hoặc thay thế này :

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

Ban đầu tôi đã cố gắng thực hiện nó trong ASCII đơn giản, nhưng chỉ giảm xuống còn 58 byte :

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

và một lần nữa, một sự thay thế :

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

Giải trình:

Ý tưởng là mã hóa các phần độc đáo (cạnh trái, cạnh phải và mẫu giữa) một cách thuận tiện, lặp lại phần giữa khi cần và đặt chúng lại với nhau. Đoạn mã cuối cùng giống với câu trả lời của Dennis; Tôi đã không cố gắng sao chép anh ta, nhưng tôi đã thử nhiều cách tiếp cận khác nhau (bao gồm khai thác nhiều đối xứng và lặp lại) và đây là cách tốt nhất.

Tôi đặt cạnh trái và phải với nhau như thế này:

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

Mẫu ở giữa có 4 cột, nhưng chúng được lặp lại N-0,5 lần, tức là một lần lặp lại được cắt làm đôi. Để thuận tiện, tôi đã sử dụng mô hình này:

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

và loại bỏ nửa đầu của sự lặp lại đầu tiên.

Vì vậy, tôi đã tham gia các bộ phận và mã hóa chúng ở dạng chuyển đổi, vì làm việc với chúng theo cách đó dễ dàng hơn. Chương trình đầu tiên và thứ ba mã hóa chuỗi này:

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

(không có dòng mới), đó là sự hoán vị của các cạnh giữa +. Chương trình thứ hai và thứ tư ("các lựa chọn thay thế") mã hóa chuỗi này:

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

một lần nữa, không có dòng mới, và đây là chuyển vị của các cạnh + giữa.

Đây là cách phần phổ biến của mã này hoạt động:

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

Sau này, việc thực hiện khác đi một chút. Trong chương trình đầu tiên và thứ ba, chúng tôi có:

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

Trong chương trình thứ hai và thứ tư (thay thế), chúng tôi có:

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

CJam, 103 92 83 69 66 57 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý tưởng

Mô hình trở nên rõ ràng hơn rất nhiều khi chúng ta hoán đổi các hàng với các cột (được đệm bên phải bằng các khoảng trắng).

Ví dụ, đối với đầu vào 3 , điều này mang lại:

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

Hai hàng đầu tiên và hai hàng cuối là đặc biệt, nhưng các hàng khác lặp lại cùng một mẫu nhiều lần.

Do đó, đối với đầu vào N , tất cả những gì chúng ta phải làm là lặp lại

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

N lần, thay thế hàng đầu tiên bằng

  ||  || 
 /  \/  \

hàng cuối cùng với

 \  /\  /
  ||  || 

và cuối cùng, hoán chuyển các hàng với các cột.

Mã

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

Javascript ( Bản nháp ES7 ), 169 163 160 158 byte

Chỉnh sửa: -6 bằng cách sử dụng chuỗi mẫu để loại bỏ một số sự lặp lại từ chuỗi mẫu.

Chỉnh sửa: -3 bằng cách chuyển từ slice(0,-2)sang slice(2)bằng cách sắp xếp lại chuỗi mẫu.

Chỉnh sửa: -2 bằng cách lặp qua bthay vì avà giảm achuỗi xuống 4 bằng một 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>

Đã bình luận:

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

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

Lấy tham số dòng lệnh:

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

JavaScript ( ES6 ), 165 166

Các yếu tố hôn:

• 2 hàng trên cùng, dựa trên '__' và '/ \' được lặp lại
• 2 hàng ngoài, dựa trên '/ \ /' được lặp lại và đặt trong '| ... | '
• 2 hàng bên trong, dựa trên '\ / \' được lặp lại và đặt trong '... /' và '/ ... \'
• 2 hàng ngoài giống nhau ở trên
• 1 hàng dưới cùng dựa trên '\ __ /' được lặp lại

Ung dung

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

Chơi gôn

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>

C ++, 1530 639 479

Điều này trông giống như một thử thách thú vị mà tôi đã chệch khỏi bản tóm tắt một chút.

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

Tôi không chắc chắn làm thế nào để đo byte kích thước của ứng dụng của tôi nhưng tôi sẽ thử tìm ra nó và cập nhật câu trả lời của tôi.

Ứng dụng của tôi có thể nhỏ hơn nhưng nó lặp lại ở cả x và y và tôi cũng như vậy: D

Trăn 2, 156 151 147 141 139

chỉnh sửa 1: chỉnh sửa để sử dụng input () thay vì hàm.

chỉnh sửa 2: sử dụng str.join và thêm vào var c để loại bỏ một số ký tự thừa.

chỉnh sửa 3: loại bỏ một số chuỗi thoát không cần thiết.

chỉnh sửa 4: đã sử dụng ~ -n thay vì a = n-1

Đây là niềm vui tốt để lập trình, golf mã đầu tiên của tôi!

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

lưu nó trong một trình soạn thảo văn bản bên ngoài dưới dạng n.py để xóa ký tự dòng mới nhất để giảm kích thước tệp xuống 1 byte, chạy mô-đun và nhập số của bạn.

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

Điều này chỉ xây dựng và in từng dòng.

Đây là mã ở dạng không được phép:

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

Chỉnh sửa: Tôi đã thay đổi ngôn ngữ thành python 2, để tương thích với câu trả lời của tôi cho # 3 (và nó cũng tiết kiệm thêm 6 byte)

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

Với khoảng trắng và một số cải tiến dễ đọc khác:

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

Đây là chủ yếu dựa trên mẫu. Mẫu tchứa tất cả 9 cột có thể có của đầu ra, nghĩa là nó mã hóa 9 * 9 = 81 ký tự hoặc 80 mà không có dòng mới.

Vì chỉ có 6 ký tự khác nhau trong mẫu (bao gồm các ký tự dòng mới), tôi đã đóng gói các cặp trong số chúng thành một ký tự mẫu, có nghĩa là mẫu có thể được lưu trữ trong 40 ký tự. Sau đó, có 6 * 6 = 36 cặp ký tự có thể được mã hóa thành các ký tự ASCII 48 đến 73. Bản dịch trở lại ký tự gốc được đưa ra bởi bảng tra cứu nhỏ m.

Phần còn lại của logic chủ yếu là lặp lại mô hình n thời gian , nghĩa là nhảy lại 4 ký tự trong mẫu, đồng thời phát ra phần bắt đầu và phần cuối của mỗi hàng một cách chính xác.

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

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

(Với khoảng trắng):

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

Tôi đã thử một vài cách để cắt các chuỗi, nhưng dường như không có cách nào đánh bại phương thức cột ngây thơ này.

JavaScript (ES6), 158 154 148 137 byte

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

Chỉnh sửa: Đã lưu 11 byte nhờ @ Bálint.

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

Giải pháp đầu tiên của tôi có rất nhiều từ khóa "tĩnh" trong đó ngắn hơn để làm cho các phương thức và thuộc tính không tĩnh và chạy mã trong hàm tạo.

PowerShell, 228 207 181 133 byte

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

Nhắc nhở - PowerShell không tự động chờ đợi trên stdin. Bạn phải đặt một cái gì đó vào, ví dụ3|%{...}

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

Mỗi chuỗi chứa mẫu AACCBBDDđược mở rộng để tạo thành AABB(CCBB)*DDPhần CCBBđược lặp lại N lần, sau đó 2 ký tự đầu tiên được loại bỏ. (Nó ngắn hơn để loại bỏ các ký tự từ đầu so với từ cuối)