CJam, 103 92 83 69 66 57 bytes

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

Try it online in the W<+2mCJam interpreter.

Idea

The pattern becomes a lot more obvious once we transpose rows with columns (padded to the right with spaces).

For input 3, for example, this gives:

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

The first two and last two rows are special, but the others repeat the same pattern over and over again.

Thus, for input N, all we have to do is repeat

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

N times, replace the first row with

 || || / \/ \ 

the last row with

 \ /\ / || || 

and, finally, transpose rows with columns.

Code

"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 Draft), 169 163 160 158 bytes

Edit: -6 by using a template string to eliminate some repetition from the pattern string.

Edit: -3 by switching from slice(0,-2) to slice(2) by rearranging the pattern string.

Edit: -2 by looping through b instead of a and reducing the a string to 4 with a 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>

Commented:

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 

Takes a command line parameter:

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

JavaScript (ES6), 165 166

Knot elements:

• 2 top rows, based on ' __' and '/ \' repeated
• 2 outer rows, based on '/\/ ' repeated and enclosed in '| ... |'
• 2 inner rows, based on '\/\ ' repeated and enclosed in '.../' and '/...\'
• the same 2 outer rows above
• 1 bottom row based on '\__/' repeated

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>

C++ , 1530 639 479

This looked like a fun challenge I deviated from the brief a little.

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

Im not sure how to measure bytes of the size of my application but I will try figure it out and update my answer.

My app could be smaller but it loops in both the x and y, and I kinda like that :D

Python 2, 156 151 147 141 139

edit 1: edited to use input() instead of a function.

edit 2: used str.join and added to var c to remove some redundant characters.

edit 3: removed some unnecessary string escape sequences.

edit 4: used ~-n instead of a=n-1

This was good fun to program, my first code golf!

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

save it in an external text editor as n.py in order to remove last newline character in order to reduce file size by 1 byte, run the module, and input your number.

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 

This one just builds and prints line by line.

Here's the code in ungolfed form:

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

Edit: I changed the language to python 2, to be compatible with my answer for #3 (and it also saves 6 more bytes)

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

With whitespace, and some other readability improvements:

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

This is primarily template based. The template t contains all 9 possible columns of the output, meaning that it encodes 9 * 9 = 81 characters, or 80 without the trailing newline.

Since there are only 6 different characters in the pattern (including newline characters), I packaged pairs of them into one template character, which means that the template can be stored in 40 characters. There are then 6 * 6 = 36 possible pairs of characters, which are encoded as ASCII characters 48 to 73. The translation back to the original character is given by the small lookup table m.

The rest of the logic is mainly to repeat the pattern n times, which means jumping back 4 characters in the template, while emitting the start and end parts of each row correctly.

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

(With whitespace):

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

I tried a few ways of chopping the strings, but none seemed to beat this naive columns method.

JavaScript (ES6), 158 154 148 137 bytes

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

Edit: Saved 11 bytes thanks to @Bálint.

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

My first solution had so many "static" keywords in it that it was shorter to make the methods and attributes non-static and run the code in the constructor.

PowerShell, 228 207 181 133 bytes

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

Reminder - PowerShell doesn't wait on stdin automatically. You have to pipe something in, e.g. 3|%{...}

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 

Each string contains the pattern AACCBBDD which is expanded to form AABB(CCBB)*DD The CCBB part is repeated N times, then the first 2 characters are removed. (It was shorter to remove characters from the start than from the end)

Vyxal, 78 bytes

‛ _m*ðp,‛/ øṀ*ðp,` /\\`w$ẋf⁋¶\/V\|p‛ |+…Ṙ…£`\/\\`w$ẋfṄðpǔð₴…ð₴ǔ,¥Ḃ,,`\__/`*ðp, 

Try it Online!

Builds it incrementally. Here's a cool version that makes it a square.