හැලොවීන් පැමිණීම නිසා මම සිතුවේ විනෝදජනක කුඩා කේත ගොල්ෆ් අභියෝගයක් ආරම්භ කළ හැකි බවයි!

අභියෝගය තරමක් සරල ය. ඔබ පහත ප්රතිඵල එක්කෝ වැඩසටහන ලිවීමට trickහෝ treat.
"ඇඹරීම?" ඔබට ඇසිය හැකිය. හොඳයි මට පැහැදිලි කිරීමට ඉඩ දෙන්න:

ඔබේ වැඩසටහන පහත සඳහන් දේ කළ යුතුය:

• විවිධ භාෂා දෙකකින් සම්පාදනය කළ හැකි / ධාවනය කළ හැකි වන්න. එකම භාෂාවේ විවිධ අනුවාදයන් ගණන් නොගනී.
• ඔබ වැඩසටහන එක් භාෂාවකින් ක්‍රියාත්මක කරන විට එය ප්‍රතිදානය කළ යුතු trickඅතර අනෙක ප්‍රතිදානය කළ යුතුය treat. නඩුව අදාල නොවන අතර සුදු පැහැති අක්ෂර සහිත නූල් පෑඩ් කිරීමට අවසර ඇත (උදාහරණ බලන්න).
• මෙය කේත-ගොල්ෆ් වේ , එබැවින් අවම බයිට් කිහිපයක් සමඟ විසඳුම ජය ගනී.

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

වලංගු ප්‍රතිදානයන් (භාෂා දෙකෙන් කේතය ධාවනය නොකිරීම සඳහා වචන සඳහා පමණි. ප්‍රතිදානයේ ආරම්භය හෝ අවසානය සං signal ා කිරීම සඳහා මිල ගණන් එකතු කිරීම. ඒවා ඔබේ විසඳුමට ඇතුළත් නොකරන්න!):

"trick"

"Treat"

"    TReAt"

"
     tRICk          "

වලංගු නොවන ප්‍රතිදානයන් :

"tri ck"

"tr
eat"

"trck"

ඔබට ඉදිරිපත් කළ හැකි දේ දැකීමට මම කැමැත්තෙමි! ප්‍රීතිමත් ගොල්ෆ් ක්‍රීඩාව!

මෙය මගේ පළමු අභියෝගය බව සටහන් කිරීමට කැමැත්තෙමි, එබැවින් ඔබට මෙම ප්‍රශ්නය පිළිබඳ යෝජනා තිබේ නම් කරුණාකර ඒවා අදහස් දැක්වීමේ ස්වරූපයෙන් තබන්න.

ප්‍රමුඛ පුවරු

නිත්‍ය ප්‍රමුඛ පුවරුවක් සහ භාෂාව අනුව ජයග්‍රාහකයින් පිළිබඳ දළ විශ්ලේෂණයක් ජනනය කිරීම සඳහා ස්ටැක් ස්නිපටයක් මෙන්න.

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

# 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

var QUESTION_ID=97472,OVERRIDE_USER=23417;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=o.replace(TAGS_REG,"")),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i,TAGS_REG = /(<([^>]+)>)/ig;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:400px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="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><div id="language-list"> <h2>Winners 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><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>

2sable / pl , බයිට් 8 යි

0000000: 74 72 65 61 74 93 d0 cb                          treat...

මෙම වැඩසටහන් දෙකම එකම බයිට් 8 ගොනුවක් සමඟ දේශීයව පරීක්ෂා කර ඇත, එබැවින් මෙය නිසි බහු භාෂාවක් වේ.

2sable: උපක්‍රමය

1252 කේත පිටුවේ ඇති වැඩසටහන මෙයයි .

treat“ÐË

එය මාර්ගගතව උත්සාහ කරන්න!

pl: සලකන්න

කේත පිටුව 437 හි ඇති වැඩසටහන මෙයයි .

treatô╨╦

එය මාර්ගගතව උත්සාහ කරන්න!

එය ක්‍රියාත්මක වන ආකාරය

2sable: උපක්‍රමය

t         Square root. Errors since there is no input. The exception is caught, the
          stack left unaltered, and the interpreter pretends nothing happened.
 r        Reverse stack.
          Reversed empty stack is still empty stack. ;(
  e       Compute nCr. Errors since there is no input.
   a      Alphanumeric test. Errors since there is no input.
    t     Square root. Errors since there is no input.
     “    Begin a lowercase string literal.
      Ð     Excluding ‘, ’, “, and ”, Ð is the 71st non-ASCII character in CP1252.
       Ë    Excluding ‘, ’, “, and ”, Ë is the 66th non-ASCII character in CP1252.
          (implicit) End string literal.
          Both characters together fetch the dictionary word at index
          71 * 100 + 66 = 7166, which is 'trick'.

pl: සලකන්න

treat     Bareword; push the string "treat" on the stack.
     ô    Unimplemented. Does nothing.
      ╨   Flatten the stack. This doesn't affect the output.
       ╦  Unimplemented. Does nothing.

පයිතන් / වින්ඩෝස් කණ්ඩායම, බයිට් 25 යි

print"trick"#||echo.treat

# ට පසුව ඇති සියල්ල පයිතන් විසින් අදහස් දැක්වීමක් ලෙස අර්ථකථනය කරන අතර || පෙර විධානය අසමත් වූ බැවින් මෙය ක්‍රියාත්මක කරන්නැයි කියමින් OR කණ්ඩායමකි.

OR එකක් භාවිතා කිරීමට මම කැමතියි එය “උපක්‍රම හෝ සංග්‍රහ කිරීම” කියවන විට :)

වයිට්ස්පේස් / ස්ටාර්රි, බයිට් 135 යි

මෙන්න හැලොවීන් හි පැහැදිලි රාත්‍රී අහසකට!

  + + + + + 
    +

* + + * + *

   + *           
     + +        

 + * +   



 + * +. +. + + * + + *. . .

ඔබ ඉහත කේතයෙන් පිටපත් කරන්නේ නම් හිස් රේඛාවල සුදු අවකාශය ආරක්ෂා නොවන බව සලකන්න

වයිට්ස්පේස් ප්‍රතිදානය "TRICK". එය මාර්ගගතව උත්සාහ කරන්න!
තරු ප්‍රතිදානයන් "TREAT". එය මාර්ගගතව උත්සාහ කරන්න!

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

තරු

තරු සියලු ටැබ් සහ නව රේඛා නොසලකා හරින බැවින් එය කියවන කේතය පහත දැක්වේ

         + + + + + +  * +   +*   +  *   +  *       + +   +* +   +* + .  + .   +      +* +   +* . . .

ස්ටාර්රි හි ඇති තොග සහ ගණිතමය මෙහෙයුම් වලට සාපේක්ෂව අගයන් තල්ලු කිරීම ඉතා මිල අධිකය. කේතය ආරම්භ වන්නේ 4 තල්ලු කිරීම හා අනුපිටපත් කිරීමෙනි. එය මත මෙහෙයුම් ගණනාවක් සිදු කරන අතර 2 සහ 1 පසුව තල්ලු කිරීමෙන් අවශ්‍ය ASCII අගයන් සියල්ලම නිපදවනු ලැබේ.

විවරණ කේතය

Stack (after op)    Code        Operation
4                            +  Push 4
4 4 4 4 4 4          + + + + +  Duplicate top of stack 5 times
4 4 4 4 16            *         Multiply top two items
4 4 4 4 16 16        +          Duplicate top of stack
4 4 4 16 4 16          +        Rotate top three items on stack right
4 4 4 16 20         *           Add top two items
4 4 20 4 16            +        Rotate...
4 4 20 64             *         Multiply...
4 64 4 20              +        Rotate...
4 64 80               *         Multiply...
4 64 80 2                  +    Push 2
4 64 80 2 2          +          Duplicate...
4 64 2 80 2            +        Rotate...
4 64 2 82           *           Add...
4 64 2 82 82         +          Duplicate...
4 64 82 2 82           +        Rotate...
4 64 82 84          *           Add...
4 64 82 84 84          +        Rotate...
4 64 82 84           .          Pop and print as character (T)
4 64 84 82            +         Swap top two items on stack
4 64 84              .          Pop and print... (R)
84 4 64                +        Rotate...
84 4 64 1                 +     Push 1
84 4 65             *           Add...
84 4 65 65           +          Duplicate...
84 65 4 65             +        Rotate...
84 65 69            *           Add...
84 65                .          Pop and print... (E)
84                   .          Pop and print... (A)
                     .          Pop and print... (T)

වයිට්ස්පේස්

නමට අනුව, වයිට්ස්පේස් අවකාශය, ටැබ් සහ නව රේඛාව යන සුදු අවකාශයේ අක්ෂර තුන පමණක් විග්‍රහ කරයි. තරු පිරුණු මෙන් නොව, Whitespace හුදෙක් යන ASCII වටිනාකම් තල්ලු T, R, I, C, හා Kහා මුද්රණ ඔවුන්.

විවරණ කේතය

<Space><Space><Space><Tab><Space><Tab><Space><Space><Tab><Space><LF> Push the ASCII value of R
<Space><Space><Space><Tab><Space><Tab><Space><Tab><Space><Space><LF> Push the ASCII value of T
<Tab><LF><Space><Space> Pop and print the T
<Tab><LF><Space><Space> Pop and print the R
<Space><Space><Space><Tab><Space><Space><Tab><Space><Space><Tab><LF> Push the ASCII value of I
<Tab><LF><Space><Space> Pop and print the I
<Space><Space><Space><Tab><Space><Space><Tab><Space><Tab><Tab><LF>   Push the ASCII value of K
<Space><Space><Space><Tab><Space><Space><Space><Space><Tab><Tab><LF> Push the ASCII value of C
<Tab><LF><Space><Space> Pop and print the C
<Tab><LF><Space><Space> Pop and print the K
<LF><LF><LF>            Terminate the program. The following line is not run.
<Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><LF>

තල්ලුව සහ මුද්‍රණය අතර අන්තර් සම්බන්ධතාවය තෝරා ගනු ලැබුවේ හුදෙක් බයිට් ගණනය කිරීමට බල නොපාන බැවින් සෞන්දර්යාත්මක හේතූන් මත ය.

ලිනක්ස් ELF x86 / DOS .COM ගොනුව, බයිට් 73 යි

00000000  7f 45 4c 46 01 00 00 00  1a 00 00 00 1a 00 43 05  |.ELF..........C.|
00000010  02 00 03 00 1a 00 43 05  1a 00 43 05 04 00 00 00  |......C...C.....|
00000020  eb 0c b4 09 ba 41 01 cd  21 c3 20 00 01 00 b2 05  |.....A..!. .....|
00000030  b9 3b 00 43 05 cd 80 2c  04 cd 80 74 72 69 63 6b  |.;.C...,...trick|
00000040  00 74 72 65 61 74 24 eb  d9                       |.treat$..|
00000049

NASM ප්‍රභවය:

ORG 0x05430000

BITS 32                                         ;
                                                ;   ELF HEADER    --   PROGRAM HEADER
; ELF HEADER                                    ; +-------------+
DB 0x7f,'E','L','F'                             ; | magic       |    +--------------------+
                                                ; |             |    |                    |
; PROGRAM HEADERS                               ; |             |    |                    |
DD 1                                            ; |*class 32b   | -- | type: PT_LOAD      |
                                                ; |*data none   |    |                    |
                                                ; |*version 0   |    |                    |
                                                ; |*ABI SysV    |    |                    |
DD 0x01a        ; offset = vaddr & (PAGE_SIZE-1); |*ABI vers    | -- | offset             |
                                                ; |             |    |                    |
entry:  DD 0x0543001a                           ; |*PADx7       | -- | vaddr = 0x0543001a |
DW 2                                            ; | ET_EXEC     | -- |*paddr LO           |
DW 3                                            ; | EM_386      | -- |*paddr HI           |
DD 0x0543001a                                   ; |*version     | -- | filesz             |
;       inc     ebx     ; STDOUT_FILENO         ; |             |    |                    |
;       mov     eax, 4  ; SYS_WRITE             ; |             |    |                    |
DD 0x0543001a                                   ; | entry point | -- | memsz              |
DD 4                                            ; | ph offset   | -- | flags: RX          |
                                                ; |             |    |                    |
        jmp     short skip                      ; |*sh offset   | -- |*align              |
BITS 16                                         ; |             |    |                    |
treat:  mov     ah, 9                           ; |             | -- |                    |
        mov     dx, trick + 0x100 + 6           ; |*flags ______|    |                    |
        int     0x21                            ; |______/      |    +--------------------+
        ret                                     ; |*ehsize      |
BITS 32                                         ; |             |
DW 32                                           ; | phentsize   |
DW 1                                            ; | phnum       |
skip:                                           ; |             |
        mov     dl, 5   ; strlen("trick")       ; |*shentsize   |
        mov     ecx, trick                      ; |*shnum       |
                                                ; |*shstrndx    |
                                                ; +-------------+
        int     0x80
        sub     al, 4   ; SYS_EXIT
        int     0x80


trick:  DB      "trick/treat$"

BITS 16
        jmp     short treat

මෙය භාවිතා කරන්නේ ELF ශීර්ෂය 7F 45 සමඟ ආරම්භ වන අතර එය x86 කේතය ලෙස අර්ථකථනය කිරීම පැනීමකි.

ඩොස් සඳහා අදාළ කොටස් .කොම්:

-u100 l2
07D2:0100 7F45          JG      0147
-u147 l2
07D2:0147 EBD9          JMP     0122
-u122 l8
07D2:0122 B409          MOV     AH,09
07D2:0124 BA4101        MOV     DX,0141
07D2:0127 CD21          INT     21
07D2:0129 C3            RET
-d141 l6
07D2:0140     74 72 65 61 74 24   -                           treat$

නපුරු / ZOMBIE , බයිට් 109

තවත් භයානක පිළිතුරක්!

xf is a vampire summon task f say "trick" stumble say "jzuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeaw" animate bind

මෙම ZOMBIEකේතය නිර්වචනය vampireනම් xfතම එකම කාර්යය finstanciation හා කැමැත්ත ප්රතිදාන ලෙස ක්රියාත්මක වේ trickවිසින් වන තුරැ පෙර එක් වරක් stumble. අනෙක් sayඇමතුම සඳහා මළ කේතය (කෙතරම් උචිතද!) ZOMBIE, නමුත් බොහෝ evilකේත අඩංගු වේ .

සඳහා evil, මෙම xfනම ඊළග කොටුවට වෙත දුරකථන ඇමතුමක් වේ j, මෙම දිව්රුම් zuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeawශිල්ප හා නිමැවුම දුක්බර පාරවල් වල treat. පහත දැක්වෙන කේතය ක්‍රියාත්මක කරනු ලැබේ (කුඩා අකුරු) හෝ නොසලකා හරින නමුත් wප්‍රතිදානයක් නොමැති බැවින් ප්‍රතිදානය නිපදවිය යුතු නොවේ.

පයිතන් / පර්ල්, බයිට් 28 යි

print([]and"trick"or"treat")

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

සිට []perl බසට ලං දී ArrayRef වේ, එය truthy, නමුත් එම නිසා එය falsy Python හිස් අරාව, වේ.

PHP / JavaScript, බයිට් 32 30

trickPHP සහ treatJS හි පෙන්වයි .

NaN?die(trick):alert('treat');

නොදන්නා NaNනියතය PHP විසින් ව්‍යංගයෙන් නූල් බවට පරිවර්තනය කර එය සත්‍ය බවට පත් කරයි. එය ජේ.එස්.

විකල්ප ක්රමය, බයිට් 38 යි

(1?0:1?0:1)?die(trick):alert('treat');

තෘතීය ක්‍රියාකරු JS හි නිවැරදි සහායකය:

                1 ? 0 : 1 ? 0 : 1
 is parsed as:  1 ? 0 : (1 ? 0 : 1)
 which equals:  0

සහ PHP හි වාම සහායක:

                1 ? 0 : 1 ? 0 : 1
 is parsed as:  (1 ? 0 : 1) ? 0 : 1
 which equals:  1

HTML / HTML + JavaScript, බයිට් 53

treat<script>document.body.innerHTML='trick'</script>

treatයනු HTML හි ලේඛනයේ පෙළ අන්තර්ගතයයි.
JS සක්‍රීය කර ඇත්නම්, එය HTML අන්තර්ගතය ප්‍රතිස්ථාපනය කරයි trick.

සී / ජාවා 7, 165 155 128 123 122 120 103 බයිට්

//\
class a{public static void main(String[] s){System.out.print("treat"/*
main(){{puts("trick"/**/);}}

// the ඊළඟ පේළිය C හි විවරණයක් ද කරයි, නමුත් එය ජාවා හි නිත්‍ය එක් පේළියක් වේ, එබැවින් ඔබට ජාවා සඳහා C නොසලකා හැරීමේ කේතය සෑදිය හැකි අතර දෙවන පේළියේ / * එකතු කිරීමෙන් ඔබට ජාවා සඳහා අදහස් දැක්වීමක් කළ හැකිය. සී මගින් කේතය ලෙස විග්‍රහ කර ඇත.

සංස්කරණය කරන්න: රේඛා සහ අදහස් ප්‍රතිසංවිධානය කිරීමෙන් මම එය ටිකක් වැඩි දියුණු කළෙමි.

Edit2: මම තවත් ප්‍රතිසංවිධානයක් කළ අතර එය තවත් කෙටි කළෙමි.

Edit3: බයිට් 5 ක් ඉවත් කිරීමට බ්‍රයින්ස්ටෝන් විසින් යෝජනා කරන ලද නිවැරදි කිරීම් මම එකතු කළෙමි, ස්තූතියි :)

Edit4: එක් නව රේඛාවක් අනවශ්‍ය බවට පත් වූ නිසා මම එය ඉවත් කළෙමි.

Edit5: මම printf put ලෙස වෙනස් කළෙමි.

Edit6: මම රේ හැමෙල් විසින් යෝජනා කරන ලද නිවැරදි කිරීමක් එක් කළෙමි.

ජොල්ෆ් + චේන්, බයිට් 12 යි

කේතන ක්‍රමයක් සමඟ උඩුගත කිරීම සඳහා චේන්ට ගොනුවක් භාර ගත නොහැකි නිසා, මම උපකල්පනය කරන්නේ යූටීඑෆ් -8 ය. (මට ISO-8859-7 උපකල්පනය කළ හැකි නම්, මෙය බයිට් 11 ක් වනු ඇත, නමුත් එය අසාධාරණ වනු ඇත.)

trick«treat

චේන් හි, «අදහස් දැක්වීමක් ආරම්භ කරන අතර, ඉතිරි කොටස වාචිකව මුද්‍රණය කෙරේ. ජොල්ෆ් හි, «නූලක් ආරම්භ කරයි. ස්තූතියි, trickහානිකර කිසිවක් නොකරයි ( 10; range(input, parseInt(input))මූලික වශයෙන්), treatඑය මුද්‍රණය කර ඇත.

මෙහි ජොල්ෆ් උත්සාහ කරන්න!

චේන් මෙහි උත්සාහ කරන්න!

ඔවුන් දෙදෙනාම මගේ බ්‍රව්සරයේ වැඩ කරයි (ෆයර්ෆොක්ස්, නවතම අනුවාදය), නමුත් අනෙක් බ්‍රව්සර් සඳහාද එයම කිව නොහැක.

#hell / ලතෝනිය , 43 බයිට්

><>සෑම තැනකම මෙතරම් , මෙය කුමක්ද, අප්රේල් මෝඩයන්ගේ අභියෝගයක්? සුදුසු තේමාත්මක භාෂාවන්ගෙන් පිළිතුරක් මෙන්න.

--<.<.<.<.<.$
io.write("trick")--+<~}~@+{+<

#hellනිමැවුම් ඇමතුම් LUAවාසනාවකට පිළිගන්නා උප කුලකයකි io.write. අප භාවිතා LUAගේ --පමණක් මෙම අත්පිටපත පිළියෙල ක්රියාත්මක කරන නිසා අදහස්.

Agonyයනු Brainfuckඑම ටේප් එහි කේතය හා කම්කරු මතක ඇති කර ගැනීමට particularity ඇති ව්යුත්පන්න. පළමු පේළියේ කේත කොටසේ අවසානයේ සිට අක්ෂර 5 ක් (සෛල 10 ක්) පමණක් මුද්‍රණය කරයි, එහිදී මම විධාන treatලෙස කේතනය කර Agonyඇත. LUAඅදහස් දැක්වීම විවෘත කිරීම --භාවිතා නොකරන සෛලයක වටිනාකම වෙනස් කරයි.

කියුබික්ස් / ෂඩාස්රාකාර , බයිට් 31 යි

t;./e;_a]"kcirt">o?@;=v=./r;\;/

එය අත්හදා බලන්න! එය මාර්ගගතව සලකන්න!

හැලොවීන් තේමාව ? මෙම භාෂා සහ කේතය පිළිබඳ බිහිසුණු කරුණු සැලකිල්ලට ගන්න:

1. හා ඔබ කිසිවක් පවා නම් (හුදෙක් කිසිදු-මෙහෙයුම් දමා) නම්, ඔබ හැකි කිසි සදහටම ධාවනය කිරීමට තීරණය කරන ලූප එළියට ...
2. ත්‍රිමාණ සහ ද්විමාන ක්‍රමලේඛන භාෂාවක් මැද සිරවී සිටීම (ඔහ් වේදනා ...)
3. මානයන් ඇතුළත, ඔබ සිටින තැන ක්‍රමයෙන් ඔබට අහිමි වනු ඇත ... ඔබ සිටි ස්ථානය ...
4. හා පවතින =v=ඔබ කේතය කිසිදු-මෙහෙයුම් දී ක්රියා කරන හිනා

මානයන් සහ භීෂණය පිළිබඳ සැඟවුණු බයිට් 31 සන්නිවේදන ප්‍රොටෝකෝලයෙහි අභිරහස සොයා බලමු ...

උපක්‍රමය

කේතය නැවී හෝ දිග හැරෙන විට ... එනම් cubified, පිරිසැලසුම මේ ආකාරයට පෙනේ:

      t ; .
      / e ;
      _ a ]
" k c i r t " > o ? @ ;
= v = . / r ; \ ; / . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

ප්රධාන කොටස මධ්යයේ මෙම කොටස වේ:

" k c i r t " > o ? @ .
. . . . . . . \ ; / . .

එය තොගයට තල්ලු k,c,i,r,tකර oප්‍රතිදාන සහ ;පරාවර්තකවලින් මායිම් වූ ලූපයක් තුළට විහිදෙන ?අතර එය තොගයේ ඉහළ අගය මත පදනම්ව ඔබට මග පෙන්වයි ...

සලකන්න

හදිසියේම, කේතය ube නකයක් සිට ෂඩාස්රයක් බවට පරිවර්තනය වේ. (එය සිතන්න)

   t ; . /
  e ; _ a ] 
 " k c i r t 
" > o ? @ ; = 
 v = . / r ;
  \ ; / . .
   . . . .

ප්රධාන කොටස මෙම කොටසයි:

   t ; . /
  e ; _ a ] 
 . . . . . . 
. . . . @ ; = 
 . . . / r ;
  . . . . .
   . . . .

එය දර්පණය t;මුද්‍රණය tකර පහර දෙන අතර එහි දිශාව SE කෙළවරේ සිට NW දෙසට හරවා තවත් කැඩපතකට පහර දෙයි. මෙම ලකුණු r;හා ආධාරක කිරීමට e;_aහා ]උපදෙස් පොයින්ටර් 1 SE හා පහර දෙමින් කෙළවරේ NE ට ආරම්භ වන එය ගෙන එයි /තිරස් අතට ගැනීමට පිළිබිඹු කරන ;පසුව t.

එවිට එය හකුළා =, ;සහ @එම අවුල අවසන් වේ.

ඉතින් ... එහි කුමක් _කරන්නේද?

එය t e a(කේතයේ පළමු අකුරු 3) ඇතුළත ඇත්තේ ඇයි ?

මෙන්න කතාවේ අවසානය පැමිණේ -

එය කිසිවක් නොකරයි .

එය භයානක කතාවක අවසානය මෙන් පෙනේද?

SQL / Javascript, බයිට් 54 යි

select('trick')
--a;function select(){alert("treat")}

මගේ QB / JS පිළිතුරට සමාන ප්‍රවේශයක් : පළමු පේළියට SQL ප්‍රකාශය ඇත, දෙවන පේළියට SQL සඳහා 'විවරණයක්' සහ JS සඳහා NOP ඇත. ඉන්පසුව, අපි SQL selectප්‍රකාශය වලංගු JS ශ්‍රිතයක් ලෙස අර්ථ දක්වන්නෙමු .

/ බ්‍රේන්ෆ්..කේ /, 143 + 3 = බයිට් 146

මෙම පිළිතුරට -AASCII හි මොළය-ෆ්ලැක් සඳහා ධජය ප්‍රතිදානය කිරීම අවශ්‍ය වන අතර වාසනාවකට මෙන් බ්‍රයින්ෆක් එම ධජය ගැන තැකීමක් නොකරන බැවින් එය බ්‍රයින්ෆක්හි ප්‍රතිදානයට බලපාන්නේ නැත.

(((((()(()()()){})({}){}){}){})+++++++[<+++<(((()()()())((((({}){}){}){}){}()))[][][][]())>>-])<[<++++>-]<.--.---------.------.>++[<++++>-]<.>>

එය මාර්ගගතව උත්සාහ කරන්න!

එය මාර්ගගතව උත්සාහ කරන්න!

මෙය ක්‍රියාත්මක වන ආකාරය

බ්‍රේන්-ෆ්ලැක් සහ බ්‍රයින්ෆක් යන වාක්‍ය ඛණ්ඩ අතර ඇති එකම අතිච්ඡාදනය වන්නේ අක්ෂර පමණි <>[]. මොළයේ දෝෂයක් සඳහා මෙය බොහෝ දුරට අදහස් කරන්නේ වැඩසටහනට ඊටත් වඩා විශාල සංඛ්‍යාත ස්විචයන් සහතික කළ යුතු බවයි <>. බ්‍රේන්ෆක් සඳහා මෙයින් අදහස් කරන්නේ මොනාඩ් භාවිතය නිසා ඇති වන අසීමිත වළළු වළක්වා ගත යුතු බවයි [].

මොළ-ෆ්ලැක් කේතය පහත පරිදි වේ:

(((((()(()()()){})({}){}){}){})[<<(((()()()())((((({}){}){}){}){}()))[][][][]())>>])<[<>]<>[<>]<>>

[<<...>>]මැද හා <[<>]<>[<>]<>>අවසානයේ ඇති කේතය හැරුණු විට මෙම කේතය මොළය-ෆ්ලැක් වැඩසටහන් යන තාක් දුරට පා course මාලාවට සමානය. [<...>]බ්‍රේන්ෆක් සඳහා ලූපයක් නිර්මාණය කිරීම සඳහා ශුන්‍යය ( ) වටා ඇති negative ණ වේ. අභ්‍යන්තරය <...>භාවිතා කරනුයේ බ්‍රයින්ෆක් හිස් සෛලයකට ගෙන යාමට පෙර එය [][][][]අනන්ත ලෙස ලූපයක් බවට පත්වේ.

Brainfuck කේතය පහත පරිදි වේ:

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

ඉහත සඳහන් කළ බිටු හැරුණු විට මෙයද ඉතා සම්මත වැඩසටහනකි, එබැවින් මම ඔබට විස්තර ඉතිරි කරමි.

> <> / මසුන් ඇල්ලීම , බයිට් 38 යි

_"kcirt"ooooo;
[+vCCCCCCCC
   `treat`N

><>/ Fishingපොලිග්ලොට් සෑදීම සඳහා .

Fishingදිගු කාලයක් ක්‍රීඩා කිරීමෙන් පසු එය මගේ පළමු කේත කොටසයි ><>.
මගේ පළමු හැඟීම: සොබාදහමේ මෙන්, ධීවරයාට යාච් pray ා කිරීමට වඩා අඩු ශාරීරික හැකියාවන් ඇති නමුත් එහි මෙවලම සමඟ එය සපුරාලයි!

මෙහි කේතය අතිශයින්ම සරල ය: සිරස් දර්පණයක් ><>ඇති පළමු පේළිය පමණක් ක්‍රියාත්මක කරන _අතර මාළු තිරස් අතට පිහිනීමට පටන් ගන්නා බැවින් කිසිදු බලපෑමක් නැත. එය තොගයට තල්ලු trickකර නැවැත්වීමට පෙර මුද්‍රණය කරන්න.
මක්නිසාද යත් Fishing, _පහළට යාමට උපදෙස් දෙයි. තුන්වන පේළියේ අක්ෂර අල්ලා ගන්නා අතරතුර ධීවරයා දෙවන පේළිය වන තට්ටුව අනුගමනය කරනු ඇත. මේවා treatටේප් එකට තල්ලු කර මුද්‍රණය කර තට්ටුවේ කෙළවරට ළඟා වන විට නතර වේ.

වැරදි කිරීමට ඉඩ දෙන්නේ නම්, ඔබට පහත කේතය සමඟ බයිට් 35 ක් දක්වා පහළට යා හැකි අතර එය තොගයෙන් මුද්‍රණය කළ ><>වහාම ක්‍රියාත්මක වන විට දෝෂයක් ඇතිවේ trick:

_"kcirt">o<
[+vCCCCCCCC
   `treat`N

ඔබ මගේ තේමාත්මක භාෂා පිළිතුරු, # හෙල් / ඇගෝනි සහ නපුරු / සොම්බි ද පරීක්ෂා කළ යුතුය !

05AB1E / ඇත්තටම බයිට් 10 ක්

"trick"’®Â

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

05AB1E

"trick"     # push the string "trick"
       ’®Â  # push the string "treat"
            # implicitly print top of stack (treat)

එය මාර්ගගතව උත්සාහ කරන්න

ඇත්තටම

"trick"     # push the string "trick"
       ’®Â  # not recognized commands (ignored)
            # implicit print (trick)

එය මාර්ගගතව උත්සාහ කරන්න

හැස්කල් / ස්ටෑන්ඩර්ඩ් එම්එල් , බයිට් 56 යි

fun putStr x=print"treat";val main=();main=putStr"trick"

හස්කල් දර්ශනය

අර්ධ සළකුණු එක් පේළියක බහුවිධ ප්‍රකාශයන්ට ඉඩ දෙන අතර රේඛා කඩනයන් මෙන් ක්‍රියා කරයි, එබැවින් අපට ලැබේ

fun putStr x=print"treat"
val main=()
main=putStr"trick"

හස්කල් වැඩසටහනක් ක්‍රියාත්මක වන්නේ mainශ්‍රිතය ඇමතීමෙනි, එබැවින් අවසාන පේළියේ putStr"trick"මුද්‍රණය වන පරිදි ක්‍රියාත්මක trickවේ.
පළමු පේළි දෙක රටාව අනුගමනය කරමින් ශ්‍රිත ප්‍රකාශන ලෙස අර්ථ දැක්වේ <functionName> <argumentName1> ... <argumentNameN> = <functionBody>. ඒ නිසා පළමු පේළිය ලෙස නම් ශ්රිතයක් funනම් තර්ක දෙකක් ගනී එය මෙසේ ප්රකාශ කරයි putStrසහ xමෙම උත්සවයට ශරීරය print"treat". මෙය වර්ගය සහිත වලංගු හැස්කල් ශ්‍රිතයක් වන අතර fun :: t -> t1 -> IO (), එයින් අදහස් වන්නේ එය අත්තනෝමතික වර්ගයක තර්කයක් ගන්නා tඅතර දෙවන වර්ගයේ වර්ගයක් t1පසුව IO- ක්‍රියාවක් ලබා දෙන බවයි. ශ්‍රිත ශරීරයේ තර්ක භාවිතා නොකරන බැවින් වර්ග tසහ t1වැදගත් නොවේ. IO- ක්‍රියා වර්ගය ප්‍රති results ල print"treat"වන අතර "treat"එය StdOut වෙත මුද්‍රණය කරයි (බලන්න ", ඒ නිසාputStrවෙනුවට printභාවිතා වේ main). කෙසේ වෙතත් එය ශ්‍රිත ප්‍රකාශයක් පමණක් බැවින්, ඇත්ත වශයෙන්ම මුද්‍රණය funනොකෙරේ main.
දෙවන පේළියේ val main=();ද එය සිදු වේ , ශ්‍රිතයක් valප්‍රකාශයට පත් කරන අතර එය අත්තනෝමතික තර්කයක් නම් mainකර නැවත ඒකකය වන හිස් ටුපල් ය (). එහි වර්ගය val :: t -> ()(අගය සහ ඒකකයේ වර්ගය යන දෙකම දක්වනු ලැබේ ()).

අයිඩියොන් මත එය උත්සාහ කරන්න.

සම්මත ML දර්ශනය

ස්ටෑන්ඩර්ඩ් එම්එල් යනු මූලික වශයෙන් ක්‍රියාකාරී භාෂාවක් වන අතර එය සින්ටැක්ස් හා සම්බන්ධ නමුත් එය හස්කල් හා සමාන නොවේ. විෙශේෂෙයන්ම, කියාකාරකම් කියාත්මක කිරීෙම්දී මූල පදය funහා valඒවා ෙනොමැති නම් පදය සමඟ උපසිරැසි ඇත. වැඩසටහන ක්‍රියාත්මක වන විට ක්‍රියාත්මක වන ඉහළ මට්ටමේ ප්‍රකාශනයක් (කිසිදු ප්‍රකාශයක් තුළ නොවේ). ( 1+2ප්‍රකාශයකින් පිටත හස්කල් ලිවීමේදී naked expression at top levelදෝෂයක් ඇතිවේ). අවසාන වශයෙන් සමානාත්මතාවය පරීක්ෂා කිරීමේ සංකේතය හස්කල් =වෙනුවට ය ==. (තවත් බොහෝ වෙනස්කම් ඇත, නමුත් මෙම වැඩසටහන සඳහා පමණක් වැදගත් වන්නේ ඒවාය.)
එබැවින් එස්එම්එල් ප්‍රකාශන දෙකක් දකී

fun putStr x=print"treat";
val main=();

ප්‍රකාශනයකින් පසුව

main=putStr"trick"

එය ඇගයීමට ලක් කෙරේ. යන්න තීරණය කිරීම සඳහා mainඑක සමානයන් putStr"trick", දෙපැත්තේ ඇගයීමට ලක් කළ යුතු හා SML ෆ්රොන්ටියර් (මෙන්ම Haskell) statically ටයිප් ඇති ලෙස දෙකම, එකම වර්ගයේ තිබිය යුතුය. අපි මුලින්ම දකුණු පැත්ත දෙස බලමු: putStrඑස්එම්එල් හි පුස්තකාල ශ්‍රිතයක් නොවේ, නමුත් අපි putStrපේළියේ නම් කරන ලද ශ්‍රිතයක් ප්‍රකාශයට පත් කළෙමු fun putStr x=print"treat";- එය තර්කයක් ගනී x(මෙය "trick"අපගේ නඩුවේ නූලයි) සහ වහාම එය නැවත අමතක කරයි. ක්‍රියාකාරී ශරීරයේ සිදු නොවේ. එවිට ශරීරය print"treat"ක්‍රියාත්මක වන්නේ කුමන මුද්‍රණද treat(කොටු නොකර ", එස්එම්එල් හස්කල්ට printවඩා වෙනස් වේ print).
printවර්ගය ඇත string -> unit, එසේම putStrවර්ගය ඇත a -> unit, එබැවින් putStr"trick"යන්තම් වර්ගය ඇතunit. හොඳින් ටයිප් කිරීමට නම්, ටයිප් ද mainතිබිය යුතුය unit. ඒකකයේ වටිනාකම හස්කල් හි ඇති ආකාරයටම එස්එම්එල් හි ඇත (), එබැවින් අපි ප්‍රකාශ කරන val main=();අතර සියල්ල හොඳින් ටයිප් කර ඇත.

කේතීකරණ භූමියේ එය උත්සාහ කරන්න.
සටහන: කොන්සෝලයේ ප්‍රතිදානය වේ

val putStr = fn : 'a -> unit                                   
val main = () : unit                                                    
treatval it = true : bool

දී නිසා SML \ එන්.ජේ. සෑම ප්රකාශය වටිනාකම සහ වර්ගය එක් එක් වූ පසු දිස් වේ. ඒ නිසා පළමු වර්ග putStrසහ mainපෙන්වා ඇත, පසුව ප්රකාශන ඇති ඇගයීමට ලක්වෙයි treatමුද්රණය කිරීමට, පසුව අදහස් ප්රකාශ කිරීමේ අගය ( trueදෙපස ලෙස =ය ()) එපිටින් ප්රතිඵලයක් විචල්ය බැඳී සිටින itපසුව ද ප්රදර්ශනය වන.

රූබි / සී, 64 යි 62 යි 51 යි බයිට් 48 යි

#define tap main()
tap{puts(0?"trick":"treat");}

රූබි දකින දේ:

tap{puts(0?"trick":"treat");}

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

රූබි හි ඇති එකම ව්‍යාජ අගයන් වන්නේ falseසහ nil. විශේෂයෙන් 0 සත්‍ය වේ. මේ අනුව, රූබි "උපක්රමය" මුද්රණය කරනු ඇත.

සී දකින දේ (පෙර සකසනයෙන් පසුව):

main(){puts(0?"trick":"treat");}

0 යනු සී හි ව්‍යාජ ය, එබැවින් සී "සංග්‍රහය" මුද්‍රණය කරයි.

ඩැනියෙරෝට ස්තූතියි බයිට් 2 ක් ඉතිරි කර ඇත.

QBasic / JavaScript, බයිට් 51 44

'';PRINT=a=>{alert("Treat")}
PRINT("Trick")

QBasic හි, එය දෙවන පේළිය මුද්‍රණය කරන අතර පළමු පේළිය ක්‍රියාත්මක නොකරන්නේ එය අදහස් දැක්වීමක් යැයි විශ්වාස කරන නිසාය (ස්තූතියි '). JS හි, එය JS NOP ට පසුව පළමු පේළියේ අර්ථ දක්වා ඇති PRINT ශ්‍රිතය ලෙස හැඳින්වේ '';.

ෂේප්ස්ක්‍රිප්ට් / ෆූ , බයිට් 13 යි

'trick'"treat

එය මාර්ගගතව උත්සාහ කරන්න! උපක්‍රමය | සලකන්න

එය ක්‍රියාත්මක වන ආකාරය

ෂේප්ස්ක්‍රිප්ට් චරිතය අනුව විග්‍රහ කර ඇත. අවසාන උපුටා දැක්වීමකින් තොරව EOF පහර දුන් විට, කිසිවක් කිසි විටෙකත් තොගයට තල්ලු නොවේ. 'trick'STDOUT වෙත ව්‍යංගයෙන් මුද්‍රණය කර ඇති උපුටා දැක්වීම් තුළට නූල තල්ලු කරයි.

Foo හි අක්ෂර සඳහා කිසිදු විධානයක් පවරා නොමැත 'trick', එම නිසා එම කොටස නිහ ly ව නොසලකා හරිනු ලැබේ. කෙසේ වෙතත්, එය ද්විත්ව උපුටා දැක්වීම් අතර ඕනෑම දෙයක් වහාම STDOUT වෙත මුද්‍රණය කරයි.

රූබි / පර්ල්, බයිට් 21 යි

print"trick"%1||treat

පර්ල්

ගනන් "trick" % 1වන 0 % 1, එසේ ||යවයි treatකිරීමට printperl බසට ලං barewords පිළිගන්නා බැවින්, ඒ වෙනුවට.

රූබි

ආකෘති වැල "trick"තර්කය සමඟ 1වන ප්රතිඵල, "trick"වන truthy, එසේ ||සකස් කර නැත.

MATL / CJam , බයිට් 17 යි

'TRICK'%];"TREAT"

MATL හි මෙය ප්‍රතිදානය TRICK කරයි. CJam හි එය ප්‍රතිදානය TREAT කරයි.

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

MATL

'TRICK'         Push this string
%];"TREAT"      Comment: ignored
                Implicit display

සී

'T              Push character 'T'
R               Push variable R, predefined to empty string
I               Push variable I, predefined to 18
C               Push variable C, predefined to 12
K               Push variable K, predefined to 20
'%              Push character '%'
]               Concatenate stack into an array
;               Discard
"TREAT"         Push this string
                Implicit display

පරමාර්ථය-සී / සී, බයිට් 50 යි

puts(){printf("trick");}main(){printf("treat\n");}

අරමුණ සී අහුලාගෙන වී පිටපත් සංග්රහ , නමුත් C සහ නෑ උපක්රමය මුද්රණය කරයි .

එය ක්‍රියාත්මක වන ආකාරය

පරමාර්ථ-සී ගැන මම බොහෝ දේ නොදනිමි , නමුත් එය මෙම තත්වය තුළ අප සාධාරණ ලෙස අපේක්ෂා කරන දේ කරයි. නැවත අර්ථ දැක්වීම putsප්‍රතිදානය කෙරෙහි බලපාන්නේ නැත, මන්ද අප කිසි විටෙකත් ශ්‍රිතය නොකියන අතර, STDOUT වෙත සංග්‍රහ කිරීම සහ රේඛීය සංග්‍රහයක් mainමුද්‍රණය කිරීම .

C ද එසේ කරනු ඇතැයි ඔබ අපේක්ෂා කළ හැකි නමුත් අවම වශයෙන් gcc 4.8, gcc 5.3, සහ clang 3.7 එසේ නොකරන්න.

අපි අවශ්ය නොවන බැවින් සැබෑ එහිදී එම (ආකෘතියක් වැලක් සහ අතිරේක තර්ක කාලයක් ගතවේ) සහ linefeed සමග අවසන් මුද්රණය වූ නූල්, අපි භාවිතා කළ හැකිය තබන වෙනුවට. බුදුන් තරමක් වේගයෙන් වඩා එහිදී එම අපි උත්සවය පරතරයන්, විවේකය නම්, ඒ (මුද්රණයට පෙර සිය තර්ක විග්රහ කිරීමට ඇති) එහිදී එම මෙන්ම, සම්පාදකවරයා මනා හා ඇමතුම විස්ථාපනය එහිදී එම වෙත දුරකථන ඇමතුමක් සමග තබන . putsතර්කය සමඟ ඇමතීම ඒ වෙනුවට උපක්‍රම"treat" මුද්‍රණය කරන බව සම්පාදකයා දන්නේ නැත !

ඇතුළු නැහැ stdio.h නිර්වචනය සිට තීරණාත්මක මෙතන, බුදුන් ශීර්ෂ ගොනුවේ එය එකම වර්ගයේ භාවිතා අවශ්ය වනු ඇත ( puts(const char*)).

අවසාන වශයෙන්, එය ඇමතුම බව විශේෂයෙන් සඳහන් කළ යුතු ය එහිදී එම දී තබන නූලක් වෙයි තොරව අගින් ඇද linefeed. එසේ නොවුවහොත්, සම්පාදකයා එම ඇමතුම “ප්‍රශස්තිකරණය” කරනු ඇත, එහි ප්‍රති a ලයක් ලෙස ඛණ්ඩනය වීමේ දෝෂයක් ඇතිවේ.

ජෙලි / පීඑල් , බයිට් 12 යි

0000000: 74 72 65 61 74 0a 7f fe 00 ba 49 fb                 treat.....I.

ජෙලිගේ කේත පිටුව භාවිතා කර පෙන්වන වැඩසටහන මෙයයි .

treatµ
“¡ṾI»

එය මාර්ගගතව උත්සාහ කරන්න!

කේත පිටුව 437 භාවිතයෙන් පෙන්වන වැඩසටහන මෙයයි .

treat
⌂■␀║I√

එය මාර්ගගතව උත්සාහ කරන්න!

මෙම වැඩසටහන් දෙකම එකම බයිට් 12 ගොනුවක් සමඟ දේශීයව පරීක්ෂා කර ඇත, එබැවින් මෙය නිසි බහු භාෂාවක් වේ.

එය ක්‍රියාත්මක වන ආකාරය

ජෙලි හි, සෑම පේළියක්ම සබැඳියක් (ශ්‍රිතය) අර්ථ දක්වයි ; අවසාන පේළිය ප්‍රධාන සබැඳිය අර්ථ දක්වයි , එය වැඩසටහන ක්‍රියාත්මක වන විට ස්වයංක්‍රීයව ක්‍රියාත්මක වේ. අවසාන 7fබයිටයට පෙර කේතය (ජෙලිගේ කේත පිටුවේ ඇති ලයින්ෆීඩ්) විග්‍රහ කිරීමේ දෝෂයක් අඩංගු නොවේ නම් (එය වහාම ක්‍රියාත්මක කිරීම නවතා දමනු ඇත), ඒවා සරලව නොසලකා හරිනු ලැබේ. අන්තිම පේළිය, උපක්‍රමය“¡ṾI» යන වචනය ලබා ගැනීම සඳහා ජෙලිගේ ශබ්දකෝෂයට සුචිගත කරයි , එය වැඩසටහන අවසානයේ ව්‍යංගයෙන් මුද්‍රණය කෙරේ.

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

කණ්ඩායම / ෂී, බයිට් 30 යි

:;echo Treat;exit
@echo Trick

පැහැදිලි කිරීම. කණ්ඩායම පළමු පේළිය ලේබලයක් ලෙස දකින අතර එය නොසලකා හරින අතර ට්‍රික් මුද්‍රණය කරන දෙවන පේළිය ක්‍රියාත්මක කරයි. @ Bd හි විධානය stdout වෙත ප්‍රතිරාවය කිරීම මර්දනය කරයි. (ලේබල කිසි විටෙකත් දෝංකාර දෙන්නේ නැත.) මේ අතර sh පහත සඳහන් දෑ දකී:

:
echo Treat
exit
@echo Trick

පළමු පේළිය කිසිවක් නොකරයි (එය අන්වර්ථයකි true), දෙවන පේළිය සංග්‍රහය මුද්‍රණය කරයි, සහ තෙවන පේළිය පිටපතෙන් පිටවෙයි, එබැවින් @echo Trick කිසි විටෙකත් ළඟා නොවේ.

sed / ෂඩාස්රාකාර 32 බයිට්

/$/ctrick
#$@$a</;r;e;/t;....\t;

sed

එය මාර්ගගතව උත්සාහ කරන්න!

trickආදාන අවසානයේ හිස් නූලක් තිබේ නම් පළමු පේළිය මුද්‍රණය වේ. (ආදානය නොමැති නම් sed කිසිවක් නොකරයි, නමුත් stdin හි හිස් රේඛාවක් මෙම අවස්ථාවේ දී අවසර දෙනු ලැබේ)

උදාහරණ ධාවනය:

$ echo | sed -f TrickOrTreat.sed
trick

ෂඩාස්රාකාරය

එය මාර්ගගතව උත්සාහ කරන්න!

පළමුවැන්න /උපදෙස් දර්ශකය ඉහළට සහ වමට හරවා යවන අතර එමඟින් පහළ වම්පස ඔතා, sed සඳහා භාවිතා කරන පෙළ මඟ හැරේ. එය sed කේතයෙන් r නැවත භාවිතා කරන අතර තවත් කිහිපයක් ක්‍රියාත්මක නොවේ. පුළුල් කළ හෙක්ස් එක මේ වගේ:

   / $ / c 
  t r i c k
 # $ @ $ a <
/ ; r ; e ; /
 t ; . . . . 
  \ t ; . .
   . . . .

ප්‍රතිදානය:

treat

සී # / ජාවා

මෙය තනිවම ක්‍රියාත්මක නොවන බැවින් මෙය බොහෝ විට සුදුසුකම් නොලබයි, නමුත් අභියෝගය මට මතක් කර දී ඇත්තේ C # සහ ජාවා නූල් සංසන්දනය වෙනස් ආකාරයකින් හසුරුවන්නේ කෙසේද යන්න පිළිබඳව ඔබට කේත අපැහැදිලි කිරීම සඳහා විනෝදයක් ලබා ගත හැකි බවයි.

පහත ශ්‍රිතය C # සහ Java වල වලංගු වේ, නමුත් වෙනත් අගයක් ලබා දෙනු ඇත ...

public static String TrickOrTreat(){
    String m = "Oct";
    String d = "31";
    return m + d == "Oct31" ? "Trick" : "Treat";
}

මොළය- නළය / මොළය-නළය, 265 253 219 165 139 115 113 101 බයිට්

සඳහා +1 ඇතුළත් වේ -A

තිරිඟු විශාරදයට ස්තූතියි, මා සමඟ, එකිනෙකා සමඟ කේතයෙන් බයිට් කිහිපයක් ගොල්ෆ් කිරීම.

((((()()()))([]((({}{}))({}([((({}()())))]([](({}{}){}){}{})))[]))[])[()()])({}()()){}({})({}[][]){}

මොළය: අන්තර්ජාලය හරහා එය උත්සාහ කරන්න!
මොළය-නළය: එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම:
පළමු කොටසේ මොළය-ෆ්ලැක් දකින අගයන් ලැයිස්තුගත කරයි.
එය Brain-Flueue වෙත මාරු වූ විට, මම Brain-Flueue දකින ආකාරයට අගයන් ලැයිස්තුගත කිරීමට පටන් ගනිමි.

# Brain-Flak
(
 (((()()()))             # Push 3 twice
  ([]                    # Use the height to evaluate to 2
   (
    (({}{}))             # Use both 3s to push 6 twice
    ({}                  # Use one of those 6s to evaluate to 6
     ([((({}()())))]     # Use the other 6 to push 8 three times and evaluate to -8
      ([](({}{}){}){}{}) # Use all three 8s to push 75
     )                   # The -8 makes this push 67
    )                    # The 6 makes this push 73
   [])                   # Use the height and the 6 to push 82
  )                      # Use the 2 to push 84

# Brain-flueue
 [])     # Use the height and 3 to push 84
[()()])  # Push 82
({}()()) # 67 is at the front of the queue, so use that to push 69
{}       # Pop one from the queue
({})     # 65 is next on the queue so move to the end
({}[][]) # 74 is next, so use that and the height to push 84
{}       # Pop that last value from TRICK

පවර්ෂෙල් / ෆූ, බයිට් 14 යි

'trick'#"treat

මෙම 'trick'PowerShell දී වැලක් නිර්මාණය හා නල මත නිවසින් පිටත්වේ. මෙම #අදහස ආරම්භ, එම වැඩසටහනට සූර්යයා හා ගම්ය Write-Outputපිටපත් trick.

Foo හි, (එය මාර්ගගතව උත්සාහ කරන්න!) , 'trick'නොසලකා හරිනු ලැබේ, #වැඩසටහන 0තත්පර ගණනක් නිදා ගැනීමට හේතු වේ (අරාවෙහි දර්ශකයේ කිසිවක් නොමැති බැවින්), පසුව "treatනූලක් ආරම්භ කරයි. EOF වෙත ළඟා වී ඇති හෙයින්, නූල "වැසීමට ඇඟවුම් කර ඇති අතර එය මුද්‍රණය කර ඇත්තේ stdout වෙත ය.

PHP / Perl, බයිට් 28 යි

print defined&x?trick:treat;

defined&x
PHP හි සත්‍යවාදී යමක් ලබා දෙයි (ඇයිදැයි නොදනී, නමුත් එය එසේ කරයි).
පර්ල් හි එය ශ්‍රිතය xඅර්ථ දක්වා ඇත්දැයි පරීක්ෂා කරයි - එය එසේ නොවේ.
-> trickPHP හි, treatපර්ල් හි.