Schreiben Sie ein vollständiges Programm oder eine Funktion, die eine positive Ganzzahl Nals Eingabe über STDIN / Befehlszeile / ARGV oder Funktionsargumente verwendet und einen ASCII-Doppelknoten entsprechend NSTDOUT ausgibt.

Der ASCII-Doppelknoten sieht folgendermaßen aus:

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

Das obige ist für N = 6

Hier sind noch ein paar Doppelknoten für andere Werte von N:

Wenn N = 1der Ausgangsdoppelknoten wie folgt aussieht:

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

Für N = 2sein

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

Für N = 3sein

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

und in ähnlicher Weise geht das Muster weiter und jeder größere Wert von N.

Details :

• Die Eingabe ist immer eine positive ganze Zahl größer als 0.
• Der Zeilenumbruch ist optional
• Es sollten entweder keine nachgestellten Leerzeichen in jeder Zeile oder genügend nachgestellte Leerzeichen vorhanden sein, damit die Länge jeder Zeile gleich ist 4*N + 2.
• Es sollte niemals ein führendes Leerzeichen geben, das nicht Teil des angegebenen Musters ist.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Serien-Bestenliste

Ich wandle dies in eine Reihe von ASCII-Kunstherausforderungen um und füge so eine Rangliste für die Reihe hinzu (Ausschnitt von Martin). Um sicherzustellen, dass Ihre Antworten angezeigt werden, beginnen Sie jede Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wobei N die Größe Ihrer Einreichung ist. Wenn Sie Ihre Punktzahl verbessern, können Sie alte Punkte in der Überschrift behalten, indem Sie sie durchstreichen. Zum Beispiel:

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

Serie soweit

1. Doppelknoten

2. Flow Snakes

3. Chinesische Schreine

4. Sternzeichen

5. Zufällige Diamantkacheln

CJam, 55 Bytes

Ich habe mich ziemlich schlecht von diesem Nerd schnappen lassen ... trotzdem habe ich mir endlich 55 Bytes ISO 8859-1 ausgedacht :

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

oder diese Alternative :

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

Anfangs habe ich versucht, es in einfachem ASCII zu machen, aber nur auf 58 Bytes reduziert :

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

und nochmal eine alternative :

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

Erläuterung:

Die Idee ist, die einzelnen Teile (linker Rand, rechter Rand und mittleres Muster) auf bequeme Weise zu kodieren, den mittleren Teil nach Bedarf zu wiederholen und sie zusammenzufügen. Der Code ähnelte in vielerlei Hinsicht Dennis 'Antwort. Ich habe nicht versucht, ihn zu kopieren, aber ich habe viele verschiedene Ansätze ausprobiert (einschließlich der Ausnutzung von mehr Symmetrien und Wiederholungen), und dies hat am besten funktioniert.

Ich habe den linken und rechten Rand so zusammengefügt:

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

Das mittlere Muster hat 4 Spalten, aber sie werden N-0,5-mal wiederholt, dh eine Wiederholung wird halbiert. Der Einfachheit halber habe ich dieses Muster verwendet:

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

und entfernte die erste Hälfte der ersten Wiederholung.

Also habe ich die Teile zusammengefügt und transponiert codiert, da es einfacher ist, auf diese Weise mit ihnen zu arbeiten. Das erste und dritte Programm codieren diese Zeichenfolge:

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

(ohne Zeilenumbruch), das ist die Transposition der Mittelkanten. Das zweite und vierte Programm (die "Alternativen") codieren diese Zeichenfolge:

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

wieder ohne Zeilenumbrüche, und dies ist die Transposition von Kanten + Mitte.

So funktioniert dieser gemeinsame Teil des Codes:

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

Danach unterscheidet sich die Implementierung geringfügig. Im ersten und dritten Programm haben wir:

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

Im zweiten und vierten (alternativen) Programm haben wir:

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 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Idee

Das Muster wird viel offensichtlicher, wenn wir Zeilen mit Spalten transponieren (rechts mit Leerzeichen aufgefüllt).

Für Eingang 3 ergibt dies beispielsweise:

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

Die ersten beiden und letzten beiden Zeilen sind speziell, aber die anderen wiederholen das gleiche Muster immer und immer wieder.

Für die Eingabe N müssen wir also nur wiederholen

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

Ersetzen Sie die erste Zeile N- mal durch

  ||  || 
 /  \/  \

die letzte Reihe mit

 \  /\  /
  ||  || 

und schließlich Zeilen mit Spalten transponieren.

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-Entwurf ), 169 163 160 158 Bytes

Bearbeiten Sie: -6, indem Sie eine Vorlagenzeichenfolge verwenden, um Wiederholungen in der Musterzeichenfolge zu vermeiden.

Editieren: -3 durch Umschalten von slice(0,-2)auf slice(2)durch Umordnen der Pattern-Zeichenkette.

Editieren: -2 durch Durchschleifen banstelle von aund Reduzieren der aZeichenkette auf 4 mit einem 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>

Kommentiert:

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

Nimmt einen Kommandozeilenparameter an:

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

JavaScript ( ES6 ), 165 166

Knotenelemente:

• 2 obere Reihen, basierend auf '__' und '/ \' wiederholt
• 2 äußere Zeilen, basierend auf '/ \ /' wiederholt und eingeschlossen in '| ... | '
• 2 innere Zeilen, basierend auf '\ / \' wiederholt und eingeschlossen in '... /' und '/ ... \'
• die gleichen 2 äußeren Reihen oben
• 1 unterste Zeile basierend auf '\ __ /' wiederholt

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

Golf gespielt

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

Das sah nach einer lustigen Herausforderung aus, von der ich ein wenig abgewichen bin.

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

Ich bin nicht sicher, wie man Bytes der Größe meiner Anwendung misst, aber ich werde versuchen, es herauszufinden und meine Antwort zu aktualisieren.

Meine App könnte kleiner sein, aber sie läuft sowohl im x als auch im y und ich mag das irgendwie: D

Python 2, 156 151 147 141 139

edit 1: bearbeitet, um input () anstelle einer Funktion zu verwenden.

edit 2: benutze str.join und füge var c hinzu, um einige überflüssige Zeichen zu entfernen.

edit 3: einige unnötige String-Escape-Sequenzen entfernt.

edit 4: benutze ~ -n anstelle von a = n-1

Es hat Spaß gemacht, dies zu programmieren, mein erster Code Golf!

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

Speichern Sie es in einem externen Texteditor als n.py, um das letzte Zeilenumbruchzeichen zu entfernen und die Dateigröße um 1 Byte zu verringern. Führen Sie das Modul aus und geben Sie Ihre Nummer ein.

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

Dieser erstellt und druckt nur Zeile für Zeile.

Hier ist der 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])

Bearbeiten: Ich habe die Sprache in Python 2 geändert, um mit meiner Antwort für # 3 kompatibel zu sein (und es werden auch 6 weitere Bytes gespart).

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

Mit Leerzeichen und einigen anderen Verbesserungen der Lesbarkeit:

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

Dies ist hauptsächlich vorlagenbasiert. Die Vorlage tenthält alle 9 möglichen Spalten der Ausgabe, dh, sie codiert 9 * 9 = 81 Zeichen oder 80 Zeichen ohne die nachfolgende Zeile.

Da das Muster nur 6 verschiedene Zeichen enthält (einschließlich Zeilenvorschubzeichen), habe ich Paare von diesen in ein Vorlagenzeichen gepackt, was bedeutet, dass die Vorlage in 40 Zeichen gespeichert werden kann. Es gibt dann 6 * 6 = 36 mögliche Zeichenpaare, die als ASCII-Zeichen 48 bis 73 codiert sind. Die Rückübersetzung zum Originalzeichen erfolgt über die kleine Nachschlagetabelle m.

Der Rest der Logik besteht hauptsächlich darin, die Musterzeiten zu wiederholen n, was bedeutet, dass 4 Zeichen in der Vorlage zurückgesprungen werden, während der Anfangs- und der Endteil jeder Zeile korrekt ausgegeben werden.

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

(Mit Leerzeichen):

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

Ich habe ein paar Möglichkeiten ausprobiert, die Saiten zu zerhacken, aber keine schien diese naive Säulenmethode zu übertreffen.

JavaScript (ES6), 158 154 148 137 Bytes

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

Bearbeiten: 11 Bytes dank @ Bálint gespeichert.

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

Meine erste Lösung enthielt so viele "statische" Schlüsselwörter, dass es kürzer war, die Methoden und Attribute nicht statisch zu machen und den Code im Konstruktor auszuführen.

PowerShell, 228 207 181 133 Byte

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

Erinnerung - PowerShell wartet nicht automatisch auf stdin. Sie müssen etwas einpfeifen, z3|%{...}

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

Jede Zeichenfolge enthält das Muster, AACCBBDDdas zur Form erweitert wird. AABB(CCBB)*DDDer CCBBTeil wird N-mal wiederholt, dann werden die ersten beiden Zeichen entfernt. (Es war kürzer, Zeichen vom Anfang als vom Ende zu entfernen)