ගොල්ෆ් ඔබ හොඳ යහපතක් සඳහා ක්වයින්!


205

ඔබ කැමති භාෂාව භාවිතා කරමින් ගොල්ෆ් ක්වයින් එකක් .

quine ආදාන ගනී සහ එහි එකම ප්රතිදාන එහි ම මූල කේතය පිටපතක් නිෂ්පාදනය කරන, හිස්-නොවන පරිගණක වැඩසටහනක්.

වංචාවක් නැත - එයින් අදහස් කරන්නේ ඔබට මූලාශ්‍ර ගොනුව කියවා මුද්‍රණය කළ නොහැකි බවයි. එසේම, බොහෝ භාෂාවල, හිස් ගොනුවක් ද ක්වයින් ය: එය නීත්‍යානුකූල ක්වීන් ලෙස ද නොසැලකේ.

දෝෂ ක්වයින් නොමැත - දෝෂ ක්වීන් සඳහා වෙනම අභියෝගයක් දැනටමත් තිබේ .

සඳහා කරුණු:

  • කුඩාම කේතය (බයිට් වලින්)
  • බොහෝ අපැහැදිලි / අපැහැදිලි විසඳුමක්
  • ව්‍යාකූල / අපැහැදිලි භාෂා භාවිතා කිරීම
  • ගොල්ෆ් ක්‍රීඩාවට අපහසු භාෂා සාර්ථකව භාවිතා කිරීම

එක් එක් භාෂාවේ වත්මන් ලකුණු පිළිබඳ ඉක්මන් දර්ශනයක් ලබා ගැනීම සඳහා පහත දැක්වෙන ස්ටැක් ස්නිපෙට් භාවිතා කළ හැකි අතර, එමඟින් දැනට පවතින පිළිතුරු ඇත්තේ කුමන භාෂාවන්ටද සහ ඔබට කුමන ඉලක්කයක් පරාජය කළ යුතුද යන්න දැන ගැනීමට:


4
ඔබ අදහස් කරන්නේ, "ගොල්ෆ් ඔබ වඩා හොඳ සඳහා ක්වයින්!"
මාටීන් උල්හාක්

52
ntmuntoo එය "මහා යහපත සඳහා හැස්කෙල් ඉගෙන ගන්න" යන නාට්‍යයයි.
රෆේ කෙට්ලර්

Answers:


111

ෂඩාස්රාකාර , පැති දිග 17 16, 816 705 බයිට්

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

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

මෙය දිග හැරෙන ආකාරයට පෙනේ:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

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

එය සාමාන්ය ප්රවේශය වෙනස් නොකර, 1 හෝ 2 පැත්තේ-දිග අඩු කිරීමට හැකියාවක් විය හැකි, නමුත් එය දැඩි වෙයි (සමග සෛල පමණක් #දැනට භාවිතයට නොගන්නා වේ හා නිකුත් කෙරුණි සඳහා ලබා ගත හැකි). මේ වන විට වඩාත් කාර්යක්ෂම ප්‍රවේශයක් සඳහා මට කිසිම අදහසක් ඉතිරිව නැත, නමුත් මට විශ්වාසයි එකක් පවතින බව. ඉදිරි දින කිහිපය තුළ මම මේ ගැන මදක් සිතා බලා පැහැදිලි කිරීමක් සහ සෑම දෙයක්ම එක් කිරීමට පෙර එක් පැත්තකින් ගොල්ෆ් කිරීමට උත්සාහ කරමි.

හොඳයි, අවම වශයෙන්, මම එය ඔප්පු කළ හැකිය ...

මගේ අනාගත යොමු කිරීම සඳහා සමහර CJam පිටපත්:


53
ආදරණීය පීට් මේ මොකක්ද.
කොනර් ඕ බ්‍රයන්

2
මෙය සෑදීමට කොපමණ කාලයක් ගතවේද?
අද්නාන්

3
AndANN මම ඊයේ සිට සාමාන්‍ය "අච්චුවක්" සඳහා සංකල්ප සමඟ සෙල්ලම් කරමින් සිටිමි (එයට සත්‍ය පරීක්‍ෂණයක් සිදු නොවීය ... 7x7 ජාලකයක යම් යම් දේ ටයිප් කර එය ක්‍රියාත්මක විය හැකිදැයි බලන්න .. මම දැනටමත් එහි දුසිම් භාගයක් ප්‍රවේශයන් ඉවත දැමුවෙමි). ඇත්ත කේතීකරණය අද සවස ගත විය ... සමහර විට පැය 3 ක්, මම කියමි.
මාටින් එන්ඩර්

12
පියවරෙන් පියවර එසෝටරික් අයිඩීඊ සමඟ මෙය ක්‍රියාත්මක වන විට මා කෙතරම් මවිතයට පත් වී ඇත්දැයි වචනවලට පැහැදිලි කළ නොහැක ... මෙය තේරුම් ගැනීමට කැමති කාටද, මෙම ෂඩාස්රය "විකේතකය" කොටස පූර්ණ සංඛ්‍යාවක් සමඟ සංකේතවත් කර මුද්‍රණය කර !පසුව මුද්‍රණය කරයි. /2 වන අන්තිම පේළියේ දර්පණය එය විකේතකය තුළට ඇතුළු වන්නේ විකේත කේතය මුද්‍රණය කිරීම සඳහා ය. මෙය ආශ්චර්යමත් ලෙස භාවිතා කර ඇති <අතර >එය බහු සංඛ්‍යා ඉතා විශාල සංඛ්‍යාවක් කියවන අතර විකේතකය ගබඩා කිරීම සඳහා ප්‍රදේශය ගොඩනඟා ඇත. සලකා බලන "ප්‍රවේශයන් දුසිම්" මොනවාදැයි දැන ගැනීමට මම ඇත්තෙන්ම කැමතියි?
සනී පුන්

3
පැහැදිලි කිරීම? ---
MD XF


72

ගොල්ෆ් ස්ක්‍රිප්ට්, බයිට් 2 යි

1

(සටහන ලුහුබඳින නව රේඛාව) මෙය අංක 1 තොගයට තල්ලු කරයි. වැඩසටහන අවසානයේදී, ගොල්ෆ් ස්ක්‍රිප්ට් තොගයේ ඇති සියලුම අයිතම මුද්‍රණය කරයි (අතර කිසිදු ඉඩක් නොමැතිව), පසුව නව රේඛාවක් මුද්‍රණය කරයි.

මෙය සත්‍ය කේතයක් (ප්‍රශ්නයේ ලැයිස්තුගත කර ඇති පරිදි), මන්ද එය ඇත්ත වශයෙන්ම කේතය ක්‍රියාත්මක කරන බැවිනි; එය "ප්‍රභව ගොනුව කියවා මුද්‍රණය කිරීම" පමණක් නොවේ (PHP ඉදිරිපත් කිරීම මෙන් නොව).


තවත් උදාහරණයක් සඳහා, මුද්‍රණය කිරීම සඳහා ගොල්ෆ් ස්ක්‍රිප්ට් වැඩසටහනක් මෙන්න 12345678:

9,(;
  1. 9: තොගයට 9 තල්ලු කරන්න
  2. ,: 9 තර්කයක් ලෙස පරිභෝජනය, අරාව තල්ලු [0 1 2 3 4 5 6 7 8]අඩුක්කුව සඳහා
  3. (: තර්කයක් ලෙස අරාව පරිභෝජනය අරාව තල්ලු [1 2 3 4 5 6 7 8]හා අයිතමය 0අඩුක්කුව සඳහා
  4. ;: තොගයේ ඉහළ අයිතමය ඉවතලන්න

තොගයේ දැන් අරාව අඩංගු වේ [1 2 3 4 5 6 7 8]. මෙය මූලද්‍රව්‍ය අතර කිසිදු ඉඩක් නොමැති සම්මත නිමැවුමකට ලියා ඇති අතර ඉන් පසුව නව රේඛාවක් ලැබේ.


18
හෝ පවර්ෂෙල්, හෝ පීඑච්පී :-)
ජෝයි

6
ඔබ නියමිත වේලාවට ආපසු ගොස් ගොල්ෆ් ස්ක්‍රිප්ට් නිර්මාණය කිරීමේ අදහස නව නිපැයුම්කරුට ලබා දුන්නේ නැත, එසේ ද?
මාටීන් උල්හාක්

78
තාක්ෂණික වශයෙන්, 1ගොල්ෆ් ස්ක්‍රිප්ට් හි ක්වයින් එකක් නොවේ: එය ප්‍රතිදානය කරයි 1\n, එහිදී \nනව රේඛාවක් දක්වයි. කෙසේ වෙතත්, ද්වි-චාර් වැඩසටහන 1\n යනු ක්වයින් ය.
ඉල්මාරි කරොනන්

19
එක් වරලත් වැඩසටහන \nබොහෝ විට ද?
ලින්

10
- අන්වර්ථ නාමයක් යනු ක්වයින් යනු වචනාර්ථයෙන් තමන්ගේම ප්‍රභවයක් මුද්‍රණය කරන වැඩසටහනකි. "ව්‍යුහය" සඳහා අත්තනෝමතික සීමාවන් ඇතැයි මම නොසිතමි.
හියුගෝ සින්ක්

72

මොළයේ-ගවුණ , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 බයිට්

දැන් නිරීක්ෂණය කළ හැකි විශ්වයට ගැලපේ!

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

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


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

මෙම ක්වීන් එසෝටරික් භාෂාවලින් බොහෝ ක්වයින්ස් මෙන් ක්‍රියා කරයි; එහි කොටස් දෙකක් එන්කෝඩරයක් සහ විකේතකයක් ඇත. එන්කෝඩරය ආරම්භයේ ඇති වරහන් සියල්ලම වන අතර විකේතකය අවසානයේ වඩාත් සංකීර්ණ කොටස වේ.

වැඩසටහන කේතනය කිරීමේ බොළඳ ක්‍රමයක් වනුයේ විකේතකයේ ඇති සෑම අක්‍ෂරයකම ASCII අගය තොගයට දැමීමයි. මෙය එතරම් හොඳ අදහසක් නොවේ, මන්ද මොළය-ෆ්ලැක් භාවිතා කරන්නේ අක්ෂර 8 ක් පමණි ( ()<>[]{}) එබැවින් ඔබ ඉතා සුළු තොරතුරු කේතනය කිරීම සඳහා බයිට් කිහිපයක් ගෙවීම අවසන් කරයි. වඩා හොඳ අදහසක්, සහ මේ දක්වා භාවිතා කර ඇති එක් වරහන් 8 න් වඩා කුඩා සංඛ්‍යාවකට (1-8) පැවරීම සහ මේවා අපගේ විකේතකය සමඟ ASCII අගයන් බවට පරිවර්තනය කිරීම ය. පෙර 252 ට සාපේක්ෂව අක්ෂරයක් කේතනය කිරීමට බයිට් 18 කට වඩා වැය නොවන නිසා මෙය හොඳයි.

කෙසේ වෙතත් මෙම වැඩසටහන ද එසේ නොවේ. එය රඳා පවතින්නේ 5 දක්වා සංඛ්‍යා සමඟ වරහන් 8 සංකේතනය කිරීම සඳහා මොළ-ෆ්ලැක් වැඩසටහන් සියල්ලම සමතුලිත වන බැවිනි. එය ඒවා පහත පරිදි සංකේතවත් කරයි.

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

සියලුම සමීප වරහන් 1 පවරා ඇත්තේ අපට විශේෂිත අවස්ථාවකදී ඒවායින් කුමන ඒවා භාවිතා කළ යුතුද යන්න තීරණය කිරීමට සන්දර්භය භාවිතා කළ හැකි බැවිනි. මෙය මොළ-ෆ්ලැක් වැඩසටහනක් සඳහා දුෂ්කර කාර්යයක් සේ පෙනෙන්නට තිබුණද එය එසේ නොවේ. නිදසුනක් ලෙස පහත දැක්වෙන කේතීකරණ විවෘත වරහන් විකේතනය කර ඇති අතර සමීප වරහන් වෙනුවට ආදේශ කර ඇත .:

(.
((..
<([.{...

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

පහත් මට්ටමේ පැහැදිලි කිරීම

වැඩ කටයුතු කරගෙන යයි


26
කේත ගොල්ෆ් අභියෝගයකට
දීර් long තම

18
පීපීසීජී නොප් ඉතිහාසයේ විශාලතම තනි ගොල්ෆ් ක්‍රීඩාව බවට පත් කළේය . 9.8e580 තවමත් ආකර්ෂණීයයි.
ඩෙනිස්

20
නිරීක්ෂණය කළ හැකි විශ්වයට ගැලපීම සඳහා +1. එසේම, TIO Nexus සමඟ, පර්මාලින්ක් පිළිතුරට ගැලපේ. tio.run/nexus/…
ඩෙනිස්

3
... ඉතා විශාල ගොල්ෆ් ...
විනාශකාරී ලෙමන්

3
කපා දැමූ බොහෝ බයිට් සඳහා ඔබ
ක්‍රිස්ටෝපර්

70

පෙරවදන , 5157 4514 2348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 බයිට්

බයිට් 3 ක් ඉතිරි කිරීම ගැන Sp3000 ට ස්තූතියි.

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

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

එම ඉලක්කම් විශාල සංඛ්‍යාව මූලික කේතයේ කේතන ක්‍රමයක් පමණක් වන අතර එම නිසා ක්වයින් දිගු වේ.

මෙම CJam ස්ක්‍රිප්ට් එක සමඟ ක්වයින් කේතනය කරන ඉලක්කම් ජනනය කර ඇත .

මේ සඳහා සම්මත-අනුකූල පරිවර්තකයෙකු අවශ්‍ය වේ, එය අක්ෂර මුද්‍රණය කරයි (අගයන් අක්ෂර කේත ලෙස භාවිතා කරයි). එබැවින් ඔබ පයිතන් පරිවර්තකය භාවිතා කරන්නේ නම් ඔබට සැකසිය NUMERIC_OUTPUT = Falseයුතුය.

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

පළමුව, පෙරවදන පිළිබඳ වචන කිහිපයක්: පෙරවදනෙහි සෑම පේළියක්ම වෙනමම "කටහ" ක් ​​වන අතර එය තමන්ගේම තොගය හසුරුවයි. මෙම තොග අසීමිත සංඛ්‍යාවක් 0s වෙත ආරම්භ කෙරේ. වැඩසටහන ක්‍රියාත්මක වන්නේ තීරුව අනුව වන අතර එහිදී තීරුවේ ඇති සියලුම විධානයන් පෙර සිරස් තත්වයන් මත පදනම්ව “එකවර” ක්‍රියාත්මක වේ. ඉලක්කම් තනි තනිව තොගයට තල්ලු කරනු ලැබේ, එබැවින් 42a තල්ලු කරයි 4, පසුව a 2. විශාල සංඛ්‍යා කෙලින්ම තල්ලු කිරීමට ක්‍රමයක් නැත, ඔබට ඒවා එකතු කිරීමට සිදුවේ. vසහ සමඟ යාබද කොටස් වලින් වටිනාකම් පිටපත් කළ හැකිය ^. වරහන් සමඟ බ්‍රේන්ෆක් විලාසිතාවේ ලූප හඳුන්වා දිය හැකිය. වැඩි විස්තර සඳහා සිරස්තලයේ ඇති සබැඳිය බලන්න.

ක්වයින් හි මූලික අදහස මෙන්න: පළමුව අපි ඉලක්කම් රාශියක් තොගයේ සිරස් අතට හරවන තොගයට තල්ලු කරමු. හරය පසුව එම ඉලක්කම් ගෙන ඒවා මුද්‍රණය කිරීමට විකේතනය කර කේතයේ පෙනෙන ආකාරයට ඉලක්කම් මුද්‍රණය කරයි (සහ පසුපසින් )).

හරය බහුවිධ රේඛා ඔස්සේ බෙදීමට මට සිදුවීම නිසා මෙය තරමක් සංකීර්ණ වේ. මුලදී මා සතුව කේතන ක්‍රමයක් තිබුනි, නමුත් අනෙක් පේළි එකම ඉඩ ප්‍රමාණයක් සහිතව ඇලවීමට අවශ්‍ය විය. ආරම්භක ලකුණු සියල්ලම එතරම් විශාල වූයේ මේ නිසා ය. දැන් මම කේතන ක්‍රමය අවසානයේ තබා ඇත, නමුත් මෙයින් අදහස් කරන්නේ මට මුලින් හරය මඟ හැර, පසුව ඉලක්කම් තල්ලු කර නැවත ආරම්භයට පැන මුද්‍රණය කළ යුතු බවයි.

එන්කෝඩින්

කේතයට ඇත්තේ කටහ two වල් දෙකක් පමණක් වන අතර, යාබදව චක්‍රීය වන ^අතර vඑය සමාන පද වේ. එය vවිශාල අක්‍ෂර කේතයක් ඇති බැවින් එය හොඳයි, එබැවින් සෑම විටම භාවිතා කිරීමෙන් එය වළක්වා ගැනීමෙන් ^කේතීකරණය සරල කරයි. දැන් සියලුම අක්ෂර කේත 10 සිට 94 දක්වා පරාසයක පවතී. මෙයින් අදහස් කරන්නේ මට සෑම අක්‍ෂරයක්ම හරියටම දශම සංඛ්‍යා දෙකකින් සංකේතනය කළ හැකි බවයි. නමුත් එක් ගැටළුවක් ඇත: සමහර අක්ෂර, විශේෂයෙන් රේඛීය පදය, ඒවායේ දශම නිරූපණයෙහි ශුන්‍ය වේ. එය ගැටළුවක් වන්නේ ශුන්‍යයන් තොගයේ පතුලේ සිට පහසුවෙන් වෙන්කර හඳුනාගත නොහැකි බැවිනි. වාසනාවකට ඒ සඳහා සරල විසඳුමක් ඇත: අපි අක්ෂර කේත මගින් ඕෆ්සෙට් කරන්නෙමු 2, එබැවින් අපට 12 සිට 96 දක්වා පරාසයක් ඇත, ඇතුළුව, තවමත් දශම සංඛ්‍යා දෙකකින් සුවපහසු ලෙස ගැලපේ. පෙරවදන වැඩසටහනේ දිස්විය හැකි සියලුම අක්ෂර දැන්,0එහි නිරූපණයෙහි 0 ක් ඇත (50), නමුත් අපට කිසිසේත් අවශ්‍ය නොවේ 0. ඒ නිසා මම භාවිතා කරන කේතන ක්‍රමය එයයි, එක් එක් ඉලක්කම් තනි තනිව තල්ලු කරයි.

කෙසේ වෙතත්, අපි තොගයක් සමඟ වැඩ කරන බැවින්, නිරූපණයන් ආපසු හරවනු ලැබේ. එබැවින් ඔබ කේතීකරණයේ අවසානය දෙස බැලුවහොත්:

...9647344257

යුගල වශයෙන් බෙදී ආපසු හරවන්න, ඉන්පසු දෙකක් අඩු කරන්න, ඉන්පසු අක්ෂර කේත බලන්න:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

එහිදී 32අවකාශ කිරීමට අනුරූප වේ. හරය හරියටම මෙම පරිවර්තනය සිදු කරයි, පසුව අක්ෂර මුද්‍රණය කරයි.

හරය

එබැවින් මෙම සංඛ්‍යා සැබවින්ම සකසන ආකාරය දෙස බලමු. පළමුවෙන්ම, ගැලපෙන වරහන් වර්‍ගවල පෙරවදනෙහි එකම පේළියේ තිබිය යුතු නැති බව සැලකිල්ලට ගැනීම වැදගත්ය. එක් තීරුවකට එක් වරහන් පමණක් තිබිය හැකි බැවින් වරහන් එකට අයත් වන අවිනිශ්චිතතාවයක් නොමැත. විශේෂයෙන්, සංවෘත වරහන් වල සිරස් පිහිටීම සැමවිටම අදාල නොවේ - ලූපය අවසන් වේද (හෝ සම්පූර්ණයෙන්ම මඟ හැරී ඇත්ද) යන්න තීරණය කිරීම සඳහා පරීක්ෂා කරනු ලබන තොගය සැමවිටම ඇති එකකි (.

අපට කේතය හරියටම දෙවරක් ධාවනය කිරීමට අවශ්‍යයි - පළමු වතාවට, අපි හරය මඟ හැර සියලු සංඛ්‍යා අවසානයේ තල්ලු කරමු, දෙවන වරට අපි හරය ධාවනය කරමු. ඇත්ත වශයෙන්ම, අපි හරය ධාවනය කිරීමෙන් පසුව, අපි එම සංඛ්‍යා නැවත තල්ලු කරන්නෙමු, නමුත් ලූපය පසුව අවසන් වන බැවින් මෙය අදාල නොවේ. මෙය පහත ඇටසැකිල්ල ලබා දෙයි:

7(
  (                   )43... encoding ...57)

පළමුවෙන්ම, අපි 7පළමු හ voice ට තල්ලු කරමු - අපි මෙය නොකරන්නේ නම්, අපි කිසි විටෙකත් ලූපයට ඇතුළු නොවෙමු (ඇටසැකිල්ලට එය වැදගත් වන්නේ මෙය ශුන්‍ය නොවන බව පමණි ... එය විශේෂයෙන් 7අපි පසුව දකින්නේ ඇයි ) . ඉන්පසු අපි ප්‍රධාන ලූපයට ඇතුළු වෙමු. දැන්, දෙවන කටහ another ේ තවත් ලූපයක් අඩංගු වේ. පළමු මුරපදයේ දී, මෙම ලූපය මඟ හැරෙනුයේ දෙවන තොගය හිස් / අඩංගු වන්නේ 0s පමණි. ඒ නිසා අපි කෙලින්ම කේතන ක්‍රමයට පැන එම ඉලක්කම් සියල්ලම තොගයට තල්ලු කරමු. මෙම 7අපි පළමු අඩුක්කුව තල්ලු තවමත් පවතී, ඒ නිසා පුඩුවක් දරුවා.

මේ වතාවේ, 7දෙවන තොගයේ ද ඇත, එබැවින් අපි දෙවන හ .ට ලූපයක් ඇතුළත් කරමු. දෙවන කටහ on ේ ඇති ලූපය නිර්මාණය කර ඇත්තේ තොගය අවසානයේ නැවත හිස් වන නිසා එය ක්‍රියාත්මක වන්නේ එක් වරක් පමණි. එය පළමු තොගය ක්ෂය කරනු ඇත ... එබැවින් අපි දෙවන හ voice ට ලූපය තැබූ විට, අපි නැවතත් සියලු ඉලක්කම් තල්ලු කරමු, නමුත් දැන් 7පළමු කොටුවේ ඉවතලනු ලැබේ, එබැවින් ප්‍රධාන ලූපය අවසන් වන අතර වැඩසටහන අවසන් වේ.

ඊළඟට, සැබෑ හරයේ පළමු ලූපය දෙස බලමු. එකවර දේවල් කිරීම (හෝ )තරමක් සිත්ගන්නා සුළුය. මම මෙහි ලූප ශරීරය සලකුණු කර ඇත්තේ =:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

ඒ කියන්නේ අඩංගු තීරුව (ලූපයේ කොටසක් ලෙස නොසැලකේ (එහි අක්ෂර ක්‍රියාත්මක වන්නේ එක් වරක් පමණක් වන අතර, ලූපය මඟ හැරියද). එහෙත් අඩංගු තීරු ) වේ කම්බියක් කොටසක් හා එක් එක් ප්රතිඵලය මත වරක් දිව වේ.

ඒ නිසා අපි තනි එකකින් පටන් ගනිමු -, එය 7පළමු තොගය සක්‍රිය කිරීම -7... නැවතත්, පසුව තවත්. නියම ලූපය සම්බන්ධයෙන් ...

ඉලක්කම් තොගය හිස් කර නොමැති අතර ලූපය දිගටම පවතී. එය වරකට ඉලක්කම් දෙකක් සකසයි. මෙම ලූපයේ පරමාර්ථය වන්නේ කේතන ක්‍රමය විකේතනය කිරීම, අක්‍ෂරය මුද්‍රණය කිරීම සහ ඒ සමඟම ඉලක්කම් තොගය පළමු හ .ට මාරු කිරීමයි. එබැවින් මෙම කොටස පළමුව:

^^^
#^#

පළමු තීරුව අංක 1 ට ඉහළින් පළමු හ .ට ගෙන යයි. දෙවන තීරුවේ ඉලක්කම් 10 පළමු හ voice ට පිටපත් කරන අතර අංක 1 නැවත දෙවන හ .ට පිටපත් කරයි. තෙවන තීරුව එම පිටපත පළමු හ .ට ගෙන යයි. ඒ කියන්නේ පළමු හ voice ට දැන් ඉලක්කම් 1 ක් දෙවරක් සහ ඉලක්කම් 10 ක් ඇත. දෙවන හ voice ට ඇත්තේ ඉලක්කම් 10 ක තවත් පිටපතක් පමණි. ඒ කියන්නේ අපට තොගවල මුදුනේ ඇති අගයන් සමඟ වැඩ කළ හැකි අතර පසුකාලීනව පළමු තොගයේ පිටපත් දෙකක් ඉතිරිව ඇති බවට වග බලා ගන්න.

දැන් අපි ඉලක්කම් දෙකෙන් අක්ෂර කේතය ලබා ගනිමු:

2+8+2-!
(1- )#

පතුල කුඩා පුඩුවක් වන අතර එය ඉලක්කම් 10 ශුන්‍යයට අඩු කරයි. එක් එක් පුනරාවර්තනය සඳහා අපට ඉහළට 10 ක් එකතු කිරීමට අවශ්‍යය. පළමුවැන්න 2ලූපයේ කොටසක් නොවන බව මතක තබා ගන්න , එබැවින් ලූප් බොඩි ඇත්ත වශයෙන්ම +8+210 ක් එකතු කරයි ( 2කලින් තල්ලු කිරීම භාවිතා කරමින් ) සහ තවත් 2 තල්ලු කරයි. එබැවින් අපි ලූපය සමඟ අවසන් වූ විට, පළමු තොගයේ ඇත්ත වශයෙන්ම පදනම ඇත- අගය 10 ක් සහ තවත් 2. -කේතීකරණයේ ඇති ඕෆ්සෙට් සඳහා ගණනය කිරීම සඳහා අපි එම 2 අඩු කර අක්ෂර සමඟ මුද්‍රණය කරමු !. මෙම #පහළ පුඩුවක් අවසානයේ පමණක් ඉවත් කර දමන්නාක් ශුන්ය.

මෙම ලූපය සම්පුර්ණ වූ පසු, දෙවන තොගය හිස් වන අතර පළමු අට්ටාලය සියලු ඉලක්කම් ප්‍රතිලෝම අනුපිළිවෙලට තබා ගනී (සහ -7පතුලේ). ඉතිරිය තරමක් සරල ය:

( 6+ !
8(1-)8)#

හරයේ දෙවන ලූපය මෙය වන අතර එය දැන් සියලු ඉලක්කම් නැවත මුද්‍රණය කරයි. එසේ කිරීම සඳහා එහි නිවැරදි අක්ෂර කේතය ලබා ගැනීම සඳහා සෑම ඉලක්කම් 48 කටම 48 ක් අවශ්‍ය වේ. අපි දිවෙන සරල පුඩුවක් සමග මේ 8වේලාවන් සහ එකතු 6එක් එක් කාල. ප්‍රති result ලය මුද්‍රණය කර !ඇති 8අතර අවසානයේ ඊළඟ ක්‍රියාවලිය සඳහා වේ.

ඉතින් මොකද -7? ඔව්, 48 - 7 = 41එය අක්ෂර කේතයයි ). මැජික්!

අවසාන වශයෙන්, අපි එම ලූපය සමඟ අවසන් වූ විට, අපි දෙවන හ .ට පිටත ලූපය තබන බව සහතික කිරීම සඳහා 8අප තල්ලු කළ දේ #ඉවතලන්නෙමු. අපි සියලු ඉලක්කම් නැවත තල්ලු කරන අතර වැඩසටහන අවසන් වේ.



19
මාටින්, ඔයා කොහේ හරි නවත්වන්න ඕන.
seequ

5
මෙය සමස්තයක් ලෙස ගොල්ෆ් 5000 කට වඩා ගොල්ෆ් කර ඇති බවත්, ඉන් 3 ක් ඉතිරි කිරීම සඳහා Sp3000 සඳහා පිළිගැනීමක් ඇති බවත් මම ප්‍රිය කරමි.
කමිල් ඩ්‍රැකාරි

2
Am කමිල් ඩ්‍රකරි ඒවා අන්තිම බයිට් 3 වුවත්, ඒ නිසා එය විශාල ගනුදෙනුවක්. ;)
මාටින් එන්ඩර්

65

ෂඩාස්රාකාර , පැති දිග 11, බයිට් 314

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

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


සටහන: දැනට කෙටිම වැඩසටහන සමාන තාක්ෂණයක් භාවිතා කරමින් දිග බයිට් 261 ක් පමණි .

පැරණි අනුවාදය:

ෂඩාස්රාකාර , පැති දිග 11, බයිට් 330

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

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

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

වැඩසටහන මෙම පයිතන් කේතයට දළ වශයෙන් සමාන වේ: එය මාර්ගගතව උත්සාහ කරන්න!

දිග හැරුණු කේතය:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .          

.S දෙකක් බිට් 1 ක් ගනී. වෙනත් ඕනෑම අක්ෂරයක් බිට් 1 ක් සහ පාදක -97 ඉලක්කම් ගනී.

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

විශාල ප්‍රමාණ සඳහා රූප මත ක්ලික් කරන්න. සෑම පැහැදිලි කිරීමේ කොටසකටම අනුරූප පයිතන් කේතය ඇත.

දත්ත කොටස

ඒ වෙනුවට වෙනත් පිළිතුරු (සමග භාවිතා සංකීර්ණ ව්යුහයක් <, "සහ තවත් දේවල්), මම, IP පහළ අර්ධ හරහා ගමන් කරමු.

දත්ත

පළමුවෙන්ම, අයිපී බොහෝ සංඛ්‍යා හරහා ගමන් කරන අතර නො-ඔප් ( .) සහ දර්පණ ( \). සෑම ඉලක්කම්ම මතකයේ ඇති අංකයට එකතු වේ, එබැවින් අවසානයේ මතක අගය වැඩසටහනේ ආරම්භයේ අංකයට සමාන වේ.

mem = 362003511...99306179

! එය මුද්‍රණය කරයි,

stdout.write(str(mem))

හා $ඉදිරි හරහා පනී >.

සිට ආරම්භ වේ <. මතක අගය memව්‍යාජ නම් ( <= 0එනම් තත්වය mem > 0සෑහීමකට පත් නොවේ), අපි වැඩසටහන මුද්‍රණය කර ඇති අතර පිටවිය යුතුය. IP ඉහළ මාවත අනුගමනය කරනු ඇත.

පිටවීම

(IP එක එබීමට පෙර විධාන 33 ක් පමණ ලොව පුරා ක්‍රියාත්මක වීමට ඉඩ දෙන්න @(එය වැඩසටහන අවසන් කරයි) එය වෙනත් තැනක තැබීමෙන් අමතර බයිට් කිහිපයක් ඇති වේ)

එය සත්‍ය නම්, අපි පහළ මාර්ගය අනුගමනය කරන්නෙමු, කිහිප වතාවක් හරවා යවා වෙනත් කොන්දේසියකට පහර දීමට පෙර තවත් විධාන කිහිපයක් ක්‍රියාත්මක කරන්න.

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

දැන් මතකය මේ වගේ ය:

මතක 1

වටිනාකම සත්‍ය නම්:

if b > 0:

පහත කේතය ක්‍රියාත්මක වේ:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

මෙම සවිස්තරාත්මක පැහැදිලි කිරීමක් බලන්න Q4දී MartinEnder ගේ HelloWorld Hexagony පිළිතුර . කෙටියෙන් කිවහොත්, මෙම කේතය .දෙවරක් මුද්‍රණය කරයි .

මුලින් මම මෙය .වරක් මුද්‍රණය කිරීමට සැලසුම් කළෙමි . මම මෙය ඉදිරිපත් කර ( .දෙවරක් මුද්‍රණය කර එය ක්‍රියාත්මක කරන විට) ඉලක්කම් 10 ක් පමණ ඉතිරි කර ඇත.

ඉන්පසු,

b = mem // a                # :

ඉලක්කම් 14 ක් පමණ මා ඉතිරි කළ බව මා වටහා ගත් වැදගත් කරුණක් මෙන්න: ඔබ ආරම්භ කළ ස්ථානයේ සිටීමට ඔබට අවශ්‍ය නැත.


මා පවසන දේ තේරුම් ගැනීමට, අපි බීඑෆ් ප්‍රතිසමයක් ලබා ගනිමු. (ඔබ දැනටමත් තේරුම් ගෙන ඇත්නම් මෙය මඟ හරින්න)

කේතය ලබා දී ඇත

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

අපි aවත්මන් සෛලයේ bවටිනාකම සහ නිවැරදි කොටුවේ වටිනාකම වීමට ඉඩ දෙමු යැයි සිතමු , මෙය BF වෙත සෘජු පරිවර්තනයකි:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

කෙසේ වෙතත්, වැඩසටහන අතරතුර අපි සෑම විටම එකම ස්ථානයක සිටීමට අවශ්‍ය නොවන බව සලකන්න. aඑක් එක් පුනරාවර්තනයේ ආරම්භයේ දී අප කුමක් වුවත් එහි වටිනාකම අපට ඉඩ දිය හැකිය , එවිට අපට මෙම කේතය ඇත:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

එය බයිට් කිහිපයක් කෙටි වේ.


එසේම, කෙළවරේ එතීමේ හැසිරීම \දර්පණයක් තිබීමෙන් මා බේරා ගනී - එය නොමැතිව මට ඉලක්කම් ( \තමාටම +2 ඉලක්කම් සහ +2 ඉලක්කම් .එහි දකුණට නොගැලපෙන අය සඳහා ගැලපීමට නොහැකි වනු ඇත. කොඩි)

(විස්තර:

  • IP පහළ වම් කෙළවරට ඇතුළු වන අතර වමට ගමන් කරයි
  • එය දකුණු කෙළවරට රත්වී, තවමත් වමට ගමන් කරයි
  • එය \පිළිබිඹු කරන a ට මුහුණ දෙයි , දැන් එය දකුණට ගමන් කරයි
  • එය කෙළවරට ගොස් පහළ වම් කෙළවරට යළිත් වර්‍ග ගත වේ

)


(ඉහත මෝඩ් 2 මෙහෙයුමේ) අගය ව්‍යාජ (ශුන්‍ය) නම්, අපි මෙම මාර්ගය අනුගමනය කරමු:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

මමත් මෙතන විස්තර පැහැදිලි නැත, නමුත් පියවා ඇත්තටම හරියටම නෑ 33, නමුත් ඇමුණුෙම් දක්වා ඇත 33, mod 256. සහ chrව්‍යංගයක් % 256ඇත.


3
මචං, ඒක ගොඩක්
ජෝ කිං

26
මම සිනාසුණේ "මම කියන දේ තේරුම් ගැනීමට, අපි [BrainFuck] ප්‍රතිසමයක් ලබා ගනිමු" යනුවෙනි. PPCG මත පමණි ... :)
ලින්

2
පිළිතුර ඉහළට ඔසවා තැබීම සඳහා මම 3 වතාවක් ඉහළට අනුචලනය කළෙමි, මම එය දැනටමත් කර ඇති බව දැනගැනීමට පමණි ...
NieDzejkob

2
අංකය කෙටි කිරීමෙන් නව අවකාශයේ වාසිය ලබා ගනිමින් බයිට් 310 ක්
ජෝ කිං

3
ඊටත් වඩා ඉඩ ප්‍රමාණයක් ලබා ගැනීමෙන් බයිට් 308 ක්
ජෝ කිං

46

Vim, බයිට් 11 යි

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: පටිගත කිරීමට පිටතින් තිබිය යුතු පෙළෙහි අනුපිටපතක් අතින් ඇතුල් කරන්න .
  • q"සහ hqP: ඇතුලත කෙලින්ම නම් නොකළ ලේඛනයට පටිගත කරන්න "", එවිට එය මැදට ඇලවිය හැකිය. මෙම hඅවශ්ය එකම නැවත ස්ථාපිත කිරීම ය; ඔබ එය සාර්ව තුළ තැබුවහොත් එය ප්‍රති .ලයට අලවනු ලැබේ.

සංස්කරණය කරන්න

සමඟ පටිගත කිරීම පිළිබඳ සටහනක් q": නම් නොකළ ලේඛනය ""විහිලු දෙයකි. පෙළ එහි ගබඩා කර නොමැති බැවින් එය අනෙක් අය මෙන් සත්‍ය ලේඛනයක් නොවේ. එය ඇත්ත වශයෙන්ම වෙනත් ලේඛනයකට යොමු කිරීමකි (සාමාන්‍යයෙන් "-නව "0රේඛාවක් නොමැති මකාදැමීම් සඳහා, යෑන්ක් "1සඳහා හෝ නව රේඛාවක් සහිත මකාදැමීම් සඳහා). q"නීති කඩ කරයි; එය සැබවින්ම ලියයි "0. ඔබ ""දැනටමත් වෙනත් ලේඛනයක් වෙත යොමු කර ඇත්නම් "0, q"නැවත ලියනු ඇත, "0නමුත් ""නොවෙනස්ව පවතී. ඔබ නැවුම් Vim එකක් ආරම්භ කරන විට, ""ස්වයංක්‍රීයව යොමු වේ "0, එබැවින් ඔබ ඒ අවස්ථාවේ හොඳින් සිටී.

මූලික වශයෙන්, විම් අමුතු හා දෝෂ සහිත ය.


ඉන්න මේ ඇයි මට වැඩ කරන්නේ නැත්තේ
විනාශකාරී ලෙමන්

EstDestructibleWatermelon නිශ්චිතවම පැවසිය නොහැක, නමුත් එක් පැහැදිලි කිරීමක් බොහෝ දුරට ඉඩ ඇත. මිනිසුන්ව ඉවත දැමිය හැකි බැවින් එය ලිවීමේදී මීට පෙර තිබිය යුතුය. සංස්කරණය කියවන්න.
udioica

yධාවනය කිරීමට පෙර එබීමෙන් හෝ යමක් උපකාර කළ හැකි ආකාරය ගැන ඔබ යමක් තැබිය යුතුය
විනාශකාරී ලෙමන්

<Esc> යතුර එබීම පෙන්වීමට ඔබ භාවිතා නොකරන්නේ ඇයි ? මෙම යුනිකෝඩ් බ්ලොක්
එකේ කොටසක්

5
@ mbomb007 <Esc>අංකනය Vim සිතියම්කරණයේ ( :help <>) සම්මත වන අතර vimgolf.com භාවිතා කරන්නේ එයයි. ඕනෑම පළපුරුදු vimgolfer එය කියවීමට පුරුදු වනු ඇත. යුනිකෝඩ් සම්බන්ධයෙන් ගත් කල, කුඩා අකුරු කියවීමට මට සිදුවේ. ඒවා ටයිප් කර උදව් ගොනුව සෙවීමේ ක්‍රමය අපැහැදිලි වේ.
udioica

45

කියුබික්ස් , බයිට් 20 යි

3434Qu$v@!<"OOw\o;/"

පාහේ \o/ ...

ශුද්ධ :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

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

එය මෙහි උත්සාහ කරන්න !

අමතර සටහන්

පසුබිම් කතාව

Answer ais523 විසින් මෙම ශ්‍රේෂ් answer පිළිතුර කියවීමෙන් පුදුමයට පත් වූ පසු , මම තවදුරටත් ක්වීන් ගොල්ෆ් ක්‍රීඩාව ගැන සිතන්නට පටන් ගතිමි. ඇත්තෙන්ම, එහි කිසිදු විකල්පයක් නොතිබූ අතර එය එතරම් සම්පීඩිත බවක් දැනුනේ නැත. කෙසේ වෙතත්, ඔහුගේ පිළිතුර (සහ මගේ මෙන්ම) භාවිතා කරන තාක්‍ෂණයට, සම්පූර්ණ රේඛා විහිදුවාලීමට කේතය අවශ්‍ය බැවින් අවම වශයෙන් බයිට් 12 ක් ඉතිරි කර ගැනීම අවශ්‍ය විය. ඔහුගේ පැහැදිලි කිරීමෙහි එක් ප්‍රකාශයක් මා සිතන්නට පටන් ගත්තේය:

මෙම කෝණුව තවදුරටත් ගොල්ෆ් කිරීමේ විෂය සම්බන්ධයෙන්, [...] එයට [නකයේ ඉහළ මුහුණත නිරූපණය කිරීමට වෙනත් ක්‍රමයක් අවශ්‍ය වේ [...]

එවිට, හදිසියේම, මම නැගිට බීමට යමක් ලබා ගැනීම සඳහා ඉවත්ව යන විට, එය මට තදින්ම කාවැදුණි: වැඩසටහන අක්‍ෂර කේත නොව ඉහළ මුහුණත නියෝජනය කිරීමට සංඛ්‍යා භාවිතා නොකළේ නම් කුමක් කළ යුතුද? අප මුද්‍රණය කරන අංකයට ඉලක්කම් 2 ක් තිබේ නම් මෙය විශේෂයෙන් කෙටි වේ. Cubix ඉලක්කම් දෙකක අංක යාමේ 3 එක්-බයිට උපදෙස් ඇත: N, Sසහ Q, වන තල්ලුව 10, 32හා 34පිළිවෙළින්, ඒ නිසා මෙම ලස්සන golfy විය යුතු, මම හිතුවා.

මෙම අදහස සමඟ ඇති පළමු සංකූලතාව නම් ඉහළ මුහුණ දැන් නිෂ් less ල සංඛ්‍යා වලින් පිරී ඇති බැවින් අපට එය තවදුරටත් භාවිතා කළ නොහැක. දෙවන සංකූලතාව නම් ඉහළ මුහුණෙහි size න ප්‍රමාණයේ වර්ගයක් ඇති අතර එයට ඊටත් වඩා විශාල ප්‍රමාණයක් අවශ්‍ය වන අතර එසේ නොවුවහොත් එක් අංකයක් උපදෙස් පොයින්ටරයේ ආරම්භක ස්ථානය මත අවසන් වන අතර එය දූෂිත සිරස් තලයකට මඟ පාදයි. මෙම සංකූලතා නිසා, මගේ කේතය 2 ප්‍රමාණයේ ube නකයක් මත සවි කිරීමට අවශ්‍ය විය (එහි අඩංගු විය හැක්කේ බයිට් 24 ක් පමණි, එබැවින් මට අවම වශයෙන් බයිට් 21 ක් වත් ගොල්ෆ් කිරීමට සිදුවිය). ඉහළ සහ පහළ මුහුණු භාවිතා කළ නොහැකි නිසා මට තිබුණේ effective ලදායී බයිට් 16 ක් පමණි.

ඒ නිසා මම ඉහළ මුහුණෙන් අඩක් බවට පත්වන අංකය තෝරා ගැනීමෙන් ආරම්භ කළෙමි. මම N(10) සමඟ ආරම්භ කළ නමුත් සෑම දෙයක්ම මුද්‍රණය කිරීමට මා ගත් ප්‍රවේශය නිසා එය සාර්ථක වූයේ නැත. කෙසේ හෝ මම නැවත ආරම්භ කර S(32) කිසියම් හේතුවක් නිසා භාවිතා කළෙමි . එහි ප්‍රති result ලය වූයේ නිසි නිශ්ශබ්දතාවයක් හෝ එසේ යැයි මම සිතුවෙමි. ඒ සියල්ල ඉතා හොඳින් ක්‍රියාත්මක වූ නමුත් උපුටා දැක්වීම් අතුරුදහන් විය. එවිට, එය බව මට සිදුවිය Q(34) ඇත්තටම ප්රයෝජනවත් වනු ඇත. සියල්ලට පසු, 34 යනු ද්විත්ව උපුටා දැක්වීමේ අක්ෂර කේතය වන අතර, එය එය තොගයේ තබා ගැනීමට අපට හැකියාව ලබා දෙයි, (2, මම එවකට භාවිතා කළ පිරිසැලසුමෙහි) වටිනා බයිට්. මම IP මාර්ගය ටිකක් වෙනස් කළ පසු, ඉතිරිව ඇත්තේ හිස් තැන් පිරවීම සඳහා වූ අභ්‍යාසයකි.

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

කේතය කොටස් 5 කට බෙදිය හැකිය. මම ඒවා එකින් එක උඩින් යන්නම්. අපි මැද මුහුණු ප්‍රතිලෝම අනුපිළිවෙලට කේතනය කරන බව සලකන්න.

පියවර 1: ඉහළ මුහුණත මුද්‍රණය කිරීම

අදාළ නොවන උපදෙස් no-ops ( .) මගින් ප්‍රතිස්ථාපනය කර ඇත . අයිපී තෙවන පේළිය ආරම්භ කරන්නේ වම් පසින් නැගෙනහිර දෙසටය. තොගය (පැහැදිලිවම) හිස් ය.

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

අයිපී අවසන් වන්නේ හතරවන පේළියේ වම් කෙළවරේ සිට බටහිර දෙසට යමින් එම රේඛාවේම දකුණු කෙළවරට එතීමට ය. ක්‍රියාත්මක කරන උපදෙස් (පාලන ප්‍රවාහ අක්‍ෂරය නොමැතිව):

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

තොගයේ අඩංගු වන්නේ 34 ක් පමණි, ප්‍රභවයේ අවසාන අක්‍ෂරය නිරූපණය කරයි.

පියවර 2: සිව්වන පේළිය කේතනය කරන්න

මෙම බිට් ඔබ බලාපොරොත්තු වන දේ කරයි: හතරවන පේළිය කේතනය කරන්න. අයිපී එම රේඛාවේ අවසානයේ ද්විත්ව උපුටා දැක්වීමෙන් ආරම්භ වන අතර බටහිර දෙසට ගමන් කරන අතර එය ගැලපෙන ද්විත්ව උපුටා දැක්වීමක් සොයා ගන්නා තෙක් එය ගොඩබසින සෑම චරිතයකම අක්ෂර කේත තල්ලු කරයි. මෙම ගැලපෙන ද්විත්ව උපුටා දැක්වීම සිව්වන පේළියේ අවසාන අක්‍ෂරය ද වේ, මන්ද යත් එය වම් කෙළවරට ළඟා වන විට IP නැවත ඔතා ඇති බැවිනි.

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

පියවර 3: තවත් උපුටා දැක්වීමක් කරන්න

අපට තවත් උපුටා දැක්වීමක් Qකළ යුතු අතර, වැඩසටහන ආරම්භයේදීම එය ප්‍රතිචක්‍රීකරණය කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද? තෙවන පේළිය සංකේතවත් කරන උපුටා දැක්වීමට IP කෙලින්ම ධාවනය වන අමතර ප්‍රසාදයක් මෙයට ඇත.

මෙන්න මෙම පියවර සඳහා ශුද්ධ අනුවාදය. අදාල නොවන උපදෙස් නැවත නො-ඕප් මගින් ප්‍රතිස්ථාපනය කර ඇත, ක්‍රියාත්මක කරන ලද නො-ඔප්ස් #නිදර්ශන අරමුණු සඳහා හැෂ් ටැග් ( ) මගින් ප්‍රතිස්ථාපනය කර ඇති අතර අයිපී ආරම්භ වන්නේ සිව්වන පේළියේ අවසාන අක්‍ෂරයෙන් ය.

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

අයිපී පළමු පේළියේ තුන්වන පේළියේ අවසන් වන අතර, එය බටහිර දෙසට යොමු වී ඇති නිසා එම රේඛාවේ අවසානයට එතීමට සූදානම් වේ. පහත දැක්වෙන උපදෙස් (පාලන ප්‍රවාහය හැර) බැහැර කර ඇත:

$uQ
$u  # Don't do anthing
  Q # Push the double quote

මෙම ද්විත්ව උපුටා දැක්වීම තුන්වන පේළියේ අවසානයේ ඇති එක නියෝජනය කරයි.

පියවර 4: තුන්වන පේළිය කේතනය කිරීම

මෙය හරියටම පියවර 2 ට සමාන වේ, එබැවින් කරුණාකර පැහැදිලි කිරීමක් සඳහා එහි බලන්න.

පියවර 5: තොගය මුද්‍රණය කරන්න

දැන් සිරස් අතට හතරවන සහ තෙවන පේළි ප්‍රතිලෝම අනුපිළිවෙලින් අඩංගු වේ, එබැවින් අප දැන් කළ යුතු සියල්ල එය මුද්‍රණය කරයි. අයිපී ආරම්භ වන්නේ තුන්වන පේළියේ අවසාන උපදෙස් වලින් බටහිර දෙසටය. මෙන්න the නකයේ අදාළ කොටස (නැවතත්, අදාල නොවන කොටස් ප්‍රතිස්ථාපනය කර ඇත).

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

ඔබ දැක ඇති / අපේක්ෂා කළ පරිදි මෙය ලූපයකි. ප්රධාන ශරීරය:

o;
o  # Print top of stack as character
 ; # Delete top of stack

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


මට මෙය තව දුරටත් ඉහළ නැංවීමට හැකි වේවායි ප්‍රාර්ථනා කරමි
මිකීටී

ත්‍යාග සැමවිටම සාදරයෙන් පිළිගනිමු ;-)
ලූක්

44

ජාවාස්ක්‍රිප්ට් ඊඑස් 6 - බයිට් 21 යි

$=_=>`$=${$};$()`;$()

මම මෙම ක්වීන් "බ්ලින්ග් ක්වයින්" ලෙස හඳුන්වමි.

සමහර විට, ඔබට ගොල්ෆ් විලාසිතාවක් තිබිය යුතුය.


!$=_=>`!$=${$}()`()ඔබට බයිට් 2 ක් ඉතිරි වේද ?
ඩවුන්ගෝට්

Invalid assignment left hand side. එය ක්‍රියාත්මක වීමට ප්‍රාර්ථනා කරන්න :(
මාමා ෆන් රෝල්

1
Ù TùxCräftîñg අච්චු අක්ෂර වටා වරහන් ඉවත් කිරීම ක්‍රියාත්මක වන්නේ වැනි දේශීය මූලාකෘති ක්‍රියාකාරකම් මත පමණි Array.prototype.join.
මාමා ෆන් රෝල්

2
හ්ම්, විශ්වාස නෑ. මම මෙය ලියා ඇත්තේ මීට වසරකට පෙරය (එය එවකට වලංගු යැයි සැලකේ), මම ක්වීන් රීති වෙනස්කම් ඉතා සමීපව අනුගමනය කර නැත. කෙසේ වෙතත්, ඊතල ශ්‍රිතය එකතු කිරීම alertහෝ console.logපසුව සහ වරහන් තුළ අච්චු නූල් එතීම ක්‍රියා කරයි.
මාමා ෆන් රෝල්

3
ඔබ මෙය කොන්කෝලය තුළ ධාවනය කරන්නේ නම්, එය මෙම වෙබ් අඩවියේ $ (jQuery ශ්‍රිතය) නැවත ලියයි, සහ ඉහළ ක්‍රියාකාරීත්වය තවදුරටත් ක්‍රියාත්මක නොවේ. :)
ස්ටීවන් පාලින්කාස්

41

Brainf * ck (අක්ෂර 755)

මෙය පදනම් වී ඇත්තේ එරික් බොස්මන් (cs.vu.nl හි ejbosman) විසින් දියුණු කරන ලද තාක්‍ෂණයකිනි. "ESultanik's Quine!" පා qu ය ඇත්තෙන්ම එය අවශ්‍ය වේ!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]

13
එය කිරීමට දක්ෂ ක්‍රමයක්.
පීටර් ඕල්සන්

13
එය ක්‍රියාත්මක වන්නේ කෙසේද?
ආඩම්බර හස්කලර්

3
roudproudhaskeller IIRC, පෙර කොටස ESultanik's Quine!මතකය තොග කේතීකරණයක් ලෙස සකසා ESultanik's Quine!ඉදිරියට යන අතර එක් එක් අක්ෂර සඳහා මතක බයිට් දෙකක් ඇත (ASCII අගය 0x1F වෙතින් ඕෆ්සෙට්). කේතයේ අවසාන කොටස මතකය හරහා ලූප වන අතර, පළමුව ++>+++…එක් එක් අක්ෂර සඳහා කේත ක්‍රමලේඛනගතව ප්‍රතිනිෂ්පාදනය කරයි , පසුව ඇත්ත වශයෙන්ම අක්ෂර මුද්‍රණය කරයි.
ESultanik

4
AtCatsAreFluffy එය quine වීමට ඔවුන් අවශ්‍ය වේ! ඒවා ඉවත් කළ හැකි බව සත්‍යයක් වන අතර, ක්වයින් දේපල නඩත්තු කිරීම සඳහා යමෙකුට පෙර කේතය වෙනස් කළ යුතුය.
ESultanik

1
ඒක ඇත්ත. එසේම නව රේඛා අවශ්‍ය වේ.
කැල්කියුලේටර්

38

ෂඩාස්රාකාර , පැති දිග 15 14 13 12, 616 533 456 383 බයිට්

ප්රවේශම් ෙගොල්ෆ් දින කිහිපයක් පසු, වළළු නැවත සකස් වීම් හා හා පුරා ආරම්භ, මම තියෙනවා අවසානයේ පැත්තක 12 ෂඩස්ර එය ගෙන්වා ගැනීමට සමත් විය.

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

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

දිග හැරෙන:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

එය ෂඩාස්රාකාර කේතයේ වඩාත්ම ගොල්ෆ් කරන ලද බවක් නොපෙනුනත්, මා භාවිතා කළ කේතන වර්ගය වැඩි කාලයක් නො-ඕප් ධාවනය සඳහා ප්‍රශස්තිකරණය කර ඇති අතර එය ඔබ වෙනත් ආකාරයකින් වළක්වා ගත හැකිය.

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

මෙය පෙර ෂඩාස්රාකාර පිළිතුරට. වඩා වෙනස් ආකාරයකින් නො- ඕප්ස් ( ) කේතනය කිරීමෙන් පරාජය කරයි . අනෙක් සෑම අක්‍ෂරයක්ම සෑදීමෙන් එම පිළිතුර අවකාශය ඉතිරි කරන අතර ., පතලේ කිසිදු සංඛ්‍යාවක් නැත. එයින් අදහස් වන්නේ ප්‍රභවය එතරම් සීමා කළ යුතු නැති බවයි.

මෙන්න මම පාදක 80 කේතීකරණයක් භාවිතා කරමි, එහිදී 16 ට අඩු සංඛ්‍යා මඟින් නොබැඳි ලකුණු පෙන්නුම් කරන අතර 16 සහ 79 අතර සංඛ්‍යා 32 ( !) සිට 95 ( _) දක්වා පරාසයක් නිරූපණය කරයි (මම දැන් වටහාගෙන ඇත්තේ මගේ සියලු දේ ගොල්ෆ් _කර ඇති බවයි කේතය lol). සමහර පයිතොනික් ව්‍යාජ කේත:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

මෙම සංඛ්‍යාව ෂඩාස්රයේ පළමු භාගය තුළ කේතනය කර ඇත

" " > 
 " " > 
  ... etc

වම් පැත්තෙන් සහ

 > ,
< "
 >
< "
... etc

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

ඉන්පසු එය පහත කොටසට ඇතුල් වන්නේ ->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!'ලූපය ආරම්භ කිරීමට පෙර අංකය මුද්‍රණය කර දකුණු මතක කොටුවට සැරිසැරීම. P='%වත්මන් අංකය 80 කින් වෙනස් කරයි. ප්‍රති result ලය 0 නම්, අවසන් වන තෙක් යන්න @, නැතිනම් පහළට ගොස් මෝඩ් ප්‍රති result ලයට යාබද කොටුවක් සාදන්න -16.

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

කොටුව (mod අගය + -16) ලෙස සකසන්න. එම අගය negative ණ නම් >+'\, අතු ඉහළට යන්න , නැතිනම් පහළට යන්න.

අගය ධනාත්මක නම්:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

දර්ශකය අවසන් වන්නේ ;-<සෛලය (mod අගය - -16) ලෙස සකසා මුද්‍රණය කරමිනි.

වටිනාකම negative ණ වේ:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

> ) <ලූපය ආරම්භ කරන කොටසට යන්න . මෙන්න එය හුදකලා වේ:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

'Q4;="=එය මුද්‍රණය කරන කේතය ක්‍රියාත්මක කරයි .( අක්ෂර සඳහා අකුරු අංක සංයෝජන සොයා ගැනීමට වැඩසටහනක් ලියූ මාටින් එන්ඩර්ට නැවතත් ස්තූතියි ) සහ ආරම්භක කොටුව වෙත ආපසු ගමන් කරයි. එය පසුව ( )) මෝඩ් අගය සෛලය වැඩි කර මෝඩ් අගය ධනාත්මක වන තෙක් නැවත ලූප කරයි.

එය සිදු කළ විට, එය ඉහළට ගමන් කර අනෙක් කොටස සමඟ සම්බන්ධ වේ:

 " " > . / < $ ; - < . . .
            \
             \

දර්ශකය නැවත විශාල ලූපයේ ආරම්භය දක්වා ගමන් කරයි

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

මෙය ක්‍රියාත්මක වන ='=:'අතර එය වත්මන් අංකය 80 න් බෙදූ අතර නිවැරදි කොටුවට ගමන් කරයි.

පැරණි අනුවාදය (පැති දිග 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

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

මට අනිවාර්යෙන්ම මෙයින් තවත් පැත්තක් ගොල්ෆ් කළ හැකිය, නමුත් මට එය හෙට වන තුරු තැබීමට සිදුවේ. මම නොඉවසිලිමත් වන අතර හෙට වන තෙක් බලා සිටිය නොහැක. සමහර විට තවත් පැත්තක් ගොල්ෆ් කළ හැකිද? :( අහ්හ්හ්හ් මම ඒක කළා!

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


13
මෙය පුදුම සහගතය. මෙම දෙමුහුන් ධාවන දිග කේතනය සඳහා අදහස ඇත්තෙන්ම පිළිවෙලයි. :) මට අමතක වුවහොත් ඔබට ත්‍යාගයක් දීමට මට මතක් කරන්න.
මාටින් එන්ඩර්

35

තැපැල් පිටපත, අක්ෂර 20 යි

කෙටි හා නීත්‍යානුකූල. නව රේඛාව පසුපස යාම ඇතුළු අක්ෂර 20 ක්.

(dup == =)
dup == =

34

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

_='_=%r;print _%%_';print _%_

මෙතනින් ගත්තා


1
+1, ඔබ මගේ සමාන විසඳුම පරාජය කළ නිසා මම එය මකා දැමුවෙමි. මෙය ක්‍රියාත්මක වන්නේ පයිතන් 2 හි පමණක් බව සැලකිල්ලට ගත යුතුය
nyuszika7h

2
එය විචල්ය නාමයෙන් අමුතු ලෙස පෙනේ _, නමුත් ඔබ එය ඕනෑම s='s=%r;print s%%s';print s%s
අකුරකට පවරන්නේ

5
මෙම විසඳුම ඔබේම නිර්මාණයක් නොවේ නම්, ඔබ එය ප්‍රජා විකියක් බවට පත් කළ යුතුය. එසේම, සබැඳිය මිය ගොස් ඇත.
mbomb007

1
මම සාදයට ටිකක් ප්‍රමාදයි, නමුත් මෙය ක්‍රියාත්මක වන ආකාරය යමෙකුට පැහැදිලි කළ හැකිද?
මැඩ්ටක්ස්

10
මේ සඳහා වලංගු වීමට පසුපස රේඛාවක් අවශ්‍ය වේ. එය එසේ නම්, ප්‍රභව කේතය ප්‍රතිදානයට නොගැලපේ.
ඩෙනිස්

33

කියුබික්ස් , බයිට් 45 යි

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

ඔබට මෙම කේතය මෙතැනින් පරීක්ෂා කළ හැකිය .

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

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

මෙය බෙෆන්ජ් විලාසිතාවේ ක්වයින් එකක් වන අතර, එය නූල් වචනාර්ථයෙන් ක්‍රියාත්මක කළ හැකි කේතයක් "එතීම" බවට පත් කිරීම සඳහා ඔතා සූරාකෑම හරහා ක්‍රියා කරයි (එකක් පමණක් ඇත " සලකුණක් සහිතව, කේතය එකවරම උපුටා දැක්වීමේ ඇතුළත හා පිටත ඇත, ඔබට ඇති විට එය කළ හැකි දෙයක් රේඛීය නොවන සහ සැලසුම් රහිත වැඩසටහන්). මෙය නිසි නිශ්ශබ්දතාවයක් පිළිබඳ අපගේ අර්ථ දැක්වීමට ගැලපෙන බව සලකන්න, මන්ද ද්විත්ව උපුටා දැක්වීම් දෙකක් තමන් විසින්ම කේතනය නොකරන නමුත් ගණිතය භාවිතයෙන් පසුව ගණනය කරනු ලැබේ.

Befunge මෙන් නොව, අපි මෙහි භාවිතා කරන්නේ එකකට වඩා නූල් හතරක් ය. මෙන්න ඔවුන් තොගයට තල්ලු කරන ආකාරය;

  1. වැඩසටහන ආරම්භ වන්නේ වම් දාරයේ ඉහළින්, දකුණට ය; එය දෙවරක් දකුණට හැරේ (R ), එය මුළු .නකම වටා එතෙන තුන්වන හා අවසාන රේඛා ඔස්සේ වමට ගමන් කරයි. ද්විත්ව උපුටා දැක්වීම එයට ගැලපේ, එබැවින් අපි මුළු තෙවන පේළියම පිටුපසට තල්ලු කරමු. ද්විත්ව උපුටා දැක්වීමෙන් පසුව ක්‍රියාත්මක කිරීම දිගටම කරගෙන යයි.

  2. මෙම uවිධානය අයිතිය සඳහා U-හැරීම කරන්නේ, ඒ නිසා ඊළඟ දේ අපට ඉන්නේ ධාවන වේ '"සිට මැද රේඛාව මත. එය තොගයට තල්ලු කරයි ". නොකඩවා ඔතා, අපි <ube නකයේ වම් පැත්තට පහර දී පසුපසට පැන්නෙමු. මෙම දිශාවට ළඟා වන විට, අපට පෙනෙන්නේ සරල "විධානයකි, එසේ නොවේ '", එබැවින් මුළු දෙවන පේළියම තුන්වන පේළියට ඉහළින් සහ ද්විත්ව උපුටා දැක්වීමට ඉහළින් පිටුපසට තල්ලු කරනු ලැබේ.

  3. අපි ආරම්භ කරන්නේ !තොගයට ( '!) තල්ලු කර එය වැඩි කිරීමෙන් ( )); මෙය අපගේ ප්‍රභව කේතයේ ද්විත්ව උපුටා දැක්වීමක් අවශ්‍ය නොවී ද්විත්ව උපුටා දැක්වීමක් කරයි (එමඟින් නූල අවසන් වේ). දර්පණයක් ( \) උතුරු දෙසට ක්‍රියාත්මක කිරීමේ දිශාව පිළිබිඹු කරයි; ඉන්පසු Wවිධානය වම් පැත්තට හැරේ. මෙය අපව හත්වන තීරුවේ ඉහළට ගමන් කරයි, මෙය ube නකයක් බැවින් තුන්වන පේළියේ වමට ද තුන්වන තීරුවේ පහළට ද ඔතා ඇත. අපි Rදකුණට හැරී ඉහළ පේළිය දිගේ වමට යන්න; ඉන්පසු අපි වැඩසටහනට ඇතුළු $වූ Rමාර්ගය මඟ හරිනු ඇත , එම නිසා ක්‍රියාත්මක කිරීම "රේඛාවේ කෙළවරට එතෙර වන අතර දෙවන හා තෙවන සඳහා අප කළ ආකාරයටම පළමු පේළිය නූලකින් අල්ලා ගනිමු.

  4. මෙම ^විධානය (කැට ඔතන සඳහා ඉඩ) වන ඇත පස්වන මත දකුණු දිගින් එකොළොස් තීරුව දක්වා උතුරු දෙසට අප යවයි. එහිදී අපට හමු වන එකම දෙය නම් !(නොන්සෙරෝ නම් මඟහරින්න; තොගයේ මුදුන ඇත්ත වශයෙන්ම නොන්සෙරෝ වේ), එය oවිධානය මඟ හැර පස්වන තීරුව මුළුමනින්ම හිස් කරයි. ඒ නිසා අපි uනැවත වරක් යූ-හැරවුම් විධානය වෙත ඔතා , නමුත් මේ වතාවේ අපට ඉතිරිව ඇත්තේ අවසාන තීරුවේ දකුණු දෙසට වන අතර එය සිව්වන තීරුවට උතුරු දෙසට ඔතා ඇත. යූ-හැරීම අතරතුර අපි ද්විත්ව උපුටා දැක්වීමක් කළෙමු, එනමුත්, අපි හතරවන තීරුව පහළ සිට ඉහළට නූලකින් අල්ලා ගනිමු. වැඩසටහනේ බොහෝ ද්විත්ව උපුටා දැක්වීම් මෙන් නොව, මෙය වැසෙන්නේ නැත; ඒ වෙනුවට, එය "ඉහළ දකුණු කෙළවරේ වසා ඇත , එයින් අදහස් වන්නේ අපි අක්ෂර නවය අල්ලා ගන්නා ...>.....බවයි.

එබැවින් තොග පිරිසැලසුම දැන් ඉහළ සිට පහළට: හතරවන තීරුව; ඉහළ පේළිය;"; මැද පේළිය; "; පහළ පේළිය. මේ සෑම එකක්ම තොගයේ මුදුනට ආසන්නයේ ඇති පළමු අක්‍ෂරය සමඟ නිරූපණය කෙරේ (කියුබික්ස් බෙෆුන්ජ් මෙන් මෙම අනුපිළිවෙලෙහි පිටුපසට නූල් තල්ලු කරයි, නමුත් සෑම අවස්ථාවකදීම අයිපී ස්වාභාවික කියවීමේ දිශාවට ප්‍රතිවිරුද්ධ දිශාවට ගමන් කරමින් සිටියදී, එබැවින් එය දෙවරක් ආපසු හැරවිය). තොගයේ අන්තර්ගතය මුල් වැඩසටහනට බොහෝ දුරට සමාන බව සැලකිල්ලට ගත හැකිය (මන්ද යත්, සිව්වන තීරුව සහ ube නකයේ උතුරු / ඉහළ මුහුණත එකම අනුපිළිවෙලෙහි එකම අක්ෂර අඩංගු වන බැවිනි; පැහැදිලිවම එය නිර්මාණය කර ඇත්තේ හිතාමතාම ය).

ඊළඟ පියවර වන්නේ තොගයේ අන්තර්ගතය මුද්‍රණය කිරීමයි. සියලු තල්ලු කිරීම් වලින් පසුව, අයිපී සිව්වන තීරුවේ උතුරු දෙසට ගමන් කරයි, එම නිසා එය >එතැනට ගොස් තද ලූපයකට ඇතුල් වේ >>o;?(එනම් "නැගෙනහිර දෙසට හැරෙන්න, නැගෙනහිර දෙසට හැරෙන්න, චරිතය ලෙස ප්‍රතිදානය, පොප්, ධනාත්මක නම් දකුණට හැරෙන්න"). හත්වන පේළිය එන්.ඕ.පී වලින් පිරී ඇති හෙයින්, ?එය පළමු දෙසට නැවත එනු ඇත> , එබැවින් මෙය තොගයේ සමස්ත අන්තර්ගතය ලෙස තල්ලු කරයි ( ?හිස් තොගයක් මත විවෘත කිරීමක් නොවේ). අපි සම්පූර්ණ වැඩසටහනම පාහේ මුද්‍රණය කළා! අවාසනාවට, එය තවම අවසන් නැත; අපට අවසානයේ ද්විත්ව උපුටා දැක්වීම මඟ හැරී ඇත.

ලූපය අවසන් වූ පසු, අපි දර්පණ යුගලයක් හරහා බටහිර දෙසට ගමන් කරමින් මධ්‍යම රේඛාව දෙසට පරාවර්තනය කරමු. (අපි \මීට පෙර දර්පණයේ "අනෙක් පැත්ත" භාවිතා කළෙමු; දැන් අපි නිරිතදිග පැත්ත භාවිතා කරමු. දර්පණය මීට පෙර භාවිතා /කර නොමැත.) අපට හමු වේ '!, එබැවින් අපි විස්මිත සලකුණක් තල්ලු කරමු (එනම් 33; අපි ASCII භාවිතා කරමු කියුබික්ස් පූර්ණ සංඛ්‍යා සහ අක්ෂර අතර වෙනස හඳුනා නොගනී) තොගයට. (පහසුව සඳහා, මෙය කලින් විධානය !මඟ හැරීම සඳහා භාවිතා කරන ලද්දකි o.) අපට Rවිධාන යුගලයක් හමු වී “අත්පොත” යූ-ටර්න් එකක් සෑදීමට ඒවා භාවිතා කරයි (මෙහි දෙවන Rවිධානය කලින් භාවිතා කිරීම සඳහා කලින් භාවිතා කරන ලදි පේළිය, ඒ නිසා වෙනත් Rවිධානයක් ඒ සමඟ ගැලපීම ස්වාභාවිකය .Wවිධානය, වමට පැත්තකට වන්න. පැති >පේළිය දෙවන පේළියේ විධානයට හරියටම කඩා වැටෙන අතර එය ක්‍රියාත්මක වූ ස්ථානය හරියටම ආපසු හරවයි . ඒ නිසා අපි නැවතත් වමට හැරී ගියෙමු, නමුත් මේ වතාවේ අපි දකුණු දෙසට යමු, එබැවින් ක්‍රියාත්මක කිරීමට ඊළඟ විධානය වන්නේ )(විශ්මය දනවන ලකුණ ද්විත්ව උපුටා දැක්වීමකට වැඩි කිරීම), ඉන්පසු o(ප්‍රතිදානය කිරීමට). අවසාන වශයෙන්, ක්‍රියාත්මක කිරීම අටවන පේළිය ඔස්සේ දෙවන තීරුවට ඔතා, එහිදී @වැඩසටහනෙන් පිටවීමට එය සොයා ගනී .

තුන්වන පේළියේ අයාලේ ගිය අපෝස්ත‍්‍රණය ගැන මම සමාව ඉල්ලමි. වැඩසටහනේ මෙම අනුවාදයේ එය කිසිවක් නොකරයි; එය මා කලින් තිබූ අදහසක කොටසක් වූ නමුත් එය අවශ්‍ය නොවන බව පෙනී ගියේය. කෙසේ වෙතත්, මට වැඩ කරන වර්‍ගයක් ලැබුනු පසු, මට අවශ්‍ය වූයේ එය තව දුරටත් අවුල් කරනවාට වඩා ඉදිරිපත් කිරීමට ය, විශේෂයෙන් එය ඉවත් කිරීම නිසා බයිට් ගණන වෙනස් නොවේ. මෙම රැජින තවදුරටත් ගොල්ෆ් කිරීම පිළිබඳ මාතෘකාව මත, පළමු පේළි පහ පමණක් භාවිතා කිරීමෙන් මෙය 3 × 3 ට කළ හැකි නම් එය මා පුදුමයට පත් නොකරනු ඇත, නමුත් මට එය කිරීමට පැහැදිලි ක්‍රමයක් නොපෙනේ, එයට අවශ්‍ය වනු ඇත control නකයේ ඉහළ මුහුණත නිරූපණය කිරීම සඳහා වෙනත් ක්‍රමයක් සමඟ සියලු පාලන ප්‍රවාහයන් තදින් ඇසුරුම් කිරීම (නැතහොත් ඇල්ගොරිතම වෙනස් කිරීම මඟින් සිව්වන තීරුව දිගින් දිගට අක්ෂර දහයක් හෝ එකොළහක් වුවද එය දිගටම භාවිතා කළ හැකිය). .


නියම වැඩක්, මෙය සැබවින්ම ආකර්ෂණීය ලකුණු වේ. මම කැමතියි ඔබ ඉහළ මුහුණත කේතනය කළ ආකාරය. :)
මාටින් එන්ඩර්

මෙය ඇදහිය නොහැකි තරම් ය! එය ඕනෑම උදව් අවශ්ය නම්, තල්ලුව හැකි තවත් මාර්ගයක් "වන්නේ Q.
ETH නිෂ්පාදන

1
වාව්! මම කවදාවත් cub නක quine එකක් දකින්නේ නැහැ!
ෆ්ලිප්ටැක්

3
මට ඊයේ පැහැදිලි කිරීම කියවීමට වෙලාවක් නොතිබුණි, නමුත් දැන් මට ඇත්තේ ... යන්තම් ... වාව්. සම්පූර්ණයෙන්ම වෙනස් අරමුණු දෙකක් හෝ තුනක් සඳහා චරිත කීයක් භාවිතා වේදැයි මට විශ්වාස කළ නොහැක. මෙය බොහෝ විට මා දැක ඇති සිසිල් කියුබික්ස් වැඩසටහන විය හැකිය.
ETH නිෂ්පාදන

හොඳ පැහැදිලි කිරීමක්.
රොබට් ෆ්‍රේසර්

32

විම්, 17 , 14 යතුරු පහර

කවුරුහරි අහඹු ලෙස මෙය ඉහළට ඔසවා තැබූ නිසා එය පවතින බව මට මතකය. මම එය නැවත කියවන විට, "හේයි, මට ඊට වඩා හොඳ දෙයක් කළ හැකිය!", එබැවින් මම බයිට් දෙකක් කපා දැමුවෙමි. එය තවමත් කෙටිම නොවේ, නමුත් අවම වශයෙන් එය වැඩිදියුණු කිරීමකි.


දීර් qu කාලයක් තිස්සේ මම කල්පනා කළේ විම් ක්වීන් එකක් කළ හැකිද යන්නයි. එක් අතකින්, එය කළ හැකි විය යුතුය. නමුත් සැබවින්ම දීර් v කාලයක් තිස්සේ වයිම් ක්වයින් එකක් සොයා බැලීමෙන් පසුව මට එකක් සොයා ගැනීමට නොහැකි විය. මම කළේ සොයා මෙම PPCG අභියෝගය , නමුත් එය හරියටම ප්රායෝගික quines ගැන වසා දමා නැහැ. ඒ නිසා මම එකක් සොයා ගැනීමට නොහැකි වූ නිසා එකක් සෑදීමට තීරණය කළෙමි.

පළමු පිළිතුර නිසා මම මෙම පිළිතුර ගැන ඇත්තෙන්ම ආඩම්බර වෙමි :

  1. මෙය මා විසින් සාදන ලද පළමු quine වේ, සහ

  2. මා දන්නා පරිදි, මෙතෙක් ප්‍රකාශයට පත් කරන ලද ලොව ප්‍රථම විම්-ක්වීන් මෙයයි! මට මේ ගැන වැරදියි, එබැවින් ඔබ එකක් ගැන දන්නේ නම් කරුණාකර මට දන්වන්න.

ඉතින්, එම දිගු හැඳින්වීමෙන් පසුව, මෙන්න:

qqX"qpAq@q<esc>q@q

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

ඔබ මෙය ටයිප් කරන විට, එය <esc>යතුරු එබීම පෙන්වන බව සලකන්න ^[. ASCII හි පැන යාමක් වන අතර , අභ්‍යන්තරව යතුර නිරූපණය කරන ආකාරය ^[නිරූපණය කරන බැවින් මෙය තවමත් නිවැරදි ය .0x1B<esc>

මෙම පරීක්ෂා ඔබ දැනට විම් සැසිය පැටවීම නම් අසමත් පිණිස, කරුණාවෙන්. මම ඔබට පිළිතුරක් ලිව්වෙමි, මෙහි ඔබට වැඩි විස්තර අවශ්‍ය නම්, නමුත් මූලික වශයෙන් ඔබ සමඟ දියත් කළ යුතුය

vim -u NONE -N -i NONE

හෝqqq මෙය ක්‍රියාත්මක කිරීමට පෙර ටයිප් කරන්න .

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

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

පැත්තක සටහනක, මෙම පිළිතුර බොහෝ විට පීපීසීජී පිළිතුරක හෝ වෙනත් යමක් සඳහා ලෝක වාර්තාවක් විය හැකිය.


1
2i2i<esc>ඉතා සමීපයි. මෙම කාර්යය කිරීමට මට කළ හැකි යමක් තිබිය යුතු යැයි මට හැඟේ.
Zwei

@zwei මම දන්නවා, ඒක කිට්ටුයි ඒක රිදෙනවා! ඇත්ත වශයෙන්ම, <Esc>V හි ගම්‍ය වේ, එබැවින් එය ක්‍රියාත්මක වේ. අවාසනාවට එය නව රේඛාවක් ද එක් කරයි, ඒ නිසා මම තවම එය පළ කර නැත.
ජේම්ස්

q"iq"qbP<Esc>qbPඔබ මෙය කර පසු 11. වේ Reddit , මම මෙහි vimgolfing පරීක්ෂණ හා ගිණුමක් කිරීමට තීරණය කර ඇත. මම එහි පළ කළ පිළිතුර මෙයයි.
udioica

2
@udioica ඔබට එය පිළිතුරක් ලෙස පළ කළ හැකිද?
ජේම්ස්

29

නැතිවූ , 120 116 98 96 76 70 66 බයිට්

සංස්කරණය කරන්න: ඔව්, 100 ට අඩු

සංස්කරණය කරන්න: /පහළම පේළියේ ඇති සියල්ලටම මාරුවීමෙන් බයිට් පොකුරක් ඉතිරි කර ඇත

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

එය මාර්ගගතව උත්සාහ කරන්න! + සත්‍යාපනය එය හැකි සෑම රාජ්‍යයක් සඳහාම නිර්ණායකයකි

ලොස්ට් යනු ආරම්භක ස්ථානය සහ දිශාව සම්පූර්ණයෙන්ම අහඹු ලෙස පවතින 2D භාෂාවකි. මෙයින් අදහස් කරන්නේ ඔබට නිවැරදි උපදෙස් දර්ශකය ලැබී ඇත්දැයි තහවුරු කර ගැනීම සඳහා සෑම අදියරකදීම වැරදි පරික්ෂා කිරීම් රාශියක් තිබිය යුතු අතර එය අහඹු ලෙස ඉබාගාතේ ගිය එකක් නොවන බවයි.

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

සියලු /පහළ මාර්ගයේ ගේ වග අභිභවනය සිරස් දිශාව හෝ පහළ රේඛා මත නිවැරදි දිශාව පෙරා ලබා සියලු සූචක බව එහි කිරීමට ය. එතැන් සිට, ඔවුන් විවිධ ස්ථාන කිහිපයකින් අවසන් වන නමුත්, ඒවා සියල්ලම කෙළවරට යයි

 ^%?>
 ////

එමඟින් තොගයේ ඇති සියලුම ශුන්‍ය නොවන සංඛ්‍යා ඉවත් කරයි. එම([ පසු ඕනෑම අමතර 0s ඉවත් කරයි.

පැහැදිලිව මධ්‍යයේ, එය %'ආරක්ෂාව' ක්‍රියා විරහිත කරන අතර එමඟින් වැඩසටහනට පහර දුන් විට එය අවසන් වීමට ඉඩ සලසයි @(මෙය නොමැතිව, දර්ශකය ආරම්භ වන්නේ නම් එය වහාම අවසන් විය හැකිය.@ ).

එතැන් සිට එය ඉතා සරල 2D භාෂා ක්වීන් එකක් කරයි, "පළමු පේළිය වටා වචනාර්ථයෙන් ( ) නූල් ඔතා, "අවකාශයක් ( :2+) සහ පසුව නව රේඛාවක් ( ) අනුකරණය කරමින් චරිතයක් තල්ලු කරයි 52*. දෙවන පේළිය සඳහා, එය /අක්ෂරයක් ( 95*2+) නිර්මාණය කර එය පොකුරක් ( >::1?:[:[[[[) අනුපිටපත් කරයි , අවසානයේ දී අවසන් වීමට පෙර @සහ තොගය ව්‍යංගයෙන් මුද්‍රණය කරයි. මෙම ?1පෙන්නුම් කරන්නක් පසුව ඒවා ඉවත් කිරීමට ඇති මත ඉතිරි මුල් ඇතුල් නම් බොහෝ ත 0 නිර්මාණය සිට ක්රියාවලිය නතර කිරීමට ය.

අන්තිම පේළිය එකම චරිතයක් බවට පත් කිරීමෙන් මම මෙහි බයිට් 20 ක් ඉතිරි කර ගත්තෙමි, එයින් අදහස් කරන්නේ මට අනුපිටපත් කිරීමේ ක්‍රියාවලියේ සිට අවසානය දක්වා කෙලින්ම යා හැකි @බවයි.

අනුපිටපත් කිරීමේ ක්‍රියාවලිය පිළිබඳ පැහැදිලි කිරීම:

[යනු 'දොර' ලෙස හැඳින්වෙන චරිතයකි. දර්ශකය a [හෝ a හි පැතලි පැත්තට පහර දෙන්නේ නම් ], එය පිළිබිඹු කරයි, එසේ නොමැති නම් එය ඒ හරහා ගමන් කරයි. දර්ශකය දොරක් සමඟ අන්තර්ක්‍රියා කරන සෑම අවස්ථාවකම එය ප්‍රතිවිරුද්ධ වර්ගයට මාරු වේ. මෙම දැනුම භාවිතා කිරීමෙන් වාරණයක් තුළ උපදෙස් කීයක් ක්‍රියාත්මක වේද යන්න පිළිබඳ සරල සූත්‍රයක් අපට ගොඩනගා ගත හැකිය >:[.

ආරම්භක උපදෙස් ප්‍රමාණය එකතු කරන්න. එක් එක් සඳහා [, එහි වම්පස උපදෙස් මෙන් 2 ගුණයක් එකතු කරන්න. උදාහරණයක් ලෙස >::::[:[[[, අපි ආරම්භක මුදල ලෙස 5 න් ආරම්භ කරමු. පළමු දොරට ඩුප් උපදෙස් 4 ක් ඇත, එබැවින් අපි 13 ලබා ගැනීම සඳහා 4 * 2 = 8 සිට 5 දක්වා එකතු කරමු. අනෙක් දොරවල් තුනට වම් පසින් ඩුප් 5 ක් ඇත, එබැවින් 43 ලබා ගැනීම සඳහා අපි 3 * (5 * 2) = 30 සිට 13 දක්වා එකතු කරමු. ද්විත්ව උපදෙස් ක්‍රියාත්මක කර >ඇති අතර, තොගයේ 44 s ඇත. එකම ක්‍රියාවලිය වෙනත් උපදෙස් සඳහා ද යෙදිය හැකිය( විශාල ප්‍රමාණයක් තොගයේ සිට විෂය පථයට තල්ලු කිරීම හෝ මෙහි භාවිතා කර ඇති පරිදි, තොගයෙන් අයිතම ඉවත් කිරීම.

0s වැඩිපුර රැවටීම වළක්වා ගැනීම සඳහා මා මෙහි භාවිතා කළ උපක්‍රමයක් නම් 1?. අක්ෂරය 0 නම්, ?1 මඟ නොහරින්න, එයින් අදහස් කරන්නේ එය ඩියුප් හි ඉතිරි කොටස සඳහා 1 අනුපිටපත් කරන බවයි. මෙය පසුව තොගය ඉවත් කිරීම වඩා පහසු කරයි.


26

සී, 64 60 බයිට්

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

මෙතෙක්, මෙය කෙටිම දන්නා C quine වේ. ක තියෙනවා දීර්ඝ සතුරෝද ඔබ කුඩා එකක් සොයා නම්.

මෙය GCC , Clang සහ TCC වල POSIX පරිසරයක ක්‍රියාත්මක වේ. එය ඔවුන් සියල්ලන් සමඟ අධික ලෙස නිර්වචනය නොකළ හැසිරීමක් ඉල්ලා සිටී.

විනෝදය සඳහා, මෙන්න මා දන්නා සියලුම සී ක්වීන් අඩංගු වන repo එකකි. පවත්නා ඒවාට වඩා අළුත් හා නිර්මාණාත්මක යමක් එකතු කරන වෙනත් එකක් ඔබ සොයා ගන්නේ නම් හෝ ලිවුවහොත් දෙබලක / පීආර් සඳහා නිදහස් වන්න.

එය ක්‍රියාත්මක වන්නේ ASCII පරිසරයක පමණක් බව සලකන්න . මෙය EBCDIC සඳහා ක්‍රියා කරයි , නමුත් තවමත් POSIX අවශ්‍ය වේ . කෙසේ වෙතත් POSIX / EBCDIC පරිසරයක් සොයා ගැනීම වාසනාව: P.


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

  1. main(s)අනිසි ලෙස mainතර්ක විතර්ක කරමින්, පාහේ ටයිප් නොකළ විචල්‍යයක් ප්‍රකාශ කරයි s. ( sඇත්ත වශයෙන්ම ටයිප් කර නැති බව සලකන්න , නමුත් ලැයිස්තුගත සම්පාදකයින් එය අවශ්‍ය පරිදි ස්වයංක්‍රීයව වාත්තු කරන බැවින් එය ද විය හැකිය *.)
  2. printf(s="..."sසපයන ලද නූලට සකසා පළමු තර්කය වෙත යොමු printfකරයි.
  3. sලෙස සකසා ඇත main(s){printf(s=%c%s%1$c,34,s);}.
  4. මෙම %cASCII කිරීමට පියවර ගෙන තිබේ 34, ". මෙමඟින් ක්වීන් හට හැකි වේ. දැන් sමේ වගේ ය :
    main(s){printf(s="%s%1$c,34,s);}.
  5. මෙම %sකිරීමට පියවර ගෙන තිබේ s# 2 නිසා හැකි වන, ම. දැන් sමේ වගේ ය :
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}.
  6. මෙම %1$cASCII 34 කිරීමට පියවර ගෙන තිබේ ", printfපළමු ** තර්කය ගේ. දැන් මෙය sපෙනේ:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... එය මුල් මූලාශ්‍ර කේතය වේ.

* උදාහරණය aPavel ** ආකෘති පිරිවිතරයෙන් පසුව පළමු තර්කයට ස්තූතියි
- මේ අවස්ථාවේ දී , s. ආකෘති පිරිවිතරයට යොමු කිරීම කළ නොහැක.


මම හිතන්නේ මෙය එකම ප්‍රවේශයකින් කෙටි එකක් ලබා ගත නොහැකි ය. නම් printfගේ ආකෘතිය විශේෂණයක් හරහා ප්රවේශ විය $, මේ බයිට් 52 ක් වැඩ ඇත:

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}

එය නිසැකවම තරඟකාරී යැයි ගණන් නොගත යුතු වුවද, 1994 අන්තර්ජාතික අපැහැදිලි සී කේත තරඟයෙන් 1994_smr.c හි “නරකම නීති රීති” ජයග්‍රාහකයා අනිවාර්යයෙන්ම කෙටි වේ.
රේ

1
AyRay එයට අවසර නැත. එය ඕනෑම අර්ථ දැක්වීමකින් නිසි නිශ්ශබ්දතාවයක් නොවේ. එම වැඩසටහන නිසා ක්වීන් නීති වෙනස් කරන ලදි: පී
එම්ඩී එක්ස්එෆ්

මම සම්පුර්ණයෙන්ම එකඟ වෙමි, නමුත් එය සිත්ගන්නා සුළු කප්පාදුවක් වන අතර, යමෙකු දන්නා කුඩාම ක්වයින් ගැන සඳහන් කරන ඕනෑම වේලාවක historical තිහාසික හේතූන් මත පමණක් සඳහන් කිරීම වටී.
රේ

4
sවර්ගය int, "ටයිප් නොකළ විචල්යයක්" නොවේ.
feersum

2
මෙම සම්පාදකයින් සියල්ලම පැහැදිලිවම දර්ශකයක් පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කිරීමට ඉඩ දෙයි. s=3පැහැදිලිවම ක්‍රියා නොකරන්නේ ඔබට දෙවරක් නූල් පසු කළ යුතු බැවිනි printf.
feersum

25

හරස් බ්‍රව්සරය ජාවාස්ක්‍රිප්ට් (අක්ෂර 41)

එය හොඳම වෙබ් බ්‍රව්සර් 5 තුළ ක්‍රියා කරයි (IE> = 8, මොසිල්ලා ෆයර්ෆොක්ස්, ගූගල් ක්‍රෝම්, සෆාරි, ඔපෙරා). ඒවායින් ඕනෑම එකක් තුළ එය සංවර්ධකයාගේ කොන්සෝලය තුළට ඇතුළත් කරන්න:

eval(I="'eval(I='+JSON.stringify(I)+')'")

එය "වංචාවක්" නොවේ - ක්‍රිස් ජෙස්ටර්-යන්ග්ගේ තනි බයිට් ක්වයින් මෙන් නොව, එය alert()ශ්‍රිතය භාවිතා කිරීම සඳහා පහසුවෙන් වෙනස් කළ හැකි බැවින් (අක්ෂර 14 ක් වැය වේ):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

හෝ පොත් සලකුණකට පරිවර්තනය කිරීම (අක්ෂර 22 ක් වැය වේ):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")

25

SO වෙතින් කෙටිම රූබි ක්වයින් දෙක මෙයයි :

_="_=%p;puts _%%_";puts _%_

හා

puts <<2*2,2
puts <<2*2,2
2

දෙවැන්න ක්‍රියා කරන්නේ කෙසේදැයි මගෙන් අහන්න එපා ...


9
දෙවැන්න හෙරඩොක් භාවිතා කරයි, <<2 ඊළඟ පේළියේ නූලක් ආරම්භ කරයි, සහ *2නූල පුනරාවර්තනය කරයි
මින්ග්-ටැං

ඔබට 2 අවශ්‍ය ඇයි?
CalculatorFeline

1
Al කැල්කියුලේටර් ෆලීන් එය හෙරෝඩොක් නූලෙහි අවසානයයි (එය තමන්ගේම රේඛාවෙන් දිස්විය යුතුය). එය ඇත්ත වශයෙන්ම 2 ක් විය යුතු නැත: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
මාටින් එන්ඩර්

25

විඛණ්ඩනය , බයිට් 6 යි

මෙම පිළිතුරු අතර කෙටිම “නිසි” නිශ්ශබ්දතාව මෙය බව පෙනේ.

'!+OR"

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

පාලන ප්‍රවාහය ආරම්භ වන්නේ Rතනි දකුණට යන (1,0)පරමාණුවකිනි. එය "ටොගල් මුද්‍රණ මාදිලියට පහර දී රේඛාව වටා එති, නැවත වරක් '!+ORපහර දීමට පෙර "මුද්‍රණය කර මුද්‍රණ ප්‍රකාරයෙන් පිටවෙයි.

එමඟින් "මුද්‍රණය වීමට ඉඩ ඇත. කෙටිම ක්‍රමය නම් '"O( '"පරමාණුවේ ස්කන්ධය අක්ෂර කේතයට සකසන්නේ කොතැනද යන්නයි" හා Oචරිතය සටහන් කර ඇති පරමාණුක විනාශ), නමුත් අපි මේ කළේ නම් "මුද්රිත මාදිලිය බාධා ඇත. ඒ වෙනුවට, එය අපි පරමාණුව වටිනාකම නියම '!(එක් වඩා අඩු "), එසේ නම් සමග වැටුප් වැඩිවීම +හා පසුව සමග ප්රතිඵලයක් මුද්රණය O.

විකල්ප

මෙන්න විකල්ප කිහිපයක්, ඒවා දිගු වේ, නමුත් සමහර විට ඔවුන්ගේ ශිල්පීය ක්‍රම මඟින් ඒවා භාවිතා කරමින් කෙටි අනුවාදයක් සොයා ගැනීමට යමෙකු පොළඹවනු ඇත (නැතහොත් සමහර විට ඒවා සාමාන්‍යකරණය කරන ලද ක්වීන් සඳහා වඩාත් ප්‍රයෝජනවත් වනු ඇත).

JUmp භාවිතා කරමින් බයිට් 8 ක්

' |R@JO"

නැවතත්, කේතය ආරම්භ වේ R. මෙම @දෙන්න හුවමාරු ස්කන්ධය හා බලශක්ති (0,1). එම Jනිසා පරමාණුව Oකෙළින්ම ඉහළට පනිනවා ". පෙර මෙන්, සියල්ල හැර අනෙක් "සියල්ලම මුද්‍රණ ආකාරයෙන් මුද්‍රණය කෙරේ. පසුව, පරමාණුව පහර දෙයි| එහි දිශාව ආපසු හැරවීමට දෙන අතර පසුව '"Oමුද්‍රණය හරහා ගමන් කරයි ". අවකාශය ටිකක් කරදරකාරී ය, නමුත් එය අවශ්‍ය බව පෙනේ, එසේ නොවුවහොත් 'පරමාණුව |කැඩපතක් වෙනුවට චරිතයක් ලෙස සලකයි .

පරමාණු දෙකක් භාවිතා කරමින් බයිට් 8 ක්

"'L;R@JO

මෙහි පරමාණු දෙකක් ඇත, වමේ සිට Lදකුණට සහ දකුණට යන්න R. වමට යන පරමාණුවට එහි අගය නියම වන '"අතර එය වහාම මුද්‍රණය කරනු ලැබේ O(පරමාණුව විනාශ වේ). දකුණට යන පරමාණුව සඳහා, අපි නැවතත් ස්කන්ධය හා ශක්තිය හුවමාරු කර ගනිමු O, ඉතිරි කේතය මුද්‍රණ ප්‍රකාරයේදී මුද්‍රණය කරන්න. පසුව එහි අගය සකසා ඇති 'Lනමුත් පරමාණුව ඉවතලන බැවින් එය වැදගත් නොවේ ;.


ප්‍රභවයේ කේත / දත්ත වෙන් කිරීම නොමැති වීම හේතුවෙන් තාක්ෂණික වශයෙන් වලංගු නොවේ.
කැල්කියුලේටරය

5
කැල්කියුලේටර් ෆයිලයින් '!+කේත ".
මාටින් එන්ඩර්

මම විඛණ්ඩනය ගැන හුරුපුරුදු නැත, නමුත් |R@JO"'වැඩ කරනු ඇත , නැතහොත් ඔබට තවමත් එම ඉඩ 'අවශ්‍යද?
MildlyMilquetoast

1
Ist මිස්ටා ෆිගින්ස් මම හිතන්නේ, නමුත් වඩා වැදගත් වන්නේ ඔබ 'පළමුව මුද්‍රණය කිරීමයි .
මාටින් එන්ඩර්

24

චිකන් , 7

chicken

නැත, මෙය කෙලින්ම ප්‍රතිරාවය නොවේ :)


දම්නිට්, ඔබ මට එයට පහර දුන්නා :)
ටකෝනට්

එය දෝංකාර දුන්නේ නැත, එය නූලයි chicken!
එරික් ද Outgolfer

කේත / දත්ත වෙන් කිරීමක් නොමැත, එබැවින් වලංගු නොවේ.
කැල්කියුලේටරය

11
CalCalculatorFeline ඔබ නීති කියෙව්වාද?
ටිම්ටෙක්

1
O ජොකිං මෙය අවලංගු යැයි මම නොසිතමි, මන්ද අභියෝගයේ නීති රීති වලංගු වන්නේ ශුන්‍ය දිග සහ වංචාව (ඔබේම මූලාශ්‍ර ගොනුව කියවීම) පමණි. නුසුදුසු ක්වීන්ස් තහනම් කරන එකම දෙය සම්මත ලිහිල් සිදුරකි - සම්මත අඩුලුහුඩු සාමාන්‍යයෙන් ඒවාට පෙර පිළිතුරු සඳහා අදාළ නොවේ.
pppery

24

ජාවා, බයිට් 528:

මුල් ප්‍රවේශයක් සහිත ජාවා විසඳුමක්:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

කියවිය හැකි ආකාරයෙන්:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}

එය ක්‍රියාත්මක වන්නේ කෙසේද?
ලූව්ජෝ

1
Oo ලූව්ජෝ: කේතය කොටස් දෙකකට කපා මුළු කේතයම ඇතුලත් කරන වෙනත් විසඳුම් මෙන්, නමුත් කේතය නැවත ඇතුලත නිරූපණය කරයි, නමුත් මුළු කේතයම නූලක් පමණක් නොව 36 වන පාදයේ දිගු අංකය ලෙස සංකේතවත් කර ඇත (අකාරාදී අක්ෂර 26 + 10 ඉලක්කම්).
පරිශීලකයා නොදන්නා

1
ඔබ තැබුවහොත් මෙය කෙටි කළ හැකිය if(++i==92),
tuskiomi

2
ustuskiomi: ස්තූතියි, අක්ෂර දෙකක් සඳහා කෙටි කර ඇත
පරිශීලක නොදන්නා

1
@userunknown ඇත්ත වශයෙන්ම, a*ජාවා හි අරාව පිටවන්නේ නැති නිසා, එය සී. ගොල්ෆ් සඳහා තවත් සමහර කොටස් : import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}, abcඅළුතින් ගණනය කරන ලද මැජික් අංක ස්ට්‍රිං වනු ඇත. ජාවා 8+ හි එය වෙනස් class a{public static void mainකිරීමට ද හැකි interface a{static void mainඅතර ජාවා 10+ හි ද එය වෙනස් කිරීමට import java.math.*;හා වෙනස් BigInteger b=new BigInteger(කිරීමට හැකියvar b=new java.math.BigInteger( හැකිය.
කෙවින් ක ru යිසන්

23

රෙටිනා , 20 14 9 7 බයිට්

අපි ආරම්භ කිරීමට පෙර, තනි එකක් අඩංගු ගොනුවක සුළු විසඳුම සඳහන් කිරීමට කැමැත්තෙමි 0. එවැනි අවස්ථාවකදී රෙටිනා 0හිස් ආදානයේ s ගණනය කිරීමට උත්සාහ කරනු ඇත , එහි ප්‍රති result ලය ද වේ0 වේ. මම එය නිසි ලෙස සලකන්නේ නැත.

එබැවින් මෙහි සුදුසු එකක් තිබේ:

>\`
>\`

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

විකල්පයක් ලෙස, අපට ;ඒ වෙනුවට භාවිතා කළ හැකිය >.

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

වැඩසටහන දෙවරක් මුද්‍රණය කරන තනි ආදේශනයකින් සමන්විත වේ.

පළමු පේළියේ දී ` වින්‍යාසය රීජෙක්ස් වෙතින් වෙන් කරයි, එබැවින් රීජෙක්ස් හිස් ය. එබැවින් හිස් නූල (එනම් නොපවතින ආදානය) දෙවන පේළිය වන වාචික සමඟ ප්‍රතිස්ථාපනය වේ.

ප්‍රති result ලය දෙවරක් මුද්‍රණය කිරීම සඳහා, අපි එය ප්‍රතිදාන අදියර දෙකකින් ඔතා. අභ්‍යන්තරය, \ප්‍රති line ලය පසුපස රේඛීය රේඛාවකින් මුද්‍රණය කරන අතර පිටත එක,> නොමැතිව මුද්‍රණය කරයි.

ඔබ රෙටිනා ගැන මඳක් හුරුපුරුදු නම්, රෙටිනාගේ ව්‍යංග ප්‍රතිදානයට කුමක් සිදුවීදැයි ඔබ කල්පනා කරනවා විය හැකිය. රෙටිනාගේ ව්‍යංග ප්‍රතිදානය ක්‍රියාත්මක වන්නේ වැඩසටහනක අවසාන අදියර ප්‍රතිදාන අවධියක ඔතාගෙන ය. කෙසේ වෙතත්, රෙටිනා මෙය නොකරයි, අවසාන අදියර දැනටමත් ප්‍රතිදාන අවධියක් නම්. එයට හේතුව සාමාන්‍ය වැඩසටහනක දී ව්‍යංග ප්‍රතිදාන අවධිය විශේෂ එකක් \හෝ ;තනි බයිටයක් සමඟ ප්‍රතිස්ථාපනය කිරීමට හැකිවීම වඩාත් ප්‍රයෝජනවත් වීමයි ( .ධජය සමඟ ව්‍යංගයෙන් මිදීමට වඩා). අවාසනාවකට මෙන්, මෙම හැසිරීම අපට ක්වයින් සඳහා බයිට් දෙකක් වැය වේ.


21

Javascript (36 char)

(function a(){alert("("+a+")()")})()

මෙය, මෙතෙක් පළ කර ඇති කෙටිම ජාවාස්ක්‍රිප්ට් ක්වීන් AFAICT ය.


1
එය ... සිත් ඇදගන්නා සුළු ය. එය මට වැඩ කරන්නේ කෙසේදැයි ඔබ පැහැදිලි කළ යුතුය 8- |
TehShrike

3
ETehShrike ඉඟිය: ඔබට ශ්‍රිතයක් නූලකට බල කිරීමෙන් එය නැරඹිය හැකිය. උදාහරණයක් ලෙස, ඔබට ශ්‍රිතයක් තිබේ නම් a, ඔබට ඇමතීමෙන් එහි අන්තර්ගතයට ප්‍රවේශ විය හැකිය a.toString.
පීටර් ඕල්සන්

7
කෙසේ වෙතත්, මෙය ඔබගේ ජාවාස්ක්‍රිප්ට් ක්‍රියාවට නැංවීම aඉහත ලියා ඇති ආකාරයටම ශ්‍රිතය දැඩි කරයි නම් මෙය ඉතා හොඳ දෙයකි . කෙසේ වෙතත්, මෙම කේතයේ ප්‍රතිදානය ඕනෑම ජාවාස්ක්‍රිප්ට් ක්‍රියාවට නැංවීමේදී හොඳ ප්‍රති be ල ලබා දෙනු ඇත.
ඉල්මාරි කරොනන්

1
මෙහි 1 බයිට කෙටි, එම quine වේ: !function a(){alert("!"+a+"()")}().
ඉස්මයිල් මිගෙල්

1
(a=()=>alert(($ {a})))()
ඩෙනිස් සී

19

ගොල්ෆ් ස්ක්‍රිප්ට්, බයිට් 8 යි

මම නිතරම සිතුවේ කෙටිම (සත්‍ය) ගොල්ෆ් ස්ක්‍රිප්ට් ක්වයින් බයිට් 9 ක් බවයි:

{'.~'}.~

ගොල්ෆ් ස්ක්‍රිප්ට් පෙරනිමියෙන් ලුහුබැඳ යන රේඛීය රේඛාවක් මුද්‍රණය කරන නිසා ලුහුබැඳීමේ රේඛීය සංග්‍රහය අවශ්‍ය වේ.

නමුත් මට දැන් බයිට් 8 ක්වයින් එකක් හමු විය, එය හරියටම එම රේඛීය සීමා සීමාව වටා ක්‍රියා කරයි:

":n`":n`

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

ඉතින් අල්ලා ගැනීම නම් ගොල්ෆ් ස්ක්‍රිප්ට් පසුපස රේඛීය රේඛාවක් මුද්‍රණය නොකිරීමයි, නමුත් එය nවැඩසටහන අවසානයේ අන්තර්ගතය මුද්‍රණය කරයි . එය nආරම්භ කිරීම සඳහා රේඛීය සංග්‍රහයක් අඩංගු වේ. එබැවින් අදහස නම් ":n`", එය නූල් වෙනුවට ආදේශ කර එය තද කර ගැනීමයි, එනම් තොගයේ මුද්‍රණය උපුටා දැක්වීම් සමඟ මුද්‍රණය කර පිටපතක් nනොමැතිව මුද්‍රණය කර ඇත .

තෝමස් ක්වා විසින් පෙන්වා දුන් පරිදි, බයිට් 7 ක CJam quine ද බයිට් 8 ක විසඳුමකට අනුවර්තනය කළ හැකිය:

".p"
.p

නැවතත්, අපට පසුපස ලයින්ෆීඩ් අවශ්‍යයි.


6
ගොල්ෆ් පිටපත අමුතුයි.
කැල්කියුලේටර්

19

ලැබ්රින්ත් , 124 110 53 බයිට්

බයිට් 9 ක් ගොල්ෆ් කිරීම ගැන Sp3000 ට ස්තූතියි, එය මට තවත් 7 ක් ගොල්ෆ් කිරීමට ඉඩ දුන්නේය.

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

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

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

ලැබ්රින්ත් 101:

  • Labyrinth යනු තොග මත පදනම් වූ 2D භාෂාවකි. තොගය පතුලක් නැති අතර ශුන්‍යයෙන් පිරී ඇත, එබැවින් හිස් තොගයකින් පැනීම දෝෂයක් නොවේ.
  • ක්‍රියාත්මක කිරීම ආරම්භ වන්නේ පළමු වලංගු අක්ෂරයෙන් (මෙහි ඉහළ වමේ). උපදෙස් හස්තයට (IP) ගත හැකි මාර්ග දෙකක් හෝ වැඩි ගණනක් ඇති සෑම හන්දියකදීම, ඊළඟට යා යුත්තේ කොතැනටද යන්න තීරණය කිරීම සඳහා තොගයේ ඉහළ කොටස පරීක්ෂා කරනු ලැබේ. සෘණ යනු වමට හැරීම, ශුන්‍යය ඉදිරියට යාම සහ ධනාත්මක දකුණට හැරීමයි.
  • ප්‍රභව කේතයේ ඉලක්කම් අනුරූප අංකය තල්ලු නොකරයි - ඒ වෙනුවට, ඒවා තොගයේ ඉහළට තල්ලු කර තල්ලු n*10 + <digit>කරයි. මෙය විශාල සංඛ්‍යාවක් පහසුවෙන් ගොඩනැගීමට ඉඩ සලසයි. නව අංකයක් ආරම්භ කිරීමට _, ශුන්‍යය තල්ලු කරන භාවිතා කරන්න .
  • " විවෘත නැත.

පළමුව, මම තරමක් සරල අනුවාදයක් පැහැදිලි කරමි, එය බයිට් දිග, නමුත් ටිකක් අඩු ඉන්ද්‍රජාලික ය:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

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

ප්‍රධාන අදහස නම් විශාල පදනමක් භාවිතා කරමින් ප්‍රභවයේ ප්‍රධාන ශරීරය තනි අංකයකින් කේතනය කිරීමයි. ප්‍රභව කේතයේ ඉතිරි කොටස මුද්‍රණය කිරීම සඳහා විකේතනය කිරීමට පෙර එම අංකය පහසුවෙන් මුද්‍රණය කළ හැකිය. විකේතනය යනු හුදෙක් නැවත නැවත යෙදීමයි divmod base, එහිදී මුද්‍රණය කර එහි ශුන්‍ය වන තෙක් modදිගටම වැඩ කරන්න div.

වළක්වා ගැනීමෙන් {}, අපට අවශ්‍ය ඉහළම අක්‍ෂර කේතය _(95) එනම් 96 වන පදනම ප්‍රමාණවත් වේ (පාදම අඩු මට්ටමක තබා ගැනීමෙන්, ආරම්භයේ සංඛ්‍යාව කෙටි වේ). එබැවින් අපට කේතනය කිරීමට අවශ්‍ය වන්නේ මෙයයි:

!
"
:_96
/6 %
@9_.

එම අක්ෂර ඒවායේ කේත ලක්ෂ්‍ය බවට හරවා ප්‍රති result ලය පදනම් -96 අංකයක් ලෙස සලකයි (අවම වශයෙන් සැලකිය යුතු සංඛ්‍යාංකයට අනුරූප වන !අතර වඩාත්ම වැදගත් වන්නේ ., එම නිසා අපි අංකය විසුරුවා හරින අනුපිළිවෙලයි), අපට ලැබේ

234785020242697299628949734639258593

දැන් කේතය ආරම්භ වන්නේ ඉතා සිසිල් උපක්‍රමයකින් (මා එසේ පැවසුවහොත්) අපට කේතන ක්‍රමය නැවත මුද්‍රණය කිරීමට සහ තවත් පිටපතක් විකේතනය සඳහා ඉතා සුළු පිරිවැයකින් තබා ගැනීමට ඉඩ සලසයි: අපි අංකය ප්‍රතිලෝමව කේතයට දමමු. මම මෙම CJam ස්ක්‍රිප්ට් එක සමඟ ප්‍රති result ලය ගණනය කළෙමි. එබැවින් අපි සත්‍ය කේතය වෙත යමු . මෙන්න ආරම්භය:

395852936437949826992796242020587432!
"

IP ආරම්භ වන්නේ ඉහළ වම් කෙළවරේ සිට නැගෙනහිර දෙසට ය. එය එම ඉලක්කම් හරහා දිවෙන අතර, එය හුදෙක් එම අංකය තොගයේ ඉහළින් ගොඩ නගයි. අංකය මුළුමනින්ම අර්ථ විරහිත ය, මන්ද එය අපට අවශ්‍ය දේ ආපසු හැරවීමයි. අයිපී එක වැදුන විට !, එය මෙම අංකය තොගයෙන් පිටතට ගෙන මුද්‍රණය කරයි. නිමැවුමේ කේතන ක්‍රමය ප්‍රතිනිෂ්පාදනය කිරීම එපමණයි.

නමුත් දැන් අයි.පී. ඒ කියන්නේ එය හැරී දැන් බටහිර දෙසට ගමන් කරයි ( !නැවත ක්‍රියාත්මක නොකර ). මෙම කාලය, පහසුවෙන්, IP සංඛ්යාව සිට ආපසු පෙරමුනකට කියවීම්, අඩුක්කුව උඩ දැන් අංකය එසේ බව කරන්නේ මූලාශ්රය ඉතිරි සෑදීමට හෝ දායක වේ.

අයිපී දැන් නැවත වම්පස ඉහළ කෙළවරට වැදුණු විට, මෙය අක්‍රීය අවසානයක් නොවේ, මන්ද යත්, අයිපී වම් හැරීමක් ගත හැකි නිසා, එය දැන් දකුණට ගමන් කරයි. මෙම "අපි කේතය ප්රධාන පුඩුවක් සිට සංඛ්යාව වෙන් කිරීමට මෙහි අවශ්ය බව, කිසිදු-op වේ. ඒ ගැන කතා කිරීම:

...
"
:_96
/6 %
@9_.

තොගයේ ඉහළ කොටස තවමත් බිංදුවක් නොමැති තාක් කල්, පහත දැක්වෙන ලූපයෙහි IP තරමක් code න කේතය හරහා ධාවනය වේ:

"
>>>v
^< v
 ^<<

හෝ රේඛීයව දක්වා ඇත:

:_96%._96/

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

ලූප් කේතය ඇත්තෙන්ම ඉතා සරල ය (එය තදින් සම්පීඩනය කිරීම මෙය තදින් සිදු නොවූ අතර Sp3000 හි ප්‍රධාන දායකත්වය වන්නේ එයයි):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

Nශුන්‍යයට පහර දුන් පසු , පාලක ප්‍රවාහ වෙනස් වේ. දැන් අයිපී කැමතියි /(එනම් බටහිර) පසු කෙළින්ම ඉදිරියට යාමට , නමුත් එහි පවුරක් ඇත. එබැවින් ඒ වෙනුවට (නැගෙනහිර) හැරී ඇත්නම්, 6නැවත ක්‍රියාත්මක කරන්න . එමඟින් තොගයේ ඉහළ කොටස ධනාත්මක වේ, එබැවින් IP දකුණට (දකුණට) හැරී ක්‍රියාත්මක කරයි 9. තොගයේ මුදුන දැන් ඇත 69, නමුත් අප සැලකිලිමත් වන්නේ එය ධනාත්මක වීමයි. අයිපී තවත් දකුණට හැරී (බටහිරට) ගමන් කරයි@ කේතය අවසන් කරන .

සියල්ලට ම, ඇත්තෙන්ම සරල ය.

හරි, දැන් අපි කොහොමද ඒ අමතර බයිට් කපා දමන්නේ? පැහැදිලිවම, එම විවෘත කිරීම නාස්තියක් ලෙස පෙනේ, නමුත් අපට එම අතිරේක පේළිය අවශ්‍ය වේ: ලූපය අංකයට යාබදව තිබුනේ නම්, සම්පූර්ණ අංකය හරහා ගමන් කරනවා වෙනුවට අයිපී දැනටමත් එහි ගමන් කරනු ඇත. ඒ නිසා අපට එම විකල්පය සමඟ ප්‍රයෝජනවත් යමක් කළ හැකිද?

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

අල්ලා ගැනීමක් ඇත, අපට මෙය කළ නොහැක:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

ගැටළුව වන්නේ දැන් අපි "a ට වෙනස් කර ඇති අතර 3එය අපට අවශ්‍ය සත්‍ය අංකයද වෙනස් කිරීමයි. එම සංඛ්‍යාව අවසන් නොවන බවට විශ්වාසයි 3. අංකය සම්පුර්ණයෙන්ම තීරණය වන්නේ කේතයෙනි, !අපට ඒ ගැන වැඩි යමක් කළ නොහැක.

නමුත් සමහර විට අපට වෙනත් ඉලක්කම් තෝරා ගත හැකිද? 3ප්‍රභවය නිවැරදිව සංකේතවත් කරන අංකයක් සමඟ අප අවසන් වන තාක් එම ස්ථානයේ යමක් තිබේදැයි අපට ප්‍රශ්නයක් නැත . හොඳයි, අවාසනාවකට මෙන්, ඉලක්කම් 10 න් එකක්වත් තෝරාගත් අංකයට නොගැලපෙන අවම-වැදගත් ඉලක්කම් සහිත කේතන ක්‍රමයක් ලබා නොදේ. වාසනාවකට මෙන්, කේතයේ ඉතිරි කොටසෙහි යම් ඉඩක් ඇත, අපට බයිට් ගණන වැඩි නොකර තවත් කේතීකරණ කිහිපයක් උත්සාහ කළ හැකිය. මම විකල්ප තුනක් සොයාගෙන ඇත:

  1. අපට වෙනස් @විය හැකිය /. එවැනි අවස්ථාවක සිට අපට ඕනෑම ඉලක්කම් භාවිතා කළ හැකිය1357 කර ගැලපෙන කේතීකරණයක් ලබා ගත හැකිය. කෙසේ වෙතත්, මෙයින් අදහස් කරන්නේ වැඩසටහන පසුව දෝෂයකින් අවසන් වන අතර එය අවසර දී ඇති නමුත් ඉතා පිරිසිදු බවක් නොපෙනේ.
  2. අවකාශයන් එකම "බිත්ති" අක්ෂර නොවේ. භාවිතා නොකරන සෑම චරිතයක්ම, විශේෂයෙන් සියලුම අකුරු වේ. අපි ලොකු අකුරක් භාවිතා කරන්නේ නම්, එයට අනුගත වීම සඳහා පදනම වැඩි කිරීමට අපට අවශ්‍ය නැත (එම කේත ලකුණු පහතින් ඇති බැවින් _). තේරීම් 26 ක් බොහෝ අවස්ථාවන් ලබා දෙයි. උදාA ඕනෑම අමුතු ඉලක්කම් වැඩ සඳහා. මෙය ටිකක් හොඳ ය, නමුත් එය තවමත් එතරම් අලංකාර බවක් නොපෙනේ, මන්ද ඔබ කිසි විටෙක සැබෑ කේතයක අකුරක් භාවිතා නොකරන බැවිනි.
  3. අපට වඩා විශාල පදනමක් භාවිතා කළ හැකිය. අපි පදනම සැලකිය යුතු ලෙස වැඩි නොකරන තාක් කල්, කේතීකරණයේ දශම සංඛ්‍යා ගණන එලෙසම පවතිනු ඇත (විශේෂයෙන් 104 දක්වා ඕනෑම පදනමක් හොඳයි, නමුත් 99 ට වඩා වැඩි පදනම් වලට ඇත්ත වශයෙන්ම කේතයේම අමතර අක්ෂර අවශ්‍ය වේ). වාසනාවකට මෙන්, 98 වන පදනම තනි ගැලපුම් විසඳුමක් ලබා දෙයි: අපි ඉලක්කම් භාවිතා කරන විට 1, කේතන ක්‍රමයද අවසන් වේ 1. 96, 97, 98, 99 පදනම් අතර ඇති එකම විසඳුම මෙයයි, එබැවින් මෙය සැබවින්ම වාසනාවකි. මෙම පිළිතුරේ ඉහළින් ඇති කේතය සමඟ අප අවසන් වන්නේ එලෙසිනි.

19

නැතිවූ , බයිට් 293 262 249

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

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

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

මෙම සමස්ත ව්‍යාපෘතියම ඉහළට හා පහළට ගොස් ඇත. එය කළ නොහැකි යැයි මම සිතමින් පසුව පිස්සු අදහසක් ඉදිරිපත් කළෙමි.

නැතිවූ ක්වයින් එතරම් අපහසු ඇයි?

ඔබ දන්නා පරිදි, ලොස්ට් යනු ආරම්භක ස්ථානය සහ දිශාව සම්පූර්ණයෙන්ම අහඹු ලෙස පවතින 2D ක්‍රමලේඛන භාෂාවකි. නැතිවූ ඕනෑම වැඩසටහනක් විකිරණ ened න කේතයක් ලිවීම තරම් අපහසු වේ. හැකි සෑම ස්ථානයක් හා දිශාවක්ම ඔබ සලකා බැලිය යුතුය.

එසේ කිරීමෙන් දේවල් කිරීමට සම්මත ක්‍රම කිහිපයක් තිබේ. උදාහරණයක් ලෙස නූලක් මුද්‍රණය කිරීමේ සම්මත ක්‍රමය මෙන්න.

>%?"Stringv"(@
^<<<<<<<<<<<<<

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

කළ යුතු පළමු දෙය නම් ලූපය නැවත සකස් කිරීමයි, පවතින ලූපය සංගීත ආකෘතියට විශේෂිත විය.

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

ඇතිවීමේ හැකියාව වළක්වා ගැනීම සඳහා අපි දෙවන ධාරාවක් එක් කළ යුතුය ! පැනීම සහ ලූපයක් නිර්මාණය .

දැන් අපට මෙය සම්මත Quine ආකෘතිය සමඟ මිශ්‍ර කිරීමට අවශ්‍යයි. ලොස්ට් ක්ලයින් මත පදනම් වී ඇති හෙයින් මාටින් එන්ඩර් සඳහා ක්ලීන් ක්වීන් ණයට ගත් මූලික වශයෙන් සොරකම් කර ඇත.

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

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

මෙහි අදහස වන්නේ අපේක්ෂිත ඊතල ගණන ලබා ගැනීම සඳහා දොරවල් භාවිතා කිරීමයි. දොරක් යනු විශේෂිත කැඩපතක් වන අතර එය පහර දෙන සෑම අවස්ථාවකම වෙනස් වේ. [වම් පසින් සහ ]දකුණෙන් එන අයිපීඑස් පිළිබිඹු කරයි . මෙම දෙපැත්තෙන්ම අයිපී එකකින් පහර දුන් විට ස්විච් දිශානතිය. නැවත නැවත මෙහෙයුමක් සිදු කිරීම සඳහා අපට මෙම දොරවල් රේඛාවක් සහ ස්ථිතික පරාවර්තකයක් සෑදිය හැකිය.

>:[[[

:තුන් වතාවක් ඉටු කරයි . මේ ආකාරයෙන් අපි අතින් තොගයට තල්ලු කළහොත් අපට <අඩු බයිට් වලින් ඒවා සෑදිය හැකිය. අපි මේවායින් 2 ක්, එක් එක් පේළියට එකක් සාදන්නෙමු, ඒවා අතර අපි නව රේඛාවක් තබන්නෙමු, කෙසේ වෙතත් දෙවැන්න අවශ්‍ය වන්නේ එය !අප විසින් එකතු කරන ලද ආවරණය වන තෙක් පමණි , වෙනත් ඕනෑම දෙයක් හිස්ව තැබිය හැකි අතර අපට බයිට් කිහිපයක් ඉතිරි වේ. හරි දැන් අපි අපේ ධාරාවන්ට සිරස් ඊතල එකතු කළ යුතුයි. යතුරු ප්‍රශස්තිකරණය පැමිණෙන්නේ මෙහිදීය. වැඩසටහනේ “ආරම්භය” වෙත සියලු අයිපී යළි හරවා යැවීම වෙනුවට අපි ඒවා වම් කෙළවරට හරවා යවමු. අනිවාර්යයෙන්ම තිබිය යුතුවැඩ කරන්න (හෝ අවම වශයෙන් අවසාන අනුවාදයේ වැඩ කරනු ඇත) අපට අනෙක් අයිපී නැවත හරවා යැවිය හැකිය. මෙය බයිට් වලින් ලාභදායී වනවා පමණක් නොව, මෙම ප්‍රශස්තිකරණය නිසා ක්වයින් හට හැකි වේ.

කෙසේ වෙතත් තවමත් ගැටළු කිහිපයක් තිබේ, වඩාත්ම වැදගත් දෙය >තල්ලු කිරීමෙන් පසුව ආරම්භ වන නමුත් අපි එහි පිටපත් සෑදීමට පෙරය. එවැනි අයිපීඑස් පිටපත් කර 0 ට පිටපත් පොකුරක් සාදනු ඇත. මෙය නරක ය, මන්ද අපගේ තොග පිරිසිදු කිරීමේ යාන්ත්‍රණය මඟින් ශුන්‍යයන් භාවිතා කරන්නේ තොගයේ පතුල තීරණය කිරීම සඳහා ය. අපි ශක්තිමත් සිරස් සනීපාරක්ෂක ක්‍රමයක් එකතු කළ යුතුයි. තොගය හිස් දැයි කීමට සැබෑ ක්‍රමයක් නොමැති බැවින්, අපට හැකි පමණින් තොගයේ ඇති අයිතම විනාශ කිරීමට උත්සාහ කළ යුතුය. මෙන්න අපි නැවත වරක් කලින් විස්තර කර ඇති දොර ක්‍රමය භාවිතා කරමු. ((((((((((([[[[[[[[[[[[[[ශුන්‍යයන් ඉවත් කිරීම සඳහා සනීපාරක්ෂක යන්ත්‍රයෙන් පසු පළමු පේළියේ අවසානයට අපි එකතු කරන්නෙමු .

දැන් තවත් එක් ගැටළුවක් ඇත, මන්ද අපි අපගේ ධාරාවන් ඉහළ වම්පස අයිපී වෙත හරවා යවා %පහළට ගමන් කිරීම දැනටමත් ආරක්ෂාව අක්‍රිය කර අකාලයේ පිටව යනු ඇත. ඒ නිසා අපි ආරක්ෂාව අක්‍රිය කළ යුතුයි. අපි මෙය කරන්නේ #ධාරාවට a එකතු කිරීමෙන් , එමඟින් ධාරාව හරහා ගලා යන අයිපීඑස් ක්‍රියා විරහිත වන නමුත් දැනටමත් සනීපාරක්ෂක කර ඇති අයිපීඑස් එසේ නොවේ. මෙම #යුතු ද දුෂ්කර මෙන්ම පළමු පෙල සංකේත කළ.

එය දැන්, මෙය දැන් ක්‍රියාත්මක වන ආකාරය ඔබට වැටහේවි.


: / යතුරු ලියනය කිරීම් සහ නැතිවූ සබැඳි
ASCII-

19

ෂඩාස්රාකාර , බයිට් 261, පැති දිග 10

113009344778658560261693601386118648881408495353228771273368412312382314076924170567897137624629445942109467..../....%'=g':..\..................\.................\................\...............\..............\.............\............\!$/'?))='%<\..>:;/$;4Q/

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

එකම කේතන පරිශීලක 202729 ගේ පිළිතුර භාවිතා කරයි , නමුත් ශුන්‍ය දෝෂයකින් බෙදීමකින් අවසන් වේ.

ආකෘතිගත කර ඇත, මෙය පෙනේ:

          1 1 3 0 0 9 3 4 4 7
         7 8 6 5 8 5 6 0 2 6 1
        6 9 3 6 0 1 3 8 6 1 1 8
       6 4 8 8 8 1 4 0 8 4 9 5 3
      5 3 2 2 8 7 7 1 2 7 3 3 6 8
     4 1 2 3 1 2 3 8 2 3 1 4 0 7 6
    9 2 4 1 7 0 5 6 7 8 9 7 1 3 7 6
   2 4 6 2 9 4 4 5 9 4 2 1 0 9 4 6 7
  . . . . / . . . . % ' = g ' : . . \
 . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . \
   . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . \
       . . . . . . . . . . . . \
        ! $ / ' ? ) ) = ' % < \
         . . > : ; / $ ; 4 Q /
          . . . . . . . . . .

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

පැහැදිලි කිරීම සඳහා සමහර පයිතන් වැනි psuedo- කේත:

n = ridiculously long number
base = 103
print(n)
while n > 0:
    b = 2
    if n%b == 1:
        c = '.'
        print(c)
    else:
        n = n//b
        b = base
        c = chr(n%b + 1)
    print(c)
    n = n//b

මෙම සංඛ්‍යාව ෂඩාස්රයේ ඉහළ භාගයට සම්පූර්ණයෙන්ම ගැලපෙන .බවත්, කේතනය කිරීමට අමතර යමක් ඉතිරි නොවන බවත් සහතික කිරීම සඳහා මම ප්‍රශස්ත පාදක 97 වෙනුවට 103 පාදම භාවිතා කරමි .

මෙන්න අ මම විශාල සංඛ්‍යාවක් ලබා ගැනීමට භාවිතා කළ පරිශීලක 202729 හි එන්කෝඩරයට සබැඳියක් වන අතර එම සංඛ්‍යාව සැබවින්ම ෂඩාස්රයට ගැලපේදැයි පරීක්ෂා කරන්න.


මෙය ඉලක්කම් 108 ට නොගැලපීම මොනතරම් ලැජ්ජාවක්ද ?
NieDzejkob

17

යූප් , 1165 879 606 561 540 522 498 + 7 = බයිට් 505

-cheatඅන්වර්ථ නාම නිර්වචනය කිරීමට ධජයට අවශ්‍ය වේ .

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

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

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

මේ සඳහා කොටස් දෙකක් තිබේ (බොහෝ ක්වයින් මෙන්). දත්ත:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

සහ විකේතකය:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

දත්ත හුදෙක් විකේතකයේ ද්විමය කේතීකරණයකි (හෝ ඒ වෙනුවට එහි ප්‍රතිලෝම). සෑම එකක්ම 0නව චරිතයක් ආරම්භ කරන අතර 1s සහ 2s යනු 0- සහ1 පිළිවෙලින් -බිට්ස් වේ.

බව සටහන 0අතර, ශුන්ය තල්ලු කරන සම්මත ඔව් වන විධානය 1හා 2මේ මොහොතේ දී අර්ථ නැත. කෙසේ වෙතත්, අපි විධානය මුළු දත්ත කොටසක් ලබා දිය %එසේ බව 1හා 2තෙක් නිර්වචනය නොකළ රැඳී සිටීමට හැකි %ඇත්තටම භාවිතා කරයි.

ඊළඟට, අපි තවත් විධාන කිහිපයක් අර්ථ දක්වන්නෙමු:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<තොගයේ ඉහළ කොටස අඩු කරයි, >එය වැඩි කරයි. 1(තරමක් නොදැනුවත්ව) තොගයේ මුදුන දෙගුණ කරයි. 2එය දෙගුණ කර වැඩි කරයි. මෙම නිර්වචන වලට ස්තූතිවන්ත වන්නට, 0221111ඇත්ත වශයෙන්ම 48 (ද්විමය 110000) තොගයේ ඉතිරි වේ.

ඉතිරි බයිට් 32 කොටස් දෙකකින් සත්‍ය විකේතනය කරයි. මුලින්ම අපි දත්ත දාමය නැවත සකස් කළ යුතුයි.

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

අවසාන වශයෙන්, අපි දත්ත නැවත තල්ලු කර එක් එක් අගය අක්‍ෂරයක් ලෙස මුද්‍රණය කරමු:

%{@}

අනාගත යොමු කිරීම සඳහා, දත්ත කේතනය කිරීම සඳහා CJam පිටපතක් මෙහි ඇත.


17

ෆියු , 423 බයිට්

Fueue ධාවන වැඩසටහන වන පෝලිමේ මත පදනම් esolang වේ වේ පෝලිමේ.

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

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

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

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

ෆියු චේට් ෂීට්

මෙම වැඩසටහනේ භාවිතා නොකරන ලද අංග කිහිපයක් ඇතුළුව විස්තර සඳහා esolang wiki ලිපිය බලන්න .

  • ආරම්භක වැඩසටහන යනු පහත දැක්වෙන අංග අඩංගු විය හැකි පෝලිමේ ආරම්භක තත්වයයි:

    • පූර්ණ සංඛ්‍යා (ප්‍රභවයේ negative ණ නොවන නමුත් negative ණාත්මක ඒවා පමණක් ගණනය කළ හැකිය), ඒවා ක්‍රියාත්මක කිරීමෙන් අක්ෂරයක් මුද්‍රණය වේ.
    • චතුරස්රාකාර වර්‍ගයෙන් වෙන් කරන ලද කැදැලි කුට්ටි, නිෂ්ක්‍රීය (සමහර ශ්‍රිත ඒවා මත ක්‍රියා නොකරන්නේ නම් නොවෙනස්ව සංරක්ෂණය කර ඇත).
    • කාර්යයන්, ඔවුන්ගේ තර්ක පෝලිම්වල වහාම අනුගමනය කරන අංග වේ:
      • +*/-%: නිඛිල අංක ගණිතය ( -ඒකීය, %තාර්කික නිෂේධනය). සංඛ්‍යා තර්ක ලබා නොදුනහොත් නිෂ්ක්‍රීය කරන්න.
      • ()<: වරහන් තුළ මූලද්‍රව්‍යය තබන්න, වාරණයෙන් වාරණ ඉවත් කරන්න, අවහිර කිරීමට අවසාන අංගය එක් කරන්න. බ්ලොක් එකක් අනුගමනය නොකරන්නේ නම් දෙවැන්න නිෂ්ක්‍රීය වේ.
      • ~:: හුවමාරු කරන්න, අනුපිටපත් කරන්න.
      • $: පිටපත් කරන්න (අංක + මූලද්‍රව්‍යය ගනී). අංකයට පෙර නිෂ්ක්‍රීය කරන්න.
      • H: වැඩසටහන නවත්වන්න.

    []කූඩුව සිටියදී , ()එසේ නොකරන්න - දෙවැන්න හුදෙක් වෙනම කාර්යයන් බව සලකන්න .

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

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

  • ශ්‍රිතයක් ක්‍රියාත්මක වන විට, එය සහ එහි තර්ක අවකාශයේ ඇති අවට මූලද්‍රව්‍ය වලින් ඉවත් වේ. සමහර තර්ක සංකීර්ණ නම්, ඒවා අතර අවකාශයක් ද තිබිය හැකිය.
  • බොහෝ ution ාතන අංශු වම් පසින් “ප්‍රමාද පිපිරීමක්” ලෙස බෙදා ඇති අතර, සැලකිය යුතු දත්ත හැසිරවීමක් සිදු කරන කොටසක සිට දකුණට වෙන් කරනු ලැබේ. ඊළඟ කොටස බලන්න.

{}ගණිතමය ප්‍රකාශනවල පූර්ණ සංඛ්‍යා ප්‍රති result ල නිරූපණය කිරීම සඳහා හෝඩුවාවන්හි කැරලි වරහන් (ෆියු හි භාවිතා නොවේ) භාවිතා වේ. මෙයට negative ණ සංඛ්‍යා ඇතුළත් වේ, ෆියු හි ඇත්තේ negative ණාත්මක නොවන වචනාර්ථයන් පමණි - -එය නිෂේධන ශ්‍රිතයයි .

විවිධ වෙනස් කළ හැකි නම් සහ ... ඒවා අගයන් සහ කෙටි යෙදුම් දැක්වීමට භාවිතා කරයි.

උපක්‍රම ප්‍රමාද කිරීම

බුද්ධිමත්ව, පෝලිම වටා ක්‍රියාත්මක කිරීමේ චක්‍ර, එය හරහා ගමන් කරන දේ අර්ධ වශයෙන් වෙනස් කිරීම. ශ්‍රිතයක ප්‍රති results ල ඊළඟ චක්‍රය තෙක් නැවත ක්‍රියාත්මක කළ නොහැක. වැඩසටහනේ විවිධ කොටස් එකිනෙකට සම්බන්ධ නොවන තාක් සමාන්තරව පරිණාමය වේ.

එහි ප්‍රති As ලයක් ලෙස, කේත බොහොමයක් සමමුහුර්තකරණය සඳහා වෙන් කර ඇත, විශේෂයෙන් වැඩසටහනේ කොටස් නියමිත වේලාවට ක්‍රියාත්මක කිරීම ප්‍රමාද කිරීම සඳහා. මෙය ගොල්ෆ් කිරීම සඳහා විකල්ප රාශියක් ඇත, එමඟින් එම කොටස් කියවිය නොහැකි බ්ලොබ් බවට පත් කිරීමට නැඹුරු වන අතර ඒවා තේරුම් ගත හැක්කේ ඒවායේ ක්‍රියාත්මක කිරීමේ චක්‍රය චක්‍රයෙන් සොයා ගැනීමෙන් පමණි.

මෙම උපක්‍රම සැමවිටම පහත සඳහන් පරිදි තනි තනිව සඳහන් නොවේ.

  • )[A]Aචක්‍රයක් සඳහා ප්‍රමාදයි . (බොහෝ විට පහසුම හා වඩාත්ම කියවිය හැකි ක්‍රමයයි.)
  • ~efමූලද්රව්ය මාරු කරයි eසහf වන ඔවුන්ගේ ක්රියාත්මක පමා කරයි. (බොහෝ විට කියවිය හැකි අවම, නමුත් බොහෝ විට සුළු ප්‍රමාදයන් සඳහා කෙටිම වේ.)
  • $1eතනි මූලද්‍රව්‍යයක් ප්‍රමාද කරයි e.
  • -සහ %සංඛ්‍යා ප්‍රමාද කිරීම සඳහා ප්‍රයෝජනවත් වේ (දෙවැන්න සඳහා 0සහ 1.)
  • පේළියක සමාන මූලද්‍රව්‍ය කිහිපයක් ප්‍රමාද කිරීමේදී :හෝ $තනි එකකින් ඒවා නිර්මාණය කිරීමට භාවිතා කළ හැකිය.
  • (nහකුළා nපසුව පහසුව ඉවත් කළ හැකි අල්ලු, දී. සංඛ්‍යාත්මක ගණනය කිරීම් සඳහා මෙය විශේෂයෙන් වැදගත් වේ, මන්දයත් සංඛ්‍යා මුලින් අස්ථායී බැවින් ඒවා පිටපත් කිරීමට පවා නොහැකි ය.

සමස්ත ව්‍යුහය

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

ආරම්භක වැඩසටහන ඔවුන් අතර බෙදී ඇති ආකාරය මෙන්න:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

වැඩසටහනේ අවසානයේ ඇති විශාල ඉලක්කම් ඉතිරි කොටස ප්‍රතිලෝමව සංකේතවත් කරයි, අක්ෂරයකට ඉලක්කම් දෙක බැගින් වන අතර එක් එක් ASCII අගයෙන් 30 ක් අඩු කරනු ලැබේ (උදා: 10a (.

ඉහළ මට්ටමක දී ඔබට මෙම වැඩසටහනේ දත්ත (බිග්නම් වලින් පටන් ගෙන) දකුණේ සිට වමට ගලා යන බවක් සිතිය හැකි නමුත් වමේ සිට දකුණට ගලායාම පාලනය කරන්න. කෙසේ වෙතත්, පහළ මට්ටමේ දී ෆියු විසින් සෑම විටම කේතය සහ දත්ත අතර වෙනස අවුල් කරයි.

  • G කොටස මඟින් බිග්නම් ASCII ඉලක්කම් වලට විකේතනය කරයි (උදා: 0පූර්ණ සංඛ්‍යා ලෙස ඉලක්කම් 48), අවම වශයෙන් සැලකිය යුතු ඉලක්කම් පළමුව බෙදයි. එය සෑම චක්‍ර 15 කටම එක් ඉලක්කම් නිපදවයි.
  • E කොටසේ ඒවා පරිභෝජනය කරන තෙක් නිෂ්පාදිත ඉලක්කම් ASCII අගයන් (එක් එක් කොටස තුළ) F කොටසේ අඩංගු වේ.
  • E කොටස මඟින් නිෂ්පාදිත ඉලක්කම් වරකට දෙකක් හසුරුවමින් ඒවා පෝරමයේ කොටස් වලට සම්බන්ධ කරයි [x[y]] , තවද එක් එක් යුගලයේ කේතනය කළ අක්‍ෂරය මුද්‍රණය කරයි.
  • D කොටස ක්‍රමානුකූලව ඉදිකරන ලද ගැඹුරින් කැදැලි කොටුවකින් සමන්විත වේ [x[y]] එය සියලු ඉලක්කම් අඩංගු වූ පසු ඒවා සියල්ලම මුද්‍රණය කර ධාවනය කර සම්පූර්ණ වැඩසටහනම නවතා දැමිය හැකිය.
  • සී කොටසේ ඩී කොටස ඉදිකිරීම හසුරුවන අතර ඊ කොටස නැවත ප්‍රතිනිර්මාණය කරයි.
  • B කොටස C කොටස මෙන්ම සෑම චක්‍ර 30 කටම ප්‍රතිනිර්මාණය කරයි.
  • A කොටස අනෙක් කොටස්වල අවසාන ක්‍රියාකාරීත්වය තෙක් චක්‍ර ගණනය කරයි. ඉන්පසු එය B කොටස නවතා D කොටස ක්‍රියාත්මක කරයි.

A කොටස

කොටස A වැඩසටහනේ අවසානය උපලේඛනගත කිරීම හසුරුවයි. තනි හුවමාරු ශ්‍රිතයක් දක්වා අඩු කිරීමට චක්‍ර 4258 ක් ගත ~වන අතර, එමඟින් B කොටසට ගැලපීමක් සිදු කරන අතර එහි ප්‍රධාන ලූපය නවතා D කොටස ක්‍රියාත්මක කිරීමට පටන් ගනී.

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • $කාර්යය පහත පිටපත් 4255 නිර්මාණය %වූ අතර (තබා ඇත්තේය ~වරහන්.
  • %පහත දැක්වෙන අංකය 0සහ අතර ටොගල් කිරීම සඳහා සෑම චක්‍රයක්ම අන්තිම භාවිතා 1වේ.
  • සියළුම %s භාවිතා කරන විට, (effectively ලදායී ලෙස NOP) $11 පිටපතක් සාදයි [~], ඊළඟ චක්‍රයේ )වරහන් ඉවත් කරයි.

බී කොටස

B කොටස සෑම චක්‍ර 30 කටම නැවත ප්‍රතිනිර්මාණය කිරීම මෙන්ම C කොටසෙහි නව ක්‍රියාවක් සිදු කරයි.

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • :(ලෙස සංක්ෂිප්ත එක් පිටපතක් පහත ලොකු වාරණ අනුපිටපත් [BkB]පසුව,) )පළමු පිටපත සිට වරහන් ඉවත් කරයි.
  • $$24%%0 A කොටසේ ඇති අංකයට සමාන ගණන් කිරීමක් සකසයි.
  • මෙය ගණන් කරන විට, :<හැරී <<, ~කුට්ටි දෙකක් මාරු කරමින් , නව කොටසක් සඳහා කේතය අවසන් වරට තබයි.
  • මෙම <කාර්යයන් දෙක අවසාන කුට්ටි දෙක පළමු එකට ඇසුරුම් කරයි - මෙය සාමාන්‍ය පුනරාවර්තනවල අතිරික්ත වේ, නමුත් ~A කොටසේ සිට අවසානයේ එහි කාර්යය කිරීමට ඉඩ දෙනු ඇත .
  • (1) ගණන් කිරීම අවසන් වූ විට ), පිටත වරහන් ඉවත් කරයි. ඊළඟ ~:)මාරුවෙන් මාරුවට බවට ):හා ~)හුවමාරු වූ) කොටස සී කේතය ආරම්භයට.
  • (2) බී කොටස දැන් එහි ආරම්භක චක්‍රයට පැමිණ ඇති අතර, )සී කොටසේ නව ක්‍රියාවලියක් ආරම්භ කිරීම සඳහා වරහන් ඉවත් කිරීමට ආසන්නව ඇත.

අවසාන පුනරාවර්තනයේදී, ~A කොටසේ සිට ඉහත (1) ස්ථානයේ දිස්වේ:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

මෙම ~හුවමාරු වන )නැවත ක්රියාත්මක කරන සිට කොටස බී වැළැක්වීම, වාරණ හරහා කොටස සී බවට.

සී කොටස

සී කොටසේ නව ඉලක්කම් අක්ෂර යුගල ඩී කොටසට ඒකාබද්ධ කිරීම සහ ඊ කොටසේ නව පුනරාවර්තන නිර්මාණය කරයි.

දර්ශන සමඟ සාමාන්ය ප්රතිඵලයක්ම පහත xහා yඉලක්කම් වෙනමත් 'ASCII කේත නියෝජනය. පළමු පුනරාවර්තනයේ දී, එන "ඩී" සහ "ඊ" මූලද්රව්ය ආරම්භක වන [H]අතර -ඒ වෙනුවට, පෙර කිසිදු අංශයක් ඉලක්කම් අක්ෂර යුගල නිපදවීමට ධාවනය කර නැත.

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • මෙම පිළිතුර සඳහා මා විසින් සොයාගත් වෙනස් සමමුහුර්ත ක්‍රමයක් මෙය භාවිතා කරයි. ඔබ swap කාර්යයන් කිහිපයක් ඇති විට ~පිට පිට, පේළිය 2/3 ක් පමණ එක් එක් චක්රයක් (එක් නිසා හැකිලීමක් ~හුවමාරු දෙකක් පහත සඳහන්) නමුත් ඉඳහිට ක ඉතිරි සමග, ~එම රටේ මත හානියක් ගෙන ප්රවේශමෙන් හසුරුවමින් පහත දේ.
  • $11~එවැනි පේළියක් නිපදවයි. ඊළඟ ~වූ හුවමාරු <පහත සඳහන් වාරණ හරහා. තවත් එකක් <අවසානයේ නව කොටසේ යුගල බ්ලොක් එකක් (ඉලක්කම් x සහ y ASCII කේත ලෙස) D කොටසට එකතු කරයි.
  • ඊළඟ චක්‍රයේ, ~පේළියේ ඉතිරියක් ඇති අතර ~~, එය ~පහත දැක්වෙන දේ ඉක්මවා යයි ). අනෙක <D කොටස කොටසකට එකතු කරයි [)))~].
  • ඊළඟට හුවමාරු ~වූ තැනැත්තා පහත කොටස බ්ලොක් කොටසේ නව කොටසේ ඊ කේතය සමඟ හුවමාරු කරයි. එවිට නව බයිනයක් ~වූ හුවමාරු )හරහා ද, සහ අවසාන පසුගිය ~~තුළ ~සාධාරණ ලෙස කොටස ඊ හරහා ඔවුන් පේළිය ස්වැප් එක් )එහි වරහන් ඉවත් කර ඇත.

අවසාන පුනරාවර්තනයේ දී, A හි කොටස B කොටස හරහා සහ C කොටසට ~මාරු කර )ඇත. කෙසේ වෙතත්, C කොටස කෙටිකාලීන බැවින් එය දැනටමත් අතුරුදහන් වී ඇති අතර,) D කොටස ආරම්භයේ දී අවසන් වේ.

ඩී කොටස

D කොටස අවසාන විශාල සංඛ්‍යා මුද්‍රණය කිරීම සහ වැඩසටහන නතර කිරීම හසුරුවයි. බොහෝ වැඩසටහන් ක්‍රියාත්මක වන විට, එය නිෂ්ක්‍රීය කොටසකි, B-G කොටස් ගොඩනැගීමට සහයෝගය දක්වයි.

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • වැඩසටහනේ පළමු චක්‍රයේ දී, වරහන් තුළ (නතර කිරීමේ කාර්යය Hඔතා. ඒ -එය වෙනුවට ඉලක්කම් යුගල පළමු ප්රතිඵලයක්ම සඳහා ආදර්ශ අංගයක් ලෙස භාවිතා කරනු ඇත, පහත සඳහන්.
  • සංස්ථාගත කරන ලද පළමු තාත්වික යුගලය, ඉලක්කම්වල [49[49]]අවසාන අගයට අනුරූප වේ 11.
  • අන්තිම ඉලක්කම් යුගල [49[48]](මෙම අනුරූප 10යන සංඛ ාංකය ආරම්භයේ දී) ඇත්තටම වාරණ ඇතුළත් නොවේ, නමුත් මේ ලෙස කිසිදු වෙනසක් )[A[B]]සහ )[A][B]දෙකම බවට හැරෙමින් සමාන වන අතර, A[B].

අවසාන පුනරාවර්තනයෙන් පසුව, )B කොටසේ සිට දකුණට මාරුවීම පැමිණෙන අතර D කොටස අවහිර කරනු ලැබේ. මෙම )))~එක් එක් උප-වාරණ ආරම්භයේ දී සියලු කොටස් අයිතිය සඳහා ක්රියාත්මක වන බවට වග බලා කරයි. අවසාන වශයෙන් අභ්‍යන්තරයේ ඇති කොටසෙහි Hවැඩසටහන නතර කිරීම අඩංගු වේ .

ඊ කොටස

E කොටස G කොටස මඟින් නිපදවන ASCII ඉලක්කම් යුගල ඒකාබද්ධ කරන අතර දෙකම අනුරූපී කේතනය කරන ලද අක්‍ෂරය මුද්‍රණය කරන අතර ඒකාබද්ධ යුගලය සමඟ වම්පස C සහ D කොටස් වෙත වාරණයක් යවයි.

නැවත වැඩසටහන් සමග සාමාන්ය ප්රතිඵලයක්ම පහත xහා yඉලක්කම් වෙනමත් 'ASCII කේත නියෝජනය.

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • එන ඉලක්කම් කුට්ටි මාරු කර, පසුව y බ්ලොක් x බ්ලොක් එකට එකතු වන අතර, මුළු යුගල කොටසම පිටපත් කරනු ලැබේ. සී සහ ඩී කොටස් සඳහා එක් පිටපතක් අවසානය දක්වා ඉතිරි වේ.
  • අනෙක් පිටපත යළිත් අවහිර කර ඇති අතර, ගණනය කිරීම සඳහා අංක ගණිත ශ්‍රිත අනුක්‍රමයක් යොදනු ලැබේ 10*x+y-498, සංකේතාත්මක අක්‍ෂරයේ ASCII අගය. 498 = 10*48+48-30මෙම 48ගේ ASCII කේතනය නැති xහා yඅතර 30සිට සංකේතවත් මුර 00–99කිරීමට 30–129සියලු මුද්රිත ASCII ද ඇතුළත් වන,.
  • එහි ප්‍රති number ලයක් ලෙස ඇති අංකය ක්‍රියාත්මක කිරීමට ඉතිරි වන අතර එමඟින් එහි අක්‍ෂරය මුද්‍රණය වේ.

එෆ් කොටස

F කොටස ASCII ඉලක්කම් සහිත නිෂ්ක්‍රීය කොටස් වලින් සමන්විත වේ. බොහෝ වැඩසටහන් ක්‍රියාත්මක වන විට මෙහි උපරිම වශයෙන් දෙකක් පවතිනු ඇත, මන්ද E කොටස ඒවා G නිපදවන වේගයෙන් පරිභෝජනය කරයි. කෙසේ වෙතත්, අවසාන මුද්‍රණ අදියරේදී අතිරික්ත 0ඉලක්කම් කිහිපයක් මෙහි එකතු වේ.

[y] [x] ...

ජී කොටස

වැඩසටහනේ අවසානයේ විශාල සංඛ්‍යාවක් බෙදීම, අවම වශයෙන් සැලකිය යුතු ඉලක්කම් පළමුව, සහ ඔවුන්ගේ ASCII කේත සමඟ බ්ලොක් අනෙක් කොටස් වෙත යැවීම G කොටස මඟින් සිදු කරයි.

එය නැවැත්වීමේ චෙක්පතක් නොමැති බැවින්, 0එම අංකය 0 දක්වා අඩු වූ විට සංඛ්‍යාංක නිපදවීම දිගටම කරගෙන යනු ඇත H.

[BkG] නව ආරම්භක ක්‍රියාවන් ආරම්භ කිරීම සඳහා ස්වයං අනුරූකරණය සඳහා භාවිතා කරන විශාල ආරම්භක කේත වාරණයේ පිටපතක් සංක්ෂිප්ත කරයි.

පළමු චක්‍රයේ ආරම්භ කිරීම:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

සාමාන්‍ය පුනරාවර්තනය, Nබෙදීමට අංකය දක්වයි:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • මෙහි ප්‍රමාද පිපිරීම විශේෂයෙන් කෙස් කළඹකි. කෙසේ වෙතත්, එකම නව ප්‍රමාද කිරීමේ උපක්‍රමය වන්නේ චක්‍ර දෙකක් ප්‍රමාද කිරීම +:5වෙනුවට භාවිතා කිරීමයි . අහෝ, මෙම වැඩසටහනේ එක් අයෙකු පමණි .--101010
  • මෙම [N]සහ [BkG]කුට්ටි පසුව එක් පිටපතක්, දෙබිඩි ඇත Nවිසින් වෙන් කර ඇත 10.
  • [{N/10}]අනුපිටපත් කර ඇති අතර, අවසාන අංකයේ ASCII කේතය ගණනය කිරීම සඳහා තවත් අංක ගණිත ශ්‍රිත භාවිතා Nකරයි 48+((-10)*(N/10)+N). මෙම ASCII කේතය සහිත කොටස F කොටස සඳහා ඉතිරිව ඇත.
  • නව පිටපතක ආරම්භය සැකසීම සඳහා අනෙක් පිටපත කොටස් [{N/10}]අතර හුවමාරු [BkG]වේ.

බෝනස් ක්වයින් (බයිට් 540)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

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

කුමන ක්‍රමය කෙටිම වේ දැයි මට නොතේරුණු හෙයින්, මම මුලින් උත්සාහ කළේ අක්ෂර අංක දෙකකින් වෙන් කොට සංඛ්‍යා කේතනය කිරීමට ය ( ය. මූලික කේතය ටිකක් කෙටි නමුත් 50% විශාල දත්ත නිරූපණය ඒ සඳහා සෑදී ඇත. අනෙකා තරම් ගොල්ෆ් ක්‍රීඩාවක් නොවේ, එය පරාජය නොවන බව මට වැටහුණු විට මම නතර කළෙමි. එයට එක් වාසියක් ඇත: එයට බිග්නම් ආධාරයෙන් ක්‍රියාත්මක කිරීම අවශ්‍ය නොවේ.

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


1
ඔබ පැහැදිලි කිරීම ගොල්ෆ් කළ යුතුය XD
VFDan

1
)$n[)](ප්‍රමාද කවුන්ටරය සඳහා බයිට් කෙටි වේ.
jimmy23013
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.