ASCII दिन की कला # 1 - डबल गाँठ

Question

एक पूर्ण प्रोग्राम या एक फ़ंक्शन लिखें जो NSTDIN / कमांड लाइन / ARGV या फ़ंक्शन तर्कों के माध्यम से इनपुट के रूप में एक सकारात्मक पूर्णांक लेता है और NSTDOUT के अनुरूप एक ASCII डबल गाँठ प्रिंट करता है ।

ASCII डबल गाँठ इस तरह दिखता है:

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

ऊपर के लिए है N = 6

यहाँ अन्य मूल्यों के लिए कुछ और डबल समुद्री मील हैं N:

यदि N = 1, आउटपुट डबल नॉट जैसा दिखता है:

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

इसके लिए N = 2,

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

इसके लिए N = 3,

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

और इसी तरह, पैटर्न जारी है और किसी भी बड़े मूल्य का है N।

विवरण :

• इनपुट हमेशा धनात्मक पूर्णांक से बड़ा होता है 0।
• अनुगामी न्यूलाइन वैकल्पिक है
• प्रत्येक पंक्ति में या तो अनुगामी स्थान नहीं होना चाहिए, या पर्याप्त अनुगामी रिक्त स्थान जैसे कि प्रत्येक पंक्ति की लंबाई है 4*N + 2।
• कोई भी अग्रणी स्थान कभी नहीं होना चाहिए जो निर्दिष्ट पैटर्न का हिस्सा नहीं हैं।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

---

श्रृंखला लीडरबोर्ड

मैं इसे ASCII कला चुनौतियों की एक श्रृंखला में परिवर्तित कर रहा हूं और इस प्रकार श्रृंखला के लिए एक लीडर बोर्ड (मार्टिन द्वारा स्निपेट) को जोड़ रहा हूं। यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाए गए हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्केड टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

# 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. फ्लो स्नेक

3. चीनी तीतर

4. राशि चक्र संकेत

5. रैंडम डायमंड टीलिंग्स

Comments

N = 3 के लिए दाहिना किनारा अलग क्यों है?

— aditsu

@aditsu हा। 4 दिन, 3K विचार, 11 उत्तर और आप इसे नोटिस करने वाले पहले व्यक्ति हैं: डी। फिक्स्ड!

— ऑप्टिमाइज़र

Answer 1

सीजेएम, 55 बाइट्स

मैं इस से बहुत बुरी तरह से झपकी ले लिया ... वैसे भी, मैं अंततः आईएसओ 8859-1 के 55 बाइट्स के साथ आया :

"²îå<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 बार दोहराया जाता है, अर्थात एक पुनरावृत्ति को आधे में काट दिया जाता है। सुविधा के लिए, मैंने इस पैटर्न का उपयोग किया:

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

और पहले पुनरावृत्ति की पहली छमाही को हटा दिया।

इसलिए मैं भागों में शामिल हो गया और उन्हें ट्रांसपोज़्ड रूप में इनकोड किया, क्योंकि उनके साथ उस तरह से काम करना आसान है। पहला और तीसरा कार्यक्रम इस तार को कूटबद्ध करता है:

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

(without newlines), जो मध्य + किनारों का ट्रांसपोज़िशन है। दूसरा और चौथा कार्यक्रम ("विकल्प") इस स्ट्रिंग को कूटबद्ध करता है:

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

फिर से, बिना सुर्खियों के, और यह किनारों + मध्य का स्थानान्तरण है।

यहां बताया गया है कि कोड का यह सामान्य हिस्सा कैसे काम करता है:

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

Comments

मुझे यकीन नहीं है कि मैंने कब तक इसे 1>W<छोटा बनाने की कोशिश की । पता चला है कि मैं केवल यह एन्कोडिंग और उपयोग करने से पहले सरणी को घुमाने के लिए किया था 2>...

— डेनिस

Answer 2

CJam, 103 92 83 69 66 57 बाइट्स

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

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

जब हम स्तंभों के साथ पंक्तियों को स्थानांतरित करते हैं, तो पैटर्न बहुत अधिक स्पष्ट हो जाता है (रिक्त स्थान के साथ दाईं ओर स्थित)।

उदाहरण के लिए इनपुट 3 के लिए, यह देता है:

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

पहले दो और अंतिम दो पंक्तियाँ विशेष हैं, लेकिन अन्य एक ही पैटर्न को बार-बार दोहराते हैं।

इस प्रकार, इनपुट एन के लिए , हम सभी को दोहराना है

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

एन बार, पहली पंक्ति को प्रतिस्थापित करें

  ||  || 
 /  \/  \

साथ अंतिम पंक्ति

 \  /\  /
  ||  || 

और, अंत में, स्तंभों के साथ पंक्तियों को स्थानांतरित करें।

कोड

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

Answer 3

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ), 169 163 160 158 बाइट्स

संपादित करें: -6 पैटर्न स्ट्रिंग से कुछ पुनरावृत्ति को खत्म करने के लिए एक टेम्पलेट स्ट्रिंग का उपयोग करके।

संपादित करें: -3 स्विच करके slice(0,-2)करने के लिए slice(2)पैटर्न स्ट्रिंग पुनः व्यवस्थित करके।

संपादित करें: -2 के bबजाय के माध्यम से पाशन aऔर aएक modulo के साथ स्ट्रिंग 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
`)

Comments

मुझे लगता है कि इससे पहले कि आप स्ट्रिंग की जगह ले सकता .split(0)साथ ('__ 0 '+(r='\\/0/\\/ 0\\/ /0 ')+r+'0\\/ /0__/\\')।

— flawr

@flawr मैं एक समान विधि का उपयोग करके इसे और भी कम करने में सक्षम था :)

— nderscore

यदि आप इस पर से गुजरते 0हैं, तो आप देखेंगे 8।

— इस्माइल मिगुएल

वे `` और ${...}वास्तव में क्या करते हैं?

— दोष

@flawr backtick `सिंटैक्स एक टेम्पलेट स्ट्रिंग घोषित करता है । किसी भी चीज़ ${}का मूल्यांकन एक जावास्क्रिप्ट अभिव्यक्ति के रूप में किया जाता है।

— रात 21:15

Answer 4

पर्ल, 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
  __  __  __  
 /  \/  \/  \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \ \/\ \/\ \/ 
 /\ \/\ \/\ \ 
| /\/ /\/ /\ |
| \/ /\/ /\/ |
 \__/\__/\__/ 

Answer 5

जावास्क्रिप्ट ( ईएस 6 ), 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('\\__/')
}

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>

Comments

0इसे पास करने की कोशिश करें और आपको 4-पैर वाला मकड़ी मिलेगा।

— इस्माइल मिगुएल

Answer 6

सी ++, 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

Comments

PPCG में आपका स्वागत है! आपका स्कोर आपके स्रोत कोड का आकार है, जो कि 1530 बाइट्स है। आप टिप्पणियों और व्हाट्सएप, और चर और फ़ंक्शन नामों को छोटा करके बाइट्स सहेजना शुरू कर सकते हैं।

— डेनिस

Wowzor बड़ा है तो बाकी हाहा मैं इसे नीचे लाने पर काम करेंगे: D

— स्पेसमैन

Answer 7

अजगर 2, 156 151 147 141 139

संपादन 1: एक फ़ंक्शन के बजाय इनपुट () का उपयोग करने के लिए संपादित किया गया।

2 संपादित करें: str.join का उपयोग किया और कुछ अनावश्यक पात्रों को हटाने के लिए var c में जोड़ा गया।

3 संपादित करें: कुछ अनावश्यक स्ट्रिंग एस्केप दृश्यों को हटा दिया।

4 संपादित करें: a = n-1 के बजाय ~ -n का उपयोग किया

यह प्रोग्राम करने के लिए अच्छा था, मेरा पहला कोड गोल्फ!

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

1 बाइट से फ़ाइल का आकार कम करने, मॉड्यूल को चलाने और अपना नंबर इनपुट करने के लिए पिछले नईलाइन वर्ण को निकालने के लिए इसे किसी बाहरी पाठ संपादक में n.py के रूप में सहेजें।

Comments

यदि आप प्रोग्राम निष्पादन स्टेटमेंट के ठीक बाद नंबर दर्ज करने की अनुमति देते हैं, तो मैं इसे 151 बाइट्स तक नीचे ले जा सकता हूं

— 20:56 15

आमतौर पर input ()STDIN से पढ़ते समय ठीक माना जाता है।

— seequ

मुझे लगता है कि आप दो बार a=n-1लिखने पर बचाने के लिए बच गए हैं *(n-1), लेकिन आप करते हैं*~-n ।

— xnor

अभी भी उसी तरह के पात्रों की एक ही राशि है, क्योंकि मैं दो बार मूल्य का उपयोग करता हूं, लेकिन अच्छी टिप।

— माईस्टेपिक

अजगर जिस तरह से स्ट्रिंग में बैकस्लैश को संभालता है उस पर आप कुछ बाइट्स बचा सकते हैं, आपको हमेशा उन्हें एनकोड करने की आवश्यकता नहीं है। देखें stackoverflow.com/a/16973452/3351622

— मैटी

Answer 8

पायथन 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])

संपादित करें: मैंने # 3 के लिए अपने उत्तर के साथ संगत होने के लिए भाषा को अजगर 2 में बदल दिया, (और यह 6 और बाइट्स भी बचाता है)

Comments

मुझे विश्वास है w=(3*' ||')[i] -> w=' |'[i&2]और ' '+s[1:-1]+' ' -> ' %s '%s[1:-1]काम (पहले एक दो स्थानों के साथ एक स्ट्रिंग है , फिर एक पाइप है, लेकिन एसई का अभिनय है)

— Sp3000

@ Sp3000 धन्यवाद! वह पहले वाला काफी स्मार्ट है। मुझे इसके बारे में सोचना चाहिए था ' ||'[i%4], लेकिन यह और भी छोटा है ( दो स्थानों के साथ )।

— मैटी

Answer 9

सी, 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३ के बीच ASCII अक्षर के रूप में एन्कोड किए गए हैं। मूल चरित्र में अनुवाद छोटे लुकअप टेबल द्वारा दिया गया है m।

बाकी तर्क मुख्य रूप से पैटर्न के nसमय को दोहराने के लिए है, जिसका अर्थ है कि प्रत्येक पंक्ति के आरंभ और अंत भागों को सही ढंग से उत्सर्जित करते हुए, टेम्पलेट में 4 वर्णों को वापस कूदना।

Answer 10

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

Comments

आप संचालकों के आसपास कुछ अनावश्यक व्हाट्सएप को हटाकर कुछ चार्ट बचा सकते हैं, उदाहरण के लिए =और आसपास .=।

— प्रोग्रामफॉक्स

Thx मैं जवाब संपादित

— मेड

Answer 11

प्रोलोग (एसडब्ल्यूआई), 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).

मैंने तारों को काटने के कुछ तरीकों की कोशिश की, लेकिन कोई भी इस भोले कॉलम विधि को हरा नहीं सकता था।

Answer 12

जावास्क्रिप्ट (ईएस 6), 158 154 148 137 बाइट्स

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

संपादित करें: सहेजे गए 11 बाइट्स @ Bálint के लिए धन्यवाद।

Comments

@ बैलिंट लेकिन /(..)(.{4})/g13 बाइट्स हैं, वही /(..)(....)/g...

— नील

@ बैलिंट मुझे वास्तव में एहसास हुआ कि मेरी पिछली 4-बाइट बचत ने मुझे ऐसा करने की अनुमति दी थी, लेकिन मैं उस समय कंप्यूटर से दूर था।

— नील

@ बेताल अच्छा लगा! मैं बार-बार \\ / \\ खंड से बचने में देखा था, लेकिन मैं एक लंबे समय से दोहराया विकल्प के लिए जाँच करने के लिए नहीं सोचा था।

— नील

Answer 13

जावा, 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);}}

मेरे पहले समाधान में इतने सारे "स्थैतिक" कीवर्ड थे कि यह गैर-स्थिर तरीकों और विशेषताओं को बनाने और कोड को निर्माणकर्ता में चलाने के लिए कम था।

Answer 14

पॉवरशेल, 228 207 181 133 बाइट्स

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

अनुस्मारक - PowerShell स्टड पर स्वचालित रूप से प्रतीक्षा नहीं करता है। आपको कुछ में पाइप करना होगा, जैसे3|%{...}

Answer 15

स्माइलबासिक, 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होता है जिसे बनाने के लिए विस्तार किया जाता है AABB(CCBB)*DD। CCBBभाग को एन बार दोहराया जाता है, फिर पहले 2 वर्ण हटा दिए जाते हैं। (यह शुरू से ही अंत से पात्रों को हटाने के लिए छोटा था)