ඒ සත්යය යන්ත්රය (බැර කිරීමට යයි මේ මිනිහා ඒ සමඟ පැමිණෙන සඳහා) භාෂාවක් වන I / O හා පාලනය ගලා පෙන්නුම් කිරීමට සැලසුම් කර, ඉතාමත් සරල වැඩසටහනක්. සත්‍ය යන්ත්‍රයක් කරන දේ මෙන්න:

• STDIN වෙතින් අංකයක් (0 හෝ 1) ලබා ගනී.

• එම අංකය 0 නම්, 0 මුද්‍රණය කර අවසන් කරන්න.

• එම අංකය 1 නම්, 1 සදහටම මුද්‍රණය කරන්න.

අභියෝගය

ඔබ කැමති භාෂාවෙන් ඉහත විස්තර කර ඇති පරිදි සත්‍ය යන්ත්‍රයක් ලියන්න. සත්‍යය යන්ත්‍රය මෙම නීති රීති අනුගමනය කරන සම්පූර්ණ වැඩසටහනක් විය යුතුය:

• STDIN වෙතින් ආදානය හෝ පිළිගත හැකි විකල්පයක් ගන්න
  • ඔබේ භාෂාවට STDIN වෙතින් ආදානය ලබා ගත නොහැකි නම්, එය දෘ c කේත විචල්‍යයකින් හෝ වැඩසටහනට සමාන සමාන ආදානයක් ලබා ගත හැකිය
• STDOUT වෙත ප්‍රතිදානය කළ යුතුය හෝ පිළිගත හැකි විකල්පයකි
  • ඔබේ භාෂාව අක්ෂර ප්‍රතිදානය කිරීමට අසමත් නම් 0හෝ 1බයිට් හෝ ඒකීය I / O පිළිගත හැකිය.
• ආදානය ඇති විට 1, එය අඛණ්ඩව මුද්‍රණය කළ යුතු 1අතර වැඩසටහන නතර වී හෝ මතකයෙන් ඉවතට ගියහොත් පමණි

• නිමැවුම විය යුත්තේ 0එක් හෝ නව රේඛාවක් හෝ අවකාශයක් හෝ අනන්ත 1s 1එකක් හෝ ඊට පසුව එකක් හෝ නව රේඛාවක් හෝ අවකාශයක් පමණි. ඔබේ භාෂාවේ පරිවර්තකයාගේ නිරන්තර ප්‍රතිදානය යටපත් කළ නොහැකි (සුබපැතුම්, ANSI වර්ණ කේත හෝ ඉන්ඩෙන්ටේෂන් වැනි) හැර වෙනත් ප්‍රතිදානයක් ජනනය කළ නොහැක. ඔබ නව රේඛා හෝ අවකාශයන් භාවිතා කිරීම අනුකූල විය යුතුය: නිදසුනක් ලෙස, ඔබ 1නව රේඛාවක් සමඟ ප්‍රතිදානය කිරීමට තෝරා ගන්නේ නම්, ඒ සියල්ලටම පසුව නව රේඛාවක් 1තිබිය යුතුය.

• ඔබේ භාෂාවට ආදානයකින් අවසන් කිරීමට නොහැකි නම් පමණක් 0කිසිවක් ප්‍රතිදානය නොකරන අසීමිත පුඩුවක් කේතයට ඇතුළත් කිරීම පිළිගත හැකිය.

මෙය නාමාවලියක් බැවින්, මෙම අභියෝගයෙන් පසුව නිර්මාණය කරන ලද භාෂාවන්ට තරඟ කිරීමට අවසර ඇත. පරිවර්තකයෙකු සිටිය යුතු බව සලකන්න, එවිට ඉදිරිපත් කිරීම පරීක්ෂා කළ හැකිය. කලින් ක්‍රියාත්මක නොකළ භාෂාවක් සඳහා මෙම පරිවර්තකයා ඔබම ලිවීමට අවසර ඇත (සහ දිරිමත් කරනු ලැබේ). ඒ හැර, කේත-ගොල්ෆ් ක්‍රීඩාවේ සියලුම සම්මත නීතිවලට අවනත විය යුතුය. බොහෝ භාෂාවල ඉදිරිපත් කිරීම් සුදුසු පෙර පැවති කේතන ක්‍රමයකින් බයිට් වලින් ලකුණු කරනු ලැබේ (සාමාන්‍යයෙන් UTF-8).

නාමාවලිය

මෙම ලිපියේ පතුලේ ඇති ස්ටැක් ස්නිපටය පිළිතුරු වලින් නාමාවලිය උත්පාදනය කරයි. අ) එක් භාෂාවකට කෙටිම විසඳුම් ලැයිස්තුවක් ලෙස සහ ආ) සමස්ත ප්‍රමුඛ පුවරුවක් ලෙස.

ඔබගේ පිළිතුර පෙන්වන බව සහතික කර ගැනීමට, කරුණාකර පහත දැක්වෙන මාර්ක්ඩවුන් අච්චුව භාවිතා කරමින් ඔබේ පිළිතුර සිරස්තලයකින් ආරම්භ කරන්න:

## Language Name, N bytes

Nඔබගේ ඉදිරිපත් කිරීමේ ප්‍රමාණය කොහිද ? ඔබ ඔබේ ලකුණු වැඩි දියුණු කරන්නේ නම්, ඔබට පැරණි ලකුණු සිරස්තලයට තබා ගත හැකිය . උදාහරණයක් වශයෙන්:

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

ඔබේ ශීර්ෂයට බහු සංඛ්‍යා ඇතුළත් කිරීමට ඔබට අවශ්‍ය නම් (උදා: ඔබේ ලකුණු ලිපිගොනු දෙකක එකතුව හෝ ඔබට පරිවර්තක ධජ ද ties ුවම් වෙන වෙනම ලැයිස්තු ගත කිරීමට අවශ්‍ය නිසා), සත්‍ය ලකුණු ශීර්ෂයේ අවසාන අංකය බවට වග බලා ගන්න :

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

ඔබට භාෂාවේ නම සබැඳියක් බවට පත් කළ හැකි අතර එය ස්නිපටයේ පෙන්වනු ඇත:

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 320px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><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>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><script>var QUESTION_ID = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; 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.toLowerCase(), 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 > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) 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); } }</script>

ෂඩාස්රාකාර , බයිට් 6 යි

මෙය පුදුම සහගත උපක්‍රමයක් වූ අතර එය ප්‍රශස්ත යැයි මට ඒත්තු ගොස් නැත ...

<.@!$?

කේතය පෑඩ් කිරීමෙන් හා දිග හැරීමෙන් පසුව, මෙය පහත දැක්වෙන හෙක්ස් ජාලකය නියෝජනය කරයි:

මෙය ප්‍රති-විකර්ණ දිගේ ගමන් කරමින් මගේ මෑත දෝෂ රහිත බළල් වැඩසටහන වැනි සමාන පාලන ප්‍රවාහයක් භාවිතා කරයි . එය සාක්ෂාත් කර ගැනීම සඳහා අපි ආරම්භ කරන්නේ උපදෙස් දර්ශකය (අයිපී) වමට හරවා දම් පාට මාර්ගය පහළ වම් කෙළවරට එතීමයි.

?ආදානය පූර්ණ සංඛ්‍යාවක් ලෙස කියවයි. !එය නැවත මුද්‍රණය කරයි. .නිකුතුවක් පමණක් නොවේ. දැන් ජාලකයේ කෙළවර ශාඛාවක් ලෙස ක්‍රියා කරයි:

ආදානය නම් 0, අයිපී රතු මාවත ඔස්සේ ඉදිරියට යනු ඇත, එමඟින් වැඩසටහන අවසන් වේ @.

ආදානය නම් 1, අයිපී හරිත මාවතේ ඉදිරියට යනු ඇත. නැවතත්, නිකුතුවක් .පමණක් නොව $එය බෙෆුන්ජ්ගේ ට්‍රම්ප් වලට සමාන වේ: එය ඊළඟ උපදෙස් මඟ හැරේ. එතීමෙන් පසු, ඊළඟ උපදෙස් වනුයේ ?, නමුත් $ක්‍රියාත්මක කිරීම හේතුවෙන් ඇත්ත වශයෙන්ම නිල් මාවතේ ඉදිරියට යන අතර, එහි !තවත් පිටපතක් මුද්‍රණය කිරීම ආරම්භ 1වේ. පමණක් අඩංගු මෙම ලූපය !..$දැන් දින නියමයක් නොමැතිව පුනරාවර්තනය වේ.

ෂඩාස්රාකාරයේ පාලන ප්රවාහය පිළිබඳ අධ්යයනයක් ...

ඉහත විසඳුම ප්‍රශස්ත යැයි මම විශ්වාස කරමි. මා විසින් තිරිසන් බලකොටුවක් ලියා ඇති අතර, එය බයිට් 6 ෂඩාස්රාකාර වැඩසටහන් සියල්ලම පරික්ෂා කරයි, එහි අවම වශයෙන් එක් එකක්වත් අඩංගු වේ ?!@(ඒවා අත්‍යවශ්‍යය; මම ද පරීක්ෂා :කර ඇති %අතර @ශුන්‍ය බෙදීමකින් අවසන් වීම වෙනුවට, නමුත් ඒකත් උදව් කළේ නැහැ). චෙක්පත මුද්‍රණය කරන්නේ අ) 0ආදානය මත නිපදවන 0සහ අවසන් කරන සහ ආ) අවම වශයෙන් 1තත්පර දෙකක් (සහ වෙනත් කිසිවක් ) නිපදවන අතර වැඩසටහනේ පළමු කිනිතුල්ලන් 60 තුළ අවසන් නොකරන්න (බයිට් 5 විසඳුම් සඳහා කිනිතුල්ලන් 200) . එවැනි කුඩා ජාලයක පළමු 0හෝ දෙවැන්න නිවැරදිව මුද්‍රණය කිරීම සඳහා ඕනෑම වලංගු විසඳුමක් කිනිතුල්ලන් 200 කට වඩා ගතවනු ඇතැයි මම සැක කරමි 1, එබැවින් විභව විසඳුම් කිසිවක් මග හැරී ඇතැයි මම නොසිතමි.

සෙවුමෙන් බයිට් 5 ක් @සඳහා කිසිදු ප්‍රති results ලයක් නොලැබුණි , නමුත් බයිට් 6 ක් සඳහා ප්‍රති results ල 57 ක් (භාවිතා කරමින් ; අපට එකම බයිට් ප්‍රමාණයකින් මෙය පිරිසිදු ලෙස විසඳා ගත හැකි නම් දෝෂයක් සමඟ අවසන් කිරීමට අවශ්‍ය නැත). එම 57 න් 6 ක් පමණක් ව්‍යාජ ධනාත්මක වූ අතර ඒවා ඇත්ත වශයෙන්ම 1තත්පර දෙකක් පමණක් මුද්‍රණය කර පසුව මුද්‍රණය නොකර අනන්ත පුඩුවක් තුළට ඇතුළු විය. එක් විසඳුමක් !විධාන දෙකක් අඩංගු බැවින් දෙවරක් ලැයිස්තුගත කරන ලදී . එමඟින් වලංගු විසඳුම් 50 ක් ඉතිරි වේ.

අක්ෂර එකක් හෝ දෙකක් සැළකිය යුතු නොවන විසඳුම් අතර යම් පරිහානියක් ඇත, උදා: ඒවා කෙසේ හෝ effectively ලදායී ලෙස නොපවතින බැවිනි. විසඳුම් අව්‍යාජව වෙනස් වැඩසටහන් 23 කට බෙදිය හැකිය (සමහර අවස්ථාවලදී, කට්ටල දෙකක් අතර ඇත්තේ එක් අක්ෂර වෙනසක් පමණි, නමුත් එය පාලන ප්‍රවාහය සැලකිය යුතු ලෙස වෙනස් කරයි, එබැවින් මම ඒවා වෙන වෙනම ගණන් කර ඇත්තෙමි). කණ්ඩායම් දෙකක් ඉතා අනපේක්ෂිත ආකාරයකින් බහු උපදෙස් පොයින්ටර් පවා භාවිතා කරයි. ශාඛා සහ දර්පණ භාවිතා කිරීමට මා කිසි විටෙකත් නොපැමිණෙන හෙයින්, ඔවුන් ෂඩාස්රාකාරයේ කුමන ආකාරයේ පාලන ප්‍රවාහයක් කළ හැකිද යන්න පිළිබඳව ඉතා රසවත් අධ්‍යයනයක් කරන අතර අනාගත ගොල්ෆ් සඳහා නව උපක්‍රම කිහිපයක් මම අනිවාර්යයෙන්ම ඉගෙන ගෙන ඇත්තෙමි.

මෙම සමස්ත පාලනය ගලා සෑම විටම පාහේ සමාන වේ: එය මුද්රණය කිරීම, ගණනාවක් කියවන්න. එය සඳහා 0මාර්ගයක් සොයා ගන්නේ @නම්, !කෙළවරේ අගයක් පවත්වා ගෙන යන අතරම දිගටම නොනවත්වා ගමන් කරන්න 1. සැලකිය යුතු ව්‍යතිරේක හතරක් ඇත:

• එක් විසඳුමක් (දෙකක් ඇති විසඳුම !) 1ජාලකය හරහා එක් පුනරාවර්තනයකට තත්පර දෙකක් මුද්‍රණය කරයි, එබැවින් බහුතර වැඩසටහන් වලට වඩා දෙගුණයක් වේගයෙන් මුද්‍රණය කරයි. මම මෙය x2පහතින් සලකුණු කර ඇත්තෙමි .
• කිහිපයක් විසඳුම් (ක අඩංගු වන අය o) වෙනුවට මෙම 1සමඟ 111(ස්වභාවය කේතය oඒ නිසා ඔවුන් මුද්රණය,) තුනක් 1 ඔවුන් වැඩසටහන් බහුතරයක් වේගයෙන් තුන් ගුණයක් විතර මුද්රණය කරමින්, ප්රතිඵලයක්ම අනුව s. මම මේවා x3පහතින් සලකුණු කර ඇත්තෙමි .
• විසඳුම් දෙකක් එක් එක් පුනරාවර්තනයේ අද්දර අගයට එකතු කරයි 1(එබැවින් 1-> 11-> 111-> ...). ඒවා ඉතා වේගයෙන් මුද්‍රණය වන නමුත් අවසානයේදී ඒවා මතකය නැති වී යයි. මම මේවා OoMපහතින් සලකුණු කර ඇත්තෙමි .
• විසඳුම් දෙකක් ඉතා තද පුඩුවක් තුළට ඇතුළු වන අතර එය හුදෙක් පිටුපසට හා පසුපසට පනින අතර !අනෙක් සෑම ටික් එකකම (සෑම 5 වන හෝ ඊට වඩා) මුද්‍රණය කරයි, එමඟින් ඒවා තරමක් වේගවත් (හා පිළිවෙලට) කරයි. මම මේවා ><පහතින් සලකුණු කර ඇත්තෙමි .

ඉතින් මුළු සත්වෝද්‍යානයම මෙන්න:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

පහත දැක්වෙන්නේ වඩාත් නියෝජිත කණ්ඩායම් අතළොස්සක් සඳහා කෙටි ගමනකි. විශේෂයෙන් 10 සහ 23 කණ්ඩායම් පරීක්ෂා කිරීම වටී. අනෙක් කණ්ඩායම් තුළ තවත් බොහෝ සිත්ගන්නාසුළු හා සමහර විට කැටි ගැසුණු මාර්ග තිබේ, නමුත් මම හිතන්නේ මේ අවසානයේ මම ඔබට ප්‍රමාණවත් තරම් කම්මැලි වී සිටිමි. ෂඩාස්රාකාරය ඉගෙන ගැනීමට සැබවින්ම කැමති ඕනෑම කෙනෙකුට, මේවා අනිවාර්යයෙන්ම විමර්ශනය කිරීම වටී, මන්ද ඒවා දර්පණවල ඊටත් වඩා භාවිතයන් ප්‍රදර්ශනය කරන $බැවිනි.

1 වන කණ්ඩායම

මෙය මගේ මුල් විසඳුමට වඩා විස්තීර්ණ නොවේ, නමුත් මාර්ග විවිධ දිශාවලට ගමන් කරයි. තනි සෛලයක විශාලතම වෙනස්කම් සංඛ්‍යාවක් සඳහා ද එය ඉඩ සලසයි, මන්දයත් දකුණේ වඩාත්ම විවරය විවිධ විධාන 5 කින් ප්‍රතිස්ථාපනය කළ හැකි අතර එමඟින් ව්‍යුහය වෙනස් නොකර මෙය වලංගු වේ:

2 වන කණ්ඩායම

මෙය තිරස් අතට පමණක් ගමන් කරන නිසා මෙය තරමක් සිත්ගන්නා සුළුය. වෙත එතීමෙන් පසු >, අයිපී වහාම ආපසු හරවා, ශාඛාව කෙළවරට ගෙන යයි. එය මුළුමනින්ම දෘශ්‍යමාන ලෙස රූප සටහනක් නොවේ, නමුත් 1අපි පළමු පේළිය නැවත ගමන් කළත්, මේ වතාවේ පසුපසට. මෙයින් අදහස් කරන්නේ අප ?නැවත දුවන බවයි , එය දැන් නැවත පැමිණේ 0(EOF). )මුද්‍රණ යන්ත්‍ර තබා ගැනීම සඳහා මෙය (වර්ධක) සමඟ සවි කර 1ඇත. ලෙස මෙය, 5 වෙනස්කම් ඇති )කිරීමට ද නියමිත විය 1හෝ o, සහ >ද විය හැකි |:

3 වන කණ්ඩායම

මෙය පෙරට වඩා බොහෝ දුරට සමාන නමුත් එය අපායක් සේ අවුල් සහගතය. පහර දීම |දක්වා පහළ හෝ ඉහළ පේළිය හරහා ගමන් කිරීම සමාන වේ. නමුත් ලූපයකදී, $දැන් කැඩපත ) මතට හැරේ. අපි හරි කිරීමට පච්ච මාර්ගය අනුගමනය ඒ නිසා, දැන් කට මඟ, වැටුප් වර්ධක පහර @අපි අවට කිරීමට ආවරණය කරනවා පෙර | නැවත හා පසුව ඉහළ ඇති හරිත මාර්ගය නැවත යන්න.

4 වන කණ්ඩායම

මම හිතුවේ මේක විශේෂයෙන් නිෆ්ටි කියලා:

_ඉහළ දකුණු කෙළවරේ ඇති දර්පණය මුලදී විවෘත නොවන නිසා අපි මුද්‍රණය කර !පහර දෙමු <. මෙම 0මාර්ගය දැන් තිරස් කැඩපත සහ අවසන් කිරීමක් වැදෙනවා. මෙම 1වුවත් මාර්ගය ඇත්තටම රසවත් ගමන් පථය ගනී: එය වසා ද්වීද්රවීය, වෙත ආධාරක !, නැවත කිරීමට හකුළා තිරස් හා පසුව දෙසට හරවා ලක්වෙයි ! නැවත . ඉන්පසු එය මෙම රොම්බස් හැඩයෙන් ඉදිරියට යමින්, නැවත නැවත දෙවරක් මුද්‍රණය කරයි (සෑම තෙවන ටික් එකකටම).

8 වන කණ්ඩායම

මෙය තදින් මුද්‍රණ පුඩුවක් සහිත විසඳුම් දෙකෙන් එකකි:

මෙම <ශාඛා ලෙස ක්රියා කරයි. දෙවරක් ඔතා, 0පහර @. 1අනෙක් අතට, පළමුව එය මඟ හැර, නැවත එය වෙත යවයි ?, එවිට >එය $මඟ හැරේ @. එවිට, IP එය අතර සහ පසුපසට රැකීමේ එහිදී පච්ච මාර්ගය බවට ඔහුම >හා <(අතර අද්දර පමණ ඔතන).

10 වන කණ්ඩායම

වෙනත් උපදෙස් පොයින්ටර් භාවිතා කරන කණ්ඩායම් දෙකෙන් එකක් වන අතර එය ඇත්තෙන්ම ලස්සනයි. ෂඩාස්රාකාරයට 6 ක් ඇත - සෑම එකක්ම වෙනස් කොනක සිට ඔරලෝසුව දිගේ ආරම්භ වේ, නමුත් වරකට ක්‍රියාත්මක වන්නේ ඒවායින් එකක් පමණි.

සුපුරුදු පරිදි, අපි කියවන්නේ ?. දැන් ~ඒකීය ප්‍රතික්ෂේප 1කිරීමකි : එය a බවට හැරේ -1. ඊළඟට, අපි පහර #. අයිපී අතර මාරුවීමට මෙය එක් ක්‍රමයකි: එය වත්මන් දාරයේ අගය මොඩියුලෝ 6 ගෙන අනුරූප අයිපී වෙත මාරු වේ (අයිපී 0දක්ෂිණාවර්ත දිශාවෙන් අංකනය කර ඇත). එබැවින් ආදානය 0එසේ නම්, අයිපී එක එලෙසම පවතින අතර, නීරස ලෙස කෙළින්ම ඉදිරියට ගමන් කරයි !@. නමුත් ආදානය නම් 1, වත්මන් අගය -1එයයි 5 (mod 6). එබැවින් අපි එකම සෛලයකින් (හරිත මාර්ගය) ආරම්භ වන IP වෙත මාරු වෙමු. දැන් #එය විවෘත නොවන ?අතර මතක දාරය සකසයි 0. )වර්ධක එසේ !මුද්‍රණය කරයි a 1. ~එය සහතික කිරීම සඳහා දැන් අපි නැවතත් පහර දෙමු#(තවමත් වැඩසටහන 1 අවසන් කරන IP 1 වෙත අපව මාරු කිරීමට වඩා වෙනස්ව). මෙම කුඩා වැඩසටහන තුළ සෑම දෙයක්ම එකට ගැලපෙන්නේ කෙසේද යන්න සිහියට නංවයි.

22 වන කණ්ඩායම

මතක තබා ගත යුතු කරුණක් නම්, මගේ මුල් විසඳුම ඇති කණ්ඩායම මෙයයි. එය විශාලතම කණ්ඩායමක් බවට පත්වේ, මන්දයත් විවෘත කිරීම වෙනස් ස්ථාන දෙකක තිබිය හැකි අතර සත්‍ය (no ලදායී නොවන) විධානය සඳහා තේරීම් කිහිපයක් තිබේ.

23 වන කණ්ඩායම

බහු අයිපී භාවිතා කරන අනෙක් කණ්ඩායම මෙයයි. ඇත්ත වශයෙන්ම මෙය විවිධ IP 3 ක් භාවිතා කරයි . ඉහළ දකුණු කෙළවරේ ටිකක් අවුල් සහගතයි, නමුත් මම ඔබව මේ හරහා ගෙන යාමට උත්සාහ කරමි:

ඉතින්, ඔබ මීට පෙර දුටු ආරම්භය: <ඊසානදිග දිශානුගත කරයි, ?ආදානය කියවයි. ]අයිපී අතර වෙනස් වීමට දැන් තවත් ක්‍රමයක් තිබේ: එය ඊළඟ අයිපී වෙත ඔරලෝසු අනුපිළිවෙලින් පාලනය කරයි. ඒ නිසා අපි ගිනිකොන දෙසට යන ඊසානදිග කෙළවරේ ආරම්භ වන (මම දකින්න අමාරුයි) තුර්කිය මාර්ගයට පාලනය මාරු කරමු. එය ක්ෂණිකව පරාවර්තනය වන අතර <එමඟින් එය ගිනිකොන දෙසින් ඔතා වයඹ දෙසට ගමන් කරයි. එය ඊළඟ අයිපී වෙත මාරු වන නිසා ද එය පහර දෙයි . මෙය නැගෙනහිර කෙළවරේ සිට නිරිත දෙසින් ගමන් කරන අළු මාර්ගයයි. එය ආදානය මුද්‍රණය කර ඊසානදිග කෙළවරට ඔතා. මාර්ගය තිරස් අතට හරවන අතර එය අනෙකා විසින් පරාවර්තනය කරයි . දැන් දකුණු අත]< <<ශාඛාවක් ලෙස ක්‍රියා කරයි: ආදානය නම් 0, අයිපී ඊසාන දෙසින් ගමන් කරයි @. ආදානය නම් 1, අයිපී වෙතට ගමන් කරයි !, <එය පරාවර්තනය වන ලෙෆ්-තෑන්ඩ් වෙත ඔතා ... දැන් කෙළවරේ, එය නැවත වෙතට ඔතා !, දකුණෙන් <පරාවර්තනය වී, වමෙන් පරාවර්තනය වී <මාර්ග ආරම්භ වේ ඉවරයි ...

තරමක් අවුල්, නමුත් ලස්සන අවුල්. :)

ටිම්විගේ විස්මිත ෂඩාස්රාකාර වර්ණකය සමඟ ජනනය කරන ලද රූප සටහන් .

මෝටරෝලා MC14500B යන්ත්‍ර කේතය, බයිට් 2 යි

හෙක්ස් වලින්:

58EC

පැහැදිලි කිරීම:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

මෝටරෝලා MC14500B යනු බිටු 1 ක ක්ෂුද්‍ර පාලකයකි; එහි එක් බිට් 1 ලේඛනයක් සහ බිට් 1 දත්ත බස් රථයක් ඇත. ඔප්කෝඩ් බිටු 4 බැගින් වන බැවින් ඇත්තේ 16 ක් පමණි; ඔවුන්ගෙන් අඩක් දත්ත බස් රථයේ ලේඛනය සහ බිට් අතර තාර්කික මෙහෙයුමක් සිදු කරයි.

පැනීමේ උපදෙස් පැනීමේ ධජයක් සකසයි; ලිපිනයක් ලබා නොදුන් විට, වැඩසටහන් කවුන්ටරය 0 ලෙස සැකසීම සාමාන්‍ය දෙයකි. ආදාන බිට් බිංදුව නම්, ප්‍රොසෙසරය පනින්නේ නැත. ආදාන බිට් 1 නම්, ප්‍රොසෙසරය නැවත ආරම්භයට පනී; අප ORආදානය සමඟ සම්බන්ධ වී සිටින බැවින්, ඉන් පසුව ආදාන සං signal ාව කුමක් වුවත් එය වැදගත් නොවේ - ලේඛනය සදහටම 1 ක් වනු ඇත.

සාම්ප්‍රදායික පරිදි, ලේඛනය 0 දක්වා ආරම්භ කෙරේ.

දත්ත පත්‍රිකාවේ හෝ මෙහි ඔප්කෝඩ් ලැයිස්තුවක් සොයාගත හැකිය .

ආර්නෝල්ඩ් සී, බයිට් 296

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

සැබවින්ම තරඟකාරී නොවේ, නමුත් එහි විනෝදය සඳහා. Stdin සඳහා සහය නොදක්වයි, ශුන්‍ය අගයක් වෙනුවට ආදේශ @NO PROBLEMOකරන්න @I LIED. @No Problemo1 වේ.

(ගොනුව truemachine.arnoldc යැයි උපකල්පනය කර) සමඟ ධාවනය කරන්න:

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, බයිට් 18 (MC අනුවාදය 15w45a)

ඔබට පෙනෙන පරිදි, පුනරාවර්තන විධාන කොටස වෙත ලීවරයක් යොමු කර ඇති අතර, එහි විධානය say 1ඇත. ඊට ඉහළින් සං signal ා ප්‍රතිලෝම පන්දමක් ඇත, එමඟින් ඒකකය ක්‍රියාත්මක වන විධාන කොටස වෙත බලය යොමු කරයි say 0.

ස්විචය සත්‍යය දෙසට යොමු කරන සෑම විටම, පුනරාවර්තක වාරණය say 1අනන්ත 1s ප්‍රතිදානය සඳහා කේතය භාවිතා කරයි . ලීවරය අසත්‍යයට හරවා යවන විට, එය තනි ප්‍රතිදානය කරයි 0.

මෙය [@]පෙරනිමියෙන් ප්‍රතිදානය කරන බව සලකන්න . ඔබට සැබවින්ම 1s සහ ශුන්‍යයන් කෙළින්ම අවශ්‍ය නම් , මෙය බයිට් 34 ක් බවට පත්වේ, එහිදී විධාන බ්ලොක් වල කේතය tellraw @a [1]සහ tellraw @a [0]. මෙටා හි සොයාගත හැකි පරිදි මෙය MC සඳහා @ Cᴏɴᴏʀ O'Bʀɪᴇɴ විසින් යෝජනා කරන ලද බයිට් ගණන භාවිතා කරයි.

Bash + GNU utils, 13

grep 0||yes 1

බාෂ්, 35

read n;for((;n;));{ echo 1;};echo 0

රූබි, 20 යි

print while/1/||gets

අනතුරු ඇඟවීම් වළක්වා ගැනීමට විධාන රේඛාවේ සිට ධාවනය කරන්න

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

පැහැදිලි කිරීම:

ගොල්ෆ් අඩුවෙන්, මේ

while /1/ || gets
  print
end

රීජෙක්ස් කොන්දේසි සහිතව භාවිතා කරන විට, විචල්‍යය $_ජනගහනය කර රටාවට නොගැලපේ නම් එය ව්‍යාජ එකක් ලෙස තක්සේරු කරයි. පළමු වරට ලූපය හරහා $_හිස්ව ඇති බැවින් STDIN වෙතින් කියවන ලද රේඛාවකට getsඑහි අගය නියම කරයි $_. printතර්ක මුද්‍රණයකින් තොරව $_. දැන් අපි නැවතත් කොන්දේසිය තක්සේරු කරමු. අපි 1 කින් කියවන්නේ නම්, අපි කෙටි පරිපථයක් තබා නැවත 1 මුද්‍රණය කරමු. එසේ නොමැති නම්, අපි පහතට වැටෙමු gets, නමුත් දෙවන ආදාන පේළියක් නොමැති බැවින්, getsනැවත පැමිණෙන්නේ නැත, එබැවින් ලූපය අවසන් වේ.

අන්වීක්ෂය, බයිට් 3 යි

i{p

මම දන්නා කෙටිම එක.

පැහැදිලි කිරීම:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

අවසන් වූ පසු මයික්‍රොස්ක්‍රිප්ට් හි රෙජිස්ටර් 1 මුද්‍රණය කර ඇති අතර ආදානය 0එක් වරක් මුද්‍රණය වීමට හේතුව එයයි .

ටියුරින් මැෂින් කේතය, බයිට් 32 යි

මෙහි ඇති රීති වගු සින්ටැක්ස් භාවිතා කිරීම .

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

ජාවාස්ක්‍රිප්ට්, බයිට් 28 යි

මක්නිසාද යත් ලූප බොහෝ විට ලූපවලට වඩා කෙටි වේ.

alert(x)ප්‍රතිලාභ undefined, එය ව්‍යාජ ය, එබැවින් බිට්වේස් හෝ ක්‍රියාකරු |එය වෙතට දමයි 0. මේ අනුව, නම් xවේ "0", සීරුවෙන් එසේ ප්රහාරක තබා, වරක්. මෙම පිළිතුරටalert STDOUT සඳහා භාවිතා කරයි .

for(x=prompt();alert(x)|x;);

පයිතන් 2, බයිට් 29 යි

a=input()
while 1:print a;1/a

මේ පිළිබඳව අංශය දෝෂය සමඟ අවසන් කිරීමක් 0වන, පෙරනිමියෙන් අවසර .

බ්‍රේන්ෆක්, බයිට් 41 36 31 30

ආදානය කළ වහාම සහ ඊතන් සහ පරිශීලක 46915 හි සහාය ඇතිව මුද්‍රණය කිරීමෙන් කෙටි වේ.

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

පෙර අනුවාදය: ආදානයෙන් 48 අඩු කරන්න, එය ශුන්‍ය නොවේ නම් 1, ASCII සදහටම මුද්‍රණය කිරීම සඳහා 48 ට 1 ක් එක් කරන්න, එසේ නොමැතිනම් මුද්‍රණය කරන්න 0.

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

මම එය මෙහි ධාවනය කළෙමි , නමුත් ස්වාරක්ෂක ප්‍රතිදානය නිසා, වැඩසටහන කිසි විටෙකත් අවසන් නොවන බැවින් ඔබට කිසිදු ප්‍රතිදානයක් දැකිය නොහැක1 .

සංස්කරණය කරන්න: 0ආදානය මත මුද්‍රණය කිරීමට මට අමතක වී තිබුණි 0. දැන් ස්ථාවරයි. මම >.<අන්තිමට මුහුණු වලට කැමතියි .

පීට්, 27 18 16 කෝඩල්

(කෝඩෙල් යනු පික්සෙල් සඳහා විසිතුරු නමක් වන අතර එය රූපයක් නැරඹීම සඳහා ව්‍යාකූල වීම වළක්වා ගැනීමට භාවිතා කරයි. මම බයිට් වෙනුවට කෝඩෙල් ගණන් කළේ පීට් ස්ක්‍රිප්ට් රූප ලෙස සුරකින බැවින් භෞතික ප්‍රමාණය වෙනස් විය හැකිය. මෙම පයිටයට හැකි තරම් කාර්යක්ෂමව බයිට් 11 ක් ගතවේ. ප්‍රායෝගිකව, මගේ කුඩා gif ගොනුව බයිට් 62 ක් වන අතර එය ප්‍රශස්ත පලත් දත්ත ඇත. කෝඩල් ප්‍රමාණය වෙනුවට මගේ ප්‍රවේශයේ ප්‍රමාණය ලෙස මෙය භාවිතා කළ යුතුදැයි මට කියන්න.)

මුල් රූපය:

විශාල:

Piet හි, වර්ණ දෙකක් අතර වෙනස යනු කුමන විධානය ක්‍රියාත්මක වේද යන්න තීරණය කරයි, එබැවින් එකම වර්ණය දෙවරක් දැකීමෙන් අදහස් කරන්නේ එය එකම ක්‍රියාව කරන බවයි. ක්‍රියාත්මක කිරීම ආරම්භ වන්නේ ඉහළ වම් කෝඩලයෙනි. ඉන්පසු එය තිරස් අතට ගමන් කරයි.

1. අංකයක් කියවා එය තොගයේ තබන්න
2. තොගයේ මුදුන අනුපිටපත් කරන්න
3. තොගයේ මුදුන පොප් කර ප්‍රතිදානය කරන්න
4. තොගයේ මුදුනේ සිට වාර ගණනින් කරකවන්න.

ආදානය 1 නම්, කර්සරය දෙහි කෝඩලය තුළට පහළට ගමන් කරයි, එය තොගයේ 1 තල්ලු කරයි. එවිට ution ාතනය දිගටම වමට යයි. කර්සරය වර්ණයක සිට සුදු පැහැයට සහ සුදු සිට වර්ණයට ගමන් කරන විට කිසිවක් සිදු නොවේ. කළු පැහැය බිත්ති ලෙස ද සලකනු ලබන බැවින්, කර්සරය ඉහළ පේළියේ දෙහි කෝඩලය වෙත ආපසු ගොස් දෙවන පියවරේ සිට සියල්ල නැවත සිදු කරයි.

කෙසේ වෙතත්, ආදානය 0 නම්, කර්සරය කිසි විටෙකත් පහළට නොයන අතර දකුණු පස නිල් ජේ වලින් අවසන් වේ (ද pun ුවම අදහස් කර ඇත, එය වටී), එය කොටු වී සිටියහොත් (ඉහළ, දකුණ, වම සහ මෙම J- හැඩැති කොටසෙහි පහළ පැති කළු කෝඩල් හෝ රූපයේ මායිම අසල ඇත). කර්සරය කොටු වී ඇති බැවින්, ක්‍රියාත්මක කිරීම අවසන් වේ.

අනපේක්ෂිත අගයන්:
පරිශීලකයා වෙනත් අංකයක් ලියන්නේ නම්, එය තවමත් මුද්‍රණය වනු ඇත, එවිට කර්සරය අගය මත පදනම්ව වැඩි හෝ අඩු වාරයක් භ්‍රමණය වේ.

• 4 හෝ 0 ගුණ කිරීම: ක්‍රියාත්මක කිරීම තිරස් අතට ඉදිරියට ගොස් අවසන් වේ.
• 3 න් ගුණ කිරීම: ඉහළට යාම කළ නොහැකි බැවින්, කර්සරය වහාම ඔරලෝසුව වටා භ්‍රමණය වී තිරස් අතට ඉදිරියට ගොස් අවසන් වේ.
• 2 න් ගුණ කළ යුතු අතර 4 න් ගුණ කළ යුතු නොවේ: කර්සරය භ්‍රමණය වී වමට ගමන් කිරීමට පටන් ගනී. වාසනාවකට මෙන්, මේ සියල්ල කරන්නේ වැඩසටහන් ප්‍රවාහයට බලපාන්නේ නැති මෙහෙයුම් සමූහයක් සිදු කිරීම සහ තොගය හිස් කිරීම ය. තොගය හිස් බැවින් මෙහෙයුමක් කළ නොහැකි විට එය නොසලකා හරිනු ලැබේ. එය ඉහළ වම් කෙළවරට වැදුණු විට, කර්සරයට වෙනත් තැනකට යා නොහැකි නමුත් නැවත දකුණට ගොස් වැඩසටහන effectively ලදායී ලෙස නැවත ආරම්භ කරයි.
• වෙනත් අගයන්: කර්සරය 1 සමඟ පහළට යන අතර එය 1 සදාකාලිකව මුද්‍රණය කරයි. ආදානය 5 නම්, ප්‍රතිදානය වනු ඇත5111111111111...

පූර්ණ සංඛ්‍යාවක් නොවන ඕනෑම අගයක් මඟින් වැඩසටහන අවසන් වේ. ක්‍රියාත්මක කිරීම සාමාන්‍යයෙන් අඛණ්ඩව සිදුවනු ඇත, නමුත් තොගයේ කිසිවක් නොමැති බැවින් සියලු මෙහෙයුම් නොසලකා හරිනු ඇත. එබැවින් එක්තරා ආකාරයකින්, වැඩසටහන කිසි විටෙකත් බිඳ වැටෙන්නේ නැත - එය සාමාන්‍යයෙන් නතර වේ, නැතහොත් සදහටම ලූප වේ.

PietDev හිතකාමී අනුවාදය

PietDev (ඉතා මූලික ඔන්ලයින් Piet IDE) සුදු කෝඩල් සමඟ ගැටළුවක් ඇති බව පෙනේ, එබැවින් මම නව අනුවාදයක් සෑදුවෙමි, එය නිසි සුදු කෝඩල් ස්වයංක්‍රීය භ්‍රමණය මත රඳා නොසිට අතින් ආපසු ඉහළට කැරකෙයි. මට නව වර්ණයක් භාවිතා කිරීමට පවා අවශ්‍ය නොවීය! ඔබට එය සමඟ පරීක්ෂා කිරීමට අවශ්‍ය නම්, කේතය වටා කළු මායිමක් අඳින්නට වග බලා ගන්න, මන්ද පීට් දේව් අභිරුචි වැඩසටහන් ප්‍රමාණයන්ට සහාය නොදක්වයි.

පැරණි අනුවාද

පළමු අනුවාදය 1 පසුපසට තල්ලු නොකළ අතර ඒ වෙනුවට පෙර අනුපිටපත් උපදෙස් වෙත යොමු විය. එහි අලංකාර නිෂ් less ල කෝඩල් ද තිබුණි.

හිස් රේඛාව ඉවත් කිරීම සඳහා තොගයේ 1 ක් තල්ලු කිරීමේ අදහස පසුව මට තිබුණි. මගේ සැරසිලි කේත වලට ස්තුතිවන්ත වෙමින් මම එය සිතූ ආකාරය විහිළුවක්.

මට තව දුරටත් අවශ්‍ය නොවන බාහිර ඩුප් එකක් ඇති බව මට වැටහී ඇති අතර, රූපයේ ඇති පලත් දත්ත සුරැකීම සඳහා වර්ණ ගණන අඩු කළෙමි. මම දන්නේ නැති නිසා තනි සැරසිලි කෝඩලය ද ඉවත් කළෙමි.

පයිත්, 4 3 2

Wp

ඇත එය නැත! පසුපස අවකාශය (ස්තූතියි isaac :)). කාල පුඩුවක් සම්පාදනය කිරීම සඳහා අවශ්‍ය අවකාශය, නමුත් එතැන් සිට පයිත් යාවත්කාලීන කර ඇත. සාමාන්‍යයෙන් එය භාවිතා කිරීමට නුසුදුසු වනු ඇත, නමුත් මෙය නාමාවලියක් බැවින් එය වලංගු විය යුතුය.

පැහැදිලි කිරීම:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

චිප් , බයිට් 6 යි

e*faAs

චිප් යනු ඒකාබද්ධ පරිපථයක් මෙන් හැසිරෙන 2D භාෂාවකි. එය වරකට එක් බයිට් එකක් ආදානය ගෙන තනි ආදාන මූලද්‍රව්‍යවලට බිටු බිඳ දමයි. ප්‍රතිදානය ප්‍රතිදාන මූලද්‍රව්‍යවල අගයන් නැවත එකට බයිට් වලට දමයි.

අපි මෙය බිඳ දමමු:

*ප්‍රභව සං signal ාවක් වන අතර, එය සියලු යාබද මූලද්‍රව්‍යයන්ට සත්‍ය අගයක් යවනු ඇත. eසහ fනිමැවුමේ පස්වන හා හයවන බිට් වලට අනුරූප වේ. ඉතින්, e*fද්විමය නිෂ්පාදනය කරයි 00110000, එය ASCII char "0" වේ.

දැන්, A පළමු බිට් ආදානය වන අතර aඑය ප්‍රතිදානයේ පළමු බිට් වේ, එබැවින් aAඑම බිට් ආදානයේ සිට ප්‍රතිදානය දක්වා පිටපත් කරයි. එබැවින්, e*fASCII "0" හි ආදානයක් "0" ද, "1" "1" ද නිපදවයි. ( fසහ aකිසිදු සං signal ාවක් නිපදවන්නේ නැති නිසා සහ අතර අන්තර් ක්‍රියාකාරිත්වයක් නොමැත .)

මෙම sඅවසන් දින, සැබෑ සංඥාවක් සක්රිය විට, ආදාන ඉදිරි බයිට කිරීමට වලක්වන්නේ, මුළු දෙයක් එම ආදාන නැවත ක්රියාත්මක කරන බව අර්ථය ඉඩ නොදෙනු ඇත.

"0" හි පළමු බයිටය ශුන්‍ය බැවින්, එය මෙම මූලද්‍රව්‍යය සක්‍රිය නොකරන අතර වැඩසටහන "0" මුද්‍රණය කරනු ඇති අතර එමඟින් එහි ආදානය අවසන් වන අතර එය අවසන් කිරීමට ඉඩ දෙයි. කෙසේ වෙතත්, "1" මෙම මූලද්‍රව්‍යය සක්‍රීය කරයි, එයින් අදහස් වන්නේ "1" ප්‍රතිදානය වන නමුත් ආදානය මත පරිභෝජනය නොකිරීම නිසා චක්‍රය දින නියමයක් නොමැතිව පුනරාවර්තනය වීමට ඉඩ සලසයි.

ASCII වෙනුවට 0x0 සහ 0x1 අගයන් ප්‍රතිදානය සඳහා භාවිතා කරන්නේ නම්, අපට එම e*fකොටස ඉවත් කළ හැකිය. බයිට් 3 ක් :

aAs

Stdin වැසෙනු ඇතැයි අපේක්ෂා කරනවාට වඩා ශුන්‍යය අවසන් විය යුතු නම්, පහත දැක්වෙන දේ අපට ලැබෙනු ඇත, එය පළමු බයිටය සමඟ ප්‍රතිලෝම කර ප්‍රති result ලය ලබා ~දෙයි t, එය වැඩසටහන අවසන් කරයි ( බයිට් 10 ):

aA~te*f
 s

( tසං signal ාවක් ද නිපදවන්නේ නැත, එබැවින් tසහ අතර අන්තර්ක්‍රියාකාරිත්වයක් නොමැත e.)

මොළය , බයිට් 5 යි

,.[.]

Brainbool යනු Brainfuck, නමුත් එය ක්‍රියාත්මක වන්නේ බිටු මත පමණක් වන අතර I / O හරහා 0සහ 1අක්ෂර හරහා ක්‍රියා කරයි .

ලොල්කෝඩ්, බයිට් 119

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE

සී, බයිට් 37 යි

සී හි එය කරන්නේ කෙසේද යන්න පිළිබඳ වෙනස් මතයක්.

main(c){for(gets(&c);putchar(c)&1;);}

cintඅගය 1 gets(&c)ට පෙරනිමි වේ. stdinමෙහි cසිට නූලක් ලැබෙනු cඇත char*. putchar(c)වටිනාකම මුද්රණය cකිරීමට stdout, සහ ප්රතිලාභ c. ASCII හි '0'48 සහ '1'49 වන බැවින්, එය කුමක්දැයි තීරණය කිරීමට අපට අවසාන බිට් ( &1) භාවිතා කළ හැකිය . එය නම් '0', ලූපය කැඩී යයි. එසේ නොමැති නම්, එය සදහටම යයි.

සම්පාදනය කරයි (පිළිබඳ අනතුරු ඇඟවීමක් සහිතව gets) සහ gcc-4.8ලිනක්ස් යටතේ ක්‍රියාත්මක වේ.

ලැබ්රින්ත් , බයිට් 7 යි

 ?+
@!:

ලැබ්රින්ත් යනු 2D සිරස් මත පදනම් වූ භාෂාවකි, එහිදී පාලක ප්‍රවාහය තොගයේ ඉහළ මූලද්‍රව්‍යයේ ලකුණ මත රඳා පවතී. ක්‍රියාත්මක කිරීම ඉහළ පේළියේ පළමු වලංගු උපදෙස් වලින් දකුණට ගමන් කිරීමට පටන් ගනී ?.

අදාළ උපදෙස්:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

ආදානය 0 නම්, අයිපී සමඟ ආදානය කියවයි ?, තොගයේ ( 0 + 0 = 0) හි ඉහළම දෙක එකතු කරයි , පසුව අනුපිටපත් කරයි: කර ප්‍රතිදානය !0 කරයි. මෙහිදී අපට වැඩසටහනේ එකම හන්දිය හමු වන අතර, තීරණය කිරීම සඳහා තොගයේ ඉහළ කොටස පරීක්ෂා කළ යුතුය. කොහෙද යන්න. ඉහළට 0 වන බැවින්, අපි ඉදිරියට ගොස් අවසන් කරමු @.

අනෙක් අතට, ආදානය 1 නම්, අපි හන්දියට ළඟා වීමට පෙර පෙර උපදෙස් (නමුත් 1 ප්‍රතිදානය කිරීම) කරන්නෙමු !. දැන් තොගයේ ඉහළ කොටස ධනාත්මක වන අතර එමඟින් අප දකුණට හැරේ ?. ඒ නිසා අපි කරන්න EOF Labyrinth මත, 0 තල්ලු 0 + 1 = 1දී +, අනුපිටපත් :, සහ ප්රතිදානය !. නැවත වරක් අපි තොගයේ ඉහළින් 1 ක් ඇති අතර ලූපය දිගටම පවතී.

ප්‍රසාද දීමනාවක් සඳහා, මෙන්න @ මාටින්බට්නර්ගේ බයිට් 7 විසඳුම, ඒ හා සමානව ක්‍රියාත්මක වේ:

?+!@
1!

බොහෝ භාෂාවන් මෙන් නොව, 1ඇත්ත වශයෙන්ම තොගයෙන් nඉවතට තල්ලු n*10 + 1වන අතර විශාල සංඛ්‍යාවක් ගොඩනැගීම පහසු කරයි. කෙසේ වෙතත්, එම අවස්ථාවේදී තොගයේ ඉහළ කොටස හිස් බැවින් එය හුදෙක් 1 තල්ලු කිරීමට වඩා වෙනස් නොවේ.

> <> , බයිට් 7 යි

i2%:n:,

මෙය භාවිතා කරන්නේ> <> EOF මත -1 තල්ලු කරයි, එය 1 මෝඩ් 2 වේ. එය අවසන් කිරීම සඳහා 0 න් බෙදීම ද භාවිතා කරයි (STDERR ප්‍රතිදානය නොසලකා හැර ඇති බවට එකඟතාව ඇති බැවින් එය හරි ය).

යොමු කිරීම සඳහා, දෝෂ නොමැතිව පිරිසිදු ලෙස පිටවීම අතිරේක බයිට් එකකි:

i2%:n?!;

ඒපීඑල්, ​​බයිට් 6 යි

→⎕←⍣⍲⎕

පැහැදිලි කිරීම:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.

බ්‍රයන් සහ චක් , බයිට් 21 යි

,}<-{-?<SOH>_{+?
_>+{?<.p

මෙන්න, <SOH>අනුරූප පාලන අක්‍ෂරය (0x01) සමඟ ප්‍රතිස්ථාපනය කළ යුතුය.

පැහැදිලි කිරීම

මූලික අදහස නම් ආදානයේ අක්ෂර කේතය (48 හෝ 49) pචක් අවසානයේ සිට අඩු කිරීම ය, එය එක්කෝ ?(වලංගු විධානයක්) හෝ a@ .

,ආදාන අක්‍ෂරය චක්ගේ පළමු කොටුවට කියවයි (සලකුණු කර ඇත _). අපට මෙම අගය දක්වා අඩු කිරීමට අවශ්‍යයි0වෙනත් වෙනස්කම් සිදු කරන අතරම ලූපයක් :

}<මෙම පියවරයන් ගනිමින් pහා -එය decrements. ඉන්පසු {ආදාන සෛල -අඩුවීම වෙත නැවත ගමන් කරයි . මෙය තවම ශුන්‍ය නොවන තාක් කල්, ?චක්ට පාලනය ලබා දෙයි. දැන් >බ්‍රයන්ගේ ටේප් හිස එක් කොටුවක් දකුණට ගෙන යයි (එය ආරම්භ කර ඇත 1) සහ එය +වැඩි කරයි. ඉන්පසු අපි ලූපය නැවත සකස් කරමු{? .

චක් හි පළමු කොටුව පහර දෙන විට 0, <SOH>සෛලය අප STDIN වෙතින් කියවා ඇති අක්ෂරයට වැඩි කර ඇති අතර pඑය ?ආදානය සඳහා 1හෝ ආදානය සඳහා වනු ඇත .@0

දැන් ?පාලනය තවදුරටත් මාරු නොවේ. මෙම 0හෝ 1මෙම ශූන්ය-බයිට (නියෝජනය වන ලෙස එය, යම් කිසි-op පසු _). {චක්ගේ පළමු කොටුව වෙත නැවත ගමන් +කරන අතර එය ධනාත්මක බව සහතික කිරීම සඳහා වර්ධක වේ? .

මෙම කාලය >+බ්‍රයන් ගේ ආරම්භක පටිය අවසන් වීමෙන් පසු සෛලය වැඩි කරයි. එම සෛලය කුණු කසළ නමුත් අපි එය කිසි විටෙකත් භාවිතා නොකරමු. දැන් {බ්‍රයන්ගේ ටේප් එකේ ඉදිරිපස පැත්තට පරිලෝකනය නොකරයි, නමුත් එය පමණි _. එබැවින් ?වත්මන් සෛලය ශුන්‍ය බැවින් එය විවෘත නොවේ. ඉන්පසු <.එකක් වමට ගෙනයන්න (ආදාන අක්‍ෂරයේ පිටපත) එය මුද්‍රණය කරයි.

අවසාන වශයෙන්, අප මුහුණ ?හෝ @. ආදානය නම් 0සහ මෙම කොටුව නම් @එය විවෘත නොවන අතර වැඩසටහන අවසන් වේ. නමුත් ආදානය තිබුනේ නම් 1සහ මෙම සෛලය ?අපි බ්‍රයන් වෙත භාර දෙන අතර ඔහු {+?චක් මත ලූපය නැවත සකසනු ඇත, දැන් අපි 1සදහටම මුද්‍රණය කරන්නෙමු (බ්‍රයන් ටේප් අවසානයේ ඇති කොටුවේ ඇති පූර්ණ සංඛ්‍යාව මතකයට නොගැලපෙන තුරු) තවත්, මම හිතන්නේ ...).

පාරිතෝෂිකය

Sp3000 සහ මම දින කිහිපයක් තිස්සේ ගොල්ෆ් ක්‍රීඩා කරමින් සිටිමු. අපි බයිට් 40 ක් පමණ ආරම්භ කර සම්පූර්ණයෙන්ම වෙනස්, නමුත් බයිට් 26 ක විසඳුම් දෙකක් වෙත පැමිණියෙමු. මගේ පැහැදිලි කිරීම ලිවීමට පටන් ගත් විට පමණක්, ඉහත බයිට් 21 විසඳුම මට සිදු විය. අදහස් හා තොරතුරු එකිනෙකාට ඉගැන්වීම සහ බී ඇන්ඩ් සී හි ගොල්ෆ් ක්‍රීඩා කිහිපයක් එකිනෙකාට ඉගැන්වීම ගැන ස්පීට බොහෝ ස්තූතියි. :)

මෙය ඔහුගේ බයිට් 26 විසඳුමයි:

>,----{?{>1?0
#I<?_}<.<<<?

මෙය මගේ ය:

,{>-<-?_0+?_1{<?
_®{?_{>.?

®174 අගය සහිත බයිට් එකක් කොහිද (උදා: ගොනුව ISO 8859-1 ලෙස සුරකින්න).

මධ්‍ය පතලේ බයිට් 21 විසඳුමට සමානව ක්‍රියා කරයි, ®එය }ආදානය සඳහා 1සහ ආදානය සඳහා ~(නො-ඔප්) බවට පත්වේ 0, නමුත් ක්‍රියාත්මක කිරීම වඩා අලංකාර නොවේ.

ප්‍රභව කේතය ASCII- පමණක් වන අතර ආදානය සැකසීමට ලූපයක් අවශ්‍ය නොවන බව ඔහුගේ විසඳුම තරමක් පිළිවෙලයි. ඒ වෙනුවට, ----මාරුවෙන් මාරුවට 1බවට -සහ 0බවට ,(අ කිසිදු-op තරිඳු සඳහා). එමඟින් බ්‍රයන් ටේප් එකේ -පළමුවැන්න ?a >බවට වෙනස් වන අතර එමඟින් 1කේස් සඳහා විවිධ පාලන ප්‍රවාහයක් නිර්මාණය වේ.

බිට්වයිස් චක්‍රීය ටැගය , බිටු 3 ක් හෝ <1 බයිට්

බිට්වයිස් චක්‍රීය ටැගය යනු එහි ඇති සරලම ටියුරින්-සම්පූර්ණ භාෂාවකි. එය බිට්ස්ට්රිං දෙකක් සමඟ වැඩ කරයි, වැඩසටහන සහ දත්ත . වල බිටු වැඩසටහන චක්රීය කියවා පහත සඳහන් ලෙස අර්ථ ඇත:

• 0: පළමු දත්ත බිට් මකන්න (සහ ප්‍රතිදානය ඇති ක්‍රියාත්මක කිරීමේදී එය ප්‍රතිදානය කරන්න).
• 1x: පළමු දත්ත බිට් නම් 1, දත්තවල අවසානයට එකතු කරන්න x(එක්කෝ 0හෝ නියෝජනය කරයි 1). (පළමු දත්ත බිට් නම් 0, කිසිවක් නොකරන්න.)

දත්ත දාමය හිස් වන තුරු වැඩසටහන ක්‍රියාත්මක වේ.

සත්‍ය යන්ත්‍රය

110

දත්ත දාමය පහත පරිදි සකසා ඇති විට 0:

• 11පළමු දත්ත බිට් නොවන නිසා කිසිවක් එකතු නොකරයි 1.
• 0මකාදැමීම් / ප්‍රතිදානයන් 0.
• දත්ත දාමය දැන් හිස්ව ඇති අතර වැඩසටහන නතර වේ.

දත්ත දාමය පහත පරිදි සකසා ඇති විට 1:

• 11 appends a 1.
• 0 deletes/outputs 1.
• The data string is back to a single 1 and the program is back to where it started, so we loop forever.

GNU sed, 10

:;/1/{p;b}

Explanation

• : define an unnamed label
• /1/ If input matches the regex 1, then
• p print the pattern space (i.e. 1)
• b and jump back to the unnamed label (forever)
• If the input was not 1 (i.e. 0), then the pattern space is printed unmodified and the program ends.

Seriously, 4 3 bytes

_{Crossed-out 4 is still 4 :(}

,W■

, reads a value from STDIN. W starts a loop that runs while the value on top of the stack is truthy, with the body ■. ■ prints the top stack element without popping. The loop is implicitly closed at EOF.

On input of 0, the loop never executes (since 0 is falsey), and the program ends at EOF, automatically popping and printing every value on the stack. On input of 1 (or any value that is not 0, "", or []), the loop runs infinitely.

In Actually, the leading , is not needed (thanks to implicit input), bringing the score down to 2 bytes.

Thue, 34 bytes

1::=12
2::=~1
0::=~0
@::=:::
::=
@

Explanation:

1::=12 Instances of the substring "1" can become "12"

2::=~1 Instances of the substring "2" can be removed, printing "1"

0::=~0 Instances of the substring "0" can be removed, printing "0"

@::=::: Instances of the substring "@" can be replaced with strings from the input

::= End list of substitution rules

@ The initial string is "@"

Arnold C, 134 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

While this isn't as entertaining as the other ArnoldC answer, it's golfed. For example, indentation is unnecessary, and so are the macros @NO PROBLEMO and @I LIED.

Tested with this version of the language, which cannot take input.

Cubix, 5 6 bytes

Cubix is @ETHproductions new 2 dimensional language where the commands are wrapped around the faces of a cube. Online interpreter Thanks to @ETHproductions for the saving.

!I\@O

This ends up expanded out to the cube

  !
I \ @ O
  .

This starts with the I command. Input an integer onto the stack.
\, redirects the instruction pointer down over the no op.
O, outputs the numeric value of top of stack.
!, skip the next command (@) if top of stack true. This will jump the \ redirect if 1
\, redirects the instruction pointer to the @ exit program.

This takes advantage of the fact the stack isn't popped by the O ? ! commands.

Foo, 6 bytes

&1($i)

Input is hardcoded as the second character, since Foo doesn't have STDIN input. Don't we agree that Foo is awesome now? :)

Explanation

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

Perl, 18 + 1 = 19 13 + 1 = 14 bytes

print while$_

Run like this:

echo -n NUM | perl -p truth.pl

Thanks to ThisSuitIsBlackNot (who is way better at Perl golfing than me) for golfing off five bytes.

><>, 6 bytes

::n?!;

Pushes the input on the stack to start

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution