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

นอกจากนี้ในขณะที่Wikipediaทั้งหมด(รายการ Wikipedia ถูกลบแต่มีสำเนาที่ archive.org ), esolangsและรหัส Rosettaมีรายการ "Hello, World!" โปรแกรมเหล่านี้ไม่สนใจที่จะมีสั้นที่สุดสำหรับแต่ละภาษา (นอกจากนี้ยังมีที่เก็บ GitHub นี้ ) หากเราต้องการเป็นเว็บไซต์ที่สำคัญในชุมชนนักกอล์ฟรหัสฉันคิดว่าเราควรลองและสร้างแคตตาล็อกสุดท้ายของ "Hello, World!" ที่สั้นที่สุด โปรแกรม (คล้ายกับวิธีการท้าทายความท้าทายพื้นฐานของเราประกอบด้วยการทดสอบที่สั้นที่สุดในภาษาต่างๆ) งั้นมาทำสิ่งนี้กันเถอะ!

กฎระเบียบ

• การส่งแต่ละครั้งจะต้องเป็นโปรแกรมเต็มรูปแบบ
• โปรแกรมจะไม่รับอินพุตและพิมพ์Hello, World!ไปที่ STDOUT (สตรีมไบต์ที่แน่นอนนี้รวมถึงการใช้อักษรตัวใหญ่และเครื่องหมายวรรคตอน) รวมถึงการขึ้นบรรทัดใหม่ที่เป็นตัวเลือกและไม่มีอะไรอื่น
• โปรแกรมจะต้องไม่เขียนอะไรไปยัง STDERR

• หากใครต้องการละเมิดสิ่งนี้โดยการสร้างภาษาที่โปรแกรมว่างพิมพ์Hello, World!ออกมาแสดงความยินดีพวกเขาเพียงแค่ปูทางสำหรับคำตอบที่น่าเบื่อมาก

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

• ส่งเป็นคะแนนในไบต์ในการเข้ารหัสที่เหมาะสม (ที่มีอยู่ก่อน) โดยปกติ (แต่ไม่จำเป็น) UTF-8 บางภาษาเช่นโฟลเดอร์เป็นบิตหากินคะแนน - หากมีข้อสงสัยกรุณาสอบถามในMeta
• นี้ไม่ได้เกี่ยวกับการหาภาษาที่สั้นที่สุด "Hello World!" โครงการ นี่คือการค้นหา "Hello, World!" ที่สั้นที่สุด โปรแกรมในทุกภาษา ดังนั้นฉันจะไม่ทำเครื่องหมายคำตอบใด ๆ ว่า "ยอมรับ"
• หากภาษาที่คุณเลือกนั้นแตกต่างจากภาษาอื่น (อาจได้รับความนิยมมากกว่า) ซึ่งมีคำตอบอยู่แล้ว (คิดว่าภาษาเบสิกหรือภาษา SQL, เชลล์ Unix หรือ Brainfuck-Derivative อันเล็ก ๆ น้อย ๆ เช่น Alphuck) พิจารณาเพิ่มคำตอบที่มีอยู่ วิธีแก้ปัญหาที่เหมือนกันหรือคล้ายกันมาก ๆ ก็เป็นภาษาที่สั้นที่สุดเช่นกัน

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

สำหรับแรงบันดาลใจให้ตรวจสอบโลกเก็บสวัสดี

แคตตาล็อก

สแต็คส่วนย่อยที่ด้านล่างของโพสต์นี้สร้างแคตตาล็อกจากคำตอบ a) เป็นรายการคำตอบสั้นที่สุดต่อภาษาและ b) เป็นลีดเดอร์บอร์ดโดยรวม

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

## Language Name, N bytes

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

## Ruby, <s>104</s> <s>101</s> 96 bytes

หากคุณต้องการรวมหลายตัวเลขไว้ในส่วนหัวของคุณ (เช่นเนื่องจากคะแนนของคุณคือผลรวมของไฟล์สองไฟล์หรือคุณต้องการแสดงรายการบทลงโทษการตั้งค่าสถานะของล่ามแยกต่างหาก) ตรวจสอบให้แน่ใจว่าคะแนนจริงเป็นตัวเลขสุดท้ายในส่วนหัว:

## Perl, 43 + 2 (-p flag) = 45 bytes

คุณสามารถทำให้ชื่อภาษาเป็นลิงค์ซึ่งจะปรากฏในตัวอย่างข้อมูล:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://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 "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://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 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,
      });
    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};
  });

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

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 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.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 500px;
  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="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

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

ติดอยู่ 0 ไบต์

ดีไม่สามารถรับสั้นกว่า ... การส่งออกโปรแกรมจะว่างHello, World!ในการติด

PHP, 13 ไบต์

Hello, World!

ใช่. มันได้ผล.

Brainfuck, 78 ไบต์

เงินรางวัลเปิด:ถ้าใครสามารถปรับปรุงคะแนนนี้ฉันจะส่งเงินรางวัล (+500) ให้พวกเขา @KSabพบวิธีแก้ปัญหา 76 72 ไบต์!

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

ลองออนไลน์!

28 ไบต์แรก--<-<<+[+[<+>--->->->-<<<]>]เริ่มต้นเทปด้วยความสัมพันธ์ที่เกิดซ้ำดังต่อไปนี้ (mod 256):

ฉ_n = 171 · (-f _n-1 - ฉ_n-2 - ฉ_n-3 + 1)มีฉ₀ = 57 , F ₁ = 123และF ₂ = 167

ปัจจัยที่ 171 เกิดขึ้นเพราะ3 ^-1 ≡ 171 (สมัย 256) เมื่อค่าปัจจุบันถูกแปลหนึ่งเซลล์กลับ (ผ่าน<+>---) ลบ 3 ในแต่ละครั้งอย่างมีประสิทธิภาพคูณมูลค่า 171

ที่n = 220ค่าที่จะแปลคือศูนย์และการวนซ้ำจะหยุด สิบไบต์ก่อนหน้าจุดหยุดมีดังต่อไปนี้:

[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]

สิ่งนี้มีส่วนประกอบทั้งหมดที่จำเป็นในการผลิตHello, World!ตามล่าและถากถางด้วยการปรับเปลี่ยนเล็กน้อย

ฉันได้พบวิธีแก้ปัญหาอื่น 78 byte:

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

ลองออนไลน์!

ฉันคิดว่าอันนี้ดีกว่าครั้งแรกด้วยเหตุผลหลายประการ: มันใช้เซลล์น้อยกว่าที่เหลืออยู่ที่บ้านมันปรับเปลี่ยนเซลล์โดยรวมน้อยลงและยุติได้เร็วขึ้น

รายละเอียดเพิ่มเติม

ความสัมพันธ์ที่เกิดซ้ำมีตัวแทนสั้น ๆ ที่น่าแปลกใจใน Brainfuck เค้าโครงทั่วไปมีดังต่อไปนี้:

{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]

ซึ่งแสดงถึง:

f _n = c ₁ · f _n-1 + c ₂ · f _n-2 + c ₃ · f _n-3 + ... + k

กับ

f ₀ = s ₁ , f ₁ = s ₂ + c ₁ · f ₀ + k , f ₂ = s ₃ + c ₂ · f ₀ + c ₁ · f ₁ + k , ฯลฯ

นอกจากนี้<+>อาจมีการเปลี่ยนแปลงในการคูณช่วงโดยค่าคงที่โดยไม่มีผลต่อจุดหยุดและอาจเพิ่มคำก่อนที่>{k}จะเปลี่ยนช่วงโดยค่าคงที่อีกครั้งโดยไม่ส่งผลกระทบต่อจุดหยุด

ตัวอย่างอื่น ๆ

ลำดับฟีโบนักชี

+[[<+>->+>+<<]>]

หมายเลข N-gonal

ตัวเลขสามเหลี่ยม

+[[<+>->++>-<<]>+]

กำหนดเป็นฉ_n = 2 ·ฉ_n-1 - ฉ_n-2 + 1กับฉ₀ = 0 , F ₁ = 1

ตัวเลขสแควร์

+[[<+>->++>-<<]>++]

ตัวเลขห้าเหลี่ยม

+[[<+>->++>-<<]>+++]

เป็นต้น

BF ขบเคี้ยว

ฉันได้รับการตีพิมพ์รหัสผมเคยพบบางส่วนของการแก้ปัญหานี้บนGitHub ต้องใช้. NET 4.0 หรือสูงกว่า

Usage: bfcrunch [--options] text [limit]

Arguments
------------------------------------------------------------
  text              The text to produce.
  limit             The maximum BF program length to search for. If zero, the length of the
                    shortest program found so far will be used (-r). Default = 0

Options
------------------------------------------------------------
  -i, --max-init=#  The maximum length of the initialization segment. If excluded, the
                    program will run indefinitely.
  -I, --min-init=#  The minimum length of the initialization segment. Default = 14
  -t, --max-tape=#  The maximum tape size to consider. Programs that utilize more tape than
                    this will be ignored. Default = 1250
  -T, --min-tape=#  The minimum tape size to consider. Programs that utilize less tape than
                    this will be ignored. Default = 1
  -r, --rolling-limit
                    If set, the limit will be adjusted whenever a shorter program is found.
  -?, --help        Display this help text.

เอาต์พุตถูกกำหนดในสามบรรทัด:

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

ตัวอย่างเช่นผลลัพธ์สุดท้ายสำหรับbfcrunch "hello world" 70 -r -i23คือ:

64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0

สิ่งนี้สอดคล้องกับโปรแกรมเต็มรูปแบบ:

++++[[<+>->+++++>+<<]>]<<<<.<+.>++++..+++.<<<.>+++.>>.+++.>.<<-.

บันทึกอื่น ๆ

สวัสดีชาวโลก!

ห่อ, 78 ไบต์ :

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

หรือ

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

ไม่ห่อ, 87 ไบต์ (ก่อนหน้านี้92 ไบต์ (mitchs) ):

--->->->>+>+>>+[++++[>+++[>++++>-->+++<<<-]<-]<+++]>>>.>-->-.>..+>++++>+++.+>-->[>-.<<]

สวัสดีชาวโลก!

ห่อ, 80 ไบต์ :

++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.

ไม่ห่อ, 81 ไบต์ (ก่อนหน้านี้92 ไบต์ (hirose) ):

+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]

สวัสดีชาวโลก!

การตัดคำ74 ไบต์ :

-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.

ไม่ห่อหุ้ม84 ไบต์ :

---->+++>++>->->++[+++++++[>+++++[>++>>+<<<-]<-]++<]>>>>.---.>---..+>->.+>-->+>[-.<]

เวอร์ชั่นEsolangs

สวัสดีชาวโลก! \ n

การห่อ, 76 ไบต์ :

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.[<]>+.

สิ่งนี้ใช้เซลล์เดียวที่เหลืออยู่ที่บ้านดังนั้นจึงถือเป็น 77

ไม่ห่อ, 83 ไบต์ :

->+>>>+>>---[++++++++++[>++++++>+++>+<<<-]-<+]>+>+.>.->--..>->-.>[>.<<]>[+>]<<.>++.

อนุมัติให้ใช้ Rdebathแล้ว profilebf เอาต์พุต:

Hello World!
Program size 83
Final tape contents:
 :   0   0  73 101 109 115 112  88  33  10   0
                                         ^
Tape pointer maximum 10
Hard wrapping would occur for unsigned cells.
Counts:     +: 720          -: 79           >: 221          <: 212
Counts:     [: 9            ]: 84           .: 13           ,: 0
Total:         1338

inversed.ru (ปีเตอร์ Karpov)

สวัสดีชาวโลก!

การตัดคำ70 ไบต์ (ก่อนหน้า 78 ¹ ):

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.

ไม่ห่อ, 77 ไบต์ (ก่อนหน้านี้ 89?):

->+>>>+>>-[++++++[>+++++++++>+++++>+<<<-]<+]>>.>--.->++..>>+.>-[>.<<]>[>]<<+.

ผู้เขียนอ้างว่ารหัสสั้นที่สุด "Hello World!" คือ 89 ไบต์ แต่ไม่มีการอ้างอิง ฉันขอสิทธิบันทึกนี้ด้วยเช่นกัน

สวัสดีชาวโลก!

การตัดคำ65 ไบต์ (ก่อนหน้า 66 ไบต์):

+++[>--[>]----[----<]>---]>>.---.->..>++>-----.<<<<--.+>>>>>-[.<]

นี่คือการเข้ารหัสด้วยมือเช่นกัน (ที่ดีที่สุดที่ฉันสามารถหาได้โดยการกระทืบคือ68 ไบต์ ) เซลล์แรกจะเริ่มต้นได้ถึง 259 (3) และลดลง 7 โดยทำซ้ำแต่ละวน 37 ครั้ง เซลล์ต่อไปคือ decremented 6 ผลใน256-6 · 37 = 34 ส่วนที่เหลือของเซลล์จะลดลง 4 ในแต่ละครั้งเพิ่มหนึ่งเซลล์ในแต่ละการทำซ้ำโดยที่แต่ละเซลล์ใหม่จะแบ่งเป็น 252 (-4) ผลที่ได้คือ:

[  3,   0,   0,   0,   0,   0,   0, ...]
[252, 250, 248,   0,   0,   0,   0, ...]
[245, 244, 244, 248,   0,   0,   0, ...]
[238, 238, 240, 244, 248,   0,   0, ...]
[231, 232, 236, 240, 244, 248,   0, ...]
[224, 226, 232, 236, 240, 244, 248, ...]
...
[ 35,  64, 124, 128, 132, 136, 140, ...]
[ 28,  58, 120, 124, 128, 132, 136, ...]
[ 21,  52, 116, 120, 124, 128, 132, ...]
[ 14,  46, 112, 116, 120, 124, 128, ...]
[  7,  40, 108, 112, 116, 120, 124, ...]
[  0,  34, 104, 108, 112, 116, 120, ...]

¹โซลูชันที่ให้ (79 ไบต์) สามารถลดลงได้เล็กน้อยโดยหนึ่ง:

-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.

ArnoldC , 71 ไบต์

IT'S SHOWTIME TALK TO THE HAND "Hello, World!" YOU HAVE BEEN TERMINATED

เพียงเพื่อ lols ..

เมล็ดพันธุ์ , 6016 4234 4203 ไบต์

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

โปรแกรม Befunge-98 ที่ได้ (ตามนี้ ) คือ

"9!dlroW ,olleH"ck,@

Mornington Crescent , 3614 3568 ไบต์

ขอบคุณ NieDzejkob สำหรับการบันทึก 46 ไบต์โดยใช้ชื่อบรรทัดที่สั้นกว่า

Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Gunnersbury
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Mile End
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Barking
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Wood Lane
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Mile End
Take Central Line to Fairlop
Take Central Line to Mile End
Take District Line to Barking
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Richmond
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Stepney Green
Take District Line to Hammersmith
Take District Line to Stepney Green
Take District Line to Upney
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

ลองออนไลน์!

นี่เป็นสิ่งที่ไม่แน่นอนที่สุด แต่มันมีขนาดเพียงครึ่งเดียวของวิธีแก้ปัญหาบน esolangs

Hello, World สร้างผ่านการแบ่งชื่อสถานีต่อไปนี้และต่อผลลัพธ์:

Hendon Central
▀▀
Holloway Road
  ▀▀▀
Heathrow Terminals 1, 2, 3
                       ▀▀
Wood Lane
▀▀
Fairlop
   ▀▀
Richmond
       ▀

สุดท้ายผมคำนวณรหัสอักขระของเป็น! (2<<4)+1 == 33ชิ้นส่วนเหล่านี้ทั้งหมดจะถูกตัดแบ่งใน Paddington และพิมพ์ใน Mornington Crescent ในที่สุด

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

ความชั่วร้าย 70 ไบต์

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

มันใช้สี่คำสั่งต่อไปนี้:

a - increment the register
u - decrement the register
e - interweave the register's bits (01234567 -> 20416375)
w - write the value of the register as an ASCII character

brainfuck, 72 ไบต์

+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.

ลองออนไลน์!

และโซลูชัน76 ไบต์แบบไม่ห่อเดิม:

+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.

ลองออนไลน์!

วิธีแก้ปัญหาที่รู้จัก (กับความรู้ของฉัน) อื่น ๆ ที่ฉันเคยพบมา

'สวัสดีชาวโลก!' 77 ไบต์:

+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.

ลองออนไลน์!

'สวัสดีชาวโลก!' 70 ไบต์:

+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.

ลองออนไลน์!

พบสิ่งเหล่านี้โดยใช้โปรแกรม c ++ ที่ฉันเขียนที่นี่: https://github.com/ksabry/bfbrute

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

ไม่มีอะไรที่ฉลาดมากเกี่ยวกับโค้ดมันเป็นสัตว์เดรัจฉานที่หลักของมัน แต่มันค่อนข้างดีที่สุด การปรับให้เหมาะสมที่สำคัญคือมันวนซ้ำผ่านโปรแกรมทั้งหมดโดยไม่มีลูป (ไม่[หรือ]) จนถึงความยาวที่ระบุ (16 ในปัจจุบัน) และแคชอาร์เรย์ของการเปลี่ยนแปลงทั้งหมดที่จะทำในอาเรย์ข้อมูล มันจะจัดเก็บโปรแกรมเดียวต่อการเปลี่ยนแปลงที่ไม่ซ้ำกันหลายรายการเท่านั้นตัวอย่างเช่นหนึ่งรายการเท่านั้น>+<<->และ<->>+<จะถูกเก็บไว้ จากนั้นจะทำซ้ำผ่านโปรแกรมที่เป็นไปได้ทั้งหมดซึ่งประกอบด้วยโปรแกรมใด ๆ ในแคชนี้ด้วยการรวมกันของลูประหว่างพวกเขา หลังจากเรียกใช้งานแต่ละโปรแกรมแล้วจะทำการโลภอย่างง่าย ๆ และกัดตัวละครและเพิ่มส่วนท้ายของโปรแกรม

หลังจากทำงานนี้ผ่านพื้นที่ของโปรแกรมทั้งหมดที่ผมสังเกตเห็นว่าเกือบทุกโปรแกรมที่สั้นที่สุด (ถึงยาว ~ 19) *[*[*]*]อยู่ในรูปแบบ การ จำกัด การค้นหาให้กับโปรแกรมในแบบฟอร์มนี้ช่วยเร่งการค้นหาอย่างมาก เจ้าของสถิติปัจจุบันพบที่ความยาว 27 อันนี้จริง ๆ แล้วคำนวณเป็นความยาว 74 แต่ฉันสังเกตเห็นลำดับเฉพาะ.>.>.>.ซึ่งโชคดีพอที่จะมี 0 ในเซลล์ข้อมูลที่ถูกต้องทำให้มันง่ายที่จะ[.>]<นำมันลงมา ถึง 72

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

Piet, 90 codels

นี่คือภาพขนาด 30 คูณ 3 อีกวิธีหนึ่งที่ codel ขนาด 10:

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

แก้ไข: @ การแก้ปัญหา

กองหญ้า , 17 ไบต์

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

ตามค่าเริ่มต้นล่ามจะอ่านจากมุมบนซ้ายไปขวาดังนั้นเราจึงสามารถใส่ "Hello, World!" ลงบนสแต็กใช้oสำหรับพิมพ์แล้ววางเข็มเพื่อดำเนินการให้เสร็จ

"Hello, World!"o|

โบนัส: เวอร์ชั่นที่น่าตื่นเต้นกว่านี้:

v      >;+o|
v      "
v      !
v      d
v      l
v      r
>>"Hello, ">>>v
       W      v
       "      v
       ^<<<<<<<

ช่วยเหลือ WarDoq! 1 ไบต์

H

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

ลองใช้ในล่ามออนไลน์อย่างเป็นทางการ (รหัสไปที่อินพุต )

MarioLANG , 259 249 242 240 235 ไบต์

+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
 !+======================---
=#>++++++++++++++.).+++.-!>!
  =======================#=#

นี้ได้รับการทดสอบในการดำเนินงานทับทิม

หลังจากทำให้งง "สวัสดีโลก!" ใน MarioLANG ฉันมองไปที่การเล่นกอล์ฟสักหน่อย ด้านบนสั้นที่สุดเท่าที่ฉันเคยพบมา

ในฐานะที่เป็นก่อนที่ผมจะเริ่มต้นจากการแก้ปัญหา brainfuck ซึ่งกำหนดสี่เซลล์ไปหลายที่ใกล้ที่สุดของ 10 ตัวอักษรHe,และพื้นที่และเปลี่ยนมัน MarioLANG จากนั้นคุณสามารถย่อรหัสให้สั้นลงได้โดยใช้พื้นเสริมในลูปซึ่งเกือบจะลดความกว้างของลูปลงครึ่งหนึ่ง โปรดทราบว่าด้านล่างจะดำเนินการเพียงครั้งเดียวน้อยกว่าด้านบนดังนั้นคุณจะไม่ได้รับทวีคูณที่แน่นอนของตัวนับเริ่มต้นในทั้ง 4 เซลล์อีกต่อไป

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

นี่น่าจะยังห่างไกลจากความสมบูรณ์แบบ แต่เป็นการปรับปรุงที่ดีกว่าโซลูชันไร้เดียงสาฉันคิดว่า

Metagolf

ถึงเวลาสำหรับระบบอัตโนมัติ ...

ฉันได้เริ่มตั้งค่าตัวแก้ปัญหาใน Mathematica เพื่อหาทางออกที่ดีที่สุด ในขณะนี้สันนิษฐานว่าโครงสร้างของรหัสได้รับการแก้ไขแล้ว: ตัวนับตั้งค่าเป็น 12, 4 เซลล์สำหรับการพิมพ์โดยมีการกำหนดค่าคงที่He,<space>และลำดับเดียวกันของเซลล์เหล่านั้น สิ่งที่แตกต่างกันคือจำนวนของ+s ในลูปรวมถึงการแก้ไขที่จำเป็นในภายหลัง:

n = 12;
Minimize[
 {
  3(*lines*)+
   12(*initialiser base*)+
   Ceiling[(n - 6)/2] 3(*additional initialiser*)+
   8(*loop ends*)+
   18(*cell moves*)+
   26(*printing*)+
   43*2(*steps between letters in one cell*)+
   -2(*edge golf*)+
   4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
     4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
   2 (Abs@c + Abs@f + Abs@i + Abs@l),
  a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
   b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
   n*a + (n - 1) b + c == 72 &&
   n*d + (n - 1) e + f == 101 &&
   n*g + (n - 1) h + i == 44 &&
   n*j + (n - 1) k + l == 32
  },
 {a, b, c, d, e, f, g, h, i, j, k, l},
 Integers
 ]

ปรากฎว่าสำหรับตัวนับเริ่มต้นของ 12 วิธีแก้ปัญหาในแบบฉบับของฉันดีที่สุด อย่างไรก็ตามการใช้ 11 แทนจะบันทึกสองไบต์ ฉันลองค่าตัวนับทั้งหมดจาก 6 ถึง 20 (รวม) ด้วยผลลัพธ์ต่อไปนี้:

6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}

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

มืด , 106 ไบต์

+h hell
h$twist sign s
s$scrawl " Hello, World!
s$read
h$twist stalker o
o$stalk
o$personal
o$echo
h$empty

ฉันจะให้คำพูดจากข้อกำหนดภาษาพูดเพื่อความฉลาดของ esolang นี้:

ความมืดเป็นภาษาที่ใช้การจัดการโลกทั้งโลกและมิติเพื่อบรรลุเป้าหมายและสร้างความเป็นจริงที่ทรมานที่สุด

เมื่อใดก็ตามที่มีข้อผิดพลาดทางไวยากรณ์เกิดขึ้น sanity ของโปรแกรมจะลดลง 1 [... ] หาก sanity ของโปรแกรมถึงศูนย์ล่ามก็จะเสียสติ

ความเสียหายพลิกบิตหนึ่งในตัวแปรเมื่อมันเกิดขึ้น

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

บังคับให้ตัวแปรฆ่าตัวเองโดยปล่อยให้เป็นอิสระ (จำไว้ว่ามันจะปล่อยให้ผุ)

ตั้งค่าตัวแปรเป็นค่าสุ่ม ใช้ Global Chaos Generator

หาก stalker ไม่ได้ถูกเตรียมข้อมูลเบื้องต้นความพยายามใด ๆ ในการทำ IO จะส่งผลให้เกิดข้อความแสดงข้อผิดพลาดที่จะถูกเขียนลงในคอนโซล

พ่อครัวขนาด 465 ไบต์

H.

Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X

Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.

Serves 1.

ทดสอบกับล่ามทับทิม ทำให้ซุปตัวอักษร

ฉันพยายามที่จะเป็นไปตามกับสเปคเดิมเท่าที่จะทำได้ดังนั้นแม้ว่าล่ามที่ผมใช้จะช่วยให้คุณวางthes ในPour contentsการเรียนการสอนฉันไม่ได้ทำเช่นนั้น

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

โฮมสปริง , 58 ไบต์

Universe net hatchery Hello,. World!  powers a b snowmelt 

พื้นที่ต่อท้ายมีความสำคัญ

ให้ฉันเล่าเรื่องให้คุณฟัง ครั้งหนึ่งเคยมีโรงไฟฟ้าที่ใช้ฟักไข่ปลาแซลมอนใกล้เคียง โรงเพาะฟักปลาแซลมอนฟักเป็นปลาแซลมอนที่ไม่มีตัวตนอายุน้อยซึ่งเริ่มต้นการเดินทางเพื่อค้นหาสปริง มันพบว่าฤดูใบไม้ผลิดังกล่าวมีชื่อบทกวี "Hello, World!" ที่มันครบกำหนดและวางไข่ปลาแซลมอนหนุ่มใหม่ ตอนนี้ปลาทั้งสองว่ายลงไปเพื่อค้นหามหาสมุทรกว้าง แต่ปากของแม่น้ำก็มีตาข่ายอยู่ในแม่น้ำ - ปลาที่โตเต็มวัยถูกจับได้และมีเพียงปลาตัวเล็กที่สามารถลอดผ่านและไปถึงมหาสมุทรและส่วนอื่น ๆ ของจักรวาล ในระหว่างนี้โรงเพาะฟักก็มีการเลี้ยงปลาแซลมอนมากขึ้นซึ่งได้เดินทางไปทางต้นน้ำด้วยเช่นกันและวางไข่ไปเรื่อย ๆ

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

อันที่จริงแล้วเป็นความหมายของโปรแกรมข้างต้น การจัดบ้านเป็นเรื่องแปลก

Piet, 84 codels

28x3 ที่นี่แสดงด้วยความกว้างของ codel 10

ที่สร้างขึ้นด้วยPietDevทดสอบกับnpiet โครงร่างของโปรแกรมมีดังต่อไปนี้:

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

เพื่อช่วยในการสร้างสิ่งนี้ฉันได้เขียนล่ามพื้นฐานสำหรับภาษาสแต็กตามด้วยคำสั่ง piet-like ซึ่งฉันได้ขนานนาม "pasm" ( แหล่งที่มา ) เอาต์พุตจากล่ามนี้ (พร้อมอินพุตนี้ ) มีดังต่อไปนี้:

    1 nop     blu1 []
    4 push 3  blu2 [3]
    5 dup     grn2 [3, 3]
    6 add     cyn2 [6]
    7 dup     ylw2 [6, 6]
    8 mul     grn1 [36]
    9 dup     red1 [36, 36]
   10 dup     blu1 [36, 36, 36]
   11 add     mgn1 [36, 72]
H  12 putc    blu0 [36]
   15 push 3  blu1 [36, 3]
   16 sub     mgn2 [33]
   17 dup     cyn2 [33, 33]
   20 push 3  cyn0 [33, 33, 3]
   21 mul     blu2 [33, 99]
   22 push 1  blu0 [33, 99, 1]
   23 add     mgn0 [33, 100]
   24 dup     cyn0 [33, 100, 100]
   25 push 1  cyn1 [33, 100, 100, 1]
   26 add     blu1 [33, 100, 101]
e  27 putc    cyn0 [33, 100]
   28 dup     ylw0 [33, 100, 100]
   32 push 4  ylw1 [33, 100, 100, 4]
   33 dup     mgn1 [33, 100, 100, 4, 4]
   34 add     red1 [33, 100, 100, 8]
   35 add     ylw1 [33, 100, 108]
   36 dup     mgn1 [33, 100, 108, 108]
l  37 putc    blu0 [33, 100, 108]
   38 dup     grn0 [33, 100, 108, 108]
l  39 putc    ylw2 [33, 100, 108]
   40 dup     mgn2 [33, 100, 108, 108]
   43 push 3  mgn0 [33, 100, 108, 108, 3]
   44 add     red0 [33, 100, 108, 111]
   45 dup     blu0 [33, 100, 108, 111, 111]
o  46 putc    cyn2 [33, 100, 108, 111]
   47 dup     ylw2 [33, 100, 108, 111, 111]
   48 dup     mgn2 [33, 100, 108, 111, 111, 111]
   53 push 5  mgn0 [33, 100, 108, 111, 111, 111, 5]
   54 div     ylw0 [33, 100, 108, 111, 111, 22]
   55 dup     mgn0 [33, 100, 108, 111, 111, 22, 22]
   56 add     red0 [33, 100, 108, 111, 111, 44]
   57 dup     blu0 [33, 100, 108, 111, 111, 44, 44]
,  58 putc    cyn2 [33, 100, 108, 111, 111, 44]
   59 dup     ylw2 [33, 100, 108, 111, 111, 44, 44]
   60 add     grn2 [33, 100, 108, 111, 111, 88]
   64 push 4  grn0 [33, 100, 108, 111, 111, 88, 4]
   65 dup     red0 [33, 100, 108, 111, 111, 88, 4, 4]
   66 mul     ylw2 [33, 100, 108, 111, 111, 88, 16]
   67 dup     mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
   68 add     red2 [33, 100, 108, 111, 111, 88, 32]
   69 putc    mgn1 [33, 100, 108, 111, 111, 88]
   70 push 1  mgn2 [33, 100, 108, 111, 111, 88, 1]
   71 sub     red0 [33, 100, 108, 111, 111, 87]
W  72 putc    mgn2 [33, 100, 108, 111, 111]
o  73 putc    blu1 [33, 100, 108, 111]
   76 push 3  blu2 [33, 100, 108, 111, 3]
   77 add     mgn2 [33, 100, 108, 114]
r  78 putc    blu1 [33, 100, 108]
l  79 putc    cyn0 [33, 100]
d  80 putc    grn2 [33]
!  81 putc    ylw1 []

ไม่มีการใช้คำสั่งตัวชี้สวิตช์หรือม้วนคำสั่ง ไม่มีการสูญเสียโคเดรด ในความเป็นจริงทั้งสองถูกนำมาใช้ซ้ำ

ช่องว่าง , 192 150 146 ไบต์

ช่องว่างต้องการเพียงช่องว่างแท็บและรายการป้อนบรรทัดขณะที่อักขระอื่น ๆ จะถูกละเว้น
ซึ่งอาจมีปัญหาในการแสดงที่นี่
ดังนั้นในโค้ดด้านล่างช่องว่าง & แท็บจึงถูกแทนที่
และ ';' ถูกวางไว้ด้านหน้า linefeeds เพื่อความชัดเจน
หากต้องการเรียกใช้รหัสให้แทนที่ก่อน และ> ตามช่องว่างและแท็บ

...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;

Hexdump ของรหัส

00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a

รหัสชุดประกอบช่องว่าง:

push 0      ;null
push -74    ;! chr(33)
push -7     ;d chr(100)
push 1      ;l chr(108)
push 7      ;r chr(114)
push 4      ;o chr(111)
push -20    ;W chr(87)
push -75    ;  chr(32)
push -63    ;, chr(44)
push 4      ;o
push 1      ;l
dup         ;l
push -6     ;e chr(101)
push -35    ;H chr(72)
p:
 dup jumpz e
 push 107 add printc
 jump p
e:
 exit

หมายเหตุ:

ฉันต้องเขียนโปรแกรมเพื่อคำนวณว่าการเพิ่ม 107 ให้สนามกอล์ฟที่ดีที่สุดสำหรับประโยค ตั้งแต่ไบต์ที่จำนวนเต็มใช้ในการเปลี่ยนแปลงรหัส : 4 + int (เอบีเอส (log2 ($ n)))
รหัสจะยังคงทำงานได้โดยไม่ต้อง "อี" ฉลากและออกจากส่วนที่เกี่ยวกับwhitespace.kauaveel.ee แต่นั่นอาจทำให้โค้ดช่องว่างไม่ถูกต้องบนคอมไพเลอร์ช่องว่างอื่น ๆ ดังนั้นไบต์เหล่านั้นจึงไม่ได้ถูกดึงออกจากสารละลาย

ควรสังเกตว่า

ดังที่ Kevin Cruijssen ชี้ให้เห็นในความคิดเห็นโดยอนุญาตให้ "exit by error" ตาม meta, Whitespace สามารถ golfcoded มากกว่า126ตัวอักษร

..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;

สภา:

push -74
push -7
push 1
push 7
push 4
push -20
push -75
push -63
push 4
push 1
dup
push -6
push -35
label_0:
push 107
add 
printc
jmp label_0

Java, 79

class H{public static void main(String[]a){System.out.print("Hello, World!");}}

Java เวอร์ชันก่อนหน้านี้อาจอนุญาตให้คุณใช้บล็อกแบบคงที่ (51 ไบต์) แต่ขณะนี้ฉันไม่ทราบวิธีหลีกเลี่ยงmainวิธีการ

CSS, 30 ไบต์

:after{content:"Hello, World!"

Cascading Style Sheets (CSS) ไม่ใช่ภาษาโปรแกรมทั่วไป แต่สามารถแก้ไขเอาต์พุตได้ค่อนข้างดี นี้จะกระทำโดยการสร้างองค์ประกอบหลอกHello, World!หลังจากองค์ประกอบที่มีเนื้อหาทุก ดังนั้นจึงเลือกเพียงองค์ประกอบเดียวเท่านั้น ( <html>) องค์ประกอบนี้จะถือว่าเราใช้เอกสาร HTML พื้นฐานที่สุดนั่นคือ

<html><style>:after{content:"Hello, World!"</style></html>

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

* :after{content:"Hello, World!"

HTML, 13 ไบต์

Hello, World!

ข้อความจะถูกแทรกโดยอัตโนมัติใน<body>และจะปรากฏขึ้น

รหัสเครื่อง x86_64 สำหรับ Linux, 32 ไบต์

เมื่อ Linux เริ่มกระบวนการใหม่การลงทะเบียนทั้งหมด (ยกเว้น RSP) เป็นศูนย์ดังนั้นเราสามารถรับ RAX = 1 โดยการปรับเปลี่ยนไบต์ต่ำเท่านั้น x86-64 System V ABI ไม่รับประกันสิ่งนี้ แต่เป็นสิ่งที่ Linux ทำ รหัสนี้ใช้งานได้เหมือนกับ_startในการปฏิบัติการแบบสแตติก

0000000000000000 <_start>:
   0:   e8 0d 00 00 00          call   12 <hello>
   5:   48 65 6c 6c 6f
   a:   2c 20 57 6f 72
   f:   6c 64 21 5e 40

0000000000000012 <hello>:
  12:   5e                      pop    rsi
  13:   40 b7 01                mov    dil,0x1
  16:   b2 0d                   mov    dl,0xd
  18:   b0 01                   mov    al,0x1
  1a:   0f 05                   syscall
  1c:   b0 3c                   mov    al,0x3c
  1e:   0f 05                   syscall

คำสั่งการโทรจะพุชแอดเดรสถัดไปซึ่งมีสตริง Hello world ไว้บนสแต็ก rsiเราปรากฏอยู่ของสตริงเข้าสู่

แล้วข้อโต้แย้งอื่น ๆ ที่มีการตั้งค่าสำหรับsyscallการsys_writeซึ่งพิมพ์สตริง

โปรแกรมสิ้นสุดลงด้วยการ syscall ส่งคืนจำนวนไบต์ที่เขียนดังนั้นไบต์บนของ RAX จะเป็นศูนย์หลังจากแรก(ยกเว้นกรณีที่ส่งคืนข้อผิดพลาด) ดังนั้นให้ RAX = ใน 2 ไบต์เท่านั้นsys_exitsys_writesyscallmov al, 60__NR_exit

คุณสามารถทำให้โปรแกรม segfault นี้โดยการปิด stdout ( ./a.out >&-) ดังนั้นsys_write()จะกลับมา-EBADFที่สองsyscallจะกลับมา-ENOSYSแล้วการดำเนินการจะล้มลงในตอนท้าย แต่เราไม่จำเป็นต้องจัดการกับwrite()ข้อผิดพลาดอย่างสง่างาม

Hexagony , 37 32 ไบต์

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

H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0

ลองออนไลน์!

ฉันภูมิใจนำเสนอภาษาการเขียนโปรแกรม 2 มิติที่สองของฉันและ (เป็นความรู้ของฉัน) ภาษา 2D ครั้งแรกในตารางหกเหลี่ยม

ซอร์สโค้ดดูไม่เหมือน 2D มากใช่ไหม? ช่องว่างเป็นทางเลือกใน Hexagony ก่อนอื่นซอร์สโค้ดจะถูกเพิ่มไปที่ตัวเลขหกเหลี่ยมที่อยู่กึ่งกลางถัดไปโดยไม่มีตัวเลือก ( .) หมายเลขดังกล่าวถัดไปคือ 37 ดังนั้นเราจึงใส่ no-op ห้าตัวที่ส่วนท้าย จากนั้นซอร์สโค้ดจะถูกจัดเรียงใหม่เป็นรูปหกเหลี่ยมปกติ:

   H ; e ;
  P 1 ; @ /
 ; W ; o ; /
l ; ; o ; Q /
 r ; l ; d ;
  2 ; P 0 .
   . . . .

นี่คือ runnable ลองออนไลน์!

Hexagony มีฟีเจอร์ขี้ขลาดมากมายรวมถึงพอยน์เตอร์คำสั่ง 6 แบบและเลย์เอาต์หน่วยความจำซึ่งเป็นกราฟเส้นของตารางหกเหลี่ยม แต่รหัสนี้ใช้ IP เพียงหนึ่งเดียวและหนึ่งขอบหน่วยความจำดังนั้นตอนนี้

นี่คือภาพรวมของคำสั่งที่เกี่ยวข้อง:

• ตัวอักษรเพียงแค่ตั้งค่าขอบหน่วยความจำปัจจุบันเป็นค่า ASCII ของพวกเขา
• ; พิมพ์ค่าปัจจุบัน modulo 256 เป็นไบต์ไปที่ STDOUT
• / เป็นกระจกเงาที่มีพฤติกรรมตามที่คุณคาดหวัง (ทำให้ IP หันมา 120 องศา)
• ตัวเลขทำงานเหมือนที่ทำในเขาวงกตพวกมันคูณเซลล์ปัจจุบันด้วย 10 แล้วเพิ่มตัวเอง
• @ ยุติโปรแกรม

ตอนนี้การจับครั้งสุดท้ายคือแหล่งที่มาล้อมรอบขอบทั้ง 3 คู่ นอกจากนี้หาก IP ออกจากกริดผ่านหนึ่งในหกมุมจะมีสองแถวที่เป็นไปได้ที่จะข้ามไป ตัวเลือกใดขึ้นอยู่กับว่ามูลค่าปัจจุบันเป็นบวกหรือไม่บวก รุ่นที่มีคำอธิบายประกอบต่อไปนี้แสดงให้เห็นว่า IP เข้ามาใหม่ทุกครั้งที่ออกจากตาราง:

         H ; e ;     -> 1
5 ->    P 1 ; @ /    -> 4
3 ->   ; W ; o ; /   -> 2
1 ->  l ; ; o ; Q /
4 ->   r ; l ; d ;   -> 5
2 ->    2 ; P 0 .    -> 3
         . . . .

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

H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

มีอะไรกับQ2, P0และP1? ตัวอักษรถูกพิมพ์อย่างง่ายดายเพราะเราสามารถตั้งค่าขอบเป็นค่าที่สอดคล้องกัน สำหรับเครื่องหมายจุลภาคพื้นที่และเครื่องหมายอัศเจรีย์ที่ไม่ทำงาน นอกจากนี้เรายังไม่สามารถเพียงแค่ตั้งค่าของพวกเขาด้วย44, 32, 33ตามลำดับเพราะขอบหน่วยความจำเป็นที่ไม่ใช่ศูนย์จะเริ่มต้นด้วยและเนื่องจากความหมายของตัวเลขของแต่ละบุคคลที่จะสนองทุกประเภทของความเสียหาย ถ้าเราต้องการที่จะทำอย่างนั้นเราจะต้องรีเซ็ตค่าขอบเพื่อเป็นศูนย์กับสิ่งที่ต้องการ*, +, -, &หรือ^แรก อย่างไรก็ตามเนื่องจากค่าถูกนำมาใช้ modulo 256 ก่อนที่จะถูกพิมพ์เราจึงไม่จำเป็นต้องตั้งค่าเป็น 44, 32, หรือ 33 ตัวอย่างเช่นQ2จะตั้งค่าขอบ81*10 + 2 = 812เป็น44256เมื่อนำมาโมดูโล วิธีนี้เราสามารถบันทึกไบต์บนอักขระสามตัวเหล่านั้นแต่ละตัว ( แต่น่าเสียดายที่มันไม่เคยเป็นไปได้ที่จะได้รับมีกับตัวเลขหลักเดียวจากค่าที่มือถือที่มีอยู่แล้วได้. ตลกขบขันที่มันไม่ทำงานเป็นoในWorldเนื่องจากว่ายังสามารถได้รับจากW9.)

คุณสามารถใช้สคริปต์ CJam นี้เพื่อค้นหาชุดตัวเลขตัวอักษรทั้งหมดที่ทำให้เกิดอักขระที่กำหนด

ฉันไม่แน่ใจว่าสิ่งนี้ดีที่สุดหรือไม่ ฉันสงสัยว่ามันเป็นไปได้ที่จะทำในรูปหกเหลี่ยมด้านยาว 3 (ที่คุณมีเพียง 19 ตัวอักษร) แต่มันอาจเป็นไปได้ที่จะแก้มันในรูปหกเหลี่ยมที่มีความยาวด้าน 4 ด้วยคำสั่งน้อยกว่า 32 เช่น ที่ไม่มี ops เพิ่มเติมในตอนท้ายของตาราง

Malbolge, 112 ไบต์

('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9&7Y#VV2TSn.Oe*c;(I&%$#"mCBA?zxxv*Pb8`qo42mZF.{Iy*@dD'<;_?!\}}|z2VxSSQ

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

สำหรับการแสดงนี่คือ "Hello World!" ไม่มีเครื่องหมายจุลภาค

(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc

ฟูริเยร์ 15 ไบต์

การเปลี่ยนแปลงครั้งใหญ่เพื่อฟูริเยร์!

`Hello, World!`

ลองใช้กับ FourIDE!

ใช่วันในการพิมพ์รหัส ASCII ของตัวละครแต่ละตัวจะหายไปตลอดกาล: ฟูริเยร์ตอนนี้ชนิดของการสนับสนุนสตริง เมื่อคุณใส่สตริงใน backticks สตริงนั้นจะถูกเอาต์พุต

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

ที่นี่คุณสามารถพบซากรถไฟที่เก่าแก่ฟูริเยร์ ;)

72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a

ลองออนไลน์!

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

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

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

โปรดทราบว่านี่สั้นกว่าการเข้าสู่รายการEsolangs ของฉันเพราะฉันไม่คิดว่าฉันจะเล่นกอล์ฟได้อีก จากนั้นเมื่อเขียนความท้าทายการเล่นสตริงของฟูริเยร์ฉันรู้ว่าฉันจะสั้นลงได้เล็กน้อย

บันทึก

หากคุณสงสัยเกี่ยวกับไวยากรณ์ของตัวแปร Geobits เขียนโปรแกรมที่ใช้ตัวแปรและมีความยาวเท่ากัน:

72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a

ลองออนไลน์!

C-- , 155 ไบต์

target byteorder little;import puts;export main;section"data"{s:bits8[]"Hello, World!\0";}foreign"C"main(){foreign"C"puts("address"s);foreign"C"return(0);}

น่าเสียดายที่คอมไพเลอร์ C - ที่รู้จักเท่านั้นที่Quick C--ไม่ได้รับการบำรุงรักษาอีกต่อไป มันเป็นความเจ็บปวดที่คอเพื่อสร้าง แต่มันเป็นไปได้ ...

C, 30 ไบต์

main(){puts("Hello, World!");}

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

อ่านไม่ได้ , 843 755 732 666 645 629 577 ไบต์

' ' ' '''' ' ' ''''' " ' '' '' '''" " '' ' ' '''' ' ' '''' ' ' ''''" " '' ' ' ' '''' '' '' ' ' '''' ' '"'' ''' "" ' ''' "" ' ''' "" ' ''' "" '"' "" ' ''' "" ' ''' "" ' '' '' ''' "" '"' "" " ' '''" " ' '''" " ' '''"' "" ' '''" " ' '''" " ' '''" " ' '''" "" ' ' '''' ' ' '''' ' ' '''' ' ' '''' " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''"' "" ' ''' "" ' ''' "" "" "" ' '' '' '' ''' "" " ' '''" " ' '''" " ' '''"' "" ' '''" " ' '''" " ' '''" "" "" " '' ' ' '''' ' ' '''' ' ' '''' ' ' '''' " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''"' "" ' ''' "" ' ''' "" ' ''' "" '' " ' ' ' '' '' '' ' ' '' '' '' '''' '''''"" "" "" "" ''" '"' '' '' '' ' ' '''' " '' ' ' ' ' '''' ' ' ''''''" " '' ' ''' "" "" "" " '"'" "" ' ' ' '' '' '' ' '"'' ''''' "" "" "" " ' '''" " '"'" "" ' ' ' '''' '' '' ''' """" ' '' ' ' ' ' '''' ' ' '''''' ' ' '''' ' ' '' '' '' ' '"'' ''''' "" "" "" " '"'" "" ' ' ' '' '' '' ' ' '''' ' '"'' ''''' "" ' '' '' '' "' ''"" ' '' ' ' ' ' '''' ' ' '''''' ' ' '''' ' ' '' '' '' ' '"'' ''''' "" "" "" " '"'" "" ' ' ' '' '' '' ' ' '''' ' '"'' ''''' "" ' '' '' '' "' ''""" " '"'" "" ' ' ' '' '' '' ' ' '''' ' '"'' ''''' "" ' '' '' '' "' ''""" " '"'" "" ' ' ' '' '' '' ' ' '''' ' '"'' ''''' "" ' '' '' '' "' ''"

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

ลองออนไลน์!

มันทำงานอย่างไร

อ่านไม่ได้มีเพียงสิบฟังก์ชั่น; หกเหล่านี้ใช้ในรหัสนี้:

'"        p Print.
'""       + Increment.
'"""      1 Return 1.
'""""""   : Set.
'"""""""  = Get.
'"""""""" - Decrement.

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

p+++                                        Print 3 + variable 2 (o).
 pp                                         Print variable 2 two times (l).
  :+1+++++++                                Save 8 + variable 3 in variable 2.
   p+                                       Print 1 + variable 3 (e).
    :++1+++++++++++++                       Save 13 + variable 4 in variable 3.
     :+++1+++++++++++++++                   Save 43 + variable 0 in variable 4.
      p++++++++++++++++++++++++++++         Print 28 + variable 0 (H).
       :-1++++++++++++                      Save 44 in variable 0.
        :1+++++++++++++++++++++++++++++++1  Save 32 in variable 1.
p=-1                                        Print variable 0 (,).
p=1                                         Print variable 1 ( ).
p=+++1                                      Print variable 4 (W).
p+++                                        Print 6 + variable 2 (r).
 p+++=+1                                    Print 3 + variable 2 (o).
p=+1                                        Print variable 2 (l).
p=++1                                       Print variable 3 (d).
p+=1                                        Print 1 + variable 1 (!).

ฉันได้สร้างซอร์สโค้ดจริงโดยรัน pseudocode ข้างต้นในเวอร์ชันที่ไม่มีข้อคิดเห็นผ่านโปรแกรม CJamนี้

Befunge 98 , 19 18 Bytes

คำตอบใหม่ (จาก undergroundmonorail)

"ck,@!dlroW ,olleH

คำอธิบาย

• " เริ่มโหมดสตริง
• ทุกสิ่งที่ตามมาจะถูกผลักไปที่กองซ้อน สแตกอยู่ในขณะนี้Hello, World!@,kc
• หลังจากกดปุ่มเสร็จสิ้นล่ามกลับไปที่จุดเริ่มต้น
• มันพบกัน"อีกครั้งในตอนท้ายโหมดสตริง
• 12 ถูกผลักไปยังสแต็ก ( c)
• k ใช้ค่าสูงสุดของสแต็กและดำเนินการคำสั่งถัดไปที่ตัวชี้คำสั่งสามารถเห็นได้หลายครั้ง
• ,ดึงค่าจากสแต็กและส่งออกเป็นถ่าน มันได้รับการดำเนินการ 12 ครั้งโดยkคำสั่งสุดท้ายและอีกครั้งหนึ่งเมื่อล่ามอ่าน,คำแนะนำจริง
• @ สิ้นสุดโปรแกรม

ความแตกต่างกับคำตอบเดิมคือเราใช้"อักขระซ้ำอย่างชาญฉลาดโดยใช้พฤติกรรมวนลูปของ Befunge เมื่อมันมาถึงจุดสิ้นสุดของบรรทัด เนื่องจากมันอาจใช้งานง่ายกว่าฉันเลยปล่อยให้เก่าเช่นกัน นอกจากนี้คุณอาจสังเกตเห็นว่าสแต็กจะยังคงมีอักขระบางตัว ( ck,@) เนื่องจากกลลวงที่ดีนี้ทำให้เกิดความยุ่งเหยิงหากเราต้องการทำบางสิ่งหลังจากนั้น

คำตอบเก่า

"!dlroW ,olleH"ck,@

ใช้งานได้กับ funge และ befunge 98

คำอธิบาย

• ทุกสิ่งระหว่าง""ถูกผลักไปที่กอง ( 'H'อยู่ด้านบน)
• c (12) ถูกผลักไปที่สแต็ก
• k ใช้ค่าสูงสุดของสแต็กและดำเนินการคำสั่งถัดไปที่ตัวชี้คำสั่งสามารถเห็นได้หลายครั้ง
• ,ดึงค่าจากสแต็กและส่งออกเป็นถ่าน มันได้รับการดำเนินการ 12 ครั้งโดยkคำสั่งสุดท้ายและอีกครั้งหนึ่งเมื่อล่ามอ่าน,คำแนะนำจริง
• @ สิ้นสุดโปรแกรม

JSFuck , 6293 6289 6277 ไบต์

นี่อาจได้รับการกล่าวถึงว่าเป็นหนึ่งใน "โปรแกรมHello, World! shortest ที่ยาวที่สุด" (อันที่จริงฉันไม่รู้ว่านี่เป็นโปรแกรมที่ดีที่สุดหรือไม่

คำเตือน: ใช้ได้กับ Firefox และ Safari เท่านั้น

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

นอกจากนี้ยังมีเวอร์ชันที่ยาวกว่าเล็กน้อย (+4 ไบต์) ซึ่งสามารถใช้งานได้กับ Chrome และ Microsoft Edge:

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

สำหรับคนที่ไม่คุ้นเคยกับ JSFuck มันเกี่ยวกับการเขียนจาวาสคริปต์ราวกับว่ามีเพียงหกตัวอักษรและมันก็ค่อนข้างบ้าคลั่งในบางครั้ง

ตารางนี้แสดงให้เห็นว่าอักขระที่ใช้ในHello, World! โปรแกรมถูกเข้ารหัสใน JSFuck alert("Hello, World!")รหัสข้อความล้วนเป็นเพียง

+----------+--------------------------------------+---------------------------+
|JavaScript|               write as               |           JSFuck          |
+----------+--------------------------------------+---------------------------+
|     a    | (false+[])[1]                        | (![]+[])[+!![]]           |
|     l    | (false+[])[2]                        | (![]+[])[!![]+!![]]       |
|     e    | (true+[])[3]                         | (!![]+[])[!![]+!![]+!![]] |
|     r    | (true+[])[1]                         | (!![]+[])[+!![]]          |
|     t    | (true+[])[0]                         | (!![]+[])[+[]]            |
|     (    | ([]+[]["fill"])[13]                  | 114 bytes                 |
|     "    | ([]+[])["fontcolor"]()[12]           | 539 bytes                 |
|     H    | btoa(true)[1]                        | 1187 bytes                |
|     o    | (true+[]["fill"])[10]                | 105 bytes                 |
|   space  | ([]["fill"]+[])[20]                  | 107 bytes                 |
|     W    | (NaN+self())[11]                     | 968 bytes                 |
|     d    | (undefined+[])[2]                    | ([][[]]+[])[!![]+!![]]    |
|     !    | atob((Infinity+[])[0]+false)[0]      | 1255 bytes                |
|     )    | (0+[false]+[]["fill"])[20]           | 114 bytes                 |
+----------+--------------------------------------+---------------------------+

นี่สตริง"fill", "fontcolor"ฯลฯ จะต้องเขียนเป็น"f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"การเข้ารหัส

ตัวบ่งชี้ระดับโลกself, atobและได้รับการเขียนเช่นbtoaFunction("return self")()

Function[]["fill"]["constructor"]ตัวเองควรจะเป็น

เครื่องหมายจุลภาค","นั้นยุ่งยากฉันไม่แน่ใจ 100% ว่ามันใช้งานได้อย่างไร แต่ใช้[]["concat"]ฟังก์ชันสร้างอาร์เรย์ ฉันจะโพสต์การอัปเดตเมื่อฉันมีเวลาทำแบบทดสอบเพิ่มเติม

ฉันเข้ารหัสสิ่งนี้โดยใช้ JScrewIt - เครดิตกับGOTO 0สำหรับการสร้างเครื่องมือที่ซับซ้อน:

• เปิด Firefox (คุณสามารถเลือกเบราว์เซอร์อื่น ๆ ได้ แต่ Firefox เท่านั้นโค้ดที่สั้นที่สุด)
• นำทางไปยังJScrewIt : http://jscrew.it
• การป้อนข้อมูล: alert("Hello, World!")
• รหัสที่ทำงานได้:ตรวจสอบแล้ว
• ความเข้ากันได้:เบราว์เซอร์นี้เท่านั้น

สิ่งนี้แตกต่างจากคำตอบของฉันสำหรับคำถามนี้ต่อหน้าเครื่องหมายจุลภาคหลัง "Hello"

น่าสนใจไวยากรณ์ของ ES6

alert`Hello, World!`

ใช้เวลาไบต์มากยิ่งขึ้นในการเข้ารหัส (1500 หรือดังนั้น) เนื่องจากความซับซ้อนสูงของการเข้ารหัสสอง backticks มากกว่าและ("")

Pada , 83 68 ไบต์

~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw

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

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

Metagolf

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

ดังนั้นฉันจึงเขียนตัวแก้ปัญหาใน Mathematica ซึ่งจริง ๆ แล้วรู้เกี่ยวกับโครงสร้างข้อมูลและตัวดำเนินการของ Pada เพื่อหาทางออกที่ดีที่สุด โดยเฉลี่ยจะเติบโตเป็นเส้นตรงกับความยาวของสตริง (แม้ว่าบางชุดที่ตัวละครเป็นบิตช้ากว่าคนอื่น) และใช้เวลาประมาณ 1.5 Hello, World!ชั่วโมง

ดังนั้นฉันจะไปเกี่ยวกับการเขียนแก้ ก่อนอื่นเราสังเกตว่าเราต้องพิจารณาตัวดำเนินการ 6 ตัวเท่านั้น: ~.oOqQ(รวมถึงสิ่งที่จำเป็นwสำหรับอักขระที่พิมพ์แต่ละตัว) การใช้สแต็คหรือบิตล็อคไม่เป็นประโยชน์ในรหัสเชิงเส้นและฉันไม่เชื่อ?และ*สามารถใช้งานได้อย่างมีประสิทธิภาพในน้อยกว่า 68 ไบต์

สถานะของ Pada (ไม่สนใจสแต็คและตัวล็อค) ประกอบด้วยสวิตช์ 7 ตัวและ 8 บิตโดยเรียงดังนี้:

       /
   /       \
 /   \   /   /
0 1 0 0 1 0 0 0

นั่นคือสภาวะที่เป็นไปได้ ขั้นตอนก่อนการประมวลผลครั้งแรกของฉันคือการตั้งค่ากราฟกำกับของรัฐที่แต่ละขอบสอดคล้องกับการดำเนินการเดียว นั่นคือกราฟมีจุดยอด 32768 แต่ละอันมีระดับนอก 6 (ขอบด้านหนึ่งขาออกสำหรับแต่ละการดำเนินการ 6 ค่าที่พิจารณา) เราสามารถใช้กราฟนี้เพื่อค้นหาเส้นทางที่สั้นที่สุดระหว่างสองสถานะ (กราฟนี้เพียงอย่างเดียวอาจมีประโยชน์มากสำหรับการเล่นกอล์ฟ Pada)215 = 32768

ตอนนี้สำหรับตัวละครแต่ละตัวเราต้องการเข้าถึงสถานะที่wพิมพ์อักขระนั้น มีกี่รัฐดังกล่าว? wอ่านไบต์จากบิตที่ถูกดร็อป (cyclically) ดังนั้นจึงมีการหมุน 8 บิตที่เป็นไปได้ของตัวละครซึ่งสามารถพิมพ์อักขระนั้นได้ สำหรับการหมุนแต่ละครั้งสวิตช์สามตัวจะถูกกำหนดไว้ (เพื่อให้wอยู่ในตำแหน่งที่ถูกต้อง) สวิตช์นี้ออกจากสวิตช์โดยพลการ 4 ตัว ดังนั้นเราจึงมีสถานะเป็นไปได้สำหรับแต่ละรหัสของเรา8 * 24 = 128w

ด้วยสิ่งที่เราสามารถแก้ปัญหากราฟอื่น: สร้างกราฟที่มีจุดสุดยอดแหล่งที่มาแล้วหนึ่ง "เลเยอร์" สำหรับตัวละครแต่ละตัวและจุดสุดยอดจม เลเยอร์ประกอบด้วย 128 สถานะสำหรับแต่ละจุดสุดยอดโหนดต้นทางสอดคล้องกับสถานะเริ่มต้นของโปรแกรม (สวิตช์ทั้งหมดไปทางซ้ายและบิตทั้งหมดเป็นศูนย์) โหนด sink สอดคล้องกับไม่มีสถานะใดเป็นพิเศษ เราได้นำขอบจากจุดยอดทุกจุดในชั้นหนึ่งไปยังจุดสุดยอดในชั้นถัดไปโดยที่น้ำหนักขอบคือระยะทางระหว่างรัฐทั้งสองในกราฟก่อนหน้าของเรา น้ำหนักของขอบจากเลเยอร์สุดท้ายไปจนถึงอ่างล้างจานมีทั้งหมด 0 นั่นคือเราสามารถคำนวณน้ำหนักขอบเหล่านั้นล่วงหน้าได้ นี้เป็นขั้นตอนที่แพงที่สุดของการคำนวณและเอา 1.5 Hello, World!ชั่วโมง

ด้วยการตั้งค่ากราฟนี้เราสามารถค้นหาเส้นทางที่สั้นที่สุดจากแหล่งไปยังอ่างล้างจานได้อย่างรวดเร็ว (ใช้เวลา 0.05 วินาทีบนเครื่องของฉัน) สำหรับHello, World!รัฐที่ต้องการคือ:

0, 16960, 22052, 13828, 13828, 30389, 12487, 8307, 27299, 23450, 18922, 22778, 18682, 18459

โดยที่บิตที่มีนัยสำคัญน้อยที่สุด 7 บิตสอดคล้องกับสวิตช์และ 8 บิตที่สำคัญที่สุดกับบิตของ Pada

ตอนนี้เรากลับไปที่รูปแบบของกราฟแรกและพบว่าขอบจริง (การดำเนินงาน IE) wที่สอดคล้องกับเส้นทางที่สั้นที่สุดระหว่างคู่ของรัฐที่ตามมาในแต่ละครั้งและจบแต่ละของพวกเขาด้วย Voilà, ทางออกที่ดีที่สุด (ขึ้นอยู่กับสมมติฐานข้างต้น)

นี่คือ Mathematica เต็มรูปแบบหากใครก็ตามที่ต้องการ metagolf สตริงที่แตกต่างใน Pada:

string = "Hello, World!";
width = StringLength@string;
getState[letter_, state_] := (
  {shift, switchState} = IntegerDigits[state - 1, 16, 2];
  bits = RotateRight[
    IntegerDigits[ToCharacterCode[letter][[1]], 2, 8], shift];
  switchState = IntegerDigits[switchState, 2, 4];
  switches = {-1, -1, -1, -1, -1, -1, -1};
  {top, middle, bottom} = IntegerDigits[shift, 2, 3];
  switches[[1]] = top;
  If[top < 1,
   switches[[2]] = middle;
   If[middle < 1,
    switches[[4]] = bottom,
    switches[[5]] = bottom
    ],
   switches[[3]] = middle;
   If[middle < 1,
    switches[[6]] = bottom,
    switches[[7]] = bottom
    ]
   ];
  For[i = 1, i <= 7, ++i,
   If[switches[[i]] < 0,
    switches[[i]] = First@switchState;
    switchState = Rest@switchState
    ]
   ];
  {bits, switches}
  )
encode[state_] := FromDigits[Join @@ state, 2]
decode[id_] := Partition[IntegerDigits[id, 2, 15], 8, 8, 1, {}]
getBitFromSwitches[switches_] := (
  If[switches[[1]] < 1,
   If[switches[[2]] < 1,
    1 + switches[[4]],
    3 + switches[[5]]
    ],
   If[switches[[3]] < 1,
    5 + switches[[6]],
    7 + switches[[7]]
    ]
   ]
  )
toggle[list_, index_] := ReplacePart[list, index -> 1 - list[[index]]]
stateEdges = Flatten@Table[
    {bits, switches} = decode@id;
    bit = getBitFromSwitches@switches;
    {
     Labeled[id \[DirectedEdge] encode@{bits~toggle~bit, switches}, 
      "~"],
     Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~1}, "."],
     If[switches[[1]] < 1,
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~2}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3}, 
        "q"],
       If[switches[[2]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~4}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~5}, 
         "O"]
        ],
       If[switches[[3]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~7}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~6}, "Q"]
        ]
       },
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~3}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2}, 
        "q"],
       If[switches[[3]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~6}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~7}, 
         "O"]
        ],
       If[switches[[2]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~5}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~4}, "Q"]
        ]
       }
      ]
     }
    ,
    {id, 0, 2^15 - 1}];
stateGraph = 
  Graph[# & @@@ stateEdges, EdgeLabels -> Rule @@@ stateEdges];
uid = 0;
layers = Join[{{{uid++, 0}}}, 
   Table[{uid++, encode@getState[#, i]}, {i, 128}] & /@ 
    Characters@string, {{{uid++, -1}}}];
edges = Flatten[Table[
      from \[DirectedEdge] to
      ,
      {from, #},
      {to, #2}
      ] & @@@ Partition[layers, 2, 1], 2];
Timing[weights = (
     {from, to} = Last /@ List @@ #;
     If[to < 0,
      0,
      GraphDistance[stateGraph, from, to]
      ]
     ) & /@ edges;]
characterGraph = Graph[edges, EdgeWeight -> weights];
Timing[path = 
  Last /@ Most@
    FindShortestPath[characterGraph, {0, 0}, layers[[-1]][[1]]]]
(PropertyValue[{stateGraph, #}, EdgeLabels] & /@ 
      DirectedEdge @@@ 
       Partition[FindShortestPath[stateGraph, ##], 2, 1] <> "w" & @@@ 
   Partition[path, 2, 1]) <> ""