นี่คือคำตอบของการผูกมัดความท้าทายในการที่แต่ละคำตอบที่สร้างขึ้นบนคำตอบก่อนหน้านี้ ฉันขอแนะนำให้เรียงลำดับกระทู้ตาม "เก่าที่สุด" เพื่อให้แน่ใจเกี่ยวกับลำดับการโพสต์

หมายเหตุ : นี่เป็นความท้าทายที่ยาวนานและการโพสต์คำตอบใหม่นั้นค่อนข้างยาก ดังนั้นตอนนี้จึงมีห้องสนทนาสำหรับความท้าทายนี้ในกรณีที่คุณต้องการคำแนะนำในส่วนหนึ่งของคำตอบที่เป็นไปได้มีแนวคิดสำหรับภาษาที่สามารถเพิ่มหรือสิ่งที่คล้ายกัน รู้สึกอิสระที่จะปล่อยถ้าคุณมีอะไรจะถามหรือพูด!

งาน

โปรแกรมที่nที่จะส่งต้องทำงานในภาษาต่าง ๆn ; โดยเฉพาะภาษาทั้งหมดที่เพิ่มในโปรแกรมก่อนหน้าที่จะส่งรวมถึงอีกหนึ่งภาษา โปรแกรมจะต้องส่งออก 1 เมื่อทำงานในภาษาแรกที่ใช้ในการตอบคำถามนี้ 2 เมื่อทำงานในภาษาที่สองและอื่น ๆ ตัวอย่างเช่นคำตอบแรกสามารถพิมพ์ 1 เมื่อทำงานใน Python 3 และคำตอบที่สองสามารถส่งออก 1 เมื่อทำงานใน Python 3 และ 2 เมื่อทำงานใน JavaScript; ในกรณีนี้คำตอบที่สามจะต้องส่งออก 1 เมื่อทำงานใน Python 3, 2 เมื่อทำงานใน JavaScript และ 3 เมื่อทำงานในภาษาอื่น ๆ

กฎเพิ่มเติม

• โปรแกรมของคุณต้องทำงานโดยไม่เกิดข้อผิดพลาดหรือหยุดทำงาน คำเตือน (และเอาท์พุท stderr อื่น ๆ ) เป็นที่ยอมรับ แต่โปรแกรมจะต้องออกตามปกติ (เช่นโดยการออกจากจุดสิ้นสุดของโปรแกรมหรือผ่านคำสั่งเช่นexitที่ดำเนินการสิ้นสุดโปรแกรมปกติ)

• เอาต์พุตจะต้องเป็นจำนวนเต็มเท่านั้น แต่การขึ้นบรรทัดใหม่จะเป็นไปตามปกติ เอาต์พุต stdout อื่นที่หลีกเลี่ยงไม่ได้ยังได้รับอนุญาต ตัวอย่าง: ชื่อและเวอร์ชันของล่ามใน Befunge-93 ช่องว่างหลังจากสตริงที่พิมพ์ใน Zephyr บางภาษามีสองวิธีในการพิมพ์โดยมีและไม่มีเว้นวรรค ในกรณีนี้วิธีที่ไม่มีช่องว่างต่อท้ายจะต้องใช้

• แต่ละคำตอบจะต้องไม่เกิน 20% หรือ 20 ไบต์ (แล้วแต่จำนวนใดจะมากกว่า) นานกว่าคำตอบก่อนหน้า (นี่คือเพื่อป้องกันการใช้ภาษาเช่น Lenguage ส่งสแปมเป็นเธรดและเพื่อสนับสนุนการตีกอล์ฟอย่างน้อยจำนวนเล็กน้อย)

• อนุญาตให้ใช้เวอร์ชันเดียวกันของภาษาเดียวกัน (แม้ว่าจะต้องพิมพ์ตัวเลขที่แตกต่างกันอย่างชัดเจนดังนั้นคุณจะต้องตรวจสอบเวอร์ชันให้พอดีกับหลายภาษา) อย่างไรก็ตามคุณไม่สามารถใช้คุณสมบัติภาษาที่ส่งคืนหมายเลขเวอร์ชันของภาษา การทำซ้ำภาษาเดียวกันที่แน่นอนคือแน่นอนว่าเป็นไปไม่ได้ (เนื่องจากโปรแกรมจะต้องพิมพ์ตัวเลขที่แตกต่างกันหนึ่งในสองอย่าง)
• เคล็ดลับเช่นการละเมิดความคิดเห็นที่มากเกินไปแม้จะถูกแบนในการแข่งขันหลายภาษา แต่ก็ดีที่นี่
• คุณไม่จำเป็นต้องใช้คำตอบก่อนหน้าเป็นแนวทางในการเขียนของคุณเอง (คุณสามารถเขียนโปรแกรมทั้งหมดหากคุณต้องการตราบใดที่มันเป็นไปตามข้อกำหนด) อย่างไรก็ตามการยึดคำตอบของคุณส่วนใหญ่เป็นคำตอบก่อนหน้านี้อาจเป็นวิธีที่ง่ายที่สุดในการแก้ปัญหา
• คุณไม่สามารถส่งคำตอบสองคำติดต่อกัน ให้คนอื่นโพสต์ในระหว่าง กฎนี้ใช้จนกว่าจะบรรลุเงื่อนไขแห่งชัยชนะ
• เนื่องจากความท้าทายนี้ต้องการให้คู่แข่งรายอื่นโพสต์ในภาษาเดียวกับคุณคุณสามารถใช้ภาษาที่มีการติดตั้งฟรีเท่านั้น (เหมือนกับการแข่งขันค็อปและโจร )
• ในกรณีที่ภาษามีล่ามมากกว่าหนึ่งท่านคุณสามารถเลือกล่ามภาษาใด ๆ ก็ได้ตราบใดที่โปรแกรมทั้งหมดที่มีความหมายว่าจะทำงานได้สำเร็จในภาษานั้นทำได้ในล่ามนั้น (ในคำอื่น ๆ หากโปรแกรมทำงานในล่ามมากกว่าหนึ่งรายการโพสต์ในอนาคตสามารถเลือกล่ามเหล่านั้นได้แทนที่จะเป็นโพสต์ "ล็อคใน" ตัวเลือกเฉพาะของล่ามสำหรับภาษา)
• ความท้าทายนี้ใช้กฎ PPCG ใหม่เกี่ยวกับการเลือกภาษา : คุณสามารถใช้ภาษาหรือล่ามภาษาแม้ว่ามันจะใหม่กว่าคำถาม อย่างไรก็ตามคุณไม่สามารถใช้ภาษา / ล่ามที่ใหม่กว่าคำถามได้หากก) ภาษาได้รับการออกแบบมาเพื่อจุดประสงค์ในการพูดหลายภาษาหรือ b) ภาษาได้รับแรงบันดาลใจจากคำถามนี้ (ดังนั้นภาษาการเขียนโปรแกรมเชิงปฏิบัติที่ได้รับการออกแบบใหม่เกือบจะเป็นไปได้อย่างแน่นอนเช่นเดียวกับ esolangs ที่ไม่เกี่ยวข้อง แต่สิ่งต่าง ๆ เช่นA Pear Treeซึ่งได้รับแรงบันดาลใจจากคำถามนี้ถูกห้าม) โปรดทราบว่าสิ่งนี้ไม่เปลี่ยนความถูกต้องของภาษาที่ออกแบบ สำหรับการพูดหลายภาษาที่เก่ากว่าคำถามนี้
• โปรดทราบว่าเงื่อนไขชัยชนะ (ดูด้านล่าง) ได้รับการออกแบบมาเพื่อทำลายห่วงโซ่ (เช่นทำให้เป็นไปไม่ได้ที่คนอื่นจะตอบหลังจากที่คุณใช้ภาษาที่ยากต่อการพูดได้หลายภาษากับภาษาอื่น ๆ ) จะทำให้คุณแพ้ เป้าหมายคือการดำเนินต่อไปตราบเท่าที่เราสามารถทำได้และหากคุณต้องการที่จะชนะคุณจะต้องเคารพมัน

รูปแบบคำตอบ

เนื่องจากคำตอบทั้งหมดขึ้นอยู่กับการมีรูปแบบคำตอบที่สอดคล้องกันจะเป็นประโยชน์ ฉันขอแนะนำให้จัดรูปแบบคำตอบของคุณดังนี้:

2. JavaScript ขนาด 40 ไบต์

(program goes here)

โปรแกรมนี้พิมพ์1ใน Python 3 และ2ใน JavaScript

(หากคุณต้องการอธิบายโปรแกรมเทคนิคการพูดหลายภาษา ฯลฯ วางไว้ที่นี่)

เงื่อนไขชัยชนะ

เมื่อไม่มีคำตอบใหม่เป็นเวลา 14 วันผู้ชนะจะเป็นใครก็ตามที่โพสต์คำตอบล่าสุดครั้งที่สองคือพูดได้หลายภาษาที่ใหญ่ที่สุดที่ได้รับการพิสูจน์แล้วว่าไม่ทำลายโซ่ การขยายห่วงโซ่หลังจากนั้นก็ยังยินดีอย่างมาก!

ผู้ชนะคือโอกาสดูตอบ 194 (TemplAt)

รายการภาษา

// This snippet is based on the snippet from hello world thread https://codegolf.stackexchange.com/questions/55422/hello-world
// It was tested only in Google Chrome

// https://stackoverflow.com/a/4673436
if (!String.prototype.format) {
  String.prototype.format = function() {
    var args = arguments;
    return this.replace(/{(\d+)}/g, (match, number) => (typeof args[number] != 'undefined' ? args[number] : match) );
  };
}

var QUESTION_ID = 102370; // from the question url
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";

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

var answers = [], answer_page = 1;

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) { $('#status').text($('#status').text() + '.'); getAnswers(); }
      else process();
    },
    // [Documentation](http://api.jquery.com/jquery.ajax/) states that `error` handler is not called for cross-domain JSONP requests, 
    // but it works here, probably because api.stackexchange.com and codegolf.stackexchange.com are on the same domain.
    error:  function (a,b,c) { 
      $('#status').text( "Failed to load answers: " + b + " " + c );
      console.log( b + " " + c );
    },
  });
}

getAnswers();

// https://stackoverflow.com/questions/6290442/html-input-type-text-onchange-event-not-working/39834997#39834997
// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event
const input = document.querySelector('input');
input.addEventListener('input', onSearchInput);

function onSearchInput(e)
{
    var table = document.getElementsByTagName("table")[0];
    var str = e.srcElement.value.toLowerCase();
    var num_results = 0;

    if(str == "") // optimization for empty input
    {
        // show all rows
        for(var i = 1, row; row = table.rows[i]; i++)
        {
            row.className = "";
            num_results++;
        }
    }
    else
    {
        for(var i = 1, row; row = table.rows[i]; i++)
        {
            var hidden = row.innerText.toLowerCase().indexOf(str) == -1;
            if(!hidden) num_results++;
            row.className = hidden ? "hidden" : "";
        }
    }
    document.getElementById("results").innerText = "Results: " + num_results;
}


/* Function ParseHeader() extracts answer number, language name and size of polyglot from answer header.
   Argument: `header` - answer header string without markup, eg. "1. Python 3 (8 bytes)" or "59. Tcl, 1324 bytes".
   Retval:  object, eg. {num: 1, language: "Python 3", size: 8} or 
            null if header has wrong format
  
   There are two formats of header, new one with comma and old one with parens.
   Parsing new format only with regexp is hard because:
   - language name may contain commas,                                 eg. "51. Assembly (x64, Linux, AS), 1086 bytes"
   - there may be several sizes, of which the last one should be used, eg. "210. Haskell without MonomorphismRestriction, 10035 9977 bytes"

   There are only several answers with old format header: 1-5, 7, 12-17, 21. All of them have single size and don't have parens in language name,
   so they can be parsed with simple regexp.
   
   Algorithm: Find commas. If there are no commas parse it as old format. Otherwise parse it as new format.
   New format parsing: Let everything after last comma be `sizes`. Check if `sizes` ends with the word "bytes". If not, set size to 0.
   Take the word before "bytes" and convert it to number. Parse the rest of the header (before last comma) with regexp.
*/
function ParseHeader(header)
{
  var a = header.split(',');
  if(a.length > 1) // current format: Number "." Language "," Size+ "bytes"
  {
    // filter(s=>s) removes empty strings from array (handle multiple consecutive spaces)
    var sizes = a[a.length-1].split(" ").filter(s=>s); // " 123 100  bytes " -> ["123", "100", "bytes"]
    var size;
    if(sizes.length < 2 || sizes[sizes.length-1] != "bytes") size = 0;
    else size = +sizes[sizes.length-2];

    a.splice(a.length-1,1); // remove last element
    var match = a.join(',').match(/(\d*)\.(.*)/);
    if (!match) return null;
    return{
            num: +match[1],
            language: match[2].trim(),
            size: size,
          };
  }
  else // old format: Number "." Language "(" Size "bytes" ")"
  {
    var format = /(\d*)\.([^(]*)\((\d*)\s*bytes\)/;
    var match = header.match(format);
    if (!match) return null;
    return{
            num: +match[1],
            language: match[2].trim(),
            size: +match[3]
          };
  }
}

// 1533246057 (number of seconds since UTC 00:00 1 Jan 1970) -> "Aug 2 '18"
// other useful Date functions: toUTCString, getUTCDate, getUTCMonth, getUTCFullYear
function FormatDate(n)
{
  var date = new Date(n*1000); // takes milliseconds
  var md = date.toLocaleDateString("en-US", {timeZone:"UTC", day:"numeric", month:"short"});
  var y  = date.toLocaleDateString("en-US", {timeZone:"UTC", year:"2-digit"});
  return md + " '" + y;
}


var processed = []; // processed answers, it's called `valid` in original snippet

function ProcessAnswer(a)
{
  var body = a.body, header;

  //
  // Extract header from answer body.
  // Try find <h1> header (markdown #). If not found try find <h2> (markdown ##).
  // Extracted header contains only text, all markup is stripped.
  // For 99 language markup is later readded to language name because markup is essential for it.
  //
  var el = document.createElement('html'); // dummy element used for finding header
  el.innerHTML = body;
  var headers = el.getElementsByTagName('h1');
  if(headers.length != 0) header = headers[0].innerText;
  else {
    headers = el.getElementsByTagName('h2');
    if(headers.length != 0) header = headers[0].innerText;
    else { console.log(body); return; } // error: <h1> and <h2> not found
  }

  var info = ParseHeader(header)
  if(!info) { console.log(body); return; } // error: unrecognised header format

  if(info.num == 99 && info.language == "99") info.language = "<i>99</i>";

  processed.push({
    num:         info.num,
    language:    info.language,
    size:        info.size,
    answer_link:   a.share_link,
    user:          a.owner.display_name,
    user_link:     a.owner.link,         // `undefined` if user was deleted
    creation_date: a.creation_date,      // unix epoch (number of seconds since UTC 00:00 1 Jan 1970)
  });
}

function process()
{
  $('#status').remove();

  answers.forEach(ProcessAnswer); // answers -> processed
  
  processed.sort( (a,b)=>(a.num-b.num) ); // sort by answer number, ascending

  processed.forEach(function (a) {
    
    var date = FormatDate(a.creation_date);

    var user = a.user_link ? ('<a href="'+a.user_link+'">'+a.user+'</a>') : a.user; // redundant code, currently the only deleted user is ais523
    if(user == "user62131") user = '<a href="https://chat.stackexchange.com/users/246227/ais523">ais523</a>';

    var style = (a.num == 194) ? "background: #ccf" : ""; // 194 is winner answer

    var row = "<tr style='{0}'><td>{1}</td> <td><a href='{2}'>{3}</a></td> <td>{4}</td> <td>{5}</td> <td>{6}</td></tr>"
              .format(style, a.num, a.answer_link, a.language, a.size, user, date);

    $('#answers').append( row );
  });
}

a {text-decoration:none}
a:visited {color:#00e}

table, td, th { border: 1px solid black; }
td, th { padding-left: 5px; padding-right: 5px; white-space: nowrap; }
tr:hover { background-color: #ff9; }
td:first-child  { text-align:center; } /* # */
td:nth-child(4) { font-style:italic; } /* author */
td:nth-child(5) { text-align:right;  } /* date */

p { margin: 8px 0px }
.hidden { display: none } /* search hides rows */

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p>
  <span>Search: </span><input autofocus> &nbsp;<span id="results"></span>
</p>
<table class="answer-list">
  <thead>
    <tr><th>#</th> <th>Language</th> <th>Size (bytes)</th> <th>Author</th> <th>Date</th></tr>
  </thead>
  <tbody id="answers">
  
  </tbody>
</table>
<div id="status">Loading answers...</div>

หมายเหตุ: หากคุณเห็นสิ่งนี้ก่อนคุณอาจต้องการเรียงลำดับที่เก่าที่สุด

17. จูเลีย (128 ไบต์)

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17)
#gg99ddi2` |1|1+6

มีสอง ESCs ในบรรทัดสุดท้ายหนึ่งก่อนที่จะเป็นครั้งแรกและหนึ่งหลังจากที่g 2สิ่งนี้อาจจะเล่นกอล์ฟได้มากกว่านี้ แต่สิ่งต่าง ๆ ก็ยุ่งไม่ต้องขอบคุณ V และ Pyth

พิมพ์ 1 ใน Python 3, 2 ใน V, 3 ใน Minkolang, 4 ใน> <>, 5 ใน Python 2, 6 ใน SMBF, 7 ใน Japtapt, 8 ใน Japtore, 8 ใน Retina, 9 ใน Perl, 10 ใน Befunge-93, 11 ใน Befunge -98, 12 ฟิชชั่น 13 ในทับทิม 14 turtled 15 ในกองหญ้า 16 Pyth และ17 ในจูเลีย

คำแนะนำ:

• การเริ่มต้นของบรรทัดที่สี่คือ Python 2/3, Perl, Ruby ท้ายที่สุดก็คือ Julia ขอบคุณสำหรับ#=ความคิดเห็นหลายบรรทัด(โปรดทราบว่า Julia ไม่มีand/or)
• V คือ<ESC>gg99ddi2<ESC>ซึ่งสามารถเล่นกอล์ฟได้แน่นอน แต่ V นั้นน่ารำคาญสำหรับการทดสอบลองออนไลน์! เนื่องจากล่ามค่อนข้างช้า
• Minkolang vและกองหญ้าลงไปในครั้งแรก Befunge-93 และ -98 bไม่ได้และขึ้นอยู่กับ
• Retina นับจำนวนช่องว่างและ 1s ในบรรทัดที่สี่และ V จะซ่อนในการกำหนดค่าสำหรับ Retina (เช่นก่อนที่จะ backtick)
• ตามคำแนะนำของ @ ETHproduction Japt ใช้ backticks เพื่อซ่อนรหัสส่วนใหญ่ในสตริง
• R"12"*ฟิชชันคือ
• SMBF ได้รับการแข็งแรงเล่นกอล์ฟไปในบรรทัดแรกบวกสุดท้าย<.6

23. Hexagony , 186 ไบต์

ขออภัยหากแผนการนี้ยุ่งเกินไป ...

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#0\32=""<0]#echo 21
#8␛dggi2␛` |1|6

␛ใช้เพื่อแทนอักขระ ESC ตามตัวอักษร

พิมพ์:

23 ในHexagony , 22 ใน Underload, 21 ใน Nim, 20 ใน Prelude, 19 ใน Reng (ทดสอบได้ที่นี่ ), 18 ใน Cardinal, 17 ใน Julia, 16 ใน Julia, 16 ใน Pyth, 15 ใน Haystack, 14 ในTurtlèd, 13 ใน Ruby, 12 in ฟิชชัน, 11 ใน Befunge-98, 10 ใน Befunge-93, 9 ใน Perl, 8 ใน Retina, 7 ในJaptap , 6 ใน SMBF, 5 ใน Python 2, 4 ใน> <>, 3 ใน Minkolang, 2 ใน Vim / V และ 1 ใน Python 3

หากต้องการไปยังภาษาที่ไม่ได้เชื่อมโยงให้คลิกchange languageปุ่มที่มุมบนขวาของลิงค์ Hexagony

Hexagony ไม่สามารถอ่านได้ (ทั้งหมด) ในรูปแบบนี้ เราต้องดูในรูปหกเหลี่ยม
โปรดทราบว่าอักขระ 2 ESC ถูกแทนที่ด้วย␛s เพื่อให้คุณเห็นได้ - มันถูกละเว้นดังนั้นจึงไม่มีผู้อื่นในโปรแกรม:

        # v 1 6 / " < " 6
       / b . q @ " ( : : )      A lot more readable, right?? No?
      : : : ( 2 2 ) S # ; n
     4 " 1 4 " # > 3 N 6 @ 1
    5 o | > ^ * t t t * ~ + +
   ~ ~ ~ % # = ~ n J < R " 1 2
  " ; # [ p r i n t ( ( 1 / 2 a
 n d 9 o r 1 3 ) - ( 0 a n d + 4
) ^ 1 < < 6 5 > > 6 2 ) # 4 6 ( 8   | Note that the 0s below can be replaced
 9 9 9 9 + + + + + ! ) = # p r i    | With anything (except "`" or " "), 
  n t ( 1 7 ) # 0 \ 3 2 = " " <     V as far as Hexagony is concerned
   0 ] # e c h o 2 1 # 8 ␛ d g
    g i 2 ␛ | 1 | 6 . . . . .    <-- the ␛ represents an esc
     . . . . . . . . . . . .         character
      . . . . . . . . . . .
       . . . . . . . . . .       A "." is a no-op
        . . . . . . . . .
                ^
                | Mirror wraps to here, going NW

สำหรับผู้ที่ไม่คุ้นเคยกับHexagonyมี 6 IP ที่เริ่มต้นที่มุมทั้งหก เพียง 1 #][มีการใช้งานได้ตลอดเวลาและมีการเปลี่ยนโดยใช้ โมเดลหน่วยความจำไม่สำคัญสำหรับโปรแกรมนี้ แต่อาจจำเป็นต้องเข้าใจในอนาคต สิ่งที่คุณต้องรู้ก็คือ 1 int จะถูกเก็บไว้ใน "memory edge" (ME สำหรับช่วงสั้น ๆ ) และ'"}{เปลี่ยน ME ที่ใช้งานอยู่

\/|_>< เป็นมิเรอร์ที่ควบคุมโฟลว์โปรแกรม

นี่คือวิธีการทำงาน:

บรรทัดแรกที่ดำเนินการ:

#       A no-op (sets active IP to 0, the currently active one)
 v      letter chars set the ME to their ASCII value - so ME is now 118
  16    Like Labyrinth, 0-9 multiplies ME by 10 and is added - ME now 11816
    /   A mirror that sends IP going NW by wrapping to the bottom

ด้านล่าง (ตัวอย่างมีการพลิกในแนวตั้งเพื่อให้คุณอ่านจากบนลงล่างได้):

    .   
   .    A series of no-ops. The IP is going NW now,
  .     because of the mirror on the top.
 .
|       Another mirror. This one sends the IP NE, into the h
 h      sets the ME to 104, the ASCII value for h
  #     104 % 6 == 2, so IP 2 is now active instead of 0

ขอบขวา:

        8  IP #2 is moving SW, starting in the right corner 
       i   Sets the ME to 105
      <    Mirror. Sends the IP going due West
    ""     These change the Active ME - just know that the new edge is 0
   =       Changes the MP (more in specs) - effectively a no-op used to fill space
\32        pushes 23, and mirrors up NE to the !

รหัสสุดท้ายที่เกี่ยวข้อง:

!          Prints the current value of the ME as an int. Success!
 20(R~     Does things to the ME - irrelevant now
      @    Ends the program!

สิ่งที่ควรทราบ:

• Hexagony ลดค่าs และ`s ทั้งหมดก่อนดำเนินการดังนั้นการเปลี่ยนแปลงใด ๆ กับสิ่งเหล่านั้นจะไม่ส่งผลต่อ Hexagony
• ฉันจำเป็นต้องใส่รหัสเพื่อที่จะตีความว่าเป็นรูปหกเหลี่ยมความยาว 9 แทนที่จะเป็น 8 - ระวังการตีกอล์ฟที่ต่ำกว่า 169 หรือสูงกว่า 217 ตัวอักษรที่เกี่ยวข้อง
• ด้วยเหตุนี้~~~และ0s 2 ในตอนท้ายสามารถเปลี่ยนแปลงได้โดยไม่เป็นอันตรายต่อรหัส
• =""แค่ในการเคลื่อนไหว ME ออกไปจากก่อนหน้านี้หนึ่งเพื่อให้ใหม่ ME สามารถแก้ไขได้ พวกเขาสามารถถูกแทนที่ด้วยตัวละครอื่น ๆ ที่ทำสิ่งเดียวกันโดยไม่เป็นอันตรายต่อโปรแกรม hexagony ( 'ตัวอย่างเช่น)
• ในทางเทคนิคแล้วไม่สามารถใช้งานได้กับสเปคของ Befunge 93 เพราะมัน จำกัด กล่องขอบเขตของรหัสไว้ที่ 80 ถึง 25 chracters อย่างไรก็ตามผู้สกัดส่วนใหญ่ไม่สนใจสเป็คนี้ (เช่น TIO) ดังนั้นฉันไม่คิดว่าเป็นการตกลงที่ยิ่งใหญ่ ถ้าคุณรู้สึกฟรีเพื่อแสดงความคิดเห็น (ถ้ามากพออยากให้ฉันเปลี่ยนมันฉันจะลอง)
• หวังว่ามันจะไม่ยากเกินไปตอนนี้

50. ทุบตี 1024 ไบต์

#16  "(}23!@)" 3//v\D(@;'[af2.qc]GkGGZ'#)"14";n4
#/*` "[!PPP(22)SP(>7 7*,;68*,@;'1,@ ␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=<xR+++++[D>+++++++L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh@O6O4/]>+.-- -. >][
#Rx%>~~~+ +~*ttt*.x
#D>xU/-<+++L
#R+.----\).>]|
#[#[/v/v(/0l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e00m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#ssseemeePaeueewuuweeeeeeeeeeCisajjapppp/*/
#define z sizeof'c'-1?"38":"37"
#include<stdio.h>
main(  )/*/
#()`#`\'*/{puts(z );}/*'``
<>{# }//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#< >"3"O.
=end #//
"""#"#//
#}
#|o51~nJ;#:p'34'\
#ss8␛dggi2␛ `|1|6$//''25  =#print(17)#>27.say#]#print(47)#]#echo 21#ss*///nd^_^_Z222999"26

ต้องการเรียนรู้เพิ่มเติมหรือไม่ ลองใช้การสนทนาหลายเหลี่ยม !

ลองออนไลน์!

ตามปกติฉันแทนที่แท็บตัวอักษรด้วย␉และตัวอักษร ESC ตามตัวอักษรด้วย␛เนื่องจากข้อ จำกัด ของ Stack Exchange คุณสามารถรับโปรแกรมเวอร์ชันที่ใช้งานง่ายได้จากกล่อง "อินพุต" ของลิงก์ TIO ด้านบน

rundown

โปรแกรมนี้พิมพ์50ใน bash, 49ใน Octave, 48ใน Deadfish ~, 47ใน Lily, 46ใน Cubix, 45ใน PicoLisp, 44ใน alphuck, 43ในalphuck, 43ใน reticular, 42ในความชั่วร้าย, 41ใน brainfest, 40 in Minimal -2D, 39ใน CoffeeScript, 38ใน C, 37ใน C ++, 36ในเขาวงกต, 35ใน INTERCAL, 34ใน Rail, 33ในเหตุการณ์, 32ในเหตุการณ์วน, 31ใน Modular SNUSP,30ในไวท์สเปซ29ในทริกเกอร์28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25ใน Pip, 24ใน Thutu, 23ใน Hexagony, 22ใน Hexagony, 22ใน Underload, 21ใน Nim, 20ใน Prelude, 19ใน Reng , 18ในพระคาร์ดินัล, 17ใน Julia, 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12ใน Fission, 11ใน Befunge-98, 10ใน Befunge-93,9ใน Perl 5, 8ใน Retina, 7ใน Japtapt, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบด้านบน ผู้ร้ายสี่คนปกติต้องทำการทดสอบแยกต่างหาก:

• มีการทดสอบเหตุการณ์โดยใช้ล่ามอย่างเป็นทางการแบบออฟไลน์

• Deadfish ~ถูกทดสอบโดยใช้ล่ามอย่างเป็นทางการออฟไลน์

• Modular SNUSPถูกทดสอบออนไลน์ที่นี่ ;

• เหรงได้รับการทดสอบออนไลน์ที่นี่

คำอธิบาย

ฉันมองไปที่กลุ่มเป้าหมายที่หลากหลายเพื่อเพิ่มภาษา สิ่งหนึ่งที่เป็นไปได้คือการค้นหาภาษาที่มี#ความคิดเห็นในบรรทัดที่อาจเพิ่มเข้าไปในบรรทัด "ภาษาสคริปต์" (ซึ่งจัดการ Perl, Python 2 และ 3 และ Ruby) ฉันใช้เวลาสักครู่ในการนึกถึงภาษาที่เหมาะสมซึ่งอาจเข้ากันได้กับไวยากรณ์ที่มีอยู่แล้ว

ปรากฎว่าคำตอบนั้นจ้องมองฉันมานานหลายปี หากคุณคลิกที่ลิงก์ TIO ด้านบนมันจะเปิดไดรฟ์เวอร์ทดสอบหลายภาษาซึ่งเขียนขึ้นด้วยการทุบตี ดังนั้นตลอดเวลานี้ฉันมีแท็บที่บอกว่า "Bash - TIO Nexus" คุณคิดว่ามันจะเป็นคำใบ้ แต่ดูเหมือนว่าฉันจะพลาด ในฐานะโบนัสการทุบตีเป็นภาษาสคริปต์ดังนั้นคำว่า "บรรทัดภาษาสคริปต์" จึงยังคงเหมาะสม

โปรแกรม bash เริ่มต้นในที่เดียวกับภาษาสคริปต์อื่น ๆ อย่างไรก็ตามมีวิธีที่ค่อนข้างง่ายในการแยกมันออกจากพวกเขา ในสตริงที่ยกมาเดี่ยว\เป็นตัวหนีในภาษาส่วนใหญ่ แต่ไม่ได้อยู่ในทุบตี ดังนั้นเราสามารถซ่อนรหัสทุบตีจากภาษาอื่น ๆ ผ่านทาง'\'…';ซึ่งเป็นคำสั่งที่เลวร้าย (ไม่มีผลกระทบ) ใน Perl, Python และ Ruby แต่ดำเนินการในทุบตี echo 50;exitเป็นวิธีที่ค่อนข้างง่ายในการจบโปรแกรม bash เกือบแล้ว

ปัญหาที่ใหญ่ที่สุดที่นี่คือการทุบตีจะexitดำเนินการแยกวิเคราะห์ต่อไปจนถึงจุดสิ้นสุดของบรรทัดปัจจุบัน (แม้ว่าจะไม่ได้เรียกใช้รหัสที่เป็นปัญหา) ดังนั้นเราจึงต้องแน่ใจว่าไม่มีข้อผิดพลาดทางไวยากรณ์ในส่วนที่เหลือของ เส้น. เรามี'เพียงแค่หลังจากexit;นั้นไม่ได้ (และไม่สามารถ) จับคู่ได้ทันที ต่อมาในบรรทัด'…'จะใช้ในการซ่อนรหัส Brain-Flak บางส่วนจากภาษาสคริปต์ แต่ที่จะยกเลิกการซ่อนจากทุบตี ด้วยเหตุนี้เราจำเป็นต้องเปลี่ยนประเภทของสตริงตัวอักษรที่เราใช้ในการซ่อนรหัสโดยเปลี่ยนจากสตริงที่ยกมาเดี่ยวและสตริงที่ยกมาสองครั้ง or"'"เคล็ดลับโดยไม่รบกวน Perl, Python หรือ Ruby (เนื่องจากอาร์กิวเมนต์ด้านซ้ายเป็นความจริงในทุกกรณี)

ตอนนี้เรามีการเสนอราคาแบบคู่ที่ไม่มีใครเทียบที่ขยายไปสู่บรรทัดในอนาคต มันค่อนข้างยากที่จะปิดโดยไม่รบกวนภาษาอื่นอย่างน้อยหนึ่งภาษา สิ่งที่เราทำจริง ๆ คือเปลี่ยนวิธีที่เราซ่อนโค้ดจาก bash จาก double quote กลับเป็น quote เดียวที่ไม่มีใครเทียบในความคิดเห็น Python / Ruby ในบรรทัดถัดไปและสุดท้ายปิด single quote ที่ท้ายบรรทัดหลังจากนั้น

Pyth และ 05AB1E

การส่งข้อความด้วยเครื่องหมายคำพูดคู่จะรบกวนภาษาที่ใช้สตริงที่มีเครื่องหมายคำพูดคู่เพื่อซ่อนรหัส, Pyth และ 05AB1E เคล็ดลับหลักที่เราใช้ที่นี่คือเพื่อให้แน่ใจว่าการเสนอราคาซ้ำทุกครั้งที่เราเพิ่มมีการเสนอราคาซ้ำอีกครั้งในไม่ช้าหลังจากนั้น (นี่จะอธิบายเครื่องหมายอัญประกาศคู่พิเศษบน__DATA__บรรทัดซึ่งไม่จำเป็นสำหรับการทุบตี) Pyth ใช้\เป็นตัวละครหนี ผลที่สุดของเรื่องนี้คือมัน จำกัด ขอบเขตการใช้งานของฉันในการเขียนข้อความด้วยภาษาบังคับให้ฉันใช้วิธีการที่ค่อนข้างซับซ้อนด้านบน (เพราะฉันไม่สามารถใช้ความแตกต่างของ\พฤติกรรมระหว่าง bash และทุกสิ่งได้อย่างง่ายดาย อื่น). ใน 05AB1E 'ทำหน้าที่เป็นตัวละครยกเว้นภายนอกเงื่อนไขและการที่มันหนีพ้นจากผู้นำ"จะไม่ทำ ดังนั้นฉันจึงจำเป็นต้องวางตัวอักษรไร้ประโยชน์ (เริ่มต้นตามปกติของฉันxทำให้อ่านง่ายขึ้น!) ภายใน"'"โครงสร้างที่ใช้ในการเปลี่ยนรูปแบบการอ้างถึง bash

โหมโรง

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

ที่แย่กว่านั้นคือบรรทัดแรกปัจจุบัน (ซึ่งฉันไม่ต้องการเขียนใหม่) วางบางสิ่งบางอย่างที่มีขีด จำกัด อย่างหนักไว้ในตำแหน่งที่วงเล็บจะปรากฏ มันเริ่มต้นด้วยตัวเลขที่ไม่ใช่ศูนย์ (อันที่จริงแล้วมีสองหลักและตามด้วยเครื่องหมายวงเล็บเปิด) นั่นคือการวนรอบในโหมโรงและวนรอบเร็วในโฟลว์การควบคุมในโหมโรงทำให้เกิดปัญหาต่าง ๆ จำนวนมาก (ส่วนใหญ่เป็นเพราะพวกเขาทำให้โค้ดทำงานมากกว่าเดิมแทนที่จะน้อยลง) ดังนั้นฉันจึงไม่จำเป็นต้องเปิดการวนซ้ำ 0 บรรทัดในบรรทัดอื่นเพื่อข้ามรหัสนั้น mainบรรทัดสำหรับโปรแกรม C มีความเหมาะสมอย่างมาก แต่เราจะต้องระมัดระวังมากกับการที่วงเล็บปิดที่ตรงกันคือ; ไปทางขวาสุดและวงเล็บเหลี่ยมที่ไม่ตรงกันบน#R+บรรทัดจะทำให้เกิดปัญหาซ้ายไปมากเกินไปและมันจะไม่คอมเม้นต์โค้ดที่เพียงพอ (โปรดทราบว่าวงเล็บเปิดในหนึ่งบรรทัดสามารถจับคู่วงเล็บปิดกับบรรทัดอื่นได้)

เมื่อเสร็จแล้วเรามีพื้นที่เพียงพอที่จะติดอยู่ในวงเล็บเปิดในบรรทัดเหตุการณ์และในที่สุดเราก็ผ่านตัวละครสองสามตัวแรกของโปรแกรมได้อย่างปลอดภัย อย่างไรก็ตามความแตกต่างของตำแหน่งในวงเล็บจะสิ้นสุดลงซึ่งหมายความว่าโค้ด Incident / Whirl บางอันทำงานใน Prelude ซึ่งทำให้สแต็คเสียหาย แทนที่จะพยายามป้องกันสิ่งนี้ฉันย้ายศูนย์ของ Whirl ไปทางขวาทำให้พวกเขาให้โปรแกรม Prelude ที่ใช้งานได้อีกครั้ง

การเปลี่ยนแปลงเล็ก ๆ น้อย ๆ อีกหนึ่งอย่างเกิดขึ้นในบรรทัดแรกของโปรแกรม วงเล็บสุดท้ายของบรรทัดอยู่ในตำแหน่งที่ยากมากที่จะหลีกเลี่ยง ฉันเพิ่มพิเศษcหลังจากรหัส Pyth เพื่อเลื่อนไปทางขวา (หลายภาษากำลังแยกวิเคราะห์จุดนั้นของโปรแกรมดังนั้นจึงมีการทดลองและข้อผิดพลาดจำนวนมากเพื่อค้นหาตัวละครที่เติมซึ่งจะไม่ทำลายภาษาอย่างน้อยหนึ่งภาษา!)

อุบัติการณ์

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

ละเอียดเพิ่มเติมคือโทเค็น ;'และ␠␠(นั่นคืออักขระเว้นวรรคสองตัว) ปัญหาก็คือทั้งสองปรากฏก่อนkGที่จะถูกใช้เพื่อข้ามไปยังจุดเริ่มต้นของโปรแกรมจึงจะทำลายการควบคุมการไหลของเหตุการณ์ (นอกเหนือจากที่จะหมดจุดศูนย์กลางของโปรแกรม)

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

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

50 ภาษาใน 1 Kib ของรหัส

มันถูกชี้ให้เห็นโดย @MistahFiggins ว่าการส่ง 1025- ไบต์ของฉันจะเป็นวิธีที่ดีกว่าถ้าเป็น 1024 ไบต์ (โดยเฉพาะอย่างยิ่งเมื่อภาษาที่ห้าสิบเป็นก้าวสำคัญในสิทธิของตนเอง) สิ่งนี้ต้องการการค้นหาจำนวนหนึ่งของการออม ในกรณีนี้ฉันบันทึกสามไบต์ใน Deadfish ~ ด้วยค่าใช้จ่ายของสองไบต์พิเศษที่ใช้ในการทำให้โทเค็นเหตุการณ์เข้าแถวอย่างถูกต้องและทำให้โปรแกรมลดลงเหลือ 1024 ไบต์

ก่อนหน้านี้สูตรที่ใช้ Deadfish ~ code คือ (2² + 2) ² + 10 × 1 + 2 = 48 สูตรใหม่คือ (3²-2) ²-1 ยังสร้างได้ 48 น่าแปลกที่ไม่ใช่ สั้นกว่ามากในการเขียนใน Deadfish ~ แม้จะง่ายกว่ามาก

สิ่งนี้ยังให้คะแนนวีไอพีที่ 0.008192 ไม่เพียง แต่เป็นสถิติใหม่เท่านั้น แต่ยังเป็นตัวเลขรอบตัวที่ถูกต้องในตัวเองด้วย

37. C ++ (gcc), 776 ไบต์

#  1"16" 2//v\(;@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#*/
#include<iostream>␉
int main()  /*/
#()"`#"\'*/{std::cout<<37;}/*'"`"
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/3!@"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ลองออนไลน์!

rundown

โปรแกรมนี้พิมพ์37ใน C ++, 36ใน Labyrinth, 35ใน INTERCAL, 34ใน Rail, 33ในเหตุการณ์, 32 in Whirl, 31ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ใน Brain-Flak, 27ใน Perl 6 , 26ใน 05AB1E, 25ใน Pip, 24ใน Thutu, 23ใน Hexagony, 22ใน Underload, 21ใน Nim, 20ใน Prelude, 19ใน Preng, 19ใน Reng, 17ใน Julia, 18 in , 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12ใน Fission, 11ใน Befunge-98, 10ใน Befunge-98, 9ใน Perl 5, 8ใน Retina, 7ใน Japt, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน คุณสามารถทดสอบ Reng ได้ที่นี่และ Modular SNUSP ที่นี่ ; พวกมันออก 19 และ 31 ตามลำดับตามต้องการ

ฉันเพิ่มรูปแบบอื่นไปยังเอาต์พุตไดรเวอร์ทดสอบที่หนีเครื่องหมายคำพูดคู่และเปลี่ยนบรรทัดฟีด นี่คือดังนั้นฉันสามารถกินสตริงบรรทัดเดียวในการเขียนโปรแกรม AC (GCC) ฉันห่อรอบฟังก์ชั่นที่สร้างขึ้นโดย @feersum ที่นี่ หวังว่าคนอื่นสามารถใช้ประโยชน์ได้ตามที่เป็นอยู่

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

ฉันพยายามที่จะแก้ไขปัญหาที่เกิดขึ้นอย่างชัดเจนเช่นโทเค็นหลังจากเริ่มต้นและสิ้นสุดการกระโดดโทเค็นและสิ่งที่ดูไม่เกี่ยวข้อง แต่ฉันไม่ได้จัดโทเค็นที่สมดุลไว้0oที่กึ่งกลาง ฉันไม่แน่ใจจริงๆว่าตรรกะคืออะไรเพื่อกำหนดจุดศูนย์กลาง ฉันหวังว่า @ ais523 จะช่วยให้มี สตริงนี้ใกล้ถึงจุดสิ้นสุด7LEintndus({})!<>+ทั้งหมดจะเป็นโทเค็นหากไม่ใช่สำหรับการรวมครั้งที่ 4 ในรหัส สิ่งเหล่านี้สามารถลบออกได้ (และแทนที่ด้วยการ.จัดตำแหน่ง Hexagony) เพื่อปรับโทเค็นกลาง

ฉันกำลังจะอัปเดตโพสต์นี้และในอีกหรือสองวันถัดไปเพื่อดูรหัส (สมมติว่าเหตุการณ์สามารถตรวจสอบ / แก้ไขได้โดยไม่ต้องนับจำนวนไบต์) แต่ตอนนี้มันช้าไปแล้วและส่วนใหญ่ฉันต้องการที่จะออกไปที่นั่นก่อนที่ฉันจะแก้ปัญหาเขาวงกตอีกเหมือนปัญหา : P

คำอธิบาย

วิธีการทำงานของรหัส C ++

ฉันคิดว่าคนส่วนใหญ่คุ้นเคยกับ C ++ มากดังนั้นฉันจะไม่ลงรายละเอียดมากเกินไป /* comment */ความคิดเห็นที่ถูกบล็อกมาในรูปแบบของ //commentสายคอมเมนต์มาในรูปแบบของ รหัสจริงโดยใช้ภาษา C ++ int main() {std::cout<<37;}ในการผลิตคำตอบคือ และไลบรารีที่ใช้ในการเชื่อมต่อกับ STDOUT นั้นถูกอ้างถึงโดยคำสั่ง#include<iostream>นี้

/ * ความเห็นการละเมิด * /

สำหรับฉันเรื่องราวของ C ++ กลับไปที่คำตอบ Brain-Flak ของฉัน

หลังจากพบ # 28 ในที่สุดฉันก็เริ่มที่จะศึกษารูปหลายเหลี่ยมอื่น ๆ ที่โพสต์ใน PPCG และสิ่งที่ศึกษาทำให้ฉันได้คำตอบง่ายๆสองสามข้อ (ส่วนใหญ่เหล่านี้ยังคงมีให้พบถ้ามีคนอื่นโน้มเอียง) แต่ที่สำคัญกว่านั้นฉันได้ข้อสรุปเกี่ยวกับรูปหลายเหลี่ยมโดยทั่วไป: รูปหลายเหลี่ยมขนาดใหญ่มีแนวโน้มที่จะตกอยู่ในหนึ่งในสองประเภทกว้าง ๆ : #ความคิดเห็นที่ไม่เหมาะสมหรือ/*ความคิดเห็นที่ไม่เหมาะสม

นี่ไม่ใช่ความจริงหรือข้อ จำกัด แต่อย่างใด แต่เป็นกรอบความคิดส่วนบุคคลที่นำคำตอบของฉันต่อไป

จากที่นี่ฉันให้เหตุผลว่าถ้านี่จะกลายเป็นคนพูดได้หลายภาษาที่ใหญ่ที่สุดในโลกซึ่งฉันคิดว่ามันจะเป็นในปัจจุบันมันจะดีที่สุดถ้ามันสามารถยกระดับการใช้ความเห็นจากครอบครัวทั้งสอง ดังนั้นฉันจึงออกเดินทางเพื่อหาวิธีรวม/*ภาษาการแสดงความคิดเห็นและผลักดันไปยังตระกูล C เนื่องจากความคุ้นเคยส่วนบุคคล

การทดสอบเบื้องต้น C ++

กระบวนการคิดเริ่มแรกของฉันคือการใช้ C # ส่วนใหญ่เนื่องจากความคุ้นเคยของฉันและอุปสรรคแรกสำหรับ C # คือการพูดหลายภาษาเข้าสู่สถานะที่สามารถยอมรับบรรทัดที่ไม่ได้เริ่มต้น#โดยไม่ได้รับการปฏิบัติเหมือนรหัสโดยภาษาสคริปต์ . คำตอบของ Rail พร้อมกับคำตอบที่พองขึ้นหลายไบต์ที่นำไปสู่คำตอบนั้นแก้ไขชิ้นนี้

ต่อมาปัญหาของวิธีการเริ่ม/*บล็อกความคิดเห็นแรก ฉันรู้ว่าบรรทัดจะต้องเริ่มต้นบรรทัดด้วยการ#ยังคงมองไม่เห็น Perl, Ruby และ Python แต่สิ่งที่มาก่อน/*จะอ่านโดย C # ฉันพยายาม#regionแท็กC # ในตอนแรก แต่นั่นก็กลายเป็นภาษา 2D เกินไป ป้อน C ++

C ++ มีคำสั่งพรีโพรเซสเซอร์หลายตัวที่เริ่มต้นด้วย#ซึ่งมีตัวเลือกมากมายสำหรับภาษา 2D ในการสำรวจ แต่กลับกลายเป็นว่าพวกเขาทั้งหมดไม่สามารถเข้ากันได้กับภาษาอย่างน้อยหนึ่งภาษาและเมื่ออยู่ในพื้นที่รหัสที่เปิดเผยด้วยภาษา C ++ ฉันมีวิธีแก้ไขปัญหา จำกัด จากความยุ่งยากและความสิ้นหวังฉันได้พบกับความจริงที่ว่า C ++ จะยอมรับเพียงหนึ่งเดียว#ก่อนบล็อกความคิดเห็น โอเคอะไรก็ได้ที่ใช้การได้ ดังนั้นฉันจึงก้าวไปข้างหน้าพร้อมกับข้อสันนิษฐานที่#/*สามารถทำงานเป็นตัวละครสามตัวแรกในกลุ่มพูดได้หลายภาษา

การตรวจสอบขั้นพื้นฐานชิ้นที่สองคือการทำให้แน่ใจว่าข้อความสั่งพิมพ์จริงสามารถใช้กับรหัสอื่นได้อย่างมีความสุข ฉันรู้จากคำตอบของ Brain-Flak ว่า Japt ไม่ชอบที่จะไม่รอดพ้น{และสิ่งที่ C ++ ต้องพูดint main() {std::cout<<37;}และ C ++ จะไม่ยอมให้ตัวละครของ Japt หลบหนีอยู่ตรงกลางรหัส คราวนี้ฉันโชคดีพอที่จะพบว่าถ้าฉันเลิกสายสัญพจน์ของ Japt สำหรับข้อความนี้ Japt จะยังคงให้ผลลัพธ์เดียวกันอย่างมีความสุข

ในขณะเดียวกันสมอง Flak ไม่ชอบ{}อย่างใดอย่างหนึ่ง แต่ผมโชคดีอีกครั้งที่จะพบว่า C ++ ตกลงกับ#ระหว่างมันint main()และ {std::cout<<37;}งบช่วยให้วงเล็บปีกกาที่จะแสดงความคิดเห็นออกมาจากมุมมองของสมองของอากาศยาน

ดังนั้นด้วยปัญหาหลักของ C ++ ที่พิสูจน์แล้วว่าสามารถแก้ไขได้ในทางทฤษฎีฉันเริ่มกระบวนการที่ยากลำบากในการแก้ไขข้อผิดพลาดทั้งหมดที่ฉันแนะนำ

ภูมิประเทศ 2 มิติ

ส่วนที่ยากที่สุดของคำตอบนี้คือการตั้งค่าใหม่ของสองบรรทัดบนสุดของโพลิกล็อต *และปัญหาที่สำคัญที่สุดคือ underload จะไม่อนุญาตให้ก่อนที่จะมี* (มันถือว่านี่เป็นการดำเนินการทางคณิตศาสตร์ในกองซ้อนที่ว่างเปล่าซึ่งมันรู้สึกว่าเป็นข้อผิดพลาด ดังนั้นกลุ่มภาษาต้องใช้(ก่อนหน้า/*แต่ C ++ ไม่อนุญาต ดังนั้นการแก้ปัญหาคือให้เรา c ++ สายความคิดเห็น//ในบรรทัดแรกจะซ่อนและจากนั้นเริ่มบรรทัดที่สองด้วย(#/*

ถัดไป Befunge จริงๆไม่ชอบความคิดของการ/ได้โดยไม่ต้องมีอะไรบางอย่างที่ถูกแบ่งแยกออกจากกัน แต่หลังจากที่ได้ศึกษาคำตอบ Begunge ที่มีอยู่ของฉันสะดุดในความคิดของจำนวนและสตริงชนเข้าด้วยกันก่อน16/"<"6/b.q@ //มันใช้งานได้และฉันไม่รู้ว่าทำไม C ++ ใช้ได้กับสิ่งนี้ แต่ยอมรับ# 1"16" 2ว่าเป็นคำสั่งเปิด ฉันจะไม่ถามคำถามนี้ แต่ฉันรู้ว่าต้องใช้ช่องว่างเพื่อให้ทำงานได้

บรรทัดที่หนึ่ง

Japt กลายเป็นพื้นที่ที่ค่อนข้างอ่อนไหวและไม่ต้องการที่จะใส่เข้าไปในสตริง backtick ที่อยู่บนบรรทัดบนสุดดังนั้น backtick ของ Pip จึงถูกย้ายไปที่บรรทัดที่สองบังคับให้มียิมนาสติกภาษาศาสตร์จำนวนมากในบรรทัดที่ 1

• พิพไม่ชอบบรรทัดที่ 1 ส่วนใหญ่ดังนั้นจะมีการเว้นวรรคที่สองหลังคำสั่งแรก#เพื่อระบุความคิดเห็น
• (สำหรับ underload จะต้องมีการหนีออกจาก Japt \กับก่อนหน้านี้
• #เป็นกระโดดเทอร์มิเนเตอร์ในTurtlèdดังนั้นจึงจำเป็น แต่ Pyth เห็นว่านี่เป็นข้อผิดพลาดในการยกเลิกลูปดังนั้น Pyth จึงต้องหารด้วย null / หลังจาก#
• ฉันไม่แน่ใจว่าสิ่งที่@อยู่ในบรรทัดแรกกำลังทำอะไรอยู่อีกต่อไป แต่ Pythe และ Japt ดูเหมือนจะปรากฏตัวได้ดีกว่าไม่ถึงแม้ว่า@จะไม่ใช่ตัวละครที่มีความหมายตามเอกสารของ Pyth
• และดูเหมือนว่าครั้งแรก;สามารถลบออกได้ ณ จุดนี้โดยไม่มีผลดังนั้นฉันไม่แน่ใจว่าสิ่งใดที่ได้รับการแก้ไขอีกต่อไปแม้ว่าฉันจะสงสัยว่ามันเกี่ยวข้องกับ Pyth แต่ดูเหมือนว่าโซลูชันในอนาคตสามารถบันทึกไบต์ได้โดยไม่ต้องใส่ข้อมูลนั้น
• <> <และTurtlèdโดยพื้นฐานแล้วทั้งสองทำงานเหมือนกับก่อนหน้านี้ด้วย <> <การสะท้อนกลับ#ไปที่บรรทัดแรกและตัดไปที่ท้ายบรรทัดหนึ่ง และTurtlèdกระโดดด้วย#เหมือนที่ฉันพูดถึงและจบลงด้วย"14"สตริงที่มันพิมพ์

การกำหนดเส้นทาง 2D

เมื่อปัญหาเหล่านี้ได้รับการแก้ไขขั้นตอนต่อไปคือการกำหนดเส้นทางภาษา 2D ก่อนหน้านี้การเริ่มต้นvถูกละเว้นโดย Befunges เนื่องจากก่อนหน้านี้#แต่ส่ง Haystack และ Minkolang ลง ตอนนี้พื้นที่เริ่มต้นพยายามที่จะส่ง Minkolang ไปตามมิติที่ 3 ซึ่งเอกสารของมันอ้างถึงเป็นมิติเวลา

กันอย่างรวดเร็วในมิติที่ 3 ของ Minolang: สำหรับฉันมันเป็นเรื่องผิดปกติที่จะเรียกสิ่งนี้ว่ามิติเวลามันดูเป็นพิเศษมากกว่าอวกาศชั่วคราวสำหรับฉัน ฉันไม่ได้รับมันจนกว่าฉันจะพบลิงค์นี้ที่แสดงแนวคิดและดูเหมือนกับกระดานหมากรุก 3 มิติหลายชั้น ความเชื่อของฉันคือว่านี่เป็นวิธีการใช้ภาษา 3 มิติโดยทั่วไป แต่นี่เป็นแนวคิดใหม่สำหรับฉันฉันคิดว่าฉันจะทิ้งข้อมูลนี้ให้ผู้อื่น

ดังนั้นหลายชั้นของ Minkolang จึงถูกคั่นด้วยบรรทัดที่ลงท้ายด้วย$$$ที่ฉันโยนไปยังจุดสิ้นสุดของรหัสรางที่นี่: #-3o4o#$$$. ตอนนี้ Minkolang ฮิตพื้นที่และตกครั้งแรก>ใน<>3N.<> ␉//และดำเนินไปทางขวา outputting 3. #>ไม่สามารถอนุญาตให้เริ่มบรรทัดนี้เพราะมันจะพยายามที่จะยุติความคิดเห็น Perl6 บล็อกเพื่อ<ใช้แทน#เพื่อความสมดุลสำหรับ SMBF และสมอง -Flak อย่างไรก็ตามนี่เป็นขั้นตอนการสลับกองซ้อนของ Brain-Flak ดังนั้นจึงใช้ชุดที่สอง<>หลังจาก Minkolang Terminates เพื่อสลับกลับไปเป็นคำตอบที่ถูกต้องของ Brain-Flak

Labrynth ในทำนองเดียวกันกระแทกขึ้นกับพื้นที่ แต่จะทำให้ Labrynth จะเลื่อนลงในคอลัมน์ 1. จากนั้นก็หันมาสาย 2 ที่จะเดินทางลงไป3ชนกำแพงอีกทำให้มันหันไปทางทิศใต้อีกครั้งและตี;ซึ่งเป็นสาเหตุ 3 ที่จะได้รับ popped . จากนั้นโปรแกรมจะดำเนินการต่อไปทางขวาที่มีการจัดเก็บและพิมพ์ 36 ก่อนที่จะหา@ทางออกได้ในที่สุด พา ธ นี้ยาวเกินกว่าที่จะต้องมี แต่ฉันพบว่าพรีลูดจะเอาท์พุท nul byte ก่อนที่มันจะเป็น 20 เอาท์พุทปกติถ้า!มันอยู่ทางด้านซ้ายมากกว่าตอนนี้โดยไม่คำนึงถึงบรรทัดที่ปรากฏ ดังนั้นฉันจึงทำให้ถูกต้องมากขึ้นเพราะฉันมีพื้นที่ให้ทำ

ถัดไปการจัดเส้นทางของ Haystack เปลี่ยนไปเพราะ/ตอนนี้มาก่อนvบรรทัดที่ 1 และสะท้อนให้เห็นถึงเส้นทางของมันเช่น Reng โชคดีที่แร้งอยู่ร่วมกันอย่างสงบสุข สิ่งหนึ่งที่เป็นปัญหาคือเข็มของ Haystack |เป็นตัวสะท้อนแสงใน Reng ดังนั้น Reng จึงใช้ Befunge เหมือนการกระโดด ( #) เหนือเข็มเพื่อสรุป Reng ให้ถูกต้อง

Befunges ดำเนินต่อไปตามบรรทัดที่ 1 จนกระทั่งถึงvและชี้ลงแล้วไปทางขวาบนบรรทัดที่สองเพื่อสรุปด้วยรหัสเดียวกันกับที่ใช้มาก่อน ความรู้สึกของฉันคือชิ้นส่วนนี้สามารถเล่นกอล์ฟได้น้อยลงในขณะนี้ภาษาที่น้อยลงพยายามที่จะสำรวจรหัสอย่างมีความหมาย แต่ฉันไม่ต้องการกำแพงอีกต่อไปที่จะตบหัวฉันดังนั้นฉันจึงทิ้งมันไว้อย่างที่เป็นอยู่

ในที่สุดจุดเริ่มต้นของพระคาร์ดินัลคือ%ไม่จำเป็นที่จะต้องเข้าไปเกี่ยวข้องกับสองบรรทัดที่มีความหนาแน่นสูงอยู่แล้ว ดังนั้นฉันจึงย้ายมันไปที่สายของงูหลาม ขณะนี้พา ธ โค้ดจำนวนมากถูก จำกัด ด้วยx's ซึ่งจะสิ้นสุดการเคลื่อนที่ของพอยน์เตอร์

บรรทัด 2 และ 3

การเปลี่ยนแปลงที่สำคัญเพียงอย่างเดียวที่นี่ก็คือการที่นัก:กอล์ฟทุกคนออกไปด้วยเหตุผลใดเหตุผลหนึ่ง บางที(ความต้องการของพรีลูดหรืออาจเป็นปัญหาการนับจำนวนไบต์ที่ง่าย - อาจเป็นได้ทั้งคู่ สิ่งอื่น ๆ auaaZก็คือว่ารหัสกระโดดไกของได้ย้ายกลับและแบรน ฉันมีที่ว่างให้เติมเพื่อให้ตรงกับเส้นทางรหัสของ Befunge และสิ่งนี้ดูดีที่สุด นอกจากนี้ยังมีต่อไปชิ้นนี้คือการสมดุลต่อไปนี้< SMBF ของ >ในที่สุดโลน”ใกล้สิ้นสุดบรรทัดที่สองคือการรักษาสตริงของ 05AB1E นอกจากนี้yyในบรรทัดที่ 3 เป็นเพียงแค่ตัวละครที่เติมสำหรับเขาวงกต

Esolangs สายใหญ่

เมื่อสองบรรทัดแรกได้รับการแก้ไขแล้วก็ถึงเวลาที่จะเริ่มขุดลงใน esolangs ที่แยกวิเคราะห์ได้อย่างเต็มที่และ Pip กลับกลายเป็นว่ามีปัญหา หากคุณจำได้ว่าเราจัดการกับเครื่องมือจัดฟันที่โค้งงอ{std::cout<<37;}โดยปล่อยสตริง Japt ออกเพื่อให้ Japt ถือเป็นรหัส Pip มีการใช้ไวยากรณ์สตริงเดียวกันและไม่ชอบบรรทัดนี้เป็นรหัสและ Pip มีตัวเลือกการประกาศสตริงที่คล้ายกันมากเป็น Japt ทั้งสองใช้เดี่ยว'เพื่อประกาศสตริงอักขระหนึ่งตัวทั้งสองใช้การประกาศ escape แบบเดียวกัน\และทั้งสองจะยอมรับ"เป็นตัวระบุสตริง ดังนั้นจึงเป็นเรื่องยากที่จะทำให้ Pip เชื่อว่าสิ่งนี้เป็นสตริงโดยไม่ทำให้ Japt เชื่อเหมือนกัน

มันกลับกลายเป็นว่า Japt นั้นมีความแตกต่างที่สามารถนำไปใช้ประโยชน์ได้ - #นำค่า ASCII ของตัวละครต่อไป ดังนั้น#"`จะยุติสตริง Japt / pip แล้วบอกให้ Japt รับค่า asci ของ"ในขณะที่บอก Pip ให้เริ่มสตริงใหม่ "อาจจะได้รับการ backtick แทนและอาจจะได้รับดีขึ้น แต่บรรทัดของฉันของการคิดคือการใช้ตัวระบุสตริงที่แตกต่างกันในภายในเป็นจุดของการจัดการสตริงอื่น ดังนั้นที่นี่เป็นอีกที่หนึ่งที่คุณสามารถบันทึกไม่กี่ไบต์ลงที่ถนน

ต่อไปฉันต้องเริ่มต้นสตริง Japt หลังจากวงเล็บปีกกาในขณะที่ช่วยให้ Pip อยู่ในสตริง ฉันทำสิ่งนี้ด้วย'"`คำพูดเดียวคำพูดสองครั้งและ backtick สำหรับ Japt 'ไม่ได้อยู่ในสตริงและเป็นตัวบ่งชี้ที่จะใช้อักขระตัวถัดไปเป็นอักขระตัวเดียว Pip เห็นเป็นส่วนหนึ่งของสตริงและยุติสตริงกับ' "และในที่สุดก็`บ่งบอกถึงทั้ง Pip และ Japt ว่ามีการเริ่มต้นสายอื่นซึ่งดำเนินต่อไปตลอดทั้งกลุ่มคนจนถึงบรรทัดสุดท้ายที่ทั้งสองภาษาดำเนินการอย่างมีความสุข

ตอนนี้ทั้ง Japtap และ Pip ทำงานที่จุดนี้ แต่ 05AB1E ล้มเหลวเนื่องจากการใช้งาน"ทำให้เกิดข้อผิดพลาดในการเปิดรับรหัส โชคดีคนนี้เป็นเรื่องง่ายพอที่จะแก้โดยการใส่ชุดอื่นของรอบสิ่งที่ทั้งออกจากชุดของกิจวัตรสตริงเป็น""`#"\\'*/{std::cout<<37;}/*'"`"

ในที่สุดเมื่อตอนนี้บรรทัดมีลักษณะเช่นนี้int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"ซึ่งอันเดอร์โหลดมีปัญหา *ข้อผิดพลาดทางไวยากรณ์อีกข้อที่ต่อเนื่องกันดังนั้นฉันจึงขว้าง()กลาง*เพื่อเอาใจมัน

Esolangs เปราะบาง

อุปสรรค์ที่ยิ่งใหญ่ตอนนี้คือสเปซไวท์ ฉันจะไม่พูดถึงรายละเอียดมากมายที่นี่เพราะคำตอบของ Whitespace ส่วนใหญ่นั้นสร้างขึ้นจากคำอธิบายที่ได้ให้ไปแล้วและฉันก็คัดค้านกรณีที่ช่องว่างบังคับให้ทำการตัดสินใจเพียงเล็กน้อย ฉันกำลังมองหาคุณเขาวงกต การเปลี่ยนแปลงครั้งใหญ่คือรหัสที่แท้จริงในการส่งออกคำตอบของ Whitespace อยู่ที่บรรทัดที่ 2-4 แทนที่จะเป็น 1-3 นี่เป็นสาเหตุหลักมาจากการเปิดเผยรหัสของ Japt ในบรรทัดที่ 1

ตูตูมีปัญหากับสิ่งที่เคยเป็นมาในสายนี้: int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". ดังนั้นฉันจึงขว้างผู้ให้บริการรายหนึ่งก่อนที่#จะซ่อนปัญหาทั้งหมดที่อยู่เบื้องหลังตัวบ่งชี้ความคิดเห็นก่อนแล้วจึงส่งอีเมลขยะจำนวนมากตาม/ที่อื่นที่ถูกเปิดเผยรหัส

ณ จุดนี้ฉันจัด Hexagony และพบปัญหาใหม่ รหัสที่จุดเริ่มต้นซึ่งเริ่มชีวิตตามที่# 1"16" 1ทำ+ใน/+23!@ไม่ล้างสแต็ค ดังนั้นฉันเพิ่งออก+มีและพบว่ามันตอนนี้การส่งออก 123 นี้เป็นง่ายพอที่จะแก้ไขโดยการเปลี่ยนกลเม็ดเปิด# 1"16" 2และเล่นกอล์ฟชิ้น Hexagony /3!@ลงไป

Whirl มีการเปลี่ยนแปลงบางอย่าง แต่ส่วนใหญ่เป็นเรื่องของการทำให้แน่ใจว่ามีหมายเลข 1 ของผู้นำที่เหมาะสมปรากฏตัวต่อหน้าสายการหมุนวนเหตุการณ์ แม้ว่าจะมีเหตุการณ์หนึ่งโทเค็นที่ยากเป็นพิเศษ ฉันมีตรง 3 ฉบับและ/**/

ในขั้นต้นฉันต้องการเพียงแค่โยนที่*//*เก่า ๆ ในรหัสเพื่อสร้างสำเนาที่ 4 ของแต่ละรายการ แต่อันเดอร์โหลดได้เห็นสิ่งที่ต่อเนื่องกัน*อีกครั้ง ในที่สุดฉันก็โยน/จุดสิ้นสุดของบรรทัดนี้int main() /*เพื่อให้มันจบลง/*/โดยคิดว่าฉันจะทำให้โทเค็นทับซ้อนกัน แต่ฉันประสบความสำเร็จในการสร้างสำเนา 4 ฉบับของหนึ่งในสองโทเค็นเท่านั้น ถูกต้อง นั่นเป็นวิธีที่ใช้งานได้ แหมดีฉันก็จะโยนที่คล้ายกัน/ในรอบสุดท้าย*/ที่จะทำให้มี 4 หลังจากนี้ฉันแทนที่พวงของ hexagony ไม่มี Ops กับสำเนาที่ 4 7LEintndus({})!<>+ของราชสกุลเหตุการณ์ที่เกิดขึ้นในหลายสายนี้ในบรรทัดสุดท้าย

ข้อสรุป

ตกลงนั่นคือรายละเอียดทั้งหมดที่ฉันมีสำหรับผู้ปรับโครงสร้างขนาดใหญ่นี้ ฉันสัญญาว่าจะไม่มากนักในการเขียนครั้งต่อไป จริง ๆ แล้วฉันไม่รู้ว่า C ++ เป็นตัวเลือกที่ดีหรือไม่ดีสำหรับคนที่พูดได้หลายคน แต่ฉันรู้สึกว่ามันเปิดตัวเลือกบางอย่าง หวังว่าสิ่งนี้จะนำไปสู่สิ่งที่ดี

การเข้ารหัสที่มีความสุข

3. Minkolang v0.15 (26 ไบต์)

#>>>>>>>>v
print(1)#>3N.i2

โปรแกรมนี้พิมพ์1ใน Python 3, 2ใน Vim และ3ใน Minkolang v0.15

ฉันหวังว่าฉันจะไม่ทำสิ่งสกปรกโดยการแนะนำภาษา 2d

ลองออนไลน์!

คำอธิบาย

#                     stops program from moving through time (really does nothing)
 >>>>>>>>             I can't use a space because then the program will move through time
         v            go down
         >            go right
          3N.         Outputs 3 and end program
                      Anything afterward is ignored since program has ended

เป็นกลุ่มอย่างใดละเว้น Minkolang ดังนั้นดี

และไม่มีปัญหากับ Python เพราะมันไม่สนใจความคิดเห็น #

ต่อไป...

สำหรับภาษาถัดไปฉันแนะนำบางอย่างเช่น> <> เนื่องจาก#ทำหน้าที่เป็นตัวสะท้อนแสง (เพื่อที่ทิศทางจะเปลี่ยนเป็นซ้ายและมันจะพันไปทางด้านขวา) เพื่อให้คุณสามารถเพิ่มรหัสที่สามารถละเว้นได้โดยภาษาอื่น

5. Python 2 (35 ไบต์)

#3N.;n4
print('1'if 1/2else'5')
#i2

โปรแกรมนี้พิมพ์1ใน Python 3, 2ใน Vim, 3ใน Minkolang v0.15, 4ใน> <> และ5ใน Python 2

ลองใช้เบต้าออนไลน์!

ใน Python 2 1/2 คือ 0 ซึ่งเป็นค่าที่ผิดพลาดซึ่งทำให้พิมพ์ Python 5 ใน Python 3, 1/2 คือ 0.5 ซึ่งเป็นค่าจริงซึ่งทำให้ Python พิมพ์ 1

4. > <> (29 ไบต์)

#>>>>>>>>v;n4
print(1)#>3N.i2

โปรแกรมนี้พิมพ์1ใน Python 3, 2ใน Vim, 3ใน Minkolang v0.15 และ4ใน> <>

ลองออนไลน์!

รหัสวิ่ง

#             - change direction to left
            4 - add 4 to stack
           n  - print as a number
          ;   - end the program

อีกภาษาหนึ่ง

ไม่มีผลต่อ Minkolang เนื่องจากมันเพิ่มตัวละครหลังจากการเปลี่ยนทิศทางทำให้ Vim ถูกละเว้นด้วยเหตุผลบางประการ #เป็นความคิดเห็นใน Python ดังนั้นจึงไม่มีการเปลี่ยนแปลงใด ๆ

28. Brain-Flakขนาด 280 ไบต์

#v`16/"<"6/b.q@"(::):::   (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and (9) or (13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'#@46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛หมายถึงอักขระ ESC ตามตัวอักษรตามปกติ

โปรแกรมนี้พิมพ์28ใน Brain-Flak , 27ใน Perl 6 , 26ใน 05AB1E , 25ใน Pip , 24ใน Thutu , 23ใน Hexagony , 22ใน Underload , 21 in Nim , 20 in Nim , 19ใน Reng (ทดสอบที่นี่ ), 18ในพระคาร์ดินัล , 17ใน Julia , 16ใน Pyth , 15ใน Haystack , 14ในTurtlèd ,13ในทับทิม , 12ในฟิชชัน , 11ใน Befunge-98 , 10ใน Befunge-93, 2ใน Vim / V , 1ใน Python 3 , 9ใน Perl 5 , 8ใน Retina , 7ใน Japtapt , 6ใน SMBF , 5ใน Python 2 , 4ใน> <> , 3ใน Minkolang

ก่อนอื่นฉันต้องการที่จะบอกว่ามันเป็นสิทธิพิเศษที่จะสามารถมีส่วนร่วมในความท้าทายนี้ เมื่อไม่กี่สัปดาห์ที่ผ่านมาฉันได้ยินเรื่องของโค้ดกอล์ฟและฉันติดใจอย่างมากมาตั้งแต่ สิ่งแรกที่ฉันทำเมื่อฉันพบความท้าทายนี้คือพยายามเรียกใช้รหัสในภาษาต่าง ๆ เพียงเพื่อดูว่าฉันสามารถหาสิ่งที่ฉันสามารถทำงานกับ นี่กลับมาอีกครั้งเมื่อเราอยู่ในอันดับที่ 6 ฉันคิดว่าความท้าทายนี้เป็นไปไม่ได้ที่คนทำบาป แต่เราอยู่ที่นี่ (# 28 ว้าว!) สิ่งที่ฉันพบในขณะนั้นคือ Brain-Flak ให้ค่าที่ 2 ดังนั้นฉันจึงออกเดินทางเพื่อเรียนรู้

Brain-Flak กลายเป็นเกมที่ยอดเยี่ยมสำหรับความท้าทายแบบนี้เพราะมันค่อนข้างง่ายที่จะเรียนรู้และมันก็ไม่สนใจตัวละครใด ๆ ยกเว้น (){}[]<>ยกเว้น #ยังเกิดความคิดเห็นอะไรหลังจากนั้นในบรรทัดเดียวกันดังนั้นส่วนเดียวของการส่งครั้งล่าสุดที่เคยพิจารณาสำหรับ Brain-Flak คือprint((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)ที่คู่นั้นลงไป((())()<<>>)ที่แล้วจับคู่ลงไปดังนั้นแผนจึงเพิ่มวงเล็บที่ฟุ่มเฟือยให้กับสิ่งที่ฉันคิดว่าเป็นรหัสไพ ธ อน

ฉันแก้ไขบิตหลามเพื่อแยกวิเคราะห์ใน Brain-Flak เป็น ((() () ())()()<<()>>)ซึ่งเท่ากับ 2 กองแรกคือ 5 และอันดับที่ 3 หลังจากนั้นฉันยกกำลัง 5 ด้วย({({})({}[()])}{})และเพิ่มผลลัพธ์เป็น 3 ด้วย({}{})3 การยกกำลังสองและการเพิ่มนี้เกิดขึ้นในสตริงจากมุมมอง Python ฉันไม่สามารถเรียกร้องให้เข้าใจเหตุผลของ Python ได้ที่นี่ แต่ฉันมั่นใจอย่างยิ่งว่าสตริงนี้จะไม่ได้รับการประเมินโดยภาษาอื่นในวิธีที่มีความหมายโดยมีข้อยกเว้นเพียงไม่กี่ข้อ

Japt ปรากฎตีความการจัดฟันเป็นลอนภายในสตริงว่ามีรหัส แต่สิ่งเหล่านี้ง่ายพอที่จะหลบหนี \ก่อนหน้า{นี้ในสตริงนี้ แต่ตอนนี้ป่องนับไบต์ นั่นคือชีวิต.

โหมโรงค่อนข้างให้อภัยกับวงเล็บทั้งหมดของฉัน ความคิดเห็นก่อนหน้านี้ชี้ให้เห็นว่าโหมโรงจะเหมาะกับ Pparentheses ที่จัดเรียงในแนวตั้งและฉันเกิดขึ้นเพื่อสร้างเพียงหนึ่ง หวาน! (ในบรรทัดด้านบนเรียงรายไปด้วยและ(9ในสายใหญ่ ดังนั้นฉันต้องเพิ่มพื้นที่เพิ่มเติมก่อน(ในบรรทัดบนสุด สมมติฐานของฉันที่นี่คือว่าช่องว่างสองครั้งเป็นตัวบ่งชี้ความคิดเห็นสำหรับบางสิ่งบางอย่างดังนั้นการเพิ่มพื้นที่เพิ่มเติมดูเหมือนเล็กน้อยและใช้งานได้ ฉันควรจะชี้ให้เห็นว่าฉันพยายามเพิ่มช่องว่างเพิ่มเติมใน(9)แทน แต่ Cardinal ไม่ให้ความร่วมมือ

05AB1E ไม่ชอบความพยายามครั้งแรกของฉันที่สตริง Python ที่ถูกห่อหุ้มด้วยเครื่องหมายคำพูดคู่ แต่ทุกคนก็เห็นด้วยกับการใช้คำพูดเดียว ไม่ใช่เรื่องใหญ่เลย

Hexagony เป็นภาษาเดียวที่เหลืออยู่ ณ จุดนี้และฉันเห็นได้ชัดว่าผ่านเกณฑ์ขนาดฐานสิบหกต่อไปดังนั้นมันถึงเวลาที่จะสกปรก นี่/^23!@คือรหัส Hexagony และฉันตื่นเต้นสุด ๆ เพราะฉันคิดว่ามันจะทำให้การเพิ่มเติมในอนาคตง่ายขึ้นมาก ชิ้นส่วนเล็ก ๆ นี้สามารถเคลื่อนย้ายไปที่ใดก็ได้ในสตริงไพ ธ อนโดยไม่ทำให้รหัสใด ๆ ขาด นี่คือสายอักขระเต็มดังนั้นเราทุกคนอยู่ในหน้าเดียวกันสำหรับ thutu BTW) ความคิดของฉันที่นี่คือถ้าคุณทำการเปลี่ยนแปลงอัตราต่อรองคือคุณจะจบลงด้วยการสตริงนี้ในบางจุดและคุณสามารถเลื่อนชิ้นส่วน Hexagony รอบ ๆ ภายในสายเพื่อจับเส้นทางรหัสและส่งไปยังข้อสรุปที่เหมาะสม เพียงระวังที่จะไม่มาระหว่าง Japt's และ. หากคุณมีปัญหากับเรื่องนี้'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'นี่คือสตริงทั้งหมดเพียงเพื่อให้พวกเราทุกคนในหน้าเดียวกัน/ที่นี่กำหนดเส้นทางของ Hexagony จากเเม่ -> NW เพื่อ W-> E ลงสายนี้ซึ่งเรามีจำนวนมากของงานที่คั่งค้างกับ (ก่อนหน้านี้\คือการหลบหนี/\{@ทางด้านขวาของสตริงจะเหลืออยู่จากโซลูชัน Hexagony อื่นและสามารถลบออกได้โดยไม่ต้องใช้ภาษาอื่น และแน่นอนถ้าคุณจับเส้นทางโค้ดของ Hexagony ไปในทิศทางตรงกันข้ามคุณสามารถใช้แน่นอน@!32^\แทนการ/^23!@แทนนอกจากนี้คุณอาจสังเกตเห็นว่าทางออกของฉันลบ===2จากรหัสเพื่อให้สิ่งต่าง ๆ ภายใต้ขีด จำกัด ไบต์ มีคนพูดถึงที่นี่ว่านี่คือการจัดตำแหน่งของ Hexagony และฉันไม่ต้องการอีกต่อไป

สุดท้ายนี้คือโค้ดชิ้นเล็ก ๆ ที่ฉันพบขณะสำรวจ codegolf ที่แปลงบรรทัดข้อความเป็นรูปหกเหลี่ยมที่อ่านได้ Hexagony เพื่อให้คุณสามารถตรวจแก้จุดบกพร่อง ฉันแน่ใจว่าผู้คนมากมายรู้เรื่องนี้ แต่ฉันไม่เห็นมันโพสต์ที่นี่ดังนั้นมันอาจช่วยคนอื่นด้วย คำเตือนที่เป็นธรรมคุณต้องเปลี่ยนอินพุตเพื่อลบ backticks และ carriage return รวมทั้งสลับ escape ตามตัวอักษรสำหรับบางสิ่งที่ใช้พื้นที่ในปริมาณปกติเพื่อรับโค้ดเพื่อจัดเรียงสิ่งต่าง ๆ ในรูปหกเหลี่ยมสวย

ป.ล. ขณะที่ฉันกำลังเขียนสิ่งนี้อยู่ฉันรู้ว่าฉันมีข้อผิดพลาด ฉันเชื่อว่าฉันกำลังล้างขอบหน่วยความจำของ Hexagony ด้วย^แต่เห็นได้ชัดว่าฉันสามารถแทนที่ด้วย no-op ไม่เป็นผล นั่น^น่าจะเป็น+หากคุณพยายามจัดการส่วนนี้ เห็นได้ชัดว่าฉันเคยผ่าน+เรื่องนี้มาก่อน แต่ผู้พูดภาษาในอนาคตอาจไม่โชคดีนัก

โชคดี!

38. C, 804 ไบต์

#  1"16" 3//v\(@#/;n4"14"
#/*`3 auaaZ<>16/"<"6/b.q@")(22)S#  ␉␉␉␉ 
#yy␉;36!@
# ␉
#=␉>
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#`<`␉|
print((eval("1\x2f2")and( 9 )or(13 ))-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"*␉
""""#//
=begin␉//
#
#*/␉
#define␉z  sizeof 'c'-1?"38":"37"
#include␉<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);;}/*'``
$'main'␉//
#-3o4o#$$$
<>3N.<>␉//
#xx
#x%~~~+␉+~*ttt*.x
#xx
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  ap
#_~nJ|#o51\   
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#^_^_7LEintndus({})!<>+]/*///Z222999/(3!@)"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ลองออนไลน์!

rundown

โปรแกรมนี้พิมพ์38ใน C, 37ใน C ++, 36ใน Labyrinth, 35ใน INTERCAL, 34ใน Rail, 33ในเหตุการณ์, 32 in Whirl, 31ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25ใน Pip, 24 in Thutu, 23ใน Hexagony, ใน Cardinal, 17ใน Julia, 16ใน Pyth, 15ในPyth, 15ใน Haystack, 14 22 in Underload, 21 in Nim, 20ใน Prelude, 19ใน Reng, 18ในTurtlèd, 13 in Ruby, 12 in Fission, 11ใน Befunge-98, 10ใน Befunge-98, 9ใน Perl 5, 8ใน Retina, 7ใน Japtap, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน คุณสามารถทดสอบ Reng ได้ที่นี่และ Modular SNUSP ที่นี่ ; พวกมันออก 19 และ 31 ตามลำดับตามต้องการ

นี่คือรุ่นเอ็นดูเล็กน้อยของฉันเหตุการณ์tokeniserที่ออกแบบมาเพื่อเป็นบิตแข็งแรงเล่นกอล์ฟน้อย แต่บิตมีประโยชน์มากขึ้น

คำอธิบาย

ฉันรักที่จะสร้างรูปหลายเหลี่ยมเล็ก ๆ น้อย ๆ แต่ก็ไม่ใหญ่เท่านี้ ฉันคิดว่าฉันควรจะไป!

หลังจากคำตอบ C ++ ของ @ Chance ที่ยอดเยี่ยม C ดูเหมือนจะเป็นทางเลือกเชิงตรรกะต่อไปและเมื่อเทียบกับคำตอบก่อนหน้านี้บางคำตอบแล้วฉันได้ตัดสินใจที่จะเพิ่มเมื่อฉันมีโอกาส!

ฉันใช้กลอุบายที่รู้จักกันดีในการบอกความแตกต่างระหว่าง C และ C ++ ขนาดของค่าคงที่อักขระคือ 1 ไบต์ใน C ++ แต่ขนาดของ int (รับประกันว่ามีอย่างน้อย 16 บิต) ใน C รหัสนี้ควรพกพาได้มาก (ยกเว้นบางทีสำหรับระบบที่ใช้ไบต์ที่มีบิตเพียงพอเพื่อให้พอดีกับ int) เว้นแต่ ฉันทำผิดโง่ ๆ

ตอนแรกฉันพยายามทำprintfทุกอย่างแบบอินไลน์ แต่วงเล็บหลายอันดูเหมือนจะทำให้เกิดปัญหาสำหรับ Japt ดังนั้นฉันจึงทำให้บรรทัดนั้นเรียบง่ายขึ้นซึ่งดูเหมือนจะแก้ไขได้

ต่อไปพระคาร์ดินัลไม่ชอบฉันเดาว่าเพราะ%ใน printf ดังนั้นฉันจึงต้องแก้ปัญหานั้นโดยเปลี่ยนไปใช้สายอักขระ

ความพยายามครั้งต่อไปของฉันพยายามกำหนดสตริงจากนั้นเปลี่ยนไบต์ที่สองโดยขึ้นกับพฤติกรรม C สิ้นสุดลงนานเกินไปและจะผลัก Hexagony ไปสู่ขนาดถัดไป ฉันต้องการหลีกเลี่ยงการทำซ้ำโดยเก็บไว้ในตัวละครพิเศษที่ฉันต้องเล่นด้วย! ฉันต้องการทุกไบต์ที่ฉันสามารถรับได้ดังนั้นฉันจึงใช้การเปลี่ยนแปลงที่ประหยัดโดยไบต์ที่แนะนำโดย @Chance

ดังนั้นฉันตีกอล์ฟรหัส C ลงเล็กน้อยและเกิดขึ้นputs(sizeof'c'-1?"38":"37");ซึ่งเกือบจะทำงานยกเว้นอันเดอร์โหลดก็แยกกันสันนิษฐานว่าเป็นเพราะการแสดงออกที่ซับซ้อนในวงเล็บ

แม้หลังจากลบส่วนเกิน>>ที่เคยมีมาเพื่อให้ตรงกับ<<ใน Perl6 ฉันก็ไม่สามารถสรุปได้อย่างกระชับพอที่จะแยกส่วนที่ซับซ้อนมากขึ้นของมันออกเป็นการกำหนดอาร์เรย์แบบ char ดังนั้นฉันจึงตัดสินใจใช้ preprocessor แทน

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

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

ตอนนี้ฉันทดสอบเหตุการณ์แล้วและใช้งานได้! ขอบคุณมากที่ @Chance และ @LliwTelracs ซึ่งฉันเพิ่งรู้ว่าไม่ใช่ชื่อชาวเวลส์ที่ช่วยให้ฉันได้สัมผัสกับมัน ดูการเน้นไวยากรณ์นี้ ฉันลบ;โทเค็นที่ปรากฏต่อหน้า#yyโทเค็นแล้ว ฉันทำสิ่งนี้โดยเพียงแค่เพิ่มส่วนเสริม;หลังจากgetsคำสั่ง (ความพยายามก่อนหน้าของฉันเกี่ยวข้องกับการแทนที่s(ซึ่งตอนนี้ปรากฏมากขึ้นในโปรแกรม C มากกว่าที่ทำไว้ก่อนหน้านี้) ในสตริง "detokenising" ด้วย;แต่มันกลับกลายเป็นว่าฉัน จริงๆแล้วตัวละครย่อสำหรับ Hexagony (ขอบคุณ @Chance) ดังนั้นหลังจากความพยายามที่จะเพิ่มอักขระพิเศษในบรรทัดสุดท้ายนี้ล้มเหลวฉันเพิ่งเปลี่ยนกลับและเพิ่มเซมิโคลอนพิเศษที่อื่น)

ฉันได้ปรับช่องว่างเล็ก ๆ น้อย ๆ เพื่อเปลี่ยนโทเค็นอื่น ๆ เพื่อพยายามจัดกึ่งกลางเพื่อจัดเรียง Tab Linefeed อีกครั้ง (โดยเลื่อนแท็บที่ส่วนท้ายของ#includeบรรทัดเป็นตรงกลางทำให้โทเค็นสามอัน) และ ลดโทเค็นโทเค็นสามช่องว่างโดยเลื่อนหนึ่งช่องว่างในdefineบรรทัด

ในที่สุดวันหนึ่งหลังจากการส่งครั้งแรกฉันตัดสินใจที่จะไปที่ด้านล่างของคำเตือน preprocessor ที่น่ากลัวที่ gcc ผลิต (และทำให้ Clang ล้มเหลว) ฉันได้พิจารณาแล้วว่าเหตุผลที่บรรทัดแรกทำงานได้ทั้งหมดเพราะมันเป็นผลลัพธ์จากตัวประมวลผลล่วงหน้าที่ให้ข้อมูลการดีบักเช่นชื่อไฟล์ดั้งเดิมและหมายเลขบรรทัด พวกเขาไม่ชอบ "2" แรกในบรรทัดแรกเพราะนี่หมายถึง "การส่งคืนจากไฟล์ที่รวมอยู่ในไฟล์ที่กำหนด" และแน่นอนว่าเป็นไปไม่ได้เนื่องจากไม่มีไฟล์ใด ๆ ที่รวมอยู่ด้วย หลังจากเปลี่ยนเป็น "1" (เริ่มต้นส่วนหัวปกติ) ทำให้ภาษาไม่กี่สำลักมากเกินไปฉันเปลี่ยนเป็น "3" (เริ่มต้นส่วนหัวขององค์ประกอบภายใน) ซึ่งแตก Hexagony เพียงเพราะตอนนี้อาศัย 2 ดังนั้นในตอนเริ่มต้นของรหัส Hexagony ฉันได้เพิ่มวงเล็บเปิด(เพื่อลดค่า 3 ถึง 2 จากนั้นวงเล็บปิด)หลังจากสิ้นสุด (@ ) ของรหัสหกเหลี่ยมเพื่อตอบสนองต่อ Retina, Prelude และ Underload ซึ่งทั้งหมดนี้คาดว่าจะได้วงเล็บที่ตรงกัน การทดสอบ Reng และ Modular SNUSP อีกครั้งไม่มีปัญหาและโทเค็นของเหตุการณ์ดูถูกต้องดังนั้นตอนนี้ฉันจึงซ่อมมันแล้ว! ฉันได้ทดสอบกับสถาปัตยกรรมที่แปลกใหม่หลายแบบและดูเหมือนว่าจะใช้ได้ ฉันรู้ว่ามันไม่สำคัญสำหรับรหัสกอล์ฟและฉันจะไม่คิดว่าผู้ส่งในอนาคตจะต้องทำลายสิ่งนี้อีกครั้งเพื่อให้อยู่ในจำนวนไบต์หรืออะไรก็ตาม (หรือถ้าใครก็ตามที่เริ่มใช้โซลูชันนี้แล้วและไม่ต้องการเปลี่ยนพวกเขา มากเกินไป) แต่มีเหตุผลหนึ่งที่ดีที่ฉันทำสิ่งนี้ - คอมไพเลอร์ Objective-C ของ TIO รองรับเฉพาะเสียงดังกราวดังนั้นสิ่งนี้จะมีประโยชน์มากถ้าใครต้องการเพิ่มมัน!

โปรดจำไว้ว่าฉันไม่เคยใช้ภาษาเหล่านี้ส่วนใหญ่ฉันหวังว่าความสำเร็จของฉันจะกระตุ้นผู้มาใหม่ให้ลองทำสิ่งนี้!

65. ALGOL 68 (Genie) , 1634 ไบต์

#16  "(}+?23!@)-("//*\Dv;'[af2.q]PkPPX'#CO)"14";n4
#/*0|7//```"`   [-'][!(>77*,;68*,@;'1,@10␉␉11)(22)S␉␉(1 P''53'S^'q
#>␉
# 36!@␉`
#
#_>++++.>.}+?
#`<`
#<]}} +<[<.>>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++59L+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52DO,2SUB#2<-#32DOREADOUT,2PLEASEGIVEUPFACiiipsddsd4O6O@oh]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\).>]|
#[#[(?2?20l0v0x1k1kMoOMoOMoOMoOMOO0l0ix0jor0h0h1d111x0eU0yx0y0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_00)
[ "]56p26q[puts 59][exit]" ,'\[' ];#/s\\/;print"24";exit}}__DATA__/
#
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.

#
'(((p\';a=a;case $argv[1]+${a:u} in *1*)echo 50;;*A)echo 54;;*)echo 58;;esac;exit;';print((eval("1\x2f2")and 9or 13)-(0and 4)^1<<(65)>>62)or"'x"or'{}{}{}{}({}<(((((()()())){}{})){}{})>){(<{}(({}){})>)}{}({}())wWWWwWWWWwvwWWwWWWwvwWWWwWWWWWWWWwWWWWwWWWWWWWwWWWWWWWW li ha '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("'3)3)3)"'
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39
""""
=begin
<>{nd
#sseeeemPaeueewuuweeeeeeeeeeCis:ajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( ){puts(p);}/*
print 61
#}
disp 49;
#{
}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.s
=end
"""#"
#}
#s|o51~nJ;#:p'34'3\=#print (17)#>27.say#]#print(47)#]#echo 21# xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi xi ax fwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm 
# sss8␛dggi2␛`|$// ''25  16*///~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#

คะแนน VIP ( เครื่องพิมพ์อเนกประสงค์ที่ใช้งานได้ ): .005949 (เพื่อปรับปรุงรายการต่อไปควรมีไม่เกิน 1710 ไบต์)

ลองออนไลน์!

rundown

โปรแกรมนี้พิมพ์65ใน ALGOL 68, 64ใน Agony, 63ใน Brian & Chuck, 62ใน Grass, 61ใน SILOS, 60ใน Moorhens 2.0, 59ใน Tcl, 58ในTcl, 58ใน Ksh, 57ใน Wise, 56ใน DC, 55ในสมอง -Flak Classic, 54 in Zsh, 53 in Shove, 52 in COW, 51 in Assembly, 50 in Bash, 49 in Octave, 48 in Deadfish ~, 47ใน Lily, 46ใน Cubix, 45ใน PicoLisp, 44ใน alphuck, 43ในตาข่าย, 42ในชั่วร้าย, 41ใน brainfuck, 40ใน Minimal-2D, 39ใน CoffeeScript, 38ใน C, 37ใน C ++, 36ในเขาวงกต, 35ใน INTERCAL, 34ในรถไฟ, 33ในเหตุการณ์32ในวน, 31ใน Modular SNUSP, 30ในช่องว่าง, 29ในทริกเกอร์, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25ใน Pip24ใน Thutu, 23ใน Hexagony, 22 in Underload, 21 in Nim, 20ใน Prelude, 19ใน Reng, 18ใน Cardinal, 17ใน Julia, 16ในJulia, 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12 in ฟิชชัน, 11ใน Befunge-98, 10ใน Befunge-93, 9ใน Perl 5, 8ใน Retina, 7ใน Japtapt, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่สามารถทดสอบได้ด้วยไดรเวอร์การทดสอบด้านบน แต่ต้องทดสอบ 6 ภาษาในพื้นที่

• เหรงสามารถทดสอบการส่งออก 19 ที่นี่

• Modular SNUSP สามารถทดสอบการส่งออก 31 ที่นี่

• มีการยืนยันเหตุการณ์เพื่อทดสอบ 33 ผ่านการปรับสมดุลโทเค็นด้วยตนเอง

• Deadfish ~ สามารถทดสอบเพื่อส่งออก 48 ในพื้นที่โดยใช้ล่ามนี้ โปรดทราบว่า Deadfish ~ ใช้เวลาหลายภาษาที่จะได้รับอาหารบน stdin แต่และพิมพ์จำนวนของ>>พรอมต์ไปยังเอาต์พุตมาตรฐานซึ่งเป็นผลมาจากการรันโปรแกรม Deadfish ใด ๆ ที่ไม่สามารถหลีกเลี่ยงได้

• Moorhens 2.0 สามารถทดสอบเพื่อส่งออก 60 โดยใช้ล่ามนี้

ALGOL 68

ALGOL น่าจะเป็นที่รู้จักน้อยที่สุดในสี่ภาษาโปรแกรมระดับสูงจากวันแรกของการเขียนโปรแกรม - ภาษาที่เหลือของความแตกต่างที่คลุมเครือนี้คือภาษาโคบอล, ฟอร์แทรนและเสียงกระเพื่อม ALGOL เป็นที่รู้จักกันดีในวงการวิชาการและคณิตศาสตร์ในเวลานั้น แต่ปัจจุบันเป็นที่รู้จักกันดีที่สุดในเรื่องอิทธิพลของภาษาสมัยใหม่ ในความเป็นจริงแล้วภาษาที่ใช้งานได้จริงส่วนใหญ่นั้นสามารถอธิบายได้ว่า“ คล้ายกับ Algol” ไม่ใช่อย่างน้อยที่สุดก็คือ C ซึ่งแน่นอนว่ามีอิทธิพลและอนุพันธ์ที่เป็นของตัวเอง

ฉันค่อนข้างตื่นเต้นที่จะรวม ALGOL เพราะเป็นอีกก้าวสำคัญในประวัติศาสตร์คอมพิวเตอร์ที่เราเพิ่มเข้าไปในอนุสาวรีย์นี้ที่เราเรียกว่าคนพูดได้หลายภาษา นั่นคือสิ่งที่ยอดเยี่ยม

ALGOL68 เป็นข้อมูลจำเพาะล่าสุดของสามหลัก ALGOL ส่วนอีกรุ่นคือ ALGOL60 และ ALGOL58 ที่น่าสนใจคือสเปคนั้นไม่มีไวยากรณ์ที่ตายตัวซึ่งหมายความว่าโทเค็นนั้นถูกกำหนด แต่ไม่ใช่การสะกด สิ่งนี้ทำให้ล่ามภาษาขึ้นอยู่กับอย่างมากเนื่องจากล่ามที่ได้รับอาจใช้สัญลักษณ์ที่แตกต่างเพื่อเริ่มต้นบล็อกความคิดเห็นตัวอย่างเช่น ข้อมูลจำเพาะอธิบายถึงการ¢เริ่มต้นบล็อกความคิดเห็น แต่เนื่องจาก¢รหัส 127 ascii ไม่ได้อยู่ในฐานจึงเข้าใจได้ว่าไม่ได้ใช้เป็นตัวบ่งชี้ความคิดเห็นในล่ามที่มีอยู่ ปรากฎว่าล่าม Genie สะกด¢เป็น#ซึ่งเป็นการเปิดทั้งหมดที่เราจำเป็นต้องได้รับตัวละครที่ผ่านมา 1 และทำหลายภาษา

ในความเป็นจริง Genie มีสามตัวเลือกไวยากรณ์ความคิดเห็นอีกสองคนcoและcommentทั้งสองซึ่งระบุว่าเป็นการเขียนเป็นตัวหนา ใช่ตัวหนา ถ้าเราใช้ตัวเอียงมันก็เป็นตัวแปร Genie แก้ปัญหานั้นให้เราอีกครั้งโดยการสะกดตัวหนาในตัวพิมพ์ใหญ่ทั้งหมด และเนื่องจากCOไม่ได้อยู่ในกลุ่มคนหลายภาษาเราจึงมีวิธีที่ง่ายในการซ่อนกลุ่มคนหลายภาษาจากเครื่องมือแยกวิเคราะห์ หากCOจำเป็นต้องใช้ถนนสำหรับภาษาเราสามารถสลับไปยังCOMMENTไวยากรณ์ที่ละเอียดยิ่งขึ้น

ไม่มีความคิดเห็นเกี่ยวกับบรรทัดใน ALGOL - เป็นรูปแบบบล็อกทั้งหมดซึ่งหมายความว่าจะต้องยกเลิก เมื่อกำหนดสถานะเริ่มต้นของ polyglot ความคิดเห็นบล็อก ALGOL ของเราจะเปิดขึ้นทันทีและสิ้นสุดลงใกล้กับจุดสิ้นสุดของบรรทัดที่ 1 เนื่องจากTurtlèdมีความคล้ายคลึงกันในการใช้#เป็นโทเค็นกระโดด Turtlèdโชคดีมากที่ไม่มีปัญหาในการเดินผ่านCและOตัวละครดังนั้นในบรรทัดที่ 1 เราสามารถแทรกCOได้ทันทีหลังจากวินาที#เพื่อเริ่มแสดงความคิดเห็นบล็อกไขมันสำหรับ ALGOL68

จากที่นี่เราแค่ไปวางCOprint("65")ที่ไหนสักแห่ง ฉันเลือกบรรทัดสุดท้ายเพราะฉันต้องการจบบรรทัดด้วย#ความคิดเห็นอื่นและฉันไม่ต้องการให้ความคิดเห็นสิ้นสุดที่#จุดเริ่มต้นของบรรทัดสุดท้าย ดังนั้นเราจึงติดตามคำสั่งการพิมพ์ ALGOL ของเราด้วย#sและ#เป็นตัวอักษรตัวสุดท้ายในกลุ่มพูดได้หลายภาษา sใน#sสำหรับ alphuck เพื่อความสมดุลออกpในการพิมพ์

ขอบคุณ @ ais523 สำหรับการเปิดท้ายโพลิกล็อตด้วยคำตอบ 59 และทำให้ทุกอย่างเป็นไปได้

SMBF

เราได้เพิ่มตัวละครที่แตกต่างกันในตอนท้ายของกลุ่มคนหลายภาษาเพื่อยุติความคิดเห็นสุดท้ายของ ALGOL และ SMBF ก่อนหน้านี้ได้อ่านตัวอักษรสุดท้ายสำหรับคำตอบ เพื่อแก้ไขปัญหานี้ฉันต้องเปลี่ยน SMBF เพื่ออ่านตัวละครที่สองเป็นตัวละครสุดท้ายโดยการเปลี่ยนรหัสนี้ในบรรทัดที่ 8 [.>-]มาที่นี่[<.>>-]นี้นี่เป็นบล็อกรหัสส่วนตัวของ SMBF เนื่องจาก MP ของ BF อยู่ที่ 0 เมื่อลูปเริ่มต้น

ไก

ณ จุดนี้ฉันสังเกตเห็นพฤติกรรมแปลก ๆ ของ SMBF และเกี่ยวข้องกับความสัมพันธ์ระหว่างส่วนของโค้ดโฆษณาเหล่านี้ในตอนท้ายของโพลิกอนต์

•ปลายทางการกระโดดของเหตุการณ์: ^_^_

•ปลายทางกระโดดของทริกเกอร์พร้อมคำตอบ: X222999

•คำตอบของ ALGOL68: COprint("65")#s

คำตอบของ ALGOL แสดงโทเค็นเหตุการณ์สองเหตุการณ์ในส่วนรหัสของรหัสดังนั้นรหัสของ ALGOL ต้องดำเนินการก่อนส่วนรหัสของเหตุการณ์ ALGOL ยังทำให้เกิดปัญหาการจัดตำแหน่งโหมโรงถ้ามันไปก่อนในการสั่งซื้อดังนั้นจึงต้องไปที่สองหรือสาม SMBF ในขณะเดียวกันก็มีความล้มเหลวที่อธิบายไม่ได้เมื่อรหัสของเหตุการณ์หายไปดังนั้นเหตุการณ์ต้องไปก่อนหรือที่สอง ฉันรู้ว่านี่เป็นปัญหาตรรกะเบื้องต้นที่ดูเหมือนจะไม่สามารถแก้ไขได้ดังนั้นฉันจึงออกเดินทางเพื่ออธิบายสิ่งที่ไม่สามารถอธิบายได้ ...

หลังจากเดินผ่าน SMBF ฉันพบว่าปัญหาของการมี ^ _ ^ _ ในตอนท้ายนั้นเป็นเพราะปรีชาญาณ รหัสของปรีชาญาณ ( ~-<~-<~-<<<~-) ไม่ได้ซ่อนอยู่หลังวนลูปที่ไม่ได้ดำเนินการซึ่งแตกต่างจากคนส่วนใหญ่ แต่ไม่มีรหัสการพิมพ์ SMBF เกี่ยวข้องกับรหัสของ Wise มันเป็นเพียงการเปลี่ยนค่าหน่วยความจำ ดูเหมือนไม่น่ากลัว แล้วปัญหาคืออะไร มันเป็นสิ่งที่ SM พูดต่อหน้า BF

รหัสของปรีชาญาณกำลังเปลี่ยนอักขระในรหัสกำลังจะถูกดำเนินการและคุณสามารถเดาได้ไหมว่าค่า ascii ของเพื่อนบ้าน^คืออะไร? ]มัน ปรีชาญาณกำลังวาง SMBF loop terminator ที่ส่วนท้ายของ polyglot ทำให้ SMBF ตกอยู่ใน loop ที่ไม่สิ้นสุด นั่นเป็นโมโจที่ไม่ดี

หลังจากที่บางคนคิดว่าผมเอาวิธีการแก้ 0 ไบต์ในการแก้ไขปัญหาและแยกกระโดดปลายทางของทริกเกอร์ ( X) จากคำตอบของมัน ( 222999) และจบพูดได้หลายภาษา ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#thusly: ใช้งานได้เนื่องจากไม่มีอักขระปรากฏขึ้นอย่างต่อเนื่องหลังจากการกระโดดของทริกเกอร์ซึ่งไม่ใช่คำตอบของทริกเกอร์

ห่อ

นั่นคือการเปลี่ยนแปลงครั้งสำคัญในรอบนี้ ฉันทำการเปลี่ยนแปลงเล็กน้อยเพื่อตัดการพูดคุยที่มากcในบรรทัดที่ 1 แต่นั่นเป็นการเปลี่ยนแปลงที่เล่นกอล์ฟอย่างแท้จริง

โชคดี!

รายงานเหตุการณ์

#<q>"3"O.sกลายเป็น#<T>"3"O.sเพราะการไม่เชื่อฟังTแทนที่จะqทำให้การทรงตัวมีประสิทธิภาพมากขึ้น

<>{กลายเป็นสิ่ง<>{ndที่ไม่เชื่อฟัง ndและ{␊

ใส่ช่องว่างระหว่าง}}และ+ใน#<]}} +<[<.>>-]>[เพื่อ detokenize }}+เพิ่มเติมอย่างถูก

2. V (11 ไบต์)

print(1)#i2

โปรแกรมนี้พิมพ์1ใน Python 3 และ2ใน V

เพียงเพื่อให้ลูกบอลกลิ้งและโยนภาษาที่ฉันชอบลงในการผสมก่อน :)

มันเป็นคำตอบที่ตรงไปตรงมามาก

print(1)#

เพียงแค่เกิดขึ้นเป็น NOP ใน V. (โชคดีสำหรับฉัน) จากนั้นi2เข้าสู่โหมดแทรกและแทรก '2' คุณสามารถลอง V ออนไลน์ได้ที่นี่

แน่นอนในหลาม

print(1)

พิมพ์ '1' และ

#i2

คือความคิดเห็น

20. โหมโรง, 167 ไบต์

#v`16 "<" 6/b0\ .q@#;n4"14""
#>3N9@15o|R"12"*^*ttt*~++%
#=|
print((1/2and 9 or 13)-(0and+4)^1<<65>>62);#35(99999+++++!) =#;print(17)
#       ~nJ<
#
#gg99ddi2` |1|1+6

ตัวอักษร ESC ตามตัวอักษรในตำแหน่งเดียวกับในการส่งก่อนหน้า (ระหว่าง#และgถึงและระหว่าง2และ`ในบรรทัดสุดท้าย) เนื่องจากคุณไม่สามารถนำ Vim ออกจากโหมดแทรกด้วยอักขระที่พิมพ์ได้

โปรแกรมนี้พิมพ์20ใน Prelude , 19ใน Reng (ทดสอบได้ที่นี่ ), 18ใน Cardinal , 17ใน Julia , 16ใน Pyth , 15ใน Haystack , 14ในTurtlèd , 13ใน Ruby , 12 in Fission , 11ใน Befunge-98 , 10ใน Befunge-93 , 9ใน Perl , 8ใน Retina , 7ใน Japtapt , 6ใน SMBF ,5ในหลาม 2 , 4ใน> <> , 3ใน Minkolang , 2ในกลุ่ม / V , 1ในหลาม 3และa partridgeในลูกแพร์ต้นไม้

โค้ดที่มีอยู่นั้นค่อนข้างจะยกเลิกตัวเองใน Prelude ซึ่งประกอบไปด้วยในขณะที่ลูปเท่านั้นที่มีข้อโต้แย้งที่ผิดพลาดและการจัดการสแต็กบางส่วนบนสแต็คที่เราไม่สนใจ ยิ่งไปกว่านั้นมีจุดในรหัสที่แสดงความคิดเห็นในทุกภาษาที่มีพวกเขา (ระหว่าง#และ=#จากการส่งก่อนหน้า) ส่วนที่ยากของการติดตั้ง Prelude ในส่วนนี้คือการสร้างตัวเลขด้วยสแต็กเดียวและไม่มีการนับจำนวนไบต์ โปรแกรมนี้ใช้ลูปที่เพิ่ม 45 ให้กับทุกองค์ประกอบสแต็กและส่งออกเป็น ASCII ดังนั้นโดยการวาง 5 ด้านบน 3 บนสแต็กเราจะได้20ผลลัพธ์เป็นเอาท์พุต (เรียบร้อยแล้ว 20 เป็นจำนวนเอาต์พุตที่ง่ายกว่า 19 ใน Prelude ดังนั้นคำตอบ 19 ที่โพสต์ช่วยฉันได้นิดหน่อย)

30. Whitespace 296 ไบต์

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999"26

␛แสดงถึงการหลบหนีที่แท้จริง

␉หมายถึงแท็บตัวอักษร

โปรแกรมนี้พิมพ์30ใน Whitespace , 29ใน Trigger , 28ใน Brain-Flak , 27ใน Perl 6 , 26ใน 05AB1E , 25ใน Pip , 24ใน Thutu , 23ใน Hexagony , 22ใน Underload , 21 in Nim , 20 in Prelude , 19ใน Reng (ทดสอบที่นี่ ), 18ใน Cardinal , 17ใน Julia , 16ใน Pyth 15 ,ใน Haystack , 14ในTurtlèd , 13ใน Ruby , 3ใน Minkolang , 2ใน V / กลุ่มและ1ในหลาม 312ในฟิชชัน , 11ใน Befunge-98 , 10ใน Befunge-93 , 9ใน Perl 5 , 8ใน Retina , 7ใน Japtapt , 6ใน SMBF , 5ใน Python 2 , 4ใน> <> ,

ช่องว่างเป็น esolang อื่นที่มีชุดอักขระที่ จำกัด อันนี้อ่านแท็บช่องว่างและตัวดึงข้อมูลบรรทัดเท่านั้น

ดังนั้นเมื่อเรานำเนื้อหาทั้งหมดที่ช่องว่างไม่ได้อ่านออกเราจะเหลือโค้ดต่อไปนี้:

[space][space][space][LF]
[space][LF]
[LF]
[LF]
[LF]
[space][space][space][space][space][LF]
[space][space][space][space]

และโค้ดสำหรับเอาต์พุต 30 คือ:

[space][space][space][tab][tab][tab][tab][space][LF]
[tab][LF]
[space][tab]

ดังนั้น 3 บรรทัดแรกของรหัสที่มีอยู่ได้รับช่องว่างเพิ่มเติมในตอนท้ายของบรรทัดเพื่อตอบสนองความต้องการ โปรดทราบว่าแท็บของบรรทัด 1 และพื้นที่ต่อท้ายอยู่ตรงกลางบรรทัดเพื่อรองรับ> <> ความต้องการของ

พื้นที่ของบรรทัด 2 ถูกเปลี่ยนเป็นแท็บที่นี่ สิ่งนี้ดูเหมือนว่าจะทำงานเหมือนกันกับที่ว่างสำหรับภาษา 2D แต่จริงๆแล้วภาพจะไม่เข้าแถวกันอีกต่อไป ¯ \ _ (ツ) _ / ¯

หลังจากคำแนะนำในการส่งออก 30 เกมเริ่มได้รับพื้นที่ที่เหลือและฟีดบรรทัดที่เหลือเพื่อทำสิ่งที่ไร้ประโยชน์และรวบรวมอย่างถูกต้อง

พื้นที่สีขาวเกิดขึ้นมีคำแนะนำที่ทำเครื่องหมาย / ข้ามตำแหน่งรหัสด้วยป้ายชื่อที่อนุญาตให้มีแท็บและช่องว่างจำนวนเท่าใดก็ได้ นอกจากนี้ยังเริ่มต้นและสิ้นสุดด้วยการป้อนบรรทัดดังนั้นจึงช่วยให้เรามีการป้อนบรรทัดในบรรทัดที่ 3-6

บรรทัดสุดท้ายไม่สามารถมี linefeed ได้โดยไม่ทำลาย Retina ดังนั้นคำแนะนำในการทำคณิตศาสตร์และการจัดการกองซ้อนโดยพลการ

นี่คือรหัสเต็มรูปแบบที่มีช่องว่างแท็บและรายการป้อนบรรทัดแทนที่ด้วยเครื่องหมายของเรา:

#v`16/"<"6/b.q@"(:[Space]::T):[Space][Space][Tab][Tab][Tab][Tab][Space]:(22)S#;n4"14"[LF]
#>3N6@15o|>[Tab]^*ttt*~++~~~%[LF]
#=~nJ<R"12";[Space][Tab][LF]
#[[Tab][LF]
#`<`|[LF]
print((eval("1\x2f2")and[Space](9)or(13))-(0and[Space]4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo[Space]21#|/=1/24=x=90/[LF]
#8␛dggi2␛[Tab]`[Space]|1|6$//''25[Space][Space]#>say[Tab][Tab][Space]27#T222999"26[LF]

และนี่คือเวอร์ชั่นที่ถูกคอมเมนต์ของช่องว่าง:

Push 30 onto the stack
[space][space][space][tab][tab][tab][tab][space][LF]

Output the number at the top of the stack
[tab][LF][space][tab] 

Jump to label null if the top of the stack is negative. (it's not)
[LF][Tab][LF]

Label this location as [Space]
[LF][Space][Space][Space][LF]

Add the top two items on the stack and replace them with the result. 
[Tab][Space][Space][Space]

Store the stack.
[Tab][Tab][Space]

การแก้ไข: Hexagony เปลี่ยนเป็นการข้ามแท็บเหมือนกับการเว้นวรรคตรงกันข้ามกับการยืนยันก่อนหน้าของฉัน @ ais523 ใจดีพอที่จะอัปเดต Hexagonizer ของ Kenney ให้บัญชีสำหรับการหลบหนีและแท็บที่แท้จริง ฉันต้องแก้ไขมันเพื่อแก้ไขการยืนยันก่อนหน้านี้ของฉันเกี่ยวกับแท็บที่ถูกอ่านเป็นแบบไม่ใช้และเพื่อแทนที่การหลบหลีกที่แท้จริงด้วย.เพราะ␛ตัวละครนั้นกว้างกว่าตัวละครอื่น ๆ ทำให้เลขฐานสิบหกไม่ตรงแนว ที่นี่การเชื่อมโยง

และนี่คือ Hex ที่เราแก้ไขปัจจุบัน:

          # v 1 6 / " < " 6 /
         b . q @ " ( : : : T )
        : : ( 2 2 ) S # ; n 4 "
       1 4 " # > 3 N 6 @ 1 5 o |
      > ^ * t t t * ~ + + ~ ~ ~ %
     # = ~ n J < R " 1 2 " ; # [ #
    < | p r i n t ( ( e v a l ( " 1
   \ x 2 f 2 " ) a n d ( 9 ) o r ( 1
  3 ) ) - ( 0 a n d 4 ) ^ ( 1 ) < < (
 6 5 ) > > 6 2 ) o r ' ( \ { ( \ { } )
  ( \ { \ / + 2 3 ! @ } [ ( ) ] ) } \
   { } ) ( \ { } \ { } ) ' # 4 6 ( 8
    + 9 + 9 + 9 + 9 + = ! ) = # p r
     i n t ( 1 7 ) # ] # e c h o 2
      1 # | / = 1 / 2 4 = x = 9 0
       / # 8 . d g g i 2 . | 1 |
        6 $ / / ' ' 2 5 # > s a
         y 2 7 # T 2 2 2 9 9 9
          " 2 6 . . . . . . .

ในที่สุดฉันเล่นกอล์ฟตัวละครที่ไม่มีความจำเป็นส่วนใหญ่จะเพิ่มก่อนหน้านี้เพื่อจัดแถววงเล็บของ Prelude และ Hexagony

รหัสของ Nim กลับมาecho 21จากecho 5+5+11

Hexagony's #@46ตอนนี้#46

รหัสของ Hexagony กลับมา/+23!@=จาก/+23!@

การจัดแนวของ Prelude ของผู้ปกครอง(9) or (13)กลายเป็น(9)and(13)

นั่นคือทั้งหมดที่ฉันได้รับ โชคดีนะทุกคน!

100 brainbool 2953 ไบต์

#16  "?63(o?23!*# #@"/*\DZZCv;'[af2.q]PkPPX)\('#CO"14"; */
#/*0|7//```"`  [>.>.])[-'][(>77*;,68*,@,1',;# l1011)(22)S\4n;iiipsddpsdoh coding:utf8ââââ(1P''53'S^'????!?!??!??!!!!???!?!??!!?!?!!!!!?!!!!?????!????????????????????!) (qx
#>â
# 36!@â`  e++++++::@ 
#~
#y
#`<`
#<<<#>>]}}+-[.+..]+-+<[<<.>>x>-]>[
#{
#x}
#2""/*\*
#=x<R+++++[D>+++++++q   L+++<-][pPLEASE,2<-#2FAC,2SUB#1<-#52FAC,2SUB#2<-#32FACREADOUT,2PLEASEGIVEUPFACs]>@@+.---@.>][
#x%+>+=ttt Z_*.
#D>xU/-<+++L
#R+.----\   \).>]4O6O@|
#[#[(?2?20l0v01k1kMoOMoOMoOMoO MOO0l0ix0jor0h0h1d111x0eU0y0yx0moO1d0y0e0e00m1d0i0fx0g0n0n11MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i0001k1x0vx0v0l111111^_0 )0\\
[  "]56p26q[puts 59][exit]" ,'\[999'];#/s\\/;print"24";exit}}__DATA__/
###x<$+@+-@@@@=>+<@@@=>+<?#d>+.--.<!\
'(wWWWwWWWWwvwWWwWWWwvwWWWw WWWWWWWWwWW/"78"oo@WWwWWWWWWWwWWWWWWWWwwwwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWw              (([5]{})))â\';';print((eval("1\x2f 2")and 9or 13<< (65)>>65or 68)-(0and 4)^1<<(65)>>62)or"'x"or' {}{}{}{}({}<(((((()()())){}{})){}{})>)(({})5){}x{(x<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)wWW no no no no no no no no no no no no no no no no no no no no no no no no no no no no no no os sp '#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("3'3)))"'a'[[@*3*74[?]*]*(<*.*\>]xxxxxxxxxxxxx)'# \\
__DATA__=1#"'x"
#.;R"12"'
###;console.log 39;'(******* **********819+*+@[*99[?]*]***|!)'
#\\
""""#\
' ( <><        (          )>  ){ ({}[()]  )}{\';      a=$(printf \\x00    );b=${#a};#\\
" }"';           ((   ( (';case "{"$ar[1]"}"${b} in *1)echo 54;;*4)echo 78;; *1*)echo 50;;*)echo 58;;esac;exit;# (((('))))#\
=begin
#p             +555/2+55x%6E2x
;set print "-";print 89;exit#ss 9
utpb now 70 dollar off!
utpb has been selling out worldwide!
#9999 9 seeeemPaeueewuuweeeeeeeeeeCis:ajjappppppp😆😨😒😨💬95💬👥➡
👋🔢🌚🌝🌝🌚🌚🌚🌚🌚

set ! 57
set ! 51
More 91 of thiset of re9
How much is it*/
#if 0
.int 2298589328,898451655,12,178790,1018168591,84934449, 12597
#endif//*
#1"" //*
#include<stdio.h> 
#defineâ x(d)â#d
#define u8 "38\0 "
main ( ) {puts( sizeof (0,u8)-5?u8"67":*u8""?"37":     x( 0'0  "'\"")[9]?"75":'??-'&1? "79":"77");"eg5""6 27""e ' Zing  ";}//*/
#if 0
#endif//* --... ...--
/*/
p=sizeof("9( 999 99\"    ); print'(''72'')';end!"            );main( ){puts(  "92");return(9-9+9 -9);}
#if 0â
#endif//* rk:start | print: "69" rk:end<(9    >5b*:,1-,@
print 61
#}
disp 49 ;9;
#{
}{}<>
$'main'3
#-3o4o#$$$
#<T>"3"O.</+++++++>/+++<-\>+++.---.
#<<<#>>> /
reg end="";print(85);reg s#++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-.
=end
;"""#"#xxxxxxxy"78"\++++>/<~#class P{        function:Main(a:String[] )~Nil{83->Print();} }
#}pS9^7^8^MUOUOF@:8:8\\
#s|)o51~nJ;#:p'34'3  \=#print(17)#>27.say#]# print(47) #]#echo 21#fwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwvm>++++
#s8âdggi2âM`|$//''  1$6~-<~-<~-<<<~-COprint ("65")#asss^_^_#
#9 "25"  +/ *///X222999686#

คะแนน VIP ( เครื่องพิมพ์อเนกประสงค์ที่ใช้งานได้ ): .002953 (เพื่อปรับปรุงรายการต่อไปควรมีไม่เกิน 3042 ไบต์)

rundown

โปรแกรมนี้พิมพ์ 1ใน Python 3 ใน Underload, 23 44ใน alphuck, 45ใน PicoLisp, 66ใน Surface, 67 2ใน V / Vim, 3ใน Minkolang, 4ใน> <>, 5ใน Python 2, 6ใน SMBF, 7ใน Japt r, 8ในจอประสาทตา, 9ใน Perl 5, 10ใน Befunge- 93, 11ใน Befunge-98, 12ใน Fission, 13ใน Ruby, 14ในTurtlèd, 15ใน Haystack, 16ในPyth, 17ใน Pyth , 17ใน Julia, 18ใน Cardinal, 19ใน Reng, 20ใน Prelude, 21ใน Nim, 22ใน Hexagony, 24ใน Thutu, 25ใน Pip, 26ใน 05AB1E, 27ใน Perl 6, 28ใน Brain-Flak, 29ใน Trigger, 30ใน Whitespace, 31ใน Modular SNUSP, 32ใน Whirl , 33ในเหตุการณ์, 34ในรถไฟ, 35ใน INTERCAL, 36ในเขาวงกต, 37ใน C ++ 03, 38ใน C99, 39ใน CoffeeScript, 40ใน Minimal-2D, 41ใน brainfuck, 42ในความชั่วร้าย, 43ในตาข่าย, 63 46ใน Cubix, 47ใน Lily, 48ใน Deadfish ~, 49ใน Octave, 50ใน Bash, 51ในการประชุม, 51 in Assembly, 52ใน COW, 53ใน Shove, 54ใน Zsh, 55ในสมอง Flak Classic, 56 in dc, 57 in Wise, 58 in Ksh, 59 in Tcl, 60 in Moorhens, 61 in SILOS, 62 in Grass, ใน Brian & Chuck, 64 in Agony, 65ใน ALGOL 68, ใน C11, 68ใน Python 1, 69ใน rk-lang, 70ในเชิงพาณิชย์, 71ในสิ่งที่, 72ใน Fortran, 73ใน Morse, 74ใน Archway, 75ใน C ++ 11, 76ใน Trefunge-98, 77ใน C ++ 14, 78 in dash, 79ใน C ++ 17, 80ใน Klein 201, 81ใน Klein 100, 82ใน Brain-Flueue, 83 in Objeck , 84ในไคลน์ 001, 85ใน zkl, 86ใน Miniflak, 87ในอลิซ, 88ใน PingPong, 89ใน gnuplot, 90ใน RunR, 91ใน Cood, 92ใน C89, 93ในชุด, 94ใน Emotinomicon, 95ใน Emoji, 96ใน EmojiCoder, 97ใน Cubically, 98ใน Archway2, 99ใน99 100ใน Brainbool

การตรวจสอบ

ลองออนไลน์! ภาษาที่ไม่มีใน TIO:

• Japt 7 ออนไลน์
• เหรง 19 ออนไลน์
• Deadfish ~ 48 ท้องถิ่น
• Moorhens 60 ท้องถิ่น ใช้ moorhens.py จากสาขา v2.0-dev
• มอร์ส, 73 คนในพื้นที่
• ซุ้มประตู 74 ท้องถิ่น
• Trefunge-98, 76 ในท้องถิ่น ใช้-d 3 -v 98สำหรับ Trefunge-98
• Objeck, 83 local
• zkl, 85 ท้องถิ่น
• PingPong, 88 คนท้องถิ่น
• RunR, 90 ท้องถิ่น
• Cood, 91 ออนไลน์
• ชุด 93 ออนไลน์
• อิโมติโนมิคอน, 94 ออนไลน์
• EmojiCoder ออนไลน์ 96
• Archway2, 98 local ฉันไม่สามารถทดสอบ Archway2 ได้เพราะฉันไม่มีคอมไพเลอร์ C ที่เหมาะสม แต่ Stasoid ยืนยันว่าใช้งานได้ใน archway2

คำอธิบาย

ฉันไม่อยากจะเชื่อเลยว่าเราได้ใช้ภาษานี้ถึง 100 ภาษาแล้ว ฉันแค่อยากจะใช้เวลาขอบคุณทุกคนที่มีส่วนร่วมในกระบวนการนี้ มันเป็นการขี่ที่สนุกและฉันหวังว่าจะเพิ่มอีก 100 กับพวกคุณ

Brainbool อยู่ในสายตาของฉันมาระยะหนึ่งแล้ว อย่างไรก็ตามเนื่องจาก brainbool สามารถแสดงผลได้สองตัวเลขเท่านั้น1และ0ฉันไม่สามารถเพิ่มได้จนถึงตอนนี้ (ตอนนี้ฉันไม่ได้อยู่ที่ 10 และ 11)

Brainbool เป็นเหมือน brainfuck ยกเว้นแทนการตัดที่ 256 มัน wraps ที่ 2. Brainbool ยังไม่ได้เพราะมันจะซ้ำซ้อนกับ- +รหัส brainbool ของเราที่จะส่งออก 100 นั้นค่อนข้างง่าย:

+.+..

เพื่อที่จะปกปิดเอาท์พุทสำหรับ brainfuck เราได้เพิ่มลูปและลบ:

+-[.+..]

ตอนนี้ทุกอย่างที่จำเป็นคือการหาสถานที่สำหรับรหัสที่จะไป สถานที่ที่ฉันเลือกเป็นคนแรก+ที่ระดับบนสุดของรหัส brainfuck ในบรรทัดที่ 8 เพื่อแทนที่ด้วยบวกเราเพิ่มรหัสของเราและ+-+ซึ่งทำหน้าที่เป็น+ใน brainfuck และ noop ใน brainbool

+-[.+..]+-+

Cubix

ฉันใส่รหัสของฉันไว้ข้างหน้าแคปซูล Cubix ทำให้กระจกส่องเข้าไปในเส้นทางของตัวชี้ ในการแก้ไขปัญหานี้ฉันย้ายแคปซูลไปข้างหน้าสองสามก้าวต่อหน้ากระจกที่ทำผิดและทุกอย่างเรียบร้อยดี

น่าแปลกที่ไม่มีสิ่งใดทำลายได้แม้กระทั่งเหตุการณ์ที่น่ารำคาญ

27. Perl 6 , 235 bytes

#v`16/"<"6/b.q@"(::):::  (22)S#;n4"14"
#>3N6@15o|> ^*ttt*~++~~~%
#=~nJ<R"12";
#[
#`<`|
print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=90/
#8␛dggi2␛` |1|6$//''25  #>say 27#"26

␛หมายถึงอักขระ ESC ตามตัวอักษรตามปกติ

โปรแกรมนี้พิมพ์27ใน Perl 6 , 26ใน 05AB1E , 25ใน Pip , 24ใน Thutu , 23ใน Hexagony , 22 in Underload , 21 in Nim , 20ในNim , 20ใน Prelude , 19ใน Reng (ทดสอบที่นี่ ), 18ใน Cardinal , 17ใน จูเลีย , 16ใน Pyth , 15ในกองหญ้า , 14ใน turtled , 13ในรูบี , 12ใน Fission ,11ใน Befunge-98 , 10ใน Befunge-93 , 9ใน Perl 5 , 8ใน Retina , 7ใน Japtapt , 6ใน SMBF , 5ใน Python 2 , 4ใน> <> , 3ใน Minkolang , 2ใน Vim / V , 1ใน Python 3และ (ตามคริสต์มาส)a partridgeใน A Pear Treeลูกแพร์ต้นไม้

ไวยากรณ์ที่ไฮไลต์ที่ Exchange Exchange สร้างขึ้นสำหรับคำตอบนี้ผิดทั้งหมด #`<เป็นหนึ่งใน Perl 6 หลายหลายเครื่องหมายแสดงความคิดเห็นและสิ้นสุดที่#>จึงรหัสเดียวที่จริงทำงานใน Perl 6 say 27เป็นเรื่องง่ายมาก ฉันเลือกเครื่องหมายความคิดเห็นนี้โดยเฉพาะเพราะ<>ไม่ใช่คู่ที่ตรงกันในภาษาส่วนใหญ่และดังนั้นจึงไม่มีผู้ใดเทียบ<ได้จะไม่ทำลายภาษาเช่น Retina ที่พยายามแยกวิเคราะห์

ฉันไม่แน่ใจว่า Hexagony ทำงานอย่างไรอีกต่อไป เมื่อมันพังฉันเปลี่ยนหนึ่งในตัวละครที่ใช้จาก a +เป็น a 0เพื่อดูว่ามันถูกตีหรือไม่; ปรากฎว่ามันเป็นและกลายเป็นโปรแกรมนี้ได้รับการแก้ไข แต่ฉันไม่แน่ใจว่าทำไม (ฉันรู้ว่ามันพังเนื่องจาก#ในช่วงของการดำเนินการ แต่ก็ไม่มีความชัดเจนว่าทำไมลบ+สิ่งที่แก้ไข) (ตัวละครที่เป็นปัญหาถูกแยกวิเคราะห์โดย Thutu แต่โชคดีที่นี่ไม่ได้สร้างความแตกต่างให้กับการทำงานของโปรแกรม Thutu เมื่อถึงจุดนั้นในโปรแกรมสิ่งใดก็ตามที่ไม่ได้=ถูกคัดลอกไปก่อนหน้านี้ในการทำงาน สตริง.) โปรดทราบว่า0and+4จากบรรทัดก่อนหน้ากลายเป็น0and 4เพื่อทำให้ตัวละครตัวหนึ่งสั้นลงจากมุมมองของ Hexagony (Hexagony ไม่เห็นช่องว่าง) นี่คือการชดเชย#|ในบรรทัดก่อนหน้ากลายเป็น#`<`|ซึ่งเป็นหนึ่งในตัวละครอีกต่อไปจากมุมมองของ Hexagony (เพราะมันไม่เห็น backquotes อย่างใดอย่างหนึ่ง) โปรดทราบว่าตอนนี้โค้ดอยู่ห่างจากการขยายความยาวด้าน Hexagony เพียงห้าไบต์และทำลายทุกอย่างเกี่ยวกับรหัส Hexagony ปัจจุบัน ฉันขอแนะนำให้ทำเช่นนี้และเพียงแค่ทำซ้ำส่วน Hexagony ของรหัส มันอาจจะง่ายขึ้นแทนที่จะยากขึ้นเพื่อให้พอดีกับทุกอย่างหลังจากการขยายตัว

ภาษาอื่นบางภาษาก็เปลี่ยนไปเช่นกันส่วนใหญ่เพื่อเพิ่มความแข็งแกร่งเพียงพอที่ฉันสามารถใส่รหัสโดยพลการในบรรทัดสุดท้าย $//เป็นเครื่องหมายแสดงความคิดเห็นในJaptéที่อนุญาตให้มีช่องว่างในบรรทัดทำให้โปรแกรมเพิ่มเติมที่มีความเปราะบางน้อยในJapté (ในขณะเดียวกันก็//จะแตกถ้ามีวงเล็บปิดในบรรทัดต่อมาและช่องว่างเป็นวงเล็บปิดใน Japt) คู่ของช่องว่างเป็นเครื่องหมายแสดงความคิดเห็นใน Pip ซึ่งหมายความว่ารหัส Pip สามารถทำให้ง่ายขึ้นอย่างมากที่นี่ นอกจากนี้ยังหมายความว่าเราสามารถลดความซับซ้อน 05AB1E "26ลงไปเล็กน้อย Retina ต้องการบรรทัดที่ห้าเป็น regex ทางกฎหมายที่ดีในการจับคู่สิ่งต่าง ๆ (ต่อท้าย|สำหรับ Retina); มันแยกวิเคราะห์แตกต่างจากบรรทัดที่เกี่ยวข้องในรายการก่อนหน้า แต่ในลักษณะที่เหมาะสม พระคาร์ดินัลก็ง่ายกว่าเล็กน้อยในรายการก่อนหน้านี้ แต่นี่เป็นเรื่องบังเอิญที่บริสุทธิ์ว่าทุกอย่างเรียงกันเป็นแนวตั้งและการเปลี่ยนแปลงคือรหัสที่ไม่ได้ทำอะไรเลย

สมมติว่าคุณทำ Hexagony ซ้ำ (คุณอาจต้องทำ) มีสถานที่ที่ปลอดภัยในการเพิ่มโค้ดในสามบรรทัดสุดท้าย: 3in #3]#ใช้สำหรับ Hexagony เท่านั้น (และเปลี่ยนได้ง่าย); ช่องว่างระหว่าง#และ"บนบรรทัดสุดท้ายจะถูกละเว้นโดยภาษาส่วนใหญ่; และไม่มีการแยกวิเคราะห์ตอนท้ายของบรรทัดที่ห้านอกเหนือจาก Retina (มีสถานที่อื่นอีกมากมายที่สามารถเพิ่มรหัสได้เช่นกัน แต่สิ่งเหล่านี้น่าจะสะดวกที่สุด)

31. Modular SNUSP , 326 ไบต์

โครงการ

#v`16/"<"6/b.q@"(: ::T):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#=~nJ<R"12"; ␉
#[␉
#`<`|
print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
#8␛dggi2␛␉` |1|6$//''25  #>say␉␉ 27#T222999+/+23!@"26

ตามปกติ␛เป็นอักขระ ESC ตามตัวอักษรและ␉เป็นแท็บตัวอักษร

rundown

โปรแกรมนี้พิมพ์31ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25ใน Pip, 24 in Thutu, 23ใน Hexagony, 22 in Underload, 21 in Nim , 20ใน Prelude, 19ใน Reng, 18ใน Cardinal, 17ใน Julia, 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ในTurtlèd, 13ใน Ruby, 12 ใน Fission,11ใน Befunge-98, 10ใน Befunge-93, 9ใน Perl 5, 8ใน Retina, 7ใน Japtapt, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ทำไมไม่มีลิงค์ในบทสรุป? เนื่องจากฉันได้พยายามทำบางสิ่งเพื่อให้การทดสอบง่ายขึ้นมากขึ้นโปรแกรมควบคุมการทดสอบที่ใช้งานโปรแกรมในภาษาส่วนใหญ่ที่แสดงไว้ที่นี่และพิมพ์ผลลัพธ์ หวังว่านี้จะทำให้การเพิ่มภาษาในอนาคตให้กับคนพูดได้หลายภาษาง่ายขึ้นมาก คุณสามารถรับผลลัพธ์ของโปรแกรมนี้ได้ 28 ภาษาจาก 31 ภาษาผ่านการใช้งานลิงค์ TIO ต่อไปนี้ (ซึ่งเป็นไดรเวอร์ทดสอบที่เขียนด้วยส่วนผสมของ Bash, Perl และ A Tree Tree):

ลองออนไลน์!

ลิงก์ยังสร้างบล็อกโค้ดที่␛/ ␉ฟอร์แมตที่เห็นด้านบนและจัดรูปแบบโค้ดให้เป็นรูปหกเหลี่ยมสำหรับคุณ:

          # v 1 6 / " < " 6 / b
         . q @ " ( : : : T ) : :
        ( 2 2 ) S # ; n 4 " 1 4 "
       # > 3 N 6 @ 1 5 o | > ^ * t
      t t * ~ + + ~ ~ ~ % # = ~ n J
     < R " 1 2 " ; # [ # < | p r i n
    t ( ( e v a l ( " 1 \ x 2 f 2 " )
   a n d ( 9 ) o r ( 1 3 ) ) - ( 0 a n
  d 4 ) ^ ( 1 ) < < ( 6 5 ) > > 6 2 ) o
 r ' ( \ { ( \ { } ) ( \ { } [ ( ) ] ) }
\ { } ) ( \ { } \ { } ) ' # 4 6 ( 8 + 9 +
 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 )
  # ] # e c h o 2 1 # | / = 1 / 2 4 = x
   = 9 [ < $ + @ + - @ @ @ @ = > + < @
    @ @ = > + < ? # > + . - - . ] / #
     8 . d g g i 2 . | 1 | 6 $ / / '
      ' 2 5 # > s a y 2 7 # T 2 2 2
       9 9 9 + / + 2 3 ! @ " 2 6 .
        . . . . . . . . . . . . .
         . . . . . . . . . . . .
          . . . . . . . . . . .

สามภาษาขาดหายไป: V ช้าเกินไปและ Reng และ Modular SNUSP ไม่ได้ถูกติดตั้งบน TIO โชคดีที่ทั้งสามมีล่ามออนไลน์:

• คุณสามารถทดสอบโปรแกรมใน V / Vim (เอาต์พุตที่ตั้งใจ: 2) ที่นี่บน TIO
• มีเหรงออนไลน์ล่าม (output ตั้งใจ: 19) ที่นี่
• มีออนไลน์ Modular SNUSP ล่าม (output ตั้งใจ: 31) ที่นี่ (โฆษณาว่าเป็นเพียงตัวแปล SNUSP แต่ Modular SNUSP เป็นภาษาถิ่นที่ใช้จริงตามที่เห็นโดย@เครื่องหมายทั่วหน้า)

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

คำอธิบาย

ก่อนอื่น Hexagony ซึ่งดูเหมือนจะต้องเปลี่ยนเสมอ มันง่ายกว่า แต่ก่อนมาก ฉันย้ายรหัส Hexagony ไปหลังจากรหัส Trigger ซึ่งหมายความว่าใกล้ถึงจุดสิ้นสุดของโปรแกรมแล้วและ "แคปซูล" Hexagony ที่พิมพ์ 23 และทางออกจะเริ่มทำงานเกือบจะในทันที บรรทัดสุดท้ายโดยทั่วไปดูเหมือนจะเป็นที่ที่เหมาะสำหรับใส่แคปซูลเนื่องจากมันหมายถึงคำสั่งที่น้อยลงที่อาจขัดขวาง Hexagony ที่จะทำงาน

การเปลี่ยนแปลงอื่น ๆ ทั้งหมดจะทำอย่างไรกับการเพิ่มรหัส Modular SNUSP สิ่งแรกที่ควรทราบคือ SNUSP เริ่มดำเนินการที่$ตัวอักษรตัวแรกในโปรแกรมและเป็นไฟล์สองมิติแบบสองมิติที่ออกหลังจากออกจากขอบของโปรแกรมและวางโปรแกรม SNUSP ที่ส่วนท้ายของบรรทัดที่ยาว (ภายใน รหัส Thutu ณ จุดที่ Thutu จะยอมรับเกือบทุกอย่าง) เราสามารถมั่นใจได้ว่า SNUSP ไม่เห็นรหัสใด ๆ จากภาษาอื่นและภาษาอื่น ๆ ส่วนใหญ่ไม่สนใจ SNUSP ภาษาหนึ่งที่ไม่สนใจคือ Perl 6 ซึ่งเป็นตัวแยกมุม; ฉันวาง<รหัสก่อนรหัส SNUSP ทันทีเพื่อให้มีความสุข (เนื่องจากวงเล็บถูกจับคู่ตามธรรมชาติแล้ว) ภาษาอื่นที่สนใจคือ SMBF.เอาต์พุตทั้งใน SMBF และ SNUSP และเราไม่ต้องการสร้างเอาต์พุตเพิ่มเติม โชคดีที่ SMBF เห็นแล้วโปรแกรมนี้<.>>[…] ตามด้วยรหัส SNUSP เช่นองค์ประกอบเทปปัจจุบันคือ 0 ดังนั้นการใส่รหัส SNUSP ในวงเล็บเหลี่ยม "แสดงความคิดเห็นออก" จากมุมมองของ SMBF

สำหรับรหัสตัวเองมันใช้เคล็ดลับที่รู้จักกันดีในการเขียนค่าคงที่ใน Modular SNUSP ซึ่งคุณเขียนคำสั่ง "โพรซีเดอร์เริ่มต้น" จำนวนมากในแถวและสร้างเรียงลำดับหมายเลขฟีโบนักชีพื้นฐานได้อย่างมีประสิทธิภาพ แนวคิดพื้นฐานคือการ+เข้ารหัสหมายเลข 1; @เพิ่มตัวเลขที่แสดงด้วยรหัสหลังพร้อมกันและจำนวนที่แสดงด้วยรหัสหลังจากลบด้วยอักขระตัวแรก และ=ไม่มีตัวเลือก (ดังนั้น@=จะเป็นสองเท่าของจำนวนทางด้านขวา) ในระบบนี้ฉันเลือก@@@@=+@@@=+#เป็นตัวแทนของหมายเลข 48

มีปัญหาอยู่ที่นี่แม้ว่า; วิธีมาตรฐานในการเขียนค่าคงที่ใน SNUSP ทำให้การควบคุมอยู่ด้านหลังจุดเริ่มต้นของโปรแกรมและด้วย oneliner (ซึ่งฉันต้องการเขียนที่นี่ด้วยเหตุผลที่ชัดเจน) ไม่มีวิธีใดที่จะเปลี่ยน IP ให้ชี้ไปในทิศทางใดก็ได้ ซึ่งหมายความว่าเราจะต้องได้รับ IP ที่จะผ่านคำจำกัดความคงที่ทั้งหมดและดำเนินการต่อไปทางขวาโดยไม่ต้องออกจากโปรแกรม (ซึ่ง#ปกติจะทำ) เพื่อที่จะแก้ไขปัญหานี้ฉันใช้คำจำกัดความของหมายเลขที่+ถูกนำหน้าด้วย=เสมอ ซึ่งหมายความว่าฉันสามารถเขียนรหัสเพื่อตั้งค่าเซลล์ที่สองถึง 48 ผ่าน@@@@=>+<@@@=>+<#ปลอดภัยในความรู้ที่ไม่มี>คำสั่งใดจะถูกข้ามโดย@คำสั่ง (และทำให้เราควบคุมตัวชี้เทป) นอกจากนี้เรารู้ว่าในที่สุด#เซลล์เทปแรกจะยังคงมีค่าเริ่มต้น ดังนั้นเราสามารถใช้เทปเซลล์แรกเป็นตัวทำเครื่องหมายเพื่อทราบว่าจะกลับจากการกำหนดโพรซีเดอร์หรือว่าจะดำเนินการต่อไปทางขวา (เราอยู่ในขั้นตอนมากมายเมื่อทำเช่นนั้น แต่เราออกจากโปรแกรมโดยหลุด ขอบเพื่อให้มันไม่สำคัญ)

รหัส SNUSP $+@+-@@@@=>+<@@@=>+<?#>+.--.สุดท้ายจึงเป็น $เครื่องหมายจุดเริ่มต้นของโปรแกรม +@+-ตั้งค่าองค์ประกอบเทปแรกเป็น 1 ( ++-แต่เมื่อโพรซีเดอร์เริ่มต้นด้วยการ@ส่งคืนมันจะเริ่มรันโค้ดจาก-เป็นต้นไปดังนั้นการตั้งค่าองค์ประกอบเทปกลับเป็น 0 ?#จะสิ้นสุดขั้นตอนเฉพาะในกรณีที่องค์ประกอบเทปแรกไม่ใช่ศูนย์ดังนั้น ในที่สุดเราก็ลงเอย#ด้วยองค์ประกอบเทปที่สองตั้งค่าเป็น 50 (48 จากนิยามคงที่บวก 2 จากสอง>+<พบเมื่อไปทางขวาหลังจากนั้น) สิ่งที่เราต้องทำคือ>+.--.การส่งออกรหัส ASCII 51 ( 3) และ 49 ( 1) และหลุดออกจากขอบของโปรแกรม ( ]ไม่มีตัวเลือกใน SNUSP และ /แสดงการไหลของการควบคุมในแนวตั้งเพื่อให้มันวิ่งออกจากขอบด้านบนของโปรแกรม); บิตนี้ใช้ได้เหมือนกันกับ brainfuck

11. Befunge 98 , 102 bytes

#v;2^0;7||"<+0+0+0+<;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

พิมพ์:

• 1 ในPython 3
• 2 in Vim - ใช้เวลาค่อนข้างนานในการส่งออกด้วยเหตุผลบางอย่าง ...
• 3 ในMinkolang v0.15
• 4 ใน> <>
• 5 ในPython 2
• 6 ในSMBF
• 7 ในJapt
• 8 ในจอประสาทตา
• 9 ในPerl
• 10 ในBefunge 93
• 11 ในBefunge 98

เพื่อความซื่อสัตย์อย่างสมบูรณ์ฉันไม่มีเงื่อนงำทำไมรหัส Vim ใช้เวลา 1 นาทีในการส่งออก นอกจากนี้ยังไม่มีเงื่อนงำว่า Retina ทำงานอย่างไร

คำอธิบาย:

#v          Skips the v, which would send the IP down
  ;         Unlike '93, where ; is a no-op, '98 skips to the next ;
            and doesn't execute anything in between
   2^0;     Not executed, unlike Befunge 93
       7|   Pushes 7 onto the stack, and then sends the IP up, because 7 is not 0
n0b1        n clears the stack, and #s are pushed until the stack is [0, 11, 1
    *.      multiplies the top 2 values of the stack to give 11, and prints it (yay!)
      _     Sends the IP right, because the top value of the stack is 0
       q    Ends the program (no-op for '93, which continues to @)

สิ่งที่ควรทราบ:

• 0ติดกับbไม่จำเป็นอย่างเคร่งครัดในสถานะปัจจุบันของรหัสและสแต็คได้รับการล้าง สามารถลบออกได้หากจำเป็น แต่อนุญาตสำหรับการจัดการสแต็กอื่นล่วงหน้าก่อนซึ่งเป็นส่วนหนึ่งของโปรแกรมในอนาคตที่เป็นไปได้
• ที่_q@นั่นเป็นส่วนหนึ่งของ Retina (มันไม่ทำงานถ้าไม่มีมันก็อย่าถามฉันว่าทำไม) การเพิ่มนอกจากqนี้ยังช่วยให้รหัส '98 เรียกใช้การtดำเนินการซึ่งแยก IP (รวมถึงการทำให้โปรแกรม Retina พิมพ์ 8 แทน 7)
• _ไม่ง่าย>เพราะที่จะรับประทานอาหารส่วน SMBF ขึ้น

แก้ไข: เพิ่งรู้ว่า_q@น่าจะเป็น@00(ที่ 0 สามารถเป็น ~ ถ่านใด ๆ ) เพื่อให้โปรแกรมมีความยืดหยุ่นมากขึ้นในอนาคต ฉันขี้เกียจเกินไป (และเหนื่อย) ที่จะเปลี่ยนลิงค์ทั้งหมดในขณะนี้ จะได้รับรอบในที่สุด ...

แก้ไข 2: ฉันไม่ได้คาดหวังอีก 6 คำตอบอย่างรวดเร็ว ฉันเดาว่ามันคงอยู่เหมือนเดิม เยี่ยมมากทุกคน!

35. INTERCAL (C-INTERCAL), 631 ไบต์

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N6@15o|>␉^*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#8␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q222999/+23!@1#"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ลองออนไลน์!

rundown

โปรแกรมนี้พิมพ์35ใน INTERCAL, 34ใน Rail, 33ในเหตุการณ์, 32ใน Whirl, 31ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ในTrigger, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25ใน Pip , 24ใน Thutu, 23ใน Hexagony, 22 in Underload, 21ใน Nim, 20ใน Prelude, 19ใน Reng, 18ใน Cardinal, 17ใน Julia, 16ใน Pyth,15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12ใน Fission, 11ใน Befunge-98, 10ใน Befunge-93, 9ใน Perl 5, 8ใน Retina, 7ใน Japt, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน คุณสามารถทดสอบ Reng ได้ที่นี่และ Modular SNUSP ที่นี่ ; พวกมันออก 19 และ 31 ตามลำดับตามต้องการ ฉันทดสอบเหตุการณ์ในพื้นที่ด้วยระบบของฉันเองโดยใช้ล่ามอย่างเป็นทางการ

โปรดทราบว่าฉันได้เพิ่มการเปลี่ยนแปลงบางอย่างในไดรเวอร์การทดสอบเพื่อให้ง่ายต่อการมองเห็นอักขระที่ซ่อนอยู่ ไบต์ NUL ต่างๆมีการพุ่งเข้าสู่ผลลัพธ์ของโปรแกรมในบางภาษา ฉันได้ตัดสินใจแล้วว่านี่อาจไม่ใช่ปัญหาเพราะก) มีการส่งที่หลากหลายและข) ล่าม Befunge ดูเหมือนจะเพิ่ม NUL ไบต์พิเศษแม้ว่าจะไม่มีสิ่งใดในโปรแกรมที่บอกเป็นนัยว่า (เว้นแต่ฉัน พลาดอะไรบางอย่างไป) ดังนั้นมันจะต้องเกิดขึ้นมานานและอาจเป็นส่วนหนึ่งของการทำงานของล่าม (โปรดทราบว่าภาษาที่ยังคงส่งออก NUL ไบต์ - Befunges และ Minkolang - ยังไม่ได้เปลี่ยนรหัสสำหรับการส่งนี้)

การส่งข้อมูล Rail ก่อนหน้าออกจากการทำงานผิดพลาดซึ่งไม่ได้รับอนุญาต แต่สามารถแก้ไขได้ง่าย (โดยการเพิ่มโปรแกรม#ที่ส่วนท้ายของโปรแกรม Rail และปรับ Hexagony ให้ตรงกัน) ดังนั้นฉันจึงไม่ได้คิดว่ามันเป็นปัญหาใหญ่ ทางออกของ Rail ในทางออกนี้ถูกต้อง

คำอธิบาย

วิธีการใช้งานรหัส INTERCAL

INTERCAL จะแยกวิเคราะห์โปรแกรมทั้งหมด อย่างไรก็ตามข้อผิดพลาดทางไวยากรณ์เป็นสิ่งรันไทม์ใน INTERCAL ไม่ใช่การคอมไพล์เวลาและมักใช้ในการสร้างความคิดเห็น (หากมีข้อผิดพลาดทางไวยากรณ์พยายามที่จะดำเนินการมันจะผิดพลาดของโปรแกรมที่มีข้อผิดพลาด ICL000I ตรงกันข้ามกับสิ่งที่ Wikipedia เรียกร้องไม่ถูกต้อง แต่ถ้าคุณสามารถป้องกันไม่ให้มันทำงานอย่างใดอย่างหนึ่ง - และ INTERCAL มีหลายวิธีในการป้องกันคำสั่งทำงาน ค่อนข้างมีความสุขที่ไม่ดำเนินการโดยไม่ทำให้เกิดปัญหา)

ด้วยเหตุนี้เราสามารถป้องกันขยะในตอนท้ายของไฟล์ที่ทำงานเพียงแค่ออกจากโปรแกรมอย่างชัดเจนก่อน (สิ่งที่ต้องการต่อไปเพราะ INTERCAL ล้มเหลวหากถึงจุดสิ้นสุดของโปรแกรมโดยไม่มีคำสั่ง exit ที่ชัดเจน) การจัดการจุดเริ่มต้นของโปรแกรมน่าสนใจยิ่งขึ้นและใช้ประโยชน์จากตัวแยกวิเคราะห์ข้อบกพร่อง คุณสามารถเขียนสิ่งที่ต้องการDO %20 READ OUT #8ส่งออกVIIIด้วยความน่าจะเป็น 20% (และไม่ทำอะไรเลย) เท่าที่ฉันสามารถบอกได้ C-INTERCAL จะแยกวิเคราะห์ lone% ในบรรทัดที่สองเพื่อระบุความน่าจะเป็น 0% สำหรับคำสั่งแรกที่เรียกใช้และทำให้จบลงอย่างต่อเนื่องไม่ทำงานทุกครั้ง (ฉันไม่แน่ใจว่าทำไมมันแยกวิเคราะห์มันเช่นนั้น แต่ดูที่รหัสรวบรวมแสดงให้เห็นว่ามันสร้างตัวเลขสุ่มและเปรียบเทียบกับ 0)

นี่คือวิธีที่โปรแกรม INTERCAL ดูก่อนที่จะปรับให้เข้ากับส่วนที่เหลือของโพลิกอน:

DO,1<-#2
DO,1SUB#1<-#52
DO,1SUB#2<-#32
DOREADOUT,1
PLEASEGIVEUP

นี่ค่อนข้างง่าย: ยกตัวอย่างอาร์เรย์ 2 องค์ประกอบ; ตั้งค่าองค์ประกอบเป็น 52 และ 32 (ฐานสิบ) ตามลำดับ (การเข้ารหัสสตริงของ INTERCAL นั้นดีที่สุดที่ไม่ได้กล่าวถึงไว้ฉันลืมวิธีการทำงานและต้องทำการทดลองต่าง ๆ เพื่อหาสาเหตุที่ตัวเลขเหล่านี้เข้ารหัส35); อ่านออกไปยังเอาต์พุตมาตรฐาน และออกจากโปรแกรม ฉันได้เพิ่ม PLEASE เพิ่มเติมในตอนท้ายเพื่อยกเลิกคำสั่ง GIVE UP เริ่มต้นคำสั่งใหม่สำหรับขยะตอนท้ายของโปรแกรมในขณะที่รักษาขอบเขตที่ยอมรับได้สำหรับการสนทนาที่สุภาพ แน่นอน INTERCAL ดูไม่เหมือนในผลิตภัณฑ์สำเร็จรูป ฉันจะอธิบายว่าทำไมเราไป

ฝังอยู่ใต้ภาระของSes

ปัญหาที่เห็นได้ชัดที่สุดกับโปรแกรม INTERCAL Sก็คือว่ามันมีตัวอักษร นี่เป็นสิ่งที่หลีกเลี่ยงไม่ได้เนื่องจากไม่มีวิธีการทำดัชนีอาร์เรย์โดยไม่ใช้ตัวอักษรที่เป็นปัญหา อย่างไรก็ตามSเป็นคำสั่งเอาต์พุตใน Underload และไม่มีวิธีที่จะป้องกันการแยกวิเคราะห์โปรแกรมทั้งหมด ทางออกเดียวคือการวางรหัส INTERCAL ไว้ในวงเล็บซึ่งเทียบเท่ากับ Underload ของตัวอักษรสตริงเพื่อที่จะไม่ทำงานทันที

อย่างไรก็ตามเรามี^ตัวละครสองตัวที่ส่วนท้ายของโปรแกรมซึ่งรันโค้ด Underload ดังนั้นพวกSมันจะถูกประหารชีวิตถ้าเราไม่ทำอะไรเกี่ยวกับมัน ฉันสามารถเปลี่ยนเป็นตัวละครอื่นได้ แต่ตัดสินใจว่าจะป้องกันรหัสได้ง่ายขึ้นเพื่อให้มันไม่มีความหมาย aหนีออกมาจากสตริงใน Underload (หมายถึงว่า^เมื่อดำเนินการสตริงจะ unescape เพียงอีกครั้งแทนที่จะผลิตผลข้างเคียงที่เป็นอันตราย) เรามีหนึ่งaในการsayใช้ในรหัส Perl 6 (ซึ่งในการจัดเรียงของรหัสนี้เป็นจริงเพียงพอเนื่องจากการเปลี่ยนแปลงที่ไม่เกี่ยวข้อง) อย่างไรก็ตามเพื่อให้ผู้คนไม่ต้องพึ่งพาสิ่งนั้นฉันจึงเพิ่มคนอื่นaในตอนท้ายของบรรทัด (ฉันต้องการตัวละครที่มีอยู่แล้วเพื่อให้สิ่งที่จะเป็นช่องว่างต่อท้ายมองเห็นได้และเพราะ Hexagony ต้องการช่องว่างตามที่เป็นอยู่โปรดทราบว่า Hexagony ค่อนข้างง่ายต่อการแก้ไขในโปรแกรมนี้และไม่ได้จริงๆ ต้องแยกการสนทนา) ดังนั้นรหัส Underload จึงมีความเปราะบางน้อยกว่าที่ควรจะเป็น

โหมโรงงานและความสับสนมากมาย

อ๊ะโหมโรง ไม่ใช่ภาษาที่ยากที่สุด แต่ในครั้งนี้ มีสองปัญหาจริง: หนึ่งคือการเพิ่มวงเล็บพิเศษในสายยาว farly จะเสี่ยงต่อการรบกวนการควบคุมการไหลของโปรแกรมโหมโรง (ตามที่พวกเขาสร้างเทียบเท่าของที่whileห่วง) และเป็นเพียงปัญหาของการป้องกันไม่ให้เยื่อบุ ขึ้นในแนวตั้ง (ซึ่งมีหน้าที่รับผิดชอบในการเคลื่อนย้ายไปมาในพื้นที่ว่างบนเส้นสุ่ม) โปรดทราบว่าช่องว่างให้ฉันปัญหาบางอย่างเกินไป แต่โปรแกรมนี้เทียบเท่ากับก่อนหน้านี้จากมุมมองของช่องว่างดังนั้นมันค่อนข้างกรณีของ "แก้ไขโหมโรงโดยไม่ทำลายช่องว่าง"

ฉันไม่แน่ใจเกินไปว่า Prelude ใช้งานได้จริง ณ จุดนี้ มีการแก้ไขหลายประการสำหรับมันเช่น 0 ใกล้กับมุมล่างซ้าย แต่พวกเขาไม่ได้ทำงานอย่างชัดเจนในแบบที่ฉันต้องการ (รหัสจูเลียก็จบลงที่การย้ายไปที่ด้านล่างของบรรทัดเนื่องจากวงเล็บในprintคำสั่งของมันยากมากที่จะจัดการกับ) บางทีเราอาจจะต้องปล่อยให้มันลึกลับ

การสลายในเครื่องปฏิกรณ์ฟิชชัน

ถึงแม้ว่าการเปลี่ยนแปลงข้างต้นจะเกิดจากปัญหาที่ค่อนข้างบอบบางซึ่งยากต่อการแก้ไข แต่ก็มีปัญหาที่ชัดเจนกว่ามาก DOREADOUTตรงกับ regex ไม่และจึงจะทำให้เกิดการแบ่งเซลล์การผลิตผลผลิตที่ไม่พึงประสงค์ในรอบที่สี่ซึ่งเป็นเวลาไม่มากพอที่จะส่งออกการส่งออกที่ตั้งใจR...O 12และ INTERCAL มีเพียงคำสั่งเดียวที่สร้างเอาต์พุต (ยกเว้นว่าคุณนับการหยุดทำงานเป็นเอาต์พุต) สิ่งหนึ่งที่แก้ไขได้คือพยายามเพิ่มช่องว่างระหว่างREADและOUTเพื่อให้เรามีเวลาในการสกัดเอาต์พุต แต่นั่นทำให้ช่องว่างโกรธ ดังนั้นในขณะที่ฉันคิดว่าโปรแกรมนี้เป็นไปไม่ได้; R, L, UและDมีทุกจุดรายการในเซลล์และทุกความสามารถในการใช้รหัสอาจมีปัญหาและคำหลัก INTERCAL จะต้องเป็นตัวพิมพ์ใหญ่

อย่างไรก็ตามมีการแก้ไขและน่าประหลาดใจอย่างมาก ในฐานะที่เป็นส่วนหนึ่งของความพยายามในระดับสากล C-INTERCAL จะยอมรับคำหลักในหลายภาษาโดยรองรับทั้งภาษาอังกฤษและละติน เราไม่สามารถหลีกเลี่ยงSเช่นนี้ แต่เราสามารถหลีกเลี่ยงO; FACเป็นตัวแทนที่ดีเลิศสำหรับDOและเช่นเดียวกันหมายความว่าสิ่งเดียวกับLEGERE EX READ OUT(โปรแกรมจบลงด้วยการผสมผสานระหว่างภาษาอังกฤษและภาษาลาติน แต่ก็ไม่เป็นไรมันแทบจะไม่ทำให้อ่านได้น้อยลง) ดังนั้นเราสามารถปล่อยให้ฟิชชันโกรธอย่างบ้าคลั่งที่มุมล่างขวาและไม่ปล่อยให้มันเกิดขึ้น เอาท์พุต เราสามารถเปลี่ยนรหัสฟิชชันที่แท้จริงให้ลงท้ายด้วย*แทน;ซึ่งออกจากโปรแกรมทั้งหมดแทนที่จะเป็นเพียงหนึ่งเธรด รหัสนี้ทำงานค่อนข้างเร็วดังนั้นจึงออกจากโปรแกรมก่อนที่จุดเข้าจรจัดทั้งหมดจะมีเวลาในการทำความเสียหายใด ๆ

ถัก 6, Perl 6

ปัญหาถัดไป: Perl 6 ความคิดเห็นการทำงานโดยการจับคู่และ< >ผู้ประกอบการที่ได้รับมอบหมาย INTERCAL <-คือ โชคดีที่มีการเพิ่มวงเล็บเปิดพิเศษดังนั้นฉันสามารถเพิ่มวงเล็บปิดสองสามอันเพื่อยกเลิกพวกเขาในตำแหน่งที่ไม่ได้แยกวิเคราะห์ในโปรแกรม (หลังรหัส Pip ในกรณีนี้)

อย่างไรก็ตามฉันไม่ต้องการเปลี่ยนงบประมาณช่องว่างของโปรแกรม แต่การย้ายรหัส Julia (สำหรับ Prelude) จบลงด้วยการเพิ่มพื้นที่พิเศษให้กับบรรทัดสุดท้าย ฉันต้องลบออกจากที่ใดที่หนึ่ง ช่องว่างสองช่องเป็นเครื่องหมายแสดงความคิดเห็นใน Pip ดังนั้นฉันแทบจะไม่สามารถเปลี่ยนแปลงสิ่งเหล่านั้นได้ say 27ตัวเลือกเดียวที่เหลืออยู่คือพื้นที่ใน นักกอล์ฟ Perl 5 จะคิดทันทีว่า "ทำได้say+27ดีแล้ว" (นักวิชาการ+มามีประโยชน์บ่อยครั้งอย่างน่าประหลาดใจ!) แต่น่าเสียดายที่นี่ไม่ใช่ไวยากรณ์ Perl 6 ที่ถูกต้อง

อย่างไรก็ตามสิ่งที่เราสามารถทำได้คือเปลี่ยนsayจากฟังก์ชั่นไวยากรณ์เป็นไวยากรณ์เมธอด ตัวอักษรจำนวนเต็มมีวิธีการมากมายรวมถึงวิธีที่จะพิมพ์ออกมาดังนั้นจึง27.sayเป็นโปรแกรมที่สมบูรณ์แบบที่มีความยาวเท่ากัน

เป็นสี่เหลี่ยมหรือไม่ อย่าอยู่ที่นั่น

ดังนั้นประเด็นต่อไปคือฉันได้เพิ่มส่วนเพิ่มเติม.ลงในโปรแกรม ผู้ใช้ SMBF จะรู้ว่านั่นเป็นปัญหาที่ชัดเจนในภาษาดังกล่าวโดยสร้างเอาต์พุตจรจัด (NUL ไบต์ในกรณีนี้) นอกจากนั้นแล้ว.การผลิตการส่งออกจรจัดโปรแกรมที่ผ่านมา แต่ไม่ได้หมายความว่าฉันไม่ควรจะใช้โอกาสที่จะแก้ไขได้

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

น่าเสียดายที่วงเล็บเหลี่ยมมีความหมายต่อ Retina มันเห็น[…<-#…และพูดว่า "ไม่สมเหตุสมผลคุณไม่สามารถสร้างช่วงนั้นเพราะ<ไม่ได้มาก่อน#" โชคดีที่มันสามารถแก้ไขได้อย่างง่ายดายด้วยแบ็กสแลชที่วางอย่างมีกลยุทธ์

เหตุการณ์ที่เป็นศูนย์กลางของโปรแกรม

นี่เป็นคำตอบสุดท้ายที่เกิดขึ้นและมันอาจจะเกิดขึ้นซ้ำ ๆ จากนี้ไป สตริงต่างๆเกิดขึ้นแบบสุ่มเกิดขึ้นสามครั้งและเลื่อนไปรอบ ๆ จุดศูนย์กลางของโปรแกรมจากมุมมองของเหตุการณ์

โทเค็นที่เร่งด่วนที่สุดที่จะจัดการเป็น1#ที่ปรากฏสามครั้งถ้าคุณทำการเปลี่ยนแปลงเหล่านี้อย่างไร้เดียงสา: #= >␉1#จุดเริ่มต้นของเส้นที่สามและ__DATA__=1# echo 21#เหตุใดจึงเป็นปัญหา เนื่องจาก1#ในบรรทัดที่สามทับซ้อนกัน#vหลังจากนั้นและโทเค็นที่ซ้อนสองอันทำให้ไม่นับรวม และ#vเป็นโทเค็นที่เราใช้ในการแสดงความคิดเห็นรหัสก่อนที่โปรแกรมจะเกิดขึ้น! ฉันแก้ไขสิ่งนี้ด้วยการแอบเข้าไป1#ใกล้จุดจบของโปรแกรม (ตัวละครสามตัวติดตาม); ไม่มีภาษาที่แยกวิเคราะห์ส่วนของโปรแกรมที่ทำอะไรกับมัน

มีโทเค็นที่มีปัญหาอื่น ๆ อีกมากมายที่จะจัดการกับ คู่เป็นตัวอักษรเดียวPและU; ฉันจัดการกับสิ่งเหล่านี้ผ่านการเปลี่ยนฟิลเลอร์ไม่มี ops ในรหัสเหตุการณ์จากxเป็นPหรือUตามลำดับโดยให้สำเนาที่สี่ การเปลี่ยนแปลงรหัสฟิชชันจะทำให้*เป็นโทเค็น แต่ที่เด่นชัดนี้จะแตกต่างจากปกติโดยปรากฏเป็นสองครั้งก่อนรหัสเหตุการณ์และเพียงครั้งเดียวหลังจากนั้น แทนที่จะเอาออกไปฉันจึงใช้มันเพื่อทำให้LEโทเค็นใหม่ที่ปรากฏในรหัส INTERCAL บางส่วนมีความสมดุล นั่นเพียงพอที่จะทำให้ศูนย์กลางของโปรแกรมกลับมาเป็นปกติ0oเหรียญ แน่นอนว่าการเปลี่ยนแปลงโปรแกรมนั้นค่อนข้างจะรบกวน (ความพยายามของฉันในการรับเหตุการณ์เข้าสู่ TIO ล้มเหลวเนื่องจาก libdivsufsort ไม่พร้อมใช้งานที่นั่นดังนั้นดูเหมือนว่าเราอาจได้รับประโยชน์จากล่ามใหม่โดยเฉพาะใน JavaScript เพื่อให้สามารถทำงานออนไลน์หากคุณสนใจลองดูที่นี่ คำถาม )

1. Python 3 (8 ไบต์)

print(1)

โปรแกรมนี้พิมพ์1ใน Python 3

เริ่มต้นด้วย Python 3 เพราะฉันรู้ว่ามันดีสำหรับ polyglots และสามารถนำไปใช้ในหลายทิศทางที่แตกต่างกัน (เช่นกันฉันต้องการให้แน่ใจว่าคำตอบแรกเป็นภาษาที่ค่อนข้างปกติมากกว่า esolang ไร้สาระที่ยากที่จะพูดได้หลายภาษา ด้วย)

10. Befunge , 95 ไบต์

#v02^0;7||"<+0+0+0+<;n4
#v0#@00
#>3N.
#|\w*
#8
#|
#M`
print(None and 9or 1/2and 1or 5)
#jd5ki2

มีอักขระ ESC ตามตัวอักษรระหว่างjและdบนบรรทัดสุดท้าย (grr, @ ais523) มันไม่รวมอยู่ในรหัสนี้ หากต้องการรับรหัสจริงโปรดไปที่Try it onlineลิงก์

สิ่งนี้พิมพ์1ใน Python 3, 2ใน Vim, 3ใน Minkolang, 4ใน <> <, 5ใน Python 2, 6ใน SMBF, 7ใน Japtor, 8ใน Retina 9ใน Perl และ10ใน Befunge

รหัสนี้แชร์*กับ Retina และ.กับ Minkolang และ SMBF

ลองออนไลน์

คำอธิบาย

โปรแกรมจริง

#v02^
    @
    .
    *



    t
    5
#v02^

บรรทัดสุดท้ายถูกเขียนเพื่อความชัดเจน ( Befunge playground is cyclic)

#

แทรมโพลีนกระโดด v

02^

กด0แล้ว2ซ้อนกันขึ้นไป

5t*.@

Push 5, no-op, คูณสององค์ประกอบใน stack ( 2and 5), print, สิ้นสุดโปรแกรม

21. นิ่ม (161 ไบต์)

#v`16/"<"6/b.q@#;n4"14""
#>3N6@15o|> ^*ttt*~++ %
#=~nJ<R"12";
#[

print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#]#echo 21
#8dggi2` |1|6

สอง<ESC>s ระหว่าง8dและระหว่าง2`ในบรรทัดสุดท้าย คุณสามารถบอกได้ว่าคนก่อนหน้าของฉันกำลังเล่นกอล์ฟอย่างเร่งรีบเพราะฉันตื่นขึ้นมาในเช้าวันนี้และรู้ว่าฉันสามารถถอดออกได้มากกว่านี้ ฉันมี 152 ไบต์ แต่ดูเหมือนว่าจะใช้งานได้เฉพาะใน Perl 5.24.0 เท่านั้นดังนั้นเพื่อประโยชน์ในการเข้ากันได้กับ TIO ฉันได้แสดงออกมาในตอนนี้

พิมพ์ 1 ใน Python 3, 2 ใน V, 3 ใน Minkolang, 4 ใน> <>, 5 ใน Python 2, 6 ใน SMBF, 7 ใน Japtapt, 7 ใน Japtapt, 8 ใน Retina, 9 ใน Perl, 10 ใน Befunge-93, 11 ใน Befunge -98, 12 ในฟิชชัน, 13 ใน Ruby, 14 ในTurtléd, 15 ใน Haystack, 16 ใน Pyth, 17 ใน Julia, 18 ใน Cardinal, 19 ใน Reng, 20 ใน Reng, และ21 ใน Nimในสะเดา

โปรดทราบว่า Nim บน ideone.com ใช้เวอร์ชัน 0.11.2 ซึ่งเก่าเกินไปเนื่องจากโปรแกรมนี้อาศัย#[ ... ]#ความคิดเห็นหลายบรรทัดที่เพิ่มในต้นปี 2559

ขอขอบคุณที่พระคาร์ดินัลของ Windows ล่ามเวิร์กโฟลว์ของฉันตอนนี้ประกอบด้วยสองแล็ปท็อปและงูหลามhttp.serverในระหว่าง

แก้ไข - คำแนะนำเพิ่มเติม:

• 8ที่เริ่มต้นของบรรทัดสุดท้ายคือการกำหนดวงเงิน Retina ไปที่ 8 การแข่งขันครั้งแรกมิฉะนั้นโดยไม่ได้ Retina 2จะเอาท์พุท โปรดทราบว่านี่หมายความว่า regex บรรทัดสุดท้ายต้องจับคู่อย่างน้อย 8 ครั้งในบรรทัดที่สองตอนนี้ซึ่งตรงข้ามกับ 8 - ในระหว่างการยุ่งของฉันฉันแก้ไข Prelude เพื่อรับ Retina ที่ถูกต้อง แต่ปรากฎว่าไม่จำเป็นในตอนท้าย .
• เครื่องหมายคำพูดที่ไม่ตรงกันในตอนท้ายของบรรทัดแรกคือเพื่อให้ Pyth ไม่ได้บ่นเกี่ยวกับไวยากรณ์ที่ไม่ถูกต้องสำหรับส่วนที่เหลือของรหัส
• ถ้าคุณปรับเปลี่ยนบรรทัดที่สองคุณอาจจะต้องเปลี่ยน6@สำหรับ Minkolang ซึ่งทำให้ตัวชี้กระโดด 6 ^ช่องว่างที่จะจอดบน
• []ตอนนี้มีคู่ของดังนั้น SMBF จะต้องอยู่ในเซลล์ 0 ก่อนที่มันจะฮิต[หรือทางเลือกที่การตกแต่งภายในเพื่อล้างเซลล์

อาจจะมีการเล่นกอล์ฟมากขึ้น (ถึงตอนนี้ฉันเห็นพื้นที่จรจัดก่อนถึง%พระคาร์ดินัล) แต่ฉันควรหยุดเล่นกอล์ฟในเวลาไม่กี่ชั่วโมงในตอนเช้า

51. การประกอบ (x64, Linux, AS) , 1086 ไบต์

#16  "(}23!@)(" 3//*v\D@;'[af2.qc]'#)"14";n4
#/*` PkPPZ (22)S"[!(>7 7*,;68*,@;'1,@␉␉␉␉ q
#>␉
# >36!@␉
#`<`
#<]+<[.>-]>[
#{
#z}
#
#=x<R+++++[D>+++++++EAL+++<-][pPLEASE,2<-#2DO,2SUB#1<-#52PLEASE,2SUB#2<-#32DOREADOUT,2DOGIVEUPDOiiipsddsdoh]>+.-- -. >][
#x%+>+=+~tt .
#D>xU/-<+++L
#R+.----\).>]|
#[#[(}2}20l0v01k1kx0l0ix0jor0h0h1d111x0eU0bx0b0o1d0b0e0e0@O6O4/0m1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10vx0v0l111111^_)  0046(8+9+9+9+9+=!)
###|
'\';echo 50;exit;';print((eval("1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or"'x"or'({({1})({1}[(0)])}{1}\{1})'#}#(prin 45)(bye)|/=1/24=x<$+@+-@@@@=>+<@@@=>+<?#d>+.--./
__DATA__=1#"'x"//
#.\."12"__*'
###;console.log 39
""""#//
=begin //
#sseemeePaeueewuuweeeeeeeeeeCisajjap*///;.int 2298589328,898451655,12,178790,1018168591,84934449,12597/*
#define p sizeof'p'-1?"38":"37"
#include<stdio.h>
main ( )/*/
#
#"`#"\'*/{puts (p);}/*'"`"
/*
<>{#65}//
#}
disp 49#//
#{
1}<>//
$'main'//
#-3o4o#$$$
#<R>"3"O.
=end #//
"""#"#//
#}
#s|o51~nJ;#:p'34'\=#print (17)#>27.say#]#print(47)#]#echo  21
#sss8␛dggi2␛ `|1|6$//''25  16*///89^_^_Z222999"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ต้องการเรียนรู้เพิ่มเติมหรือไม่ ลองใช้การสนทนาหลายเหลี่ยม !

ลองออนไลน์!

คะแนน VIP ( เครื่องพิมพ์อเนกประสงค์จำนวนเต็ม ): .008186 (เพื่อปรับปรุงรายการต่อไปควรมีไม่เกิน 1151 ไบต์)

โปรแกรมนี้พิมพ์51ในการประชุม, 50ใน Bash, 49ในคู่, 48ใน Deadfish ~, 47ใน Lily, 46ใน Cubix, 45ใน PicoLisp, 44ในอัลฟา, 43ในตาข่าย, 42ในความชั่วร้าย, 41ในสมอง *** , 40ใน Minimal-2D, 39ใน CoffeeScript, 38ใน C, 37ใน C ++, 36ใน Labyrinth, 35ใน INTERCAL, 34 in Rail, 33ในเหตุการณ์, 32 in Whirl,31ในเบฟเฟส -98ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25 in Pip, 24 in Thutu, 23ใน Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude , 19ใน Reng, 18ใน Cardinal, 17ใน Julia, 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12ใน Fission, 1110ใน Befunge-93, 9ใน Perl 5, 8ใน Retina, 7ใน Japtf, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ในVink และ1ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน

• เหรงสามารถทดสอบการส่งออก 19 ที่นี่

• Modular SNUSP สามารถทดสอบการส่งออก 31 ที่นี่

• รูปทรงลูกบาศก์ของ Cubix ดูที่นี่

• มีการตรวจสอบเหตุการณ์โดยทำให้โทเค็นสมดุลตามที่อธิบายไว้ในคำตอบก่อนหน้า

• สำหรับเดดฟิช ~ สามารถทดสอบกับเอาต์พุต 48 ด้วยวิธีนี้ได้ได้ โปรดทราบว่า Deadfish ~ จะใช้รูปหลายภาษาเพื่อป้อนบน stdin แต่และพิมพ์จำนวน>>พรอมต์ไปยังเอาต์พุตมาตรฐานซึ่งเป็นผลลัพธ์ที่หลีกเลี่ยงไม่ได้ในการรันโปรแกรม Deadfish ใด ๆ

• สามารถทดสอบชุดประกอบเพื่อส่งออก 51 ได้ที่นี่

ขอขอบคุณและขอแสดงความยินดี

เมื่อคำตอบ 50-in-1-k ของ @ ais523 ลดลง 2 สัปดาห์ที่ผ่านมาน้ำตาไหลอาบแก้มของฉัน มันสวยเกินไป และมันก็อยู่ใน Bash มันสมบูรณ์แบบเกินไป

ฉันหันไปหาภรรยาและพูดว่า“ ฉันคิดว่าคนพูดหลายภาษาเสร็จแล้ว” รู้สึกภูมิใจอย่างมาก

เธอหันมามองฉันในตาหยุดสักครู่แล้วพูดว่า“ ดี เอาขยะออกไป”

สิ่งที่เธอหมายถึงคือเธอรู้สึกดีใจอย่างยิ่งสำหรับฉันและเพื่อนในอินเทอร์เน็ตของฉัน ขอขอบคุณและขอแสดงความยินดีกับทุกคน

คำอธิบายการชุมนุม

ในวันที่ตามมาจิตใจของฉันยังคงหลงทางกลับไปที่บางสิ่งบางอย่าง @ ais523 พูดในการสนทนาหลายภาษาก่อนที่จะโพสต์ Bash เขาชี้ให้เห็นว่าบางส่วนของการชุมนุมใช้#ความคิดเห็นตามบรรทัดและ/*บล็อกความคิดเห็น นั่นก็เพียงพอแล้วสำหรับฉันที่จะค่อยๆสูญเสียความคิดของฉันในอีก 2 สัปดาห์ข้างหน้า

มีความท้าทายโดยนัยในรูปหลายภาษาที่จะรวมภาษาที่ถูกกฎหมาย ฉันใช้คำที่ถูกต้องตามกฎหมายที่นี่อย่างอิสระ แต่ฉันคิดว่าเราทุกคนสามารถห้อมล้อมสิ่งที่ฉันได้รับ มันเป็นสิ่งหนึ่งที่จะรวม Brainf *** แต่มันเป็นอีกสิ่งหนึ่งที่รวมเอา Mathlab หรือ R. Assembly ไว้ในหมวดหมู่หลังอย่างแน่นอนและจิตใจของฉันก็ไม่สามารถปล่อยมันไปได้ แต่ฉันไม่รู้จักสมัชชาดังนั้นนี่เป็นการต่อสู้ที่ยากเย็นแสนเข็ญ

หลังจากต่อสู้กับปัญหาไปพักหนึ่งมองหาหนทางสำหรับ Assembly และ C / C ++ เพื่ออยู่ร่วมกันฉันพบว่านี่เป็นเอกสารสำหรับแอสเซมเบลอร์ GNU:

เพื่อให้เข้ากันได้กับแอสเซมบลีที่ผ่านมาบรรทัดที่ขึ้นต้นด้วย '#' มีการตีความพิเศษ การทำตาม '#' ควรเป็นนิพจน์แบบสัมบูรณ์ (ดูนิพจน์): หมายเลขบรรทัดโลจิคัลของบรรทัดถัดไป จากนั้นอนุญาตให้ใช้สตริง (ดูสตริง): หากมีชื่อไฟล์โลจิคัลใหม่ ส่วนที่เหลือของบรรทัดถ้ามีควรเป็นช่องว่าง

สิ่งนี้ฉันสังเกตว่าคล้ายกับคำสั่งพรีโปรเซสเซอร์ของเราสำหรับ C / C ++ ในบรรทัดที่ 1 ของโพลิกอน หลังจากการทดลองและข้อผิดพลาดฉันพบว่า#1 “bla” 1//*จะใส่ความคิดเห็นบล็อกสำหรับสภาเท่านั้น

และมีหลายภาษาที่ทำ

ด้วยปัญหาการบล็อคที่ใหญ่ที่สุดได้รับการแก้ไขฉันจึงตัดสินใจออกตัวอย่างที่ดีของโลกนี้

.intel_syntax noprefix
.section .data
     msg: .asciz "51"
.section .text
.global _start
_start:
    # write syscall
    mov     rax, 1
    # file descriptor, standard output
    mov     rdi, 1
    # message address
    mov     rsi, OFFSET FLAT:msg
    # length of message
    mov     rdx, 14
    # call write syscall
    syscall
    #End the Program
    mov    rax, 60
    mov    rdi, 0
    syscall

เครดิตของผู้เขียนหลัก

อันที่จริงฉันโกหกเมื่อหนึ่งนาทีที่แล้วรหัสแอสเซมบลีรุ่นแรกที่ฉันใช้คือในรูปแบบ AT&T ซึ่งเป็นหนึ่งในสองสาขาไวยากรณ์ของแอสเซมบลี หนึ่งในองค์ประกอบหลักของไวยากรณ์ AT&T คือการอ้างอิงการลงทะเบียนใช้%คำนำหน้าและนี่เป็นปัญหาสำหรับกลุ่มคนที่พูดได้หลายภาษา พระคาร์ดินัลใช้%เป็นจุดกำเนิดของตัวชี้ดังนั้นถ้าเราทิ้งขยะ%ประมาณหนึ่งอันมันก็เหมือนกับปฏิกิริยาฟิชชันที่สอง

สาขาวากยสัมพันธ์อื่น ๆ ที่ไม่ได้ใช้ %เป็นคำนำหน้าลงทะเบียนเรียกว่าไวยากรณ์ของ Intel การหาประโยชน์ที่เราใช้ในกลุ่มคนหลายภาษาเพื่อให้ผ่านบรรทัดแรกและป้อนความคิดเห็นแบบบล็อกอยู่ใน GNU Assembler (GAS หรือ AS โดยย่อ) AS มีคุณสมบัติที่มีความสุขในการอนุญาตให้ทั้งสองสาขาวากยสัมพันธ์ คุณเพียงแค่ต้องประกาศว่าคุณต้องการใช้ไวยากรณ์ของ Intel ซึ่งเกิดขึ้นในบรรทัดที่ 1 ของรหัสแอสเซมบลี

แอสเซมบลีใช้รีจิสเตอร์ซึ่งเป็นตำแหน่งหน่วยความจำขนาดเล็กจำนวนมากซึ่งตั้งอยู่บน CPU เพื่อความเร็วในการเข้าถึง นี่ไม่ใช่เอกลักษณ์ของแอสเซมบลีอื่นนอกจากความจริงที่ว่าการใช้งานของพวกเขานั้นไม่ได้แยกออกจากความกังวลของนักพัฒนา

มีรีจิสเตอร์หลากหลายชนิดที่ใช้เพื่อวัตถุประสงค์ที่ต่างกัน จาก Wikipedia:

•ขวานคูณ / หารโหลดสตริง & จัดเก็บ

•นับ CX สำหรับการทำงานของสตริงและการเลื่อน

•ที่อยู่พอร์ต DX สำหรับเข้าและออก

•การลงทะเบียนดัชนี BX สำหรับ MOVE

•แต้ม SP ไปที่ด้านบนสุดของสแต็ก

• BP ชี้ไปที่ฐานของเฟรมสแต็ก

• SI ชี้ไปที่แหล่งข้อมูลในการดำเนินการสตรีม

• DI ชี้ไปยังปลายทางในการดำเนินการสตรีม

AX ถูกใช้ในบรรทัดฟังก์ชัน _start ที่นี่: mov rax, 1. rในraxบ่งชี้ว่าหน่วยความจำ 64 บิต หากเราสลับค่านี้เป็นค่าeที่แสดงถึงหน่วยความจำแบบ 32 บิตซึ่งใช้ได้กับตัวประมวลผลแบบ 64 บิตโดยสิ้นเชิง เราจะไม่ใช้ครึ่งบนของหน่วยความจำที่มีอยู่ เพื่อระบุหน่วยความจำ 16 บิตคุณแค่ใช้axซึ่งก็ดีสำหรับเราเพราะเราเพิ่งพิมพ์จำนวนเต็ม ดังนั้นเราสามารถตีกอล์ฟได้ไม่กี่ไบต์โดยเปลี่ยนการอ้างอิงการลงทะเบียนทั้งหมดเป็น 16 บิต

rเอาล่ะไม่มากทั้งหมดที่ลงทะเบียนลำดับที่อาจลดลง mov rsi, OFFSET FLAT:msg. หากคุณคุ้นเคยกับแอสเซมบลี แต่ไม่ใช่คำสั่งนี้นั่นเป็นเพราะนี่เป็นลักษณะเฉพาะของ AS อย่างน้อยที่สิ่งที่ผมรวบรวมได้จากนี้lea rsi,mซึ่งช่วยให้ผมทองลงคำสั่งเพียงแค่

หลังจากนี้ฉันพบจากประสบการณ์ที่ฉันสามารถล้ม_start:ลงเพียง_pและตัดออก.global _startทั้งหมดโดยมีเพียงคำเตือนที่ออก ประการที่สองก็จะลดลงเพียงตัวแปรตัวเดียวmsg: p:ฉันเลือกpทั้งตัวแปรสตริงและฟังก์ชั่นเริ่มต้นเพื่อชดเชยบางส่วนของsสมัชชาที่เพิ่มเข้ามาเพื่อประโยชน์ของ Alphuck

จากนั้นฉันก็ใส่;คำสั่งเพื่อกำหนดขอบเขตเพื่อที่จะทำให้พวกเขาทั้งหมดในบรรทัดเดียว นี่คือหลักเพื่อหลีกเลี่ยงการต่อท้ายมากเกินไป#//ในแต่ละบรรทัดเพื่อประโยชน์ของ Thutu นอกจากนี้ฉันสังเกตว่าแอสเซมเบลอร์ของเราไม่ปรากฏตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ดังนั้นฉันเพิ่งจะใส่อักขระต่าง ๆ ขึ้นหรือลงเพื่อหลีกเลี่ยงความไม่สมดุลของเหตุการณ์

กอล์ฟนี้เราต้องการ:

.intel_syntax noprefix;.text;mov ax,1;mov di,1;lea rsi,m;mov dx,2;syscall;mov ax,60;mov di,0;syscall;m:.asciz "51"

หลังจากทั้งหมดนี้Japtéและ Underload เป็นเด็กที่มีปัญหาเพียงคนเดียวในคำตอบนี้ Japt มีเนื้อบางส่วนที่มีการ*เพิ่มในบรรทัดที่ 1 แต่ดูเหมือนว่าจะได้รับการแก้ไขโดยการย้อนกลับไปยังputs(p);บรรทัดจากคำตอบ C ++ ฉันลงเอยด้วยการโยน a (ในบรรทัดนี้แล้วปิดมันลงบนเส้นของ Octive นี่เป็นสิ่งที่ Underload จะหยุดการโจมตี การรักษาที่คล้ายกันมีอยู่ในบรรทัดที่ 1 เพื่อเพิ่มใน*นั้น

นี่เพียงพอที่จะตอบสนองความต้องการไบต์ของความท้าทายนี้ อันที่จริงฉันตรวจสอบสิ่งนี้ด้วยการผลิตโพลีกล็อตรุ่นนี้ แต่ฉันต้องการพยายามปรับปรุงคะแนนวีไอพีเช่นกันถ้าเป็นไปได้ และเนื่องจากฉันได้ทำตามข้อกำหนดทั้งหมดของความท้าทายฉันก็รู้สึกว่าตกลงที่จะร่วมมือกันตีรหัส ดังนั้นฉันจึงหยุดพูดคุยกับคนหลายภาษาเพื่อขอความช่วยเหลือจากสนามกอล์ฟ

เราจะต้องลงลึก

@ ais523 แสดงให้เห็นถึงเทคนิคการส่งคำแนะนำไปยังแอสเซมเบลอร์เป็นรหัสเครื่องด้วยคำสั่งนี้

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 รหัสเครื่องเป็นชุดของคำแนะนำเชิงตัวเลขที่ดำเนินการโดยตรงโดย CPU ซึ่งสามารถแสดงเป็นทศนิยมฐานสิบหกหรือฐานแปด ทศนิยมของเรานั้นสั้นที่สุดเนื่องจาก (ฐานสิบหกนำหน้า0xเพื่อเป็นตัวแทน) .longคำสั่งที่นี่จะทำให้การประกาศว่าสิ่งที่ตามมาคือชุดของคำแนะนำรหัสเครื่องทศนิยม

ฉันแหย่ที่ข้อความนี้เช่นกันเพื่อดูว่าผู้ประกอบจะอนุญาตอะไรบ้างและทำการเปลี่ยนแปลงสองสามครั้ง ครั้งแรกฉันพบว่าฉันสามารถลบ.text;ทั้งหมดพร้อมกับปัญหาการเตือนเท่านั้นซึ่งเป็นการประหยัดไบต์ขายค่อนข้าง หลังจากนั้นไม่นานฉันก็พบว่าคำสั่งนี้ในเอกสารข้อมูลจำเพาะของ AS

. long เหมือนกับ .int

เย็น. ดังนั้นเราสามารถทำการสลับนั้นเป็นไบต์ที่รวดเร็ว ตอนนี้การชุมนุมของเรา แต่รหัสเครื่องจริงถูกตัดลงไปที่นี้

.int 2298589328,898451655,12,178790,1018168591,84934449,12597.

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

นี่คือข้อมูลโค้ด

และนี่เป็นเพียงการชุมนุม

nop
mov    $0x1,%al
mov    %eax,%edi
lea    0xc(%rip),%rsi
mov    $0x2,%dx
syscall 
mov    $0x3c,%al
xor    %edi,%edi
syscall 
.byte 0x35
xor    %eax,(%rax)

ลิงค์นั้นยังแสดงตัวเลขฐานสิบหกตัวอักษร 2 ตัวพร้อมกับแต่ละบรรทัดของชุดประกอบ ที่สอดคล้องกับคำแนะนำทศนิยม ตัวอย่างเช่นถ้าคุณใส่2298589328ลงในนี้ทศนิยมเพื่อแปลงฐานสิบหกคุณจะได้รับ8901B090กลับมา และถ้าคุณดูอย่างใกล้ชิดคำสั่งเหล่านี้คือคำสั่งฐานสิบหก 4 อันดับแรกจากการถ่ายโอนข้อมูลวัตถุ (ในลำดับที่กลับกัน)

จากสิ่งที่ฉันสามารถบอกได้ว่าชุดเลขฐานสิบหก 4 ชุดมักใช้เพื่อแปลงเป็นทศนิยมและเคล็ดลับการประหยัดไบต์หลักที่ใช้ที่นี่คือการจัดโครงสร้างชุดประกอบเพื่อให้ตัวเลขฐานสิบหกจำนวนสุดท้ายในชุด 4 ของเราเป็น 00 เพื่อนำเลขศูนย์เมื่อเราใส่ลงใน.intคำสั่งที่เพิ่งถูกละเว้น

นี่คือสิ่งที่เกิดขึ้นใน 12แถลงการณ์ 0c 00 00 00ในส่วนฐานสิบหกของวัตถุที่ถ่ายโอนข้อมูลนี้อยู่

เท่าที่ความเข้าใจของฉันเกี่ยวกับการประชุมได้รับใน 2 สัปดาห์ เป็นอะไรที่ผิดพลาดแน่นอน!

อุบัติการณ์

เหตุการณ์ที่เกิดขึ้นเป็นการแก้ปัญหาที่ยากขึ้นในการนำแอสเซมบลีที่สั้นกว่ามาใช้ นี่คือรายงานเหตุการณ์

• ! ในบรรทัดที่ 2 detokenizes !

• ครั้งแรกEAในบรรทัด INTERCAL detokenizes ตัวเอง

• ช่องว่างสุดท้ายของบรรทัดที่สองถึงบรรทัดสุดท้ายทำให้โทเค็นสเปซ - อวกาศว่าง

• 85 ในบรรทัดสุดท้าย detokenizes

• Rใน#<R>"3"O.detokenizesR

• 65ในโท<>{#65 }//เค็น65

• 16 ในบรรทัดสุดท้าย detokenizes ตัวเอง

• 89 ในบรรทัดสุดท้ายโทเค็นตัวเอง

พระราชาคณะ

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

= คัดลอกค่าที่แอคทีฟของตัวชี้ไปยังค่าที่ไม่ได้ใช้งาน

นี่ไม่ใช่เคล็ดลับที่ใช้ในกลุ่มคนหลายภาษา วิธีการแก้ปัญหาเก่ารวมถึงคำแนะนำเหล่านี้: `++ ~ * t

++ ไม่เกิน 2

~ เปลี่ยนสแต็คที่ใช้งานอยู่

* เพิ่มสแต็ค

ฉันรู้ว่า~*สามารถทำได้ด้วยการ=เรียนการสอนดังนั้นฉันจึงปรับแก้ปัญหาเพื่อให้ได้การแลกเปลี่ยนสแต็กที่ไร้ประโยชน์และเพิ่มในการประหยัดไบต์ขนาดเล็กนี้

6. SMBFขนาด 45 ไบต์

#v<++++<;n4
#>3N.
print('1'if 1/2else'5')
#i2

ลองออนไลน์

โปรแกรมนี้พิมพ์1ใน Python 3, 2ใน V, 3ใน Minkolang v0.15, 4ใน> <>, 5ใน Python 2 และ6ใน SMBF

SMBF (aka ตนเองปรับเปลี่ยน brainfuck) <++++<>.การใช้งาน ตัวชี้ถูกย้ายไปทางซ้าย (ไปยังอักขระตัวสุดท้ายของซอร์สโค้ด) และเซลล์จะเพิ่มขึ้นสี่ครั้งจากนั้นพิมพ์

13. ทับทิม (129 ไบต์)

#v;2^0;7||"<+0+0+0+<*!2'!1'L;n4
#v0#_q@
#>3N.
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

โปรดสังเกตว่าตัวEscอักษรในบรรทัดสุดท้ายระหว่างjและdตามคำตอบ Perl ของais523

ลองออนไลน์!

สิ่งนี้พิมพ์1ใน Python 3, 2ใน Vim, 3ใน Minkolang, 4ใน <> <, 5ใน Python 2, 6ใน SMBF, 7ใน Japt R, 8ใน Retina, 9ใน Perl, 10ใน Befunge, 11ใน Befunge- 98, 12ในฟิชชันและ13ในรูบี

เพียงแค่ปรับเปลี่ยนเล็กน้อยในprintคำสั่งที่มีอยู่เพื่อละเมิดความจริงที่เป็นจริง0ในทับทิม ฉันต้องเพิ่มช่องว่างในงบอื่น ๆ เพื่อให้มันแยกวิเคราะห์ได้อย่างถูกต้อง

15. กองหญ้า (141 ไบต์)

#v;2^0;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^1b0<
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#jd5ki2

หมายเหตุ: มีการESCหลังoในบรรทัดที่สามและหลังจากjในบรรทัดสุดท้าย

นี้จะพิมพ์1ในหลาม3 , 2ใน Vim, 3ใน Minkolang, 4ใน <> <, 5ใน Python 2 , 6ใน SMBF, 7ใน Japt R, 8ใน Retina, 9ใน Perl, 10ใน Befunge, 11ใน Befunge- 98 , 12ในฟิชชัน, 13ใน Ruby, 14ในเต่า, และ15ใน Haystack

ลองออนไลน์!

คำอธิบาย

#v                           go down
 v
 >                           go right
  3N.                        does nothing important
     15o|                    outputs 15 and ends program
                             there is an <ESC> after 'o' since 'o' in Vim enters insert mode
         1                   I added this to satisfy Retina

9. Perl, 84 ไบต์

#v;7||"<+0+0+0+<;n4
#>3N.
#|\w*
#8
#|

#M`
print(None and 9or 1/2and 1or 5)
#j␛d5ki2

มีตัวอักษร ESC ตามตัวอักษรในรหัสจริงระหว่างjและd; มันถูกแทนที่ด้วย␛ที่นี่เพื่อการมองเห็น

สิ่งนี้พิมพ์1ใน Python 3 , 2ใน Vim (ทดสอบเฉพาะที่, แต่นี่คือลิงค์สำหรับภาษา V ที่คล้ายกันมาก), 3ใน Minkolang , 4ใน <> < , < 5 , ใน Python 2 , 6ใน SMBF , 7ใน Japt , 8ในจอประสาทตาและ9ใน Perl

มารับภาษา exoteric เพิ่มเติมด้วยการใช้เลขคณิตที่ผิดซึ่งทำงานแตกต่างกันไปในภาษาต่างๆ ( Noneเป็นเท็จใน Python แต่ความจริงใน Perl และand/ orchains ทำงานในลักษณะเดียวกันทั้งสองภาษา)

นอกเหนือจาก Python ฉันต้องเปลี่ยนรหัส vim ด้วย แทนที่จะทำให้เป็นแบบไม่มี ops ฉันแค่ปล่อยให้มันใส่ขยะแล้วลบขยะอีกครั้งในตอนท้าย

36. เขาวงกต 647 ไบต์

#v`16/"<"6/b.q@"(: ::Q):  ␉␉␉␉ :(22)S#;n4"14"
#>3N36!@@15o|>␉^?.*ttt*~++~~~%
#= >␉1#v#v0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#[␉
#`<`|
print((eval(" 1\x2f2")and(9)or(13))-(0and 4)^1<<(65)>>(62))or' (\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
""""#//
=begin␉//
$'main'//
#-3o4o#␉
=end   #//
"""#"#//
#0]#echo 21#/ (\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE) a
#   +/Jn~
#0␛dggi2␛`␉|1|6$//''25  >>>#>27.say# =#print(17)#$nd^_^_.]Q2229991#;abcd!fghij/+23!@"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ลองออนไลน์!

rundown

โปรแกรมนี้พิมพ์ 36 ใน Labyrinth, 35 ใน INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl, 31 ใน Modular SNUSP, 30 ใน Whitespace, 29 ใน Whitespace, 29 in Trigger, 28 in Brain-Flak, 27 ใน Perl 6, 26 in 05AB1E , 25 ใน Pip, 24 ใน Thutu, 23 ใน Hexagony, 22 ใน Underload, 21 ใน Nim, 20 ใน Prelude, 19 ใน Reng, 18 ใน Rinal, 18 ใน Cardinal, 17 ใน Julia, 16 ใน Pyth, 15 ใน Haystack, 14 ในTurtlèd, 13 ใน Ruby, 12 ใน Fission, 11 ใน Befunge-98, 10 ใน Befunge-93, 9 ใน Perl 5, 8 ใน Retina, 7 ใน Japtapt, 6 ใน SMAPF, 5 ใน SMBF, 5 ใน Python 2, 4 ใน> <>, 3 ใน Minkolang , 2 ใน V / Vim และ 1 ใน Python 3

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน คุณสามารถทดสอบ Reng ได้ที่นี่และ Modular SNUSP ที่นี่ ; พวกเขาออก 19 และ 31 ตามลำดับ @ ais523 ช่วยแก้ปัญหาและแก้ไขรหัสเหตุการณ์ซึ่งตอนนี้ใช้งานได้

Labyrinth ทำงานอย่างไร

เขาวงกตเริ่มเลื่อนบางคอลัมน์ในแหล่งที่มาเล็กน้อย แต่หลังจากไม่กี่ก้าวตัวชี้จะไปที่ที่Nอยู่บนบรรทัดที่ 2 (เริ่มแรกตามเวลาที่ตัวชี้ไปที่นั่นไม่มีอีกแล้วN) ย้ายไปทางขวา ด้วย 0 ที่ด้านบนสุดของสแต็ก จากนั้นมันเพียงแค่กดและพิมพ์ 36 และยุติด้วย36!@

สิ่งที่ฉันทำ

ฉันรู้ว่าฉันต้องการที่จะเพิ่มเขาวงกตเพราะมันเป็นหนึ่งในไม่กี่ esolangs ที่ฉันรู้เกี่ยวกับ ด้วยการดีบักเกอร์ฉันพบว่าการเปลี่ยน 8 ในบรรทัดสุดท้ายเป็น 0 เขาวงกตไม่ติดอยู่ในวงวนไม่สิ้นสุดและแปลกไม่มีอะไรที่ดูเหมือนจะแตก จากที่นั่นฉันเพิ่งทิ้งไปในคำสั่ง raw 36 และคำสั่งเอาต์พุตที่ฉันต้องการและสิ่งที่นำไปสู่การ@ยุติสิ่งต่างๆ

จากนั้นมันก็จะทำการซ่อมแซมสิ่งที่ฉันทำพัง: มิงโกลังพระคาร์ดินัลและ Hexagony

!ทำ Minko @ข้ามตัวอักษรถัดไปซึ่งมันจะต้องยุติดังนั้นฉันเพิ่งเพิ่มพิเศษ จนถึงตอนนี้ดีมาก

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

Hexagony โชคดีที่การแก้ไขค่อนข้างง่ายฉันเพิ่งโยนสตริงตัวอักษรเพื่อให้ตัวชี้พบรหัส ฉันคิดว่าตัวอักษรไม่ควรปรากฏมาก่อนและจะไม่ทำให้เกิดปัญหากับเหตุการณ์ นี่คือเมื่อฉันรู้ว่าฉันไม่ได้ทดสอบเหตุการณ์ ขอบคุณ @ ai523 ฉันรู้แล้วว่าฉันต้องการเครื่องหมายอัศเจรีย์พิเศษดังนั้นeในสตริงตัวอักษรจึงเปลี่ยนเป็น!ในสตริงตัวอักษรที่ถูกเปลี่ยนไปเป็น

คะแนนจากเครื่องพิมพ์จำนวนเต็มอเนกประสงค์

เพียงเพื่อเริ่มต้นและเลิกความเห็น @Stewie Griffin ในคำถามนี่เป็นตัวอย่างที่แสดงให้เห็นว่าแต่ละคำตอบจะได้คะแนนถ้าเข้าสู่ "The Verstatile Integer Printer"

// This was stolen/sloppily hacked together from the snippet here: https://codegolf.stackexchange.com/questions/55422/hello-world. Feel free to clean it up if you'd like.
/* Configuration */

var QUESTION_ID = 102370; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

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

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*)[,\(].*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

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

function getScore(langs, bytes) {
  var l = Math.pow(langs,3);
  return bytes/l;
}

function process() {
  var valid = [];
 
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
        score: getScore(match[1].split(".")[0],+match[2]).toFixed(5),
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link, score: a.score};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    return a.lang_raw.split(".")[0] - b.lang_raw.split(".")[0];
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.score)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

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

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<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="language-list">
  <h2>Scores from <a href="https://codegolf.stackexchange.com/questions/65641/the-versatile-integer-printer">The Versatile Integer Printer</a></h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><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>

41. สมอง *** , 916 ไบต์

#  4"16" 3//v\(@#/;\D"14"<;n4
#/*`3 afaaZ">;[77*,68*,@;'1,'1,q)(22)S#   ␉␉␉␉ (
#yy␉;36!@
#`<` ␉
#=␉x
#<]+<[.>-]>[
#␉<
###xR+++++[D>+++++++L+++<-][<<<]>+.---.>][
#px%>~~~+␉+~*ttt*.x
#D>xU/-<+++L)
#R+.----.R␉>]|
#[#yy#yy0l0mx01k1k0l0ix0jx0h0h1d111P0eU0bx0b0o1d0b0e0e00x1d0i0fx0g0n0n11x0o0n0cx0c0o0f0c0gx0g0f0h0j0j0i0001k10mx0m0l11111100(^_)
#|␉
print((eval("1\x2f2")and(9)or(13   ) )-(0and 4)^1<<(65)>>(62))or'(\{(\{})(\{}[()])}\{}\{}\{})'#46(8+9+9+9+9+=!)#1111|=/=1/24=x=9[<$+@+-@@@@=>+<@@@=>+<?#>+.--.]/
__DATA__=1#//
#.\."12"␉*
###; console.log  39
""""#//
=begin␉//
#*/
#define␉z  sizeof 'c'-1?"38":"37"
#include<stdio.h>
int main()  /*/
#()`#`\'*/{puts(z);}/*'``
$'main'␉//
#-3o4o#$$$
<>"3"O.<␉>//
#
=end   #//
"""#"#//
#0]#echo 21#/(\[FAC,1<-#2FAC,1SUB#1<-#52FAC,1SUB#2<-#32FACLEGEREEX,1PLEASEGIVEUPPLEASE)  a>>>
#>27.say# /7Jn~15o|  
#8␛dggi2␛`␉|1|6$//''25  =#print(17) ###^_^_LEintnd"3"z!]/}23!@/*///Z222999"26

␉เป็นแท็บ␛ตัวอักษรตัวอักษร ESC ตัวอักษร; การแลกเปลี่ยนแบบสแต็กจะทำให้โปรแกรมหยุดทำงาน ฉันขอแนะนำให้คัดลอกโปรแกรมจากช่อง "อินพุต" ของลิงก์ TIO ด้านล่างหากคุณต้องการใช้งาน

ลองออนไลน์!

คะแนน VIP (เครื่องพิมพ์อเนกประสงค์จำนวนเต็ม): 0.01329

rundown

โปรแกรมนี้พิมพ์41ใน brainf ***, 40ใน Minimal-2D, 39ใน CoffeeScript, 38ใน C, 37ใน C ++, 36ใน Labyrinth, 35ใน INTERCAL, 34ในรถไฟ, 33ในเหตุการณ์, 32ใน Whirl, 31ใน Modular SNUSP, 30ใน Whitespace, 29ใน Trigger, 28ใน Brain-Flak, 27ใน Perl 6, 26ใน 05AB1E, 25 in Pip, 24 in Thutu, 23ใน Hexagony, 22 in Underload,21ใน Nim, 20ใน Python 3ใน Prelude, 19ใน Reng, 18ใน Cardinal, 17 in Julia, 16ใน Pyth, 15ใน Haystack, 14ในTurtlèd, 13ใน Ruby, 12ในRuby, 12ใน Fission, 11ใน Befunge-98, 10ใน Befunge-93, 9ใน Perl 5, 8ใน Retina, 7ใน Japtap, 6ใน SMBF, 5ใน Python 2, 4ใน> <>, 3ใน Minkolang, 2ใน V / Vim, และ1

การตรวจสอบ

ภาษาส่วนใหญ่ผ่านการทดสอบโดยไดรเวอร์ทดสอบที่แสดงด้านบน คุณสามารถทดสอบ Reng ได้ที่นี่และ Modular SNUSP ที่นี่ ; พวกมันออก 19 และ 31 ตามลำดับตามต้องการ

ทดสอบไดร์เวอร์ได้รับการปรับปรุงเพื่อรวม Tokenizer ในที่สุด รหัส C ทั้งหมดถูกเก็บไว้เป็นอาร์กิวเมนต์จากมุมมองของ Bash Script ฉันยังเปลี่ยนเอาต์พุตเป็นห่อในแนวนอนด้วยช่องว่างต่อท้ายหลังจากแต่ละโทเค็นแทนที่จะแสดงผลในแนวตั้ง นี่เป็นเพียงการตั้งค่าของฉันเพื่อให้ตรงกับผลลัพธ์ของช่องว่าง แต่ใคร ๆ ก็สามารถเปลี่ยนได้ถ้าพวกเขารู้สึกว่ามันสับสนเกินไป

ฉันยังทำการปรับ Test Driver เพื่อจัดการช่องว่างระหว่างคอลัมน์สำหรับ UFT8 ของTurtlèdในบทสรุป การเยื้องศูนย์นั้นทำให้ฉันรู้สึกแย่! “ แก้ไข” นั้นค่อนข้างแฮ็ค - ไอเนื่องจากมันแค่มองหาèและเปลี่ยนความกว้างของคอลัมน์สำหรับกรณีนั้น แต่มันก็ทำให้งานเสร็จ

คำอธิบาย

ก่อนอื่นฉันอยากจะบอกว่า SnoringFrog ยอดเยี่ยมของ Integrator Printer Integer Printer Score รหัสย่อของ Rundown จากโพสต์ล่าสุดเป็นอย่างไร ฉันคำนวณคำตอบก่อนที่จะโพสต์ซักพักและสิ่งนี้ได้แรงบันดาลใจให้ฉันทำให้มันเล็ก ฉันคิดว่าเราสามารถเอาชนะคำตอบของ @ sp3000 ได้ในที่สุด

ดังนั้นฉันจึงเริ่มทำงานกับคำตอบนี้โดยพยายามตีสิ่งที่ทำได้และฉันก็ประสบความสำเร็จ ฉันยังมีคำตอบในภาษาอื่นที่มีจำนวนไบต์น้อยกว่า # 40 แต่ในขณะที่ฉันพยายามเล่น Minimal-2D ฉันต้องเรียนรู้ BF ดังนั้นฉันจึงสามารถทำงานกับอนุพันธ์ของมันได้ดีขึ้นและในกระบวนการฉันพบว่า @ Primo ทำลายสถิติHello, World! . ฉันตกหลุมรักความสง่างาม

Minimal-2D มันกลับกลายเป็นว่ามันไม่ได้มีประสิทธิภาพเพียงพอที่จะใช้เทคนิคการกำหนดค่าเริ่มต้นของเทปที่ @Primo แต่ตอนนี้ฉันเห็นว่ามันน่าจะเป็นไบต์ที่หนักเกินไป เราพยายามพิมพ์จำนวนเต็มเท่านั้น แต่ @Primo ส่งฉันมาตามทางเพื่อเรียนรู้วิธีการคูณใน BF ซึ่งฉันนำมาสู่โค้ดของ Minimal-2D

หลังจากทั้งหมดนี้ฉันได้อ่านความคิดเห็นของ @ SnoringFrog อีกครั้งเกี่ยวกับวิธีรวม BF และตระหนักว่าไม่เพียง แต่ฉันสามารถทำได้ แต่ฉันสามารถใช้รหัส Minimal-2D จำนวนมากที่ฉันตีกอล์ฟลงในคำตอบ BF ดังนั้นฉันจึงขุดเพื่อตอบกับ BF และที่นี่เรา

อีกอย่างหนึ่งก่อนที่ฉันจะลงรายละเอียด มีการเปลี่ยนแปลงบางอย่างที่ฉันทำด้วยเหตุผลที่ไม่ใช่กอล์ฟ ก่อนอื่นฉันย้ายส่วนของรหัส @SnoringFrog ที่เพิ่มไปด้านล่างภาษา 2D ในหลายแถวบนสุด สำหรับฉันมันเป็นการเคลื่อนไหวเชิงกลยุทธ์ระยะยาวเพื่อป้องกันไม่ให้ 2D-traversing ศูนย์กลางของคนพูดได้หลายภาษาเพื่อป้องกันข้อบกพร่องในอนาคตหากเป็นไปได้ จำนวนไบต์ต่ำสำหรับการย้ายครั้งนี้ดังนั้นฉันจึงไปต่อ

ประการที่สองในช่วงปัจจัยต่าง ๆ ฉันได้เรียนรู้ว่า Begunges และ Minkolang ให้พื้นที่ต่อท้ายหลังจากเอาท์พุทตัวเลขและนี่เป็นสาเหตุของไบต์ว่างที่เราเห็นใน Test Driver สำหรับภาษาเหล่านี้ ฉันแก้ไขสิ่งเหล่านี้ด้วยการส่งค่าสแต็กเป็นรหัส ascii (ซึ่งไม่รวมคุณลักษณะการลากต่อท้ายพื้นที่) แทนค่าโดยตรง มีการตีไบต์ขนาดเล็กสำหรับการเปลี่ยนแปลงนี้เช่นกัน แต่ตอนนี้ผลลัพธ์ของโปรแกรมควบคุมการทดสอบมีความเหมือนกันมาก ฉันจะทำไม่ได้?

เอสเอ็ม / BF

เรามาดูพื้นฐานเบื้องต้นกันอย่างรวดเร็ว เหล่านี้เป็นคำสั่งที่ใช้ได้สำหรับ SMBF และ BF เท่านั้น:

>   Move the pointer to the right
<   Move the pointer to the left
+   Increment the memory cell under the pointer
-   Decrement the memory cell under the pointer
.   Output the character signified by the cell at the pointer
,   Input a character and store it in the cell at the pointer
[   Jump past the matching ] if the cell under the pointer is 0
]   Jump back to the matching [ if the cell under the pointer is nonzero

ทั้งสองภาษามีเทปหน่วยความจำที่เก็บค่าและเปลี่ยนแปลง ความแตกต่างเพียงอย่างเดียวของ SMBF คือรหัสอะไรก็ตามที่ถูกเรียกใช้จะถูกเก็บไว้ในเทปหน่วยความจำทางด้านซ้ายของจุดเริ่มต้น ตามที่ @SnoringFrog ชี้ให้เห็นว่าได้รับ SMBF และ BF เพื่อสร้างผลลัพธ์ที่แตกต่างกันในการย้ายตัวชี้หน่วยความจำไปทางซ้ายของแหล่งกำเนิด ในล่าม BF ของ Tio ตัวชี้หน่วยความจำสามารถเคลื่อนที่ไปทางซ้ายของต้นกำเนิดและจะพบ 0 แทนรหัส ascii ของ Polyglot ที่ SMBF เห็น นี่คือตัวอย่างที่สามารถเรียกใช้ทั้งใน SMBF และ BF เพื่อเป็นตัวอย่างความแตกต่าง

ในช่วงเริ่มต้นของการพูดได้หลายภาษาที่ที่ Befunges ต้อง>ในแถวที่สองที่จะทำงานให้แล้วเสร็จและ Perl6 ต้องการให้ทุกคนนำหน้าด้วย> <ดังนั้น SM / BF เริ่มต้นด้วย<>การออกจากตัวชี้หน่วยความจำที่จุดเริ่มต้นจากนั้นกด[ตัวอักษรที่กระโดดข้ามอักขระที่ไม่เหมาะสมสำหรับทั้งสองภาษาไปยัง]แถวที่ 6

+<ต่อไปเราจะเพิ่มเซลล์หน่วยความจำแหล่งที่มาสำหรับทั้งภาษาและย้ายตัวชี้หน่วยความจำไปทางซ้ายด้วย (สำหรับการประชุมเชิงสนทนาเราจะเรียกเซลล์หน่วยความจำกำเนิดเป็นเซลล์ 0 เซลล์ทางด้านขวาของจุดกำเนิด 1, 2, ... และเซลล์ทางซ้าย -1, -2, …) Cell -1 มีรหัส asci ของอักขระตัวสุดท้ายใน polyglot ใน SMBF และ 0 ใน BF ดังนั้นเมื่อ[พบถัดไปBF จะข้ามไปยังถัดไป]ในขณะที่ SMBF ส่งผ่านเข้าไปในรหัส

ในฐานะที่เป็น SMBF ลัดเลาะ[.>-]มันพิมพ์ 6 พบในตอนท้ายของพูดได้หลายภาษาและจากนั้นย้ายตัวชี้หน่วยความจำกลับไปยังเซลล์ 0, ]การตั้งค่าของมันกลับไปที่ศูนย์เพื่อออกจาก ในการตรวจสอบเทปที่ไพนต์นี้คือ: เซลล์เชิงลบของ SMBF ถือ polyglot และเป็น 0 และเซลล์บวกถือศูนย์ เซลล์ลบและเซลล์บวกของ BF เก็บศูนย์ในขณะที่เซลล์กำเนิดถือ 1

ถัดไป>ย้าย SMBF ไปที่เซลล์ 1 และ BF กลับไปที่เซลล์ 0 อนุญาตให้ BF ใส่รหัสบล็อกส่วนตัว: [<+++++[>++++++++++<-][<<<]>+.---.>](ฉันได้ลบอักขระที่ไม่ใช่ BF ออกจากเรื่องนี้) ที่นี่เราย้ายกลับไปที่เซลล์ -1 และเริ่มต้นตัวแปรควบคุมการวนลูปของเรา (เซลล์ -1) เป็นค่า 5 จากนั้นเราป้อนลูปที่เราเพิ่ม 10 ลงในเซลล์ 0 และเซลล์ลดลง -1 ห้าครั้งก่อนออกจากลูปที่ เราจะชี้ไปที่เซลล์ -1 ด้วยค่า 0

ต่อไปเราพบ[<<<]ในขณะที่ชี้ไปที่ศูนย์ดังนั้น BF ไม่ผ่านสิ่งนี้ จุดประสงค์ในที่นี้คือการสร้างความสมดุลให้กับจำนวน>ก่อนหน้า<ดังนั้น Perl6 จึงไม่ผิดพลาด

ณ จุดนี้เซลล์ 0 มีค่าเท่ากับ 51 ค่า ascii ของ 4 คือ 52 ดังนั้นเราจึงย้ายตัวชี้ไปยังเซลล์ 0 เพิ่ม 1 แล้วพิมพ์ค่า และในที่สุดเราพร่องเซลล์ 0 กลับไปที่ตัวอักษร ASCII 1 และพิมพ์อีกครั้งก่อนที่จะตั้งตัวชี้หน่วยความจำไปยังโทรศัพท์มือ 1 (ราคา 0) ]เพื่อออกจากที่ผ่านมา

SMBF และ BF ทั้งคู่เข้าสู่[บรรทัดสุดท้าย8 ต่อไปในขณะที่ทั้งคู่วางอยู่บนค่า 0 ดังนั้นทั้งคู่กระโดดข้ามรหัส Minimal-2D ที่เหลือจนกระทั่ง]พบในบรรทัดที่ 11 แต่นี่เป็นช่วงเวลาสั้น ๆ เพราะบรรทัดที่ 12 เริ่มต้นด้วยอีก[ภาษาหนึ่งซึ่งจะนำทั้งสองภาษาไปเกือบสิ้นสุดของกลุ่มคนที่ไม่พบคำแนะนำเพิ่มเติม

Refactors

Minimal-2D

การเขียนใหม่ของ Minimal-2D นั้นส่วนใหญ่จะช่วยประหยัดไบต์ในรูปแบบที่คล้ายคลึงกับเทคนิคการคูณของ BF Minimal-2D แต่ไม่มี[และ]ตัวอักษรสำหรับการควบคุมวง แต่มันมีคำสั่งเหล่านี้:

/   Skips next instruction if the data pointer is set to 0.
U   Tells the program to switch to the up direction of processing instructions.
D   Tells the program to switch to the down direction of processing instructions.
L   Tells the program to switch to the left direction of processing instructions.
R   Tells the program to switch to the right direction of processing instructions.

สิ่งเหล่านี้สามารถนำมาใช้ในการผลิตโครงสร้างตรรกะเดียวกันแม้จะอยู่ในคฤหาสน์ 2D เช่นเดียวกับ BF ตัวอย่างเช่น BF ++++++[>++++++<-]>.นั้นเทียบเท่ากับสิ่งนี้ใน Minimal-2D

นี่เป็นรุ่นที่เรียบง่ายของ Minimal-โค้ด 2 #มิติในหลายภาษาที่มีทั้งหมดรหัสภายนอกลบออกและทุกสถานที่ที่ถือตัวละครแทนที่ด้วย

###################D
###R+++++[D>+++++++L
###>
D>#U/-<+++L)
R+.----.R

Dในบรรทัดที่ 1 ส่งตัวชี้คำสั่งลงไปLในสาย 8 จากหลายภาษาซึ่งจะส่งตัวชี้ไปทางซ้าย ที่นี่เราตั้งค่าตัวแปรควบคุมการวนซ้ำ (เซลล์ 0) เป็น 7 ย้ายตัวชี้หน่วยความจำไปยังเซลล์ 1 และเข้าสู่วง ในลูปเราเพิ่ม 3 ลงในเซลล์ 1 ลดค่าเซลล์ 0 จากนั้นตรวจสอบว่าค่าของเซลล์ 0 เป็นศูนย์หรือไม่ ถ้าไม่เราเพิ่มอีก 8 ในเซลล์ 1 จากนั้นลดค่าและตรวจสอบอีกครั้ง ผลลัพธ์ของลูปนี้คือค่าของเซลล์ 1 ถูกตั้งค่าเป็น 51 ที่ส่วนท้ายของลูป (6 * 8 + 3)

เราออกจากลูปโดยการกระโดดUย้ายตัวชี้หน่วยความจำไปยังเซลล์ 1 และลงไปทางขวาบนบรรทัดที่ 11 ของโพลิกล็อต และสุดท้ายเราเพิ่มขึ้นเป็นค่า ascii สำหรับ 4 จากนั้นลดลงเป็นค่า ascii เป็น 0 ก่อนที่จะวิ่งไปทางขวาเพื่อสิ้นสุดโปรแกรม

จอตา

จอประสาทตามีข้อกำหนดมากมายที่ยากต่อการทำงานกับอนุพันธ์ BF ทั้งหมด มันไม่ชอบติดต่อกัน+'s หรือไม่ตรงกันหรือ() []แต่สิ่งเหล่านี้เป็นเพียงข้อกำหนดสำหรับทุก ๆ บรรทัดดังนั้นงานจำนวนมากสำหรับ BF, SMBF และ Minimal-2D หมุนรอบวางโค้ดจำนวนมากลงบนบรรทัดที่เป็นเลขคู่

ไบต์หนึ่งมุ่งมั่นที่จะ Retina แต่เพียงผู้เดียว|ในตอนท้ายของบรรทัดที่ 11 การอ้าง @ ais523 "regexes ส่วนใหญ่ลงท้ายด้วย | จะจับคู่อะไรก็ได้ " หากไม่มีสิ่งนี้ Retina จะคืนค่า 0 เหตุใดจึงแก้ไขได้ฉันไม่รู้ ฉันไม่จำเป็นต้องขุดจอประสาทตามากเกินไปอาจเป็นเพราะฉันหลีกเลี่ยงสายยาว ๆ แต่เช่นเดียวกับโหมโรงฉันพบว่าฉันไม่จำเป็นต้องเข้าใจมันมากเท่าที่ฉันต้องเข้าใจวิธีการแก้ไขข้อบกพร่องซึ่งในกรณีนี้ส่วนใหญ่ประกอบด้วยการลบบรรทัด (ในทวีคูณของ 2) จนกระทั่งฉันพบบรรทัด นั่นทำให้มันพัง ฉันเดาที่แก้ไขนี้ตามความคิดเห็นของ @ ais523 และได้รับรางวัล ฉันเจ๋งเกินไปสำหรับโรงเรียนฉันเดา

พระราชาคณะ

ฉันชอบที่ @ SnoringFrog ของ Minimal-2D สัมพันธ์กับรหัสของ Cardinal มันเป็นสถานที่ที่ดีเมื่อพิจารณาจาก Cardinal ไม่ทำให้จอประสาทตาไม่พอใจและดูเหมือนว่าจะอนุญาตให้มีการผสมผสานระหว่าง Minimal-2D ดังนั้นเมื่อฉันออกเดินทางไปดินแดน Minimal-2D ถึง 2D ดินแดนฉันก็นำพระคาร์ดินัลไปด้วย แม้ว่าจะมีการเปลี่ยนแปลงบางอย่างเกี่ยวกับเครื่องสำอางของ Cardinal แต่ อย่างแรกฉันโยน>จุดเริ่มต้นของคำสั่ง#p x%>~~~+ +~*ttt*.xสำหรับ Minimal-2D เพื่อเปลี่ยนพอยน์เตอร์ของหน่วยความจำภายในลูป / วินาทีฉันเปลี่ยนทุกตัวละครหนึ่งตัวไปทางขวาเพื่อให้ห้อง Minimal-2D เพื่อออกจากลูปมันอย่างงดงาม การpต่อยนี้มีไว้สำหรับการขยายตัวของอักขระนี้

Befunge / 98

Befunges นั้นจริง ๆ แล้วที่ฉันเริ่มพยายามตีโปกล็อตเนื่องจาก C ++ refactor เปลี่ยนโค๊ด 2D ภาษาอื่นทั้งหมดยกเว้นอันนี้ ในการพยายามที่จะเรียนรู้ WTF เกิดขึ้นในรหัสนี้ฉันพบสิ่งนี้ในเอกสารประกอบการเริ่มต้น:

.คำสั่งจะปรากฏค่าปิดกองและ output เป็นจำนวนเต็มทศนิยมตามด้วยช่องว่างค่อนข้างชอบ Forth ,จะป็อปค่าตีความว่ามันเป็นค่า ASCII ของตัวละครและเอาท์พุทตัวละครนั้น ( ไม่ได้ตามด้วยช่องว่าง )

โฮลี่มูน! เราสามารถล้างค่า null null ในผลลัพธ์ หลังจากนี้มันเป็นเพียงแค่การหาวิธีการป้อนค่า asci ที่มีขนาดใหญ่ขึ้นและการแยกรหัส Befunge-98 มีรหัสกระโดด;บอกให้ข้ามมากกว่า[77*,68*,@ใน;[77*,68*,@;'1,'1,qซึ่งทำให้เราแยกจากกัน

Befunge-98 ยังมีคำสั่ง ( ') เพื่อรับรหัส ascii ของตัวละครต่อไป ดังนั้น'1,ต้องใช้รหัส asci รหัสสำหรับตัวอักษรที่1ทำให้มันในกองแล้วพิมพ์อักขระ ASCII ,สำหรับค่าบนสแต็คที่มี เพียงแค่ทำสองครั้งเพื่อพิมพ์ 11 และปล่อยqเพื่อออกไปอย่างสง่างาม

Befunge เหมาะสมน้อยสะดวก แต่เพียงแค่ ที่นี่เราต้องทำการคำนวณเพื่อวางโค้ดที่ต้องการลงในสแต็ก โชคดีที่รหัสของเราได้อย่างง่ายดายด้วยการคูณ 7 * 7 และ 6 * 8 ,ก่อนที่จะมีคำสั่งเอาท์พุทเดียวกัน จากนั้นเราก็ออกจาก Befunge ด้วย@ก่อนที่โค้ดของพี่ชายจะปนเปื้อนเอาท์พุท

Minkolang

หลังจากพบการแก้ไขสำหรับช่องว่างที่ตามมาของ Befunge ฉันก็รู้สึกเบื่อหน่ายกับแนวคิดในการค้นหาตัวแก้ไข Minkolang ด้วยและเอกสารของ Minkolang กล่าวว่าคำสั่งเอาต์พุตที่ใช้จนหมดในจุดนี้ในลักษณะเดียวกับ Befunge Interpreter Oที่เกิดขึ้นกับได้รับการบันทึกว่าเป็นคำสั่งที่ส่งออกอื่นที่ไม่ได้อธิบายว่าการแบ่งปันนี้ Begunge-Ness ดังนั้นฉันเพียงแค่เอายิงในที่มืดและพยายาม outputting "3"สตริง ชัยชนะที่สมบูรณ์แบบ

> <>

หนึ่งในสิ่งแรกที่ฉันดูเมื่อย้ายรหัส Minimal-2D คือการตรวจสอบว่าฉันสามารถย้าย> <> ไปพร้อมกับมัน ถ้าฉันจะจัดการกับการตัดขวางแบบหลายภาษาแบบ 2 มิติฉันจะจัดการกับการละเมิดทั้งหมด โดยทั่วไปฉันโชคดีไล่ออกจากทางของฉันไปยังทางออกของการวาง;n4 ที่ส่วนท้ายของบรรทัด 1 และย้าย\Dกลับไปที่บรรทัดที่ 1 อีก BTW ฉันไม่ทราบว่า> <> สามารถนำลงก่อนคำตอบ 40 เพราะมันมีอยู่อย่างดี . ฉันต้องการคิดว่าสามารถใช้สิ่งนี้ภายหลังเพื่อแยกแยะ> <> จากภาษาอื่นที่คล้ายคลึงกัน

Perl6

ฉันได้พูดคุยเกี่ยวกับ<>ปัญหาความสมดุลของ Perl6 ที่อื่นในคำตอบนี้ดังนั้นฉันจะไม่ข้ามมันอีก แต่ฉันต้องการชี้ให้เห็นว่าฉันย้าย#>27.say#ไปที่บรรทัดที่สองถึงบรรทัดสุดท้าย คำตอบนี้ไม่มีวัตถุประสงค์ในการใช้งาน จริง ๆ แล้วฉันทำให้การเคลื่อนไหวนี้เพื่อตอบสนองคำตอบที่แตกต่างกันซึ่งฉันลงเอยด้วยการไม่ใช้รอบนี้ ฉันตัดสินใจทิ้งไว้ตั้งแต่ฉันวางแผนที่จะโพสต์คำตอบนั้นในโอกาสต่อไปของฉันและฉันไม่ต้องการรบกวนการเลิกทำและทำซ้ำอีกครั้ง

แก้ไขข้อผิดพลาด

05as1e

05as1e ไม่ชอบ Begunge code ใหม่เท่า ๆ กับเวอร์ชั่นเก่า ฉันคิดว่ามันเป็นเพราะมันเป็น,ตัวละครปฏิวัติเท่านั้น ไม่ว่าในกรณีใดฉันต้องเลื่อน"ไปข้างหลังในบรรทัดที่สองเพื่อซ่อนคำสั่งที่ไม่เหมาะสมและฉันรู้ว่าสิ่งที่"ต้องทำก่อนเส้นทางของรหัส Befunge เนื่องจาก"เป็นทั้งสองภาษา (ผมก็สามารถทำขึ้นคำเช่นขวาใช่-op?) สาย 2 ของ 2 dimentionality แข็งสวย แต่ฉันก็สามารถที่จะแทนที่<ก่อนที่จะมีเส้นทางรหัส Begunge "กับ <แต่เป็นความต้องการของ Perl6 (มันต้องมี<ก่อนหน้านี้ทุก>ตัว) ฉันสามารถดรอป<อินไลน์ที่ตำแหน่งที่กำหนดโดยสัญชาตญาณและความรู้ล่วงหน้าเพื่อแก้ไขความขัดแย้ง 05ab1e และ Perl6

วน

การเปลี่ยนแปลงของ Befunge ในบรรทัดที่ 2 ได้เพิ่มส่วนเสริม1ของรูปหลายเหลี่ยมก่อนหน้าบรรทัดเหตุการณ์ / การหมุนวน สิ่งนี้1ทำให้ Whirl เริ่มที่จะชี้ไปที่คำแนะนำที่ผิดบนพวงมาลัย สิ่งแรก1ในคำสั่งตัวประมวลผลล่วงหน้าของ C / C ++ นั้นเป็นเพียงการอ้างอิงหมายเลขบรรทัดในรหัสและนี่อาจเป็นหมายเลขบรรทัดอื่น ๆ ได้อย่างง่ายดายดังนั้นฉันจึงเปลี่ยนสิ่งนี้เพื่อ4ให้เป็นที่พอใจ

อุบัติการณ์

สตริง detokenizing ที่ส่วนท้ายของ polyglot เป็นที่รู้จักกันดี ณ จุดนี้ดังนั้นฉันจะไม่เข้าไป ฉันลบสิ่งที่ฉันสามารถทำได้และเพิ่มโทเค็นใหม่ที่จำเป็น มี 2 ​​ตัวอักษร detokenizing ที่ไม่ได้อยู่ในสายนี้แม้ว่าฉันควรจะชี้ให้เห็น ประการแรกจำเป็นต้องใช้ที่สองRใน #R+.----.R >]|ที่นี่เพราะมันเป็นจุดเริ่มต้นของฟิวชั่นและมันปลอดภัยกว่าในบรรทัดนี้เพราะมีจุดเริ่มต้นของฟิวชั่นที่มุ่งหน้าไปในทิศทางเดียวกันแล้ว สองxใน#= xคือการลบโทเค็นที่เกี่ยวข้องใน␉␊#รูปแบบซึ่งได้กลายเป็นเรื่องธรรมดามากขึ้น

คนอื่น ๆ

Hexagony ช่องว่างและพรีลูดทั้งหมดมีการปรับเปลี่ยนเล็กน้อยตามปกติ แต่ไม่มีอะไรพิเศษที่ควรพูดถึง

ความคิดสุดท้าย

นั่นคือทั้งหมดที่ฉันมีสำหรับคำตอบนี้ สำหรับผู้ที่มองหาจุดเริ่มต้นในคำตอบต่อไปฉันขอแนะนำความชั่วร้าย ดูเหมือนว่าใช้งานได้แม้ว่าฉันจะไม่ได้ดูอย่างใกล้ชิด แต่ฉันคิดว่ามันจะไม่ยากเกินไปที่จะรวมเข้าด้วยกัน ฉันรู้ว่ามันมีคำสั่งกระโดดที่จะช่วยให้ข้ามกลุ่มคนที่พูดได้หลายคน โชคดี.

183. อิมเมจสำหรับบูตIntel 8080 (ZEMU), 9870 ไบต์

#16  "?63(o+?50;+'51;'  # #@ " /*"r"{\D-v e-'[fa5.q]PkPPX)\( 9 '#CO"14"^ 92                                       7 222222222222222222222222                                                             ##*/
#/*1&7//```"`    [>.>.]       )[-'][(7  >77*,68*,@'_      7 )(22)S    / \iiipsddpsdoh#####(#######??   #### ##  ######     ####         ###### # ####  #######     ####         ###### # ####  #######  a5# \7aa*+42@n; 7 999993 1 7 3 1 8 1 1 55 EEEEEδΘΔΔΔΘΔΘλa k zzzzkf kf k zzzzzd kf k zzzzza kf bfz coding=utf8 p''53'S^'                                                                                                          ! 1>?7ДOq#t#>2/Wr#t#t#q#68#r#t#t#68#q#63#r#t#t#6v#>#</Wr#6}#y/===Wr#7ЯOq#>J7Д/Wr#y<Wr#>5/Wr#t#t#6y#>-=/Wr#6|#>6/Wr122! 1退
#>x#z#111#y#y#y#_#0111118&1& 1111/"78"oo@         xxxxxxxxxxx        /112\     ##### #######   # #    ##### h#115#  o#    ##### ####  ###   #### #  # #####  #    ##### ####  ###   #### #  # #####  #    #
# 36!@`D  e ++++++::@                 L               R.----._      x-----x ########8=,_## ### ###### ######## #### ##### ####### ##### ###    # # #### ### ##### ####### ##### ###    # # #### ### ##### #
#comment -[af] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # ##########  ### ## #####  ## #### ## # #####  ## ##### ####   ##### ## # ##  ## ####  ## ##### ####   ##### ## # ##  ## ####
#~==RtRtRtMbMbMbPSPSPS                                                       # ????!?!??!??!!!!???!?!??!!?!?!!!!!?!!!!?????!????????????????????!                                                           
#[#[]]QhQhQhQrQrQrHnHnHnbqbqbqLzLzLzQtQtQtTcTcTcRQRQRQ                       #
#<<<#++R++  ++++++++++++++++++++++++++++++++++++++++++U+++.._+++++++._       #
############################################################################## 4O6O@
 #-]+-}}[.^x+;;+;;+;;+<>;;+;;+;;+;;;;;;+;;+;;.._]}--<^>++[+++++[>+++++++<-]>._ ++++._+++._^<]+-+<[<<._>>>-]^>[<+++++[>++++++++++<-]>@@+.---@._+>][[
#{  
#=  
#*  
#cs  
#2""/*  
#9999 9 9
#9 999 99 9999 9
#9  
# 9 9999
#`<`(+?+?0l0v01k1kMoOMoOMoOMoOMOOx0l0ix0jor0h0h1d111 0eU0y0yx0moO1d0y0e0e00m1d0i0fx0g0n0n11yxMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOotMOo0moo0n0tx0t0moO0f0t0gOOM0g0f0h0j0j0i000x1k1x0vx0v0l11110000011100^_)\\
[ "`e```.1'.0'.6''i]56pq\{}26q[puts 59][exit]" ,'_\['];#/s\\/;print"24"; exit}}__DATA__/
###x<$+@+-@@@@=>+<@@@=>+<?#d>;?\:-._++._++++._#/<?\>3-++._6+---2._#</++++++++++++++++++++++++++++++++++++++++++++++++._++._++++++.>!\
' wWWWwWWWWwvwWWwWWWwvwWWWwWWWW\WWWWwWWWWwWWWWW/WW\wWWWWWWWWwwwwvwWW/WwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWW ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho ho dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO dO MU ([])  ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)  (<><()>){({}[()])}{  # {((((((\';  a=$(printf \\x00);b=$(echo -n $a|wc -c);case $b[1] in 1*)echo 54;;4*)echo 78;;8*)echo 166;;*1*)echo 50;;*)echo 58;;esac;exit;#)';  print(( eval("1\x2f 2")and(9)or 13<< (65 )>>65or 68)-(0and eval("\"ppp\".bytes.class==Array and(4)or(95==\"ar_\"[2]and 5-96 or-93)"))^1<<(65)>>62) or"'x"or'wWW s'#}#(prin 45)(bye)46(8+9+9+9+9+=!)((("3'3)))"'a'[[@*3*74[?]* *]* * *(<\>]xxxxxxxxxxxxxxxxxxxxxxxx)'#\\
__DATA__=1  
#  
###;{a=1}={a:null};console.log a&&39||180
#  \\
""""  
#  
#  \
=begin  
#p :1*23!/5x%6E0 !|*****[[[828+*+@+*99]]]*****|!
;set print'-';print 89;exit#ss
[mxf]-main=-[165]- ###jxf*#p 173#*
p now 70 dollar off!
p has been selling out worldwide!
#PLACET,2<- #2FAC,2SUB#1<- #52FAC,2SUB#2<- #32FACREADOUT,2PLEASEGIVEUPFACs>>>
seeeemPaeue_ewuuweeee_eeeeeeCisajjapp_ppppxf⠆⠄⡒⡆⡘😆😨😒😨💬95💬👥➡😻😹😸🙀🙀😹😼😿🙀🙀😼😼😸🙀🙀🙀🙀  
👋🔢🌚🌝🌝🌚🌚🌚🌚🌚▲▲▲²²²²▲¡▼¡▲▲¡→  
밠밠따빠빠맣박다맣받다맣희맣희うんたんたんたんたんうんうんうんうんうんたんうんうんうんたんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんたんたんうんうんうんうんたんたんうんたんたんたんうんうんうんたんうんうんたんうんうんたんうんうんたんうんたんうんうんうんたんたんうんたんたんうんたんたんうんたんたんうんたんたんたんうんうん  
😊♈💖  
😇♈♈  
😊♉♈  
😇♈♈  
😇♈♉  
😇♈💜  
😊♉♈  
😊📢♈  
😈♈💜  
😊📢♈  
😇♉💞  
😊📢♉⠀⢃⠛⠋  
#-49,A,-1                              #
#-5,A,-1                               #
#6,A,-1                                #
1     ! !
2   !    !
1      !!
1  x*
53  ++-------+
1  x*|$0011 \|
51  +|/1000 /|
1  x*|\ 0011\|
34  +|/01 00/|
15  +|\ 0011\| R"12"R _* ?   ?@       _     !
1   *|@ 0110/| @  %"18" ?@    ?
1    |      +|            +   *
1   !+-------+---       ?  !  ?
1    !            <``=>  ? @ ?
<  <    <<   <  <
< B=  =====  =>8 =
, 8= > B    = =
=  ==  =    = >   8  =
D B+  +=   D  x   xxx x
` `    =   >  8  = >
 x ~   B  =   =  = = > ~
 B +   =  D+  ~ 8  = >x
x   x  x x      x  xx  x
x   x    x+   xx   x + +  +    +    +    <>
x    x xx     xx                +++   +   e$P+++++*D*+++1++1E!s
x+  +x +x     x + +      +  +
 8=+,  _         +    +   +         +
   +     +                +  +    +
 +             +  +  +      + + +    +
   +    +      +           +
   +    +      +          +    +      +
   +           +            +
   +      +  + +            +
   +       +   +            +
          +    +            +
# +   +                  +
#+     +     ++  +     +     +
#  +      +     +
+#
  *   +
  *+*

#  *************************************************+
# +  +
#          +                                       +
   +    + *
         *****+
# +       +
#   +        +
  * *
   +*****
#        +
 (printout t 164 )
(exit )  
#cepp  
MsgBox (0,"",169     )
#cs  
Yo::=~147
::=  
You can see an x here.<<<<
  
>{-<<<<<  
> 176
>> Output 1
>SET x TO 120. [0]{472454523665721469465830106052219449897}   @,-1,:*b5<>␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␌␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␌␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋␋
>X x. PPQ-}
>x--/2  
> =157;y=146--/2 
>main=print y{-ss s
  
\begin{code}  
{-x   ␉␉␉␉ 
␉
 ␉  



-}
open import IO;main = run(putStr"159" )
\end{code}
ppppppppppppp
out &49 &1
out &56 &1
out &50 &1

Take Northern Line to Tooting Bec
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take Bakerloo Line to Embankment
7 UP
Take Northern Line to Mornington Crescent
7 RIGHT
7 RIGHT
7 TEACH
6 BOND
6 BOND
6 BOND
5 RIGHT
5 LEFT
5 RIGHT
7 BOND
7 TEACH
5 TEACH
6 YELL
5 TEACH
6 YELL
6 YELL
set ! 57,,...,,.,,..,,,,,,..,,,.$^
set ! 51.                         #"60"e.0,1,_ye do{--}gibe16"124"#8+*sizeString tnd xfmain=los*81''cagem x=4721en nd ogola=1ay $0C0 00 3cod/|puts_e
More 91 of this
How much is it
red down one blue up red down one blue up red up one red right two blue up sss
baa baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeeeeet bleeeeeeeeeeeeet bleeeeeeeeeet baaaa bleet bleeeeeeeeeet bleeet bleeeeeeeeeet
wwWWWwWWWWWwWWWWWWWwWWWWWWWWppppp
When this program starts:
There is a scribe called x
x is to write 179

*/
#if 0
.int 2298589328,898451655,12,178790,1018168591,84934449,12597
#endif//*
#1""//*
#include<stdio.h>
#define  x(d) #d
#define u8 "38\0 "//"
char*x="24 10 31 1"
"a c #FFC0FF""B c #0000C0""d c #58007B""e c #0C8302"
"h c #E60001""i c #CAFFFF""j c #280000""k c #CA0000""l c #CA007F""n c #330001 ""q c #E60000"
"o c #FF8000""t c #FF00BC""u c #008080"
"A c #0040C0""E c #808000""F c #00C040""G c #008000 ""R c #800000"
"H c #0000AA""I c #00AA00""J c #55FFFF""K c #AAAAAA"
"r c red""g c green""b c blue""c c cyan""m c magenta""y c #FFFF00""x c black""_ c #FFFFFF"
"HHHahtdegggggggyrggggggc"
"IHHaixuEFbGGbggbryAEGRgc"
"JJHajyurbgbgggggggb____o"
"IJHakmyyyyyyyyyyyyyyyyye"
"I__almyyyyyyyyyyyyyyyyye"
"K__anmyyyyyyyyyyyyyy_y_e"
"HH_aqggyyyyyyyyg____m_Je"
"JH_axxxxxxxxxxxxxxxxxxxx"
"K__aaaam___bbbbbBm_bbBab"
"K__________bbbbb___bbxbb";//"
int f(char*a,char*b ){puts(a?"124":sizeof(0,u8)-5?u8"67":*u8""?"37":x(0'0  "'\"")[9]?"75":'??-'&1? "79":"77");}main(){f(x,x=0);}//<*/
#1""/*/
 
>import Text.Heredoc--WWWWWWWWWWWWWW<<W
>instance Num B where fromInteger _=B 170;negate _=B$x#x
>data B=B{u::Integer};g=[here|here<-"W>W"] --WWWWWWWWWW570rt Unc27<<[w|]
>x=1;y#a=128;x#a=174
>main=print$last$172:[u$[-1]!!0|g<"Z>"] --}
 
 console.log 178;
 
#1""/*/
#if 0
#endif//* --... ...--
/*/
p=sizeof(" (\");print'(''72'')';end!");main(){puts('??-'&1?"101":"92" );return 0;}
#if 0
#endif//* rk:start | print: "69" rk:end
print 61
#}
disp 49
#{
}{}<>        K yya+-        &  g+$
$'main'3x             A=AgRA;       AC
#-3o4o#$$$
#<T>"3"O._</+++++++>/+++<-\>+++.---.\_<!+++++++++++++++++++++++++++++++++++++++++++++++++._++.-.>@
#<<<#>>>  /
reg end="";print(85);reg s#++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-.
=end
;"""#"#xxxxclou"78"<\++++>/<~#class P{function:Main(a:String[])~Nil{83->Print();}}
#endcOmment
#nocOmment outtext("155")
#ce pS9^7^8^MUOUOF @0:8:8      \    @,,1'1'<> @125iRE
#p|o51~nJ;#:p'34'3             \=# print(size([[1] [3]][1,:]   )[1]==2?158+4:17)#>say 27#>>>say 170-3#]#print(47)#]#echo 21#>/#print(171)#s-#print 175#s
#8M`|   <esc>dggi2<esc>//      $}<}}<}>}[<< }<<<<<}<<}<<<<}<<<}}}<}}<}}<}     }<}}<}}<}}}<}}<<<<<<<<<<<}}}<}}<}}<}}<}}<}}<}}}<<<<<<<<<<}+++++++++++++++++++++++++++++++++++++++++++++++++._++.._#]~-<~-<~-<<<~-<COprint("65")#`=>ass^_^_#
#9 "25"   +/pppppppx     eeee*n*n*n*es*s*s*^ee*n*n*n*e*sss*e*n*n*n*ee*s<* 5>1  e*///\)Q222999686#

ลองออนไลน์!

คำอธิบาย

ขอบคุณ Potato44 สำหรับแนวคิดในการเพิ่มรหัสเครื่องมันสนุกมากที่ได้รับคำตอบนี้

ฉันไม่ได้ทำไฟล์ CP / M COM เพราะมัน จำกัด ขนาดของ polyglot ไว้ที่ประมาณ 60KB ซึ่งฉันต้องการหลีกเลี่ยง อิมเมจสำหรับบูตเปิดใช้งานได้ง่ายกว่า COM เนื่องจาก ZEMU โหลดเซกเตอร์สำหรับบู๊ตจากเซกเตอร์ลำดับที่ 6 ตามค่าเริ่มต้น (เซกเตอร์โลจิคัลที่ใช้ 1 ไบต์, 128 ไบต์) ดังนั้นการเริ่มต้นโพลีกลอตจึงไม่จำเป็นต้องดำเนินการ รหัสการบู๊ตจะต้องอยู่ที่ offset 0x280 ((6-1) * 128) ในรูปหลายภาษา

ฉันใช้ตัวจำลองZEMUซึ่งเชื่อมโยงจากหน้านี้ ในการใช้งานหลายภาษาใน ZEMU:

• ดิสก์> A: เลือกไฟล์ polyglot
• ตัวเลือก> ชุดคำสั่ง I8080
• กดปุ่ม Boot

ฟังก์ชันที่พิมพ์หนึ่งอักขระไปยังคอนโซล ( cns$ot) ถูกคัดลอกจาก BIOS22Dv221.ASM จากการกระจาย ZEMU ฉันทำการเปลี่ยนแปลงสองครั้ง: อักขระไม่ถูกปิดบังเป็น 7 บิต ASCII เนื่องจากเราควบคุมพารามิเตอร์และjrz cns$otถูกแทนที่ด้วยjz cns$otเพราะjrz(กระโดดสัมพัทธ์ถ้าเป็นศูนย์) คือคำสั่ง Zilog Z80 ที่ไม่มีอยู่ใน Intel 8080

โปรแกรมเริ่มต้น ( ไวยากรณ์ของ Intel , แอสเซมเบลอร์ที่เชื่อมโยงจากที่นี่ ):

    org 3120h    ; chosen so that cns$ot == 0x3131, easier to generate
                 ; this program will be generated at this offset
                 ; to run it directly specify org 0100h

    mvi c,31h    ; '1'
    call cns$ot
    mvi c,38h    ; '8'
    call cns$ot
    db 38h       ; for answer 188, NOP in I8080
    mvi c,33h    ; '3'
    call cns$ot
    hlt          ; halt processor

;;;;;;;;; copied from BIOS22Dv221.ASM
cno$sp equ 7dh
cno$sb equ 01h
cno$si equ 00h
cno$dp equ 7ch

; print char to console, receives char in c register
cns$ot:
    in cno$sp    ; in status
    xri cno$si   ; adjust polarity
    ani cno$sb   ; mask status bit
    jz cns$ot    ; repeat until ready
    mov a,c      ; get character in a
    out cno$dp   ; out character
    ret

โปรแกรมนี้มีตัวอักษรที่ไม่สามารถใช้งานได้โดยตรงในหลายภาษา ตัวอักษรควบคุม ASCII ส่วนใหญ่ (รหัส <0x20) ไม่ได้รับอนุญาตใน Simula, ตัวอักษรที่ไม่ใช่ ASCII (รหัส> = 0x80) ไม่สามารถปรากฏได้เพียงลำพังเพราะไฟล์นั้นต้องเป็น UTF-8 ที่ถูกต้อง ดังนั้นโปรแกรมดังกล่าวถูกสร้างขึ้นโดยโปรแกรมอื่นที่ถูกต้อง UTF-8

โปรแกรมต่อไปนี้สร้างรหัสที่ต้องการแล้วข้ามไป ld (hl),aไม่สามารถใช้เนื่องจาก Grass ( 'w'==0x77) sub h(0x94) และxor a(0xAF) เป็นไบต์ต่อเนื่อง UTF-8 พวกเขาจะต้องมีการเสริมด้วยไบต์นำ UTF-8 คำสั่งret nc(= 0xD0, ส่งคืนหากไม่ได้พกพา) ถูกใช้เป็นไบต์นำ UTF-8 ที่จะทำให้มันไม่ทำอะไรเลยมันจะนำหน้าด้วยscfคำแนะนำ (set ดำเนินการตั้งค่าสถานะ) หลีกเลี่ยง','(0x2C) และ'.'(0x2E) สำหรับ DOBELA ด้วย org 0100hไม่ได้ใช้คำสั่งเนื่องจากแอสเซมเบลอร์ที่ใช้ไม่เข้าใจ (ตั้งอยู่ใน GUI) โปรแกรมนี้เป็นตำแหน่งที่อิสระต่อไป ฉันชอบความจำของ Zilog มากกว่าฉันจึงใช้มันสำหรับโปรแกรมที่ยาวกว่า

ไวยากรณ์ Zilogผู้ประกอบเชื่อมโยงจากที่นี่ :

  ; generate: 0E 31 CD 31 31 0E 38 CD 31 31 38 0E 33 CD 31 31 76 DB 7D EE 00 E6 01 CA 31 31 79 D3 7C C9

  ld hl,3120h

  ld a,3Fh
  scf       ; set carry flag so that ret nc does nothing
  ret nc    ; utf8 lead byte for next insn
  sub h     ; a -= h; a = 0Eh;  utf8 cont byte (opcode 0x94)
  ld c,a

  ld (hl),c ; 0Eh    ; not using ld (hl),a because it is 'w'
  inc hl

  ld (hl),h ; 31h
  inc hl

  ld a,32h
  cpl       ; a = ~a; a = 0xCD
  ld d,a
  ld (hl),d ; CDh
  inc hl

  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),38h ; 38h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),38h ; 38h
  inc hl

  ld (hl),c ; 0Eh
  inc hl
  ld (hl),33h ; 33h
  inc hl

  ld (hl),d ; CDh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),76h ; 76h
  inc hl

  ld a,23h  ; not using ld a,24h because it has '$' (breaks SNUSP)
  inc a
  cpl       ; a = ~a; a = 0xDB
  ld d,a
  ld (hl),d ; DBh
  inc hl

  ld (hl),7Dh ; 7Dh
  inc hl

  ld a,c    ; a = 0Eh
  cpl       ; a = F1h
  dec a
  dec a
  dec a     ; a = EEh
  ld d,a
  ld (hl),d ; EEh
  inc hl

  scf
  ret nc
  xor a     ; a ^= a; a = 0; utf8 cont byte
  ld c,a
  ld (hl),c ; 00h
  inc hl

  ld a,4Ah
  scf
  ret nc
  sub h     ; a -= h; a = 0x19;  utf8 cont byte
  cpl       ; a = ~a; a = 0xE6
  ld d,a
  ld (hl),d ; E6h
  inc hl

  ld a,c
  inc a
  ld d,a
  ld (hl),d ; 01h
  inc hl

  ld a,35h
  cpl       ; a = 0xCA
  ld d,a
  ld (hl),d ; CAh
  inc hl
  ld (hl),h ; 31h
  inc hl
  ld (hl),h ; 31h
  inc hl

  ld (hl),79h ; 79h
  inc hl

  ld a,2Dh  ; not using ld a,2Ch because it has ','
  dec a
  cpl       ; a = 0xD3
  ld d,a
  ld (hl),d ; D3h
  inc hl

  ld (hl),7Ch ; 7Ch
  inc hl

  ld a,36h
  cpl       ; a = 0xC9
  ld d,a
  ld (hl),d ; C9h

  ld sp,3232h  ; set up stack for generated program

  ld hl,3120h  ; not using ld l,20h because it has '.'
  jp (hl)      ; go to generated program 
               ; confusing mnemonic - actually it is jp hl, ie. PC = HL
               ; opcode 0xE9, utf8 lead byte (0xE9 = 0b11101001), must be followed by 2 cont bytes
  db 80h,80h

โปรแกรมนี้ประกอบเป็น:

! 1>?7ДOq#t#>2/Wr#t#t#q#68#r#t#t#68#q#63#r#t#t#6v#>#</Wr#6}#y/===Wr#7ЯOq#>J7Д/Wr#y<Wr#>5/Wr#t#t#6y#>-=/Wr#6|#>6/Wr122! 1退

จะต้องอยู่ที่ offset 0x280 ในรูปหลายเหลี่ยม (ดูบรรทัดที่ 2) การทดสอบสิ่งที่เป็นนามธรรมในไดรเวอร์การทดสอบตรวจสอบว่า

refactorings

เปลือกหอย

ย้ายกระสุนกลับไปที่บรรทัดที่ยาวที่สุด ฉันชอบเลย์เอาต์นี้มากกว่าเพราะผู้ปกครองไม่ได้ปรับให้สอดคล้องกับภาษาอื่น ๆ ย้าย Moorhenses และ Flaks ก่อนกระสุนดังนั้นพวกมันจะไม่แตกเมื่อกระสุนเปลี่ยนไป บรรทัดที่ยาวที่สุดมีเค้าโครงนี้ในขณะนี้:

Grass  Moorhenses  Flaks  Shells  Rubies/Pythons/Perl5  PicoLisp  Prelude  Klein001

รหัสกระสุนใหม่:

a=$(printf \\x00)
b=$(echo -n $a | wc -c)
case $b[1] in 1*)echo 54;; 4*)echo 78;; 8*)echo 166;; *1*)echo 50;; *)echo 58;; esac
exit

รหัสกระสุนเก่า:

a=$(printf \\x00)
b=${#a}
case "{"$ar[1]"}"${b} in *1)echo 54;; *4)echo $((19629227668178112600/ 118248359446856100));; *1*)echo 50;; *)echo 58;; esac
exit

ความยาวของ$aคำนวณโดย$(echo -n $a | wc -c)ตอนนี้ (จากที่นี่ ) ตอนแรกฉันใช้สิ่งนี้เพื่อกำจัด#แต่ตอนนี้มันถูกใช้เพราะรหัสที่สั้นกว่า #เชลล์สามารถมีได้เนื่องจาก Flaks อยู่ก่อนหน้าเชลล์

Yash (166) ใช้คำสั่ง echo ในตัวซึ่งไม่รองรับตัวเลือกตามค่าเริ่มต้นดังนั้น "-n" และ linefeed จะได้เป็นส่วนหนึ่งของเอาต์พุตซึ่งให้ 4 ไบต์เพิ่มเติม เมื่อไม่ได้ตั้งECHO_STYLEค่าเริ่มต้นเป็นSYSV( -nตัวเลือกไม่ได้รับการยอมรับ)

ลิงก์ TIO นี้ทดสอบโค้ดในเชลล์ทั้งหมด

เพิ่มเติม(((((ก่อนที่หอยจะแก้ไข Underload และ Retina เพิ่มอีกหนึ่งคู่ของ parens เพื่อซ่อน58จาก Prelude (ปิดด้วย#)หลังจากexit) {ก่อนหน้า((((((นั้นสำหรับ Japtor โดยที่ไม่มี Japt hangs

Flaks

เนื่องจากการย้ายรหัสเริ่มต้น Flaks สามารถทำให้ง่ายขึ้น - เหลือเพียง([]):

     line 21      (Grass(([5]{})))    scripting langs                  clear stack     Flaks main code                                                                                      begin skip code      the rest of polyglot   end skip code   print(85)
old: []{}[][][]   ((([]{})))          ((()()<<()>>)((()([])))<<()>>)   {}{}{}{}{}{}{}  ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()
new: []{}[][][]     ([]  )                                                             ({}<(((((()()())){}{})){}{})>)(({})){}{(<(<()>)({})({}<{}>({}){})>){({}[()])}}({}){}({}()<()()()>)   (<><()>){({}[()])}{           ...           }{}<>              ()

ลิงค์ TIO นี้ทดสอบโค้ดใน Flaks ทั้งหมด

ฟิชชัน & พระคาร์ดินัล

ฟิชชั่นถูกย้ายเข้ามา R"12"R _*LNUSP: ตัวชี้ที่สองถูกใช้เพื่อยุติการแยกโดยเร็วที่สุด - ในขั้นตอนที่ 3 ดูคำตอบที่ 54สำหรับข้อมูลเพิ่มเติม

พระคาร์ดินัลถูกย้ายเข้ามา @ %"18"LNUSP: เช่นเดียวกับในฟิชชันตัวชี้ที่สองถูกใช้เพื่อยุติ Cardinal โดยเร็วที่สุด - ในขั้นตอนที่ 3

MarioLANG

ใช้####...แทน====...เป็นแพลตฟอร์ม:

Minimal-2D

พูดได้หลายภาษากับ MarioLANG:

Wierd & 1L_a

Wierd: ใช้พื้นที่ที่บรรทัด 10 คอลัมน์ 79 เพื่อสะท้อน IP
1L_a, Wierd: ช่องว่างที่บรรทัด 9 คอลัมน์ 79 เป็นสิ่งสำคัญ

Cubically

รหัสใหม่: :1*23!/5x%6E0

:1*23!/5x%6E0
! - skip over / in Klein 201
x - destroy Cardinal pointer before it hits /

pure:
:1*23/5%6E0

faceval:
0 0
1 9
2 18
3 27
4 36
5 45

program:
:1   mem = 9
*23  mem *= 18; mem *= 27
/5   mem /= 45
%6   print mem
E0   exit

9*18*27/45 == 97 (integer division)

6 in %6 is used to print mem because 0-5 are used to print faceval (eg. %3 prints 27)
0 in E0 is not an exit code, it is present just to trigger E instruction

ไคลน์ 201/100

รหัสใหม่: !|*****[[[828+*+@+*99]]]*****|!

หลังจากสแต็คการคูณทั้งหมดมีศูนย์เดียวเนื่องจากการ popping จากสแต็กเปล่าให้ศูนย์ ศูนย์นี้จะถูกเพิ่มเข้าไปในหมายเลขหลักที่+อยู่ถัด@จาก ก่อนหน้านี้จะถูกยกเลิกด้วย?โปรดดูที่Klein 001 คำตอบคำตอบ

ประตูทำงานอย่างไรในไคลน์:

วน

รหัสWhirlนั้นเหมือนกันการเปลี่ยนแปลงเพียงอย่างเดียวคือโค้ดหลักจะถือว่าการทำงานปัจจุบันเป็น ops.one (2) ไม่ใช่ ops.load (4)

อย่างมีประสิทธิภาพวนสามารถคิดว่ามี 3 การดำเนินงาน:

• 1 หมุนหนึ่งขั้นตอน
• 0 สลับทิศทางการหมุน
• 00 รันคำสั่งปัจจุบันและสวิตช์วงแหวน

การดำเนินการแบบรวมเพื่อลดความซับซ้อนของการให้เหตุผลเกี่ยวกับโปรแกรม:

• 0000 ถ้า op ปัจจุบันของวงแหวนที่ไม่ได้ใช้งานนั้นเป็น noop ดังนั้นให้เรียกใช้ op ปัจจุบันของ active ring โดยไม่มีผลข้างเคียงใด ๆ
• 11..11 หมุน n ก้าว
• 011..11 สลับทิศทางและหมุน n ก้าว

0000ดำเนินการคำสั่งปัจจุบันของแหวนที่ใช้งาน แต่ยังดำเนินการคำสั่งปัจจุบันของแหวนที่ไม่ได้ใช้งานเป็นผลข้างเคียง หากการเรียนการสอนปัจจุบันของแหวนที่ไม่ได้ใช้งานนั้นไม่เป็นอันตรายเราก็สามารถมุ่งเน้นไปที่การใช้งานวงแหวนที่ใช้งานอยู่โดยไม่คิดว่าจะเกิดอะไรขึ้นกับวงแหวนที่ไม่ทำงาน สิ่งนี้มีประโยชน์อย่างยิ่งกับโปรแกรมนี้เนื่องจากมีการแยกอย่างชัดเจน: อันดับแรกหมายเลข 32 ถูกสร้างขึ้นโดยใช้วงแหวนคณิตศาสตร์เท่านั้นจากนั้นเราสลับไปที่ ops ring และดำเนินการ 2 คำแนะนำที่นั่น (พิมพ์และออก)

ก่อนอื่นฉันต้องการให้การดำเนินการปัจจุบันบน ops ring เป็น noop เมื่อรหัสหลักเริ่มการทำงาน มันมีข้อดี 2 ประการ: 1) รหัส Whirl หลักสามารถเรียกใช้งานแบบสแตนด์อโลนและ 2) เราสามารถลืมแหวน ops เมื่อสร้างหมายเลข 32 ด้วยวงแหวนคณิตศาสตร์ อย่างไรก็ตามมันทำให้รหัสยาวกว่าเดิมดังนั้นแทนที่จะเป็นรหัสหลักถือว่าการทำงานปัจจุบันเป็น ops.one (2) หมายความว่า ops.value ถูกตั้งค่าเป็น 1 เป็นผลข้างเคียงของการดำเนินการทางคณิตศาสตร์ซึ่งจะใช้สำหรับการพิมพ์ โค้ดเก่าบรรลุผลเช่นเดียวกันกับคำสั่ง ops.load แต่การใช้ ops.one แสดงความตั้งใจชัดเจนยิ่งขึ้น - เพื่อตั้งค่า ops.value ที่ไม่ใช่ศูนย์

at this point current ring is ops, dir = clockwise, cur op = ops.one
00    switch to math ring
011   rotate to math.not
0000  math.not (math.val = 1)
01111 rotate to math.store
0000  math.store (mem[0] = 1)
1     rotate to math.add
0000  math.add (math.val = 2)
01    rotate to math.store
0000  math.store (mem[0] = 2)
011   rotate to math.mult
0000  math.mult (math.val = 4)
0000  math.mult (math.val = 8)
0000  math.mult (math.val = 16)
0000  math.mult (math.val = 32)
011   rotate to math.store
00    math.store (mem[0] = 32), switch to ops ring
up to this point the program is the same as before

01111 rotate to ops.intio
0000  ops.intio - print mem[0] as number
0111  rotate to ops.exit
00    ops.exit

รหัสใหม่สั้นลงเนื่องจากรหัสเก่ามีสวิตช์ที่ซ้ำซ้อนสองทิศทางในส่วนที่สองของโปรแกรมไม่ใช่เพราะข้อสมมติฐานใหม่

old: (1111) 00011000001111000010000010000011000000000000000001100 01111110000011100
new: (11)   00011000001111000010000010000011000000000000000001100   011110000011100

วิธีรักษา Whirl ให้ถูกต้องเมื่อทำการเปลี่ยนแปลงบางอย่างก่อนเหตุการณ์ / บรรทัดวน:

• ตรวจสอบให้แน่ใจว่ามีจำนวนแม้แต่0ก่อนรหัสหลักของ Whirl
• ตรวจสอบให้แน่ใจว่าไม่มีสอง0s ติดต่อกัน
• เพิ่ม / ลบพอ1s จนกระทั่ง Whirl ทำงานอีกครั้ง; การเพิ่ม ns 1นั้นเทียบเท่ากับการลบ 12- 1s และในทางกลับกัน

ฉันทำลายกฎข้อแรกโดยไม่รู้ตัวเมื่อเพิ่ม Ropy เมื่อมีจำนวนคี่ของ0รหัสหลักเริ่มดำเนินการด้วยทิศทางที่ไม่ถูกต้องของแหวน ops ซึ่งแบ่งการเรียนการสอนออกจาก ตอนนี้มี0บรรทัดที่ 3 ซึ่งชดเชย0กับบรรทัดที่ 1

คนอื่น ๆ

CoffeeScript : console.log a&&39||180(จากที่นี่ )

INTERCAL : ย้ายไปที่บรรทัด 37
Brainfuck , Agony : ย้ายไปยังอนุพันธ์ brainfuck อื่น ๆ ในบรรทัด 10

xEec : ย้ายไปที่ 1L_a ( h#115# o#)

CSL : ย้ายไปที่บรรทัดที่ 80
Trefunge : ย้ายไปที่บรรทัดที่ 120
Gaot ++ , Stones : วางบนบรรทัดแยก

16. Pyth (159 ไบต์)

#v\;2^0\;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4
#v0#_q@
#>3N.15o|1
#|\w*
#8  ^<1b0 <
#|
#M`
print ((0 and'13')or(None and 9 or 1/2 and 1 or 5))
#"07|5//00;16 "jd5ki2

หมายเหตุ:มีESCไบต์ ( 0x1B) หลังจากoในบรรทัดที่สามและหลังjในบรรทัดสุดท้าย