เขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่ใช้จำนวนเต็มบวกNเป็นอินพุตผ่าน STDIN / บรรทัดคำสั่ง / ARGV หรือฟังก์ชั่นการขัดแย้งและพิมพ์ ASCII ดับเบิลปมที่สอดคล้องกับการNSTDOUT

ASCII double knot มีลักษณะดังนี้:

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

ด้านบนมีไว้สำหรับ N = 6

นี่คือปมคู่อีกสองสามค่าสำหรับค่าอื่น ๆ ของN:

หากN = 1เอาต์พุตปมคู่ดูเหมือนว่า:

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

สำหรับN = 2มัน

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

สำหรับN = 3มัน

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

และในทำนองเดียวกันรูปแบบจะดำเนินต่อไปและมีค่าNมากขึ้น

รายละเอียด :

• อินพุตเป็นจำนวนเต็มบวกมากกว่า0เสมอ
• ขึ้นบรรทัดใหม่ต่อท้ายเป็นตัวเลือก
• 4*N + 2มีทั้งที่ควรจะไม่มีช่องว่างต่อท้ายในแต่ละบรรทัดหรือช่องว่างต่อท้ายพอดังกล่าวว่าระยะเวลาในแต่ละแถวคือ
• ไม่ควรมีช่องว่างนำหน้าซึ่งไม่ได้เป็นส่วนหนึ่งของรูปแบบที่ระบุ

นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ลีดเดอร์บอร์ดซีรี่ส์

ฉันกำลังแปลงสิ่งนี้เป็นความท้าทายทางศิลปะของ ASCII และเพิ่มกระดานผู้นำสำหรับซีรี่ส์ (ตัวอย่างโดย Martin) เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มต้นทุกคำตอบด้วยพาดหัวโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

โดยที่ N คือขนาดของการส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

ซีรี่ส์จนถึงตอนนี้

1. ปมคู่

2. Flow Snakes

3. ศาลเจ้าจีน

4. สัญญาณราศี

5. การเอียงเพชรแบบสุ่ม

CJam, 55 ไบต์

ฉันถูก nerd sniped ค่อนข้างไม่ดีโดยนี้ ... ต่อไปในที่สุดฉันก็มาด้วย55 ไบต์ของ ISO 8859-1:

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

หรือทางเลือกนี้:

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

ตอนแรกฉันพยายามที่จะทำใน ASCII ธรรมดา แต่เพียงได้ถึง58 ไบต์ :

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

และอีกทางเลือกหนึ่ง :

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

คำอธิบาย:

ความคิดคือการเข้ารหัสส่วนที่ไม่ซ้ำกัน (ขอบซ้าย, ขอบขวาและรูปแบบกลาง) ในวิธีที่สะดวกสบายทำซ้ำส่วนตรงกลางตามความจำเป็นและนำมารวมกัน รหัสจบลงด้วยความคล้ายคลึงกันในหลาย ๆ วิธีเพื่อตอบเดนนิส; ฉันไม่ได้พยายามที่จะคัดลอกเขา แต่ฉันพยายามวิธีที่แตกต่างกันมากมาย (รวมถึงการหาประโยชน์จากสมมาตรและการทำซ้ำ ๆ ) และนี่คือสิ่งที่ดีที่สุด

ฉันวางขอบซ้ายและขวาเข้าด้วยกันดังนี้:

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

รูปแบบกลางมี 4 คอลัมน์ แต่มีการทำซ้ำ N-0.5 เท่านั่นคือการตัดหนึ่งครั้งซ้ำ ๆ จะถูกตัดครึ่ง ฉันใช้รูปแบบนี้เพื่อความสะดวก:

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

และลบครึ่งแรกของการทำซ้ำครั้งแรก

ดังนั้นฉันจึงเข้าร่วมส่วนและเข้ารหัสพวกเขาในรูปแบบ transposed เพราะมันง่ายกว่าที่จะทำงานกับพวกเขาในแบบนั้น โปรแกรมแรกและที่สามเข้ารหัสสตริงนี้:

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

(โดยไม่ต้องขึ้นบรรทัดใหม่) ซึ่งเป็นการเปลี่ยนตำแหน่งของขอบกลาง + โปรแกรมที่สองและสี่ ("ทางเลือก") เข้ารหัสสตริงนี้:

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

อีกครั้งโดยไม่ขึ้นบรรทัดใหม่และนี่คือการย้ายของ edge + middle

นี่คือวิธีการที่ส่วนทั่วไปของรหัสทำงาน:

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

หลังจากนี้การใช้งานจะแตกต่างกันเล็กน้อย ในโปรแกรมแรกและโปรแกรมที่สามเรามี:

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

ในโปรแกรมที่สองและสี่ (ทางเลือก) เรามี:

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 ไบต์

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

ลองใช้ออนไลน์ในล่าม CJam

ความคิด

รูปแบบมีความชัดเจนมากขึ้นเมื่อเราย้ายแถวกับคอลัมน์ (เบาะไปทางขวาด้วยช่องว่าง)

สำหรับอินพุท3ตัวอย่างเช่นสิ่งนี้ให้:

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

สองแถวแรกและสองแถวสุดท้ายเป็นแบบพิเศษ แต่แถวอื่น ๆ จะทำซ้ำในรูปแบบเดียวกันซ้ำแล้วซ้ำอีก

ดังนั้นสำหรับอินพุตNสิ่งที่เราต้องทำคือทำซ้ำ

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

ไม่มีครั้งแทนที่แถวแรกด้วย

  ||  || 
 /  \/  \

แถวสุดท้ายด้วย

 \  /\  /
  ||  || 

และสุดท้ายแปลงแถวด้วยคอลัมน์

รหัส

"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 ( ฉบับร่าง ES7 ), 169 163 160 158 ไบต์

แก้ไข: -6 โดยใช้สตริงเท็มเพลตเพื่อกำจัดการทำซ้ำบางส่วนจากสตริงรูปแบบ

แก้ไข: -3 โดยเปลี่ยนจากslice(0,-2)เป็นslice(2)โดยจัดเรียงสตริงรูปแบบใหม่

แก้ไข: -2 โดยวนลูปbแทนaและลดaสตริงเป็น 4 ด้วยโมดูโล

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>

แสดงความคิดเห็น:

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

รับพารามิเตอร์บรรทัดคำสั่ง:

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

JavaScript ( ES6 ), 165 166

องค์ประกอบปม:

• 2 แถวบนสุดตาม '__' และ '/ \' ซ้ำ
• 2 แถวด้านนอกตาม '/ \ /' ซ้ำและล้อมรอบใน '| ... | '
• 2 แถวด้านในโดยยึดตาม '\ / \' ซ้ำและล้อมรอบใน '... /' และ '/ ... \'
• 2 แถวนอกเดียวกันข้างบน
• 1 แถวด้านล่างตาม '\ __ /' ซ้ำแล้วซ้ำอีก

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

แข็งแรงเล่นกอล์ฟ

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

ดูเหมือนว่าจะเป็นการท้าทายที่ฉันเบี่ยงเบนไปจากบทสรุปเล็กน้อย

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

ฉันไม่แน่ใจว่าจะวัดขนาดของใบสมัครของฉันได้อย่างไร แต่ฉันจะลองหาคำตอบและอัปเดตคำตอบของฉัน

แอปของฉันอาจเล็กลง แต่มันวนซ้ำทั้งใน x และ y และฉันก็ชอบ: D

Python 2, 156 151 147 141 139

แก้ไข 1: แก้ไขเพื่อใช้อินพุต () แทนฟังก์ชั่น

แก้ไข 2: ใช้ str.join และเพิ่มใน var c เพื่อลบอักขระซ้ำซ้อนบางส่วน

แก้ไข 3: ลบลำดับ escape string ที่ไม่จำเป็นออก

แก้ไข 4: ใช้ ~ -n แทน a = n-1

มันสนุกดีที่ได้เขียนโปรแกรมกอล์ฟรหัสแรกของฉัน!

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

บันทึกไว้ในโปรแกรมแก้ไขข้อความภายนอกเป็น n.py เพื่อลบอักขระบรรทัดใหม่ล่าสุดเพื่อลดขนาดไฟล์ 1 ไบต์เรียกใช้โมดูลและใส่หมายเลขของคุณ

Python 2, 139 133 129 ไบต์

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

อันนี้เพิ่งสร้างและพิมพ์ทีละบรรทัด

นี่คือรหัสในรูปแบบ 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])

แก้ไข:ฉันเปลี่ยนภาษาเป็น python 2 เพื่อให้เข้ากันได้กับคำตอบของฉันสำหรับ # 3 (และยังประหยัดอีก 6 ไบต์)

C, 159 ไบต์

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

ด้วยช่องว่างและการปรับปรุงการอ่านอื่น ๆ :

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

นี่คือเทมเพลตเป็นหลัก เทมเพลตtมีคอลัมน์ที่เป็นไปได้ทั้งหมด 9 คอลัมน์ของผลลัพธ์หมายความว่ามันเข้ารหัส 9 * 9 = 81 ตัวอักษรหรือ 80 โดยไม่ต้องขึ้นบรรทัดใหม่

เนื่องจากมีเพียง 6 ตัวอักษรที่แตกต่างกันในรูปแบบ (รวมถึงอักขระขึ้นบรรทัดใหม่) ฉันจึงบรรจุคู่ของพวกเขาเป็นหนึ่งแม่แบบของตัวละครซึ่งหมายความว่าแม่แบบนั้นสามารถเก็บไว้ได้ 40 ตัว นอกจากนี้แล้ว 6 * 6 = 36 คู่ที่เป็นไปได้ของตัวละครซึ่งจะมีการเข้ารหัสเป็นอักขระ ASCII 48 73. mการแปลกลับไปที่ตัวละครเดิมจะได้รับจากการค้นหาตารางเล็ก

ส่วนที่เหลือของตรรกะส่วนใหญ่จะทำซ้ำnครั้งรูปแบบซึ่งหมายถึงการกระโดดกลับ 4 ตัวอักษรในแม่แบบในขณะที่เปล่งส่วนเริ่มต้นและจุดสิ้นสุดของแต่ละแถวอย่างถูกต้อง

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 ไบต์

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

(ด้วยช่องว่าง):

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

ฉันลองใช้การสับสตริงสักสองสามวิธี แต่ดูเหมือนไม่มีวิธีใดที่จะเอาชนะวิธีคอลัมน์ไร้เดียงสานี้ได้

JavaScript (ES6), 158 154 148 137 ไบต์

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

แก้ไข: บันทึกแล้ว 11 ไบต์ด้วย @ Bálint

Java, 339 330 ไบต์

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

ทางออกแรกของฉันมีคำหลัก "คงที่" จำนวนมากซึ่งสั้นกว่าเพื่อให้วิธีการและคุณลักษณะไม่คงที่และเรียกใช้รหัสในตัวสร้าง

PowerShell, 228 207 181 133 ไบต์

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

คำเตือน - PowerShell ไม่รอ stdin โดยอัตโนมัติ คุณต้องทำอะไรบางอย่างเช่น3|%{...}

SmileBASIC ขนาด 149 ไบต์

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

แต่ละสายมีรูปแบบAACCBBDDที่มีการขยายในรูปแบบส่วนหนึ่งจะถูกทำซ้ำ N ครั้งแล้ว 2 ตัวอักษรแรกจะถูกลบออก (มันสั้นกว่าที่จะลบตัวละครออกจากจุดเริ่มต้นกว่าจากตอนท้าย)AABB(CCBB)*DDCCBB