1 සිට 9 දක්වා N අංකයකින් ගන්නා වැඩසටහනක් ලියන්න. එහි ස්වදේශීය ස්වරූපයෙන් ඔබේ වැඩසටහන N + NEg ප්‍රතිදානය 2N නම් 1, 4N නම් 2, 6N නම් 3, එසේ නම් කළ යුතුය.

ඔබේ වැඩසටහනේ සෑම අක්ෂරයක්ම අනුපිටපත් කර ඇති විට, එය N (තවමත් 1 සිට 9 දක්වා) ලබා ගන්නා වැඩසටහනක් විය යුතු අතර N 1නම් N × NEg ප්‍රතිදානය N නම් 1, 4N නම් N නම් 2, 9N නම්3 , එසේ නම්.

ඔබේ වැඩසටහනේ සෑම අක්ෂරයක්ම තුන් ගුණයකින් ත්‍රිත්ව වූ විට, එය N (තවමත් 1 සිට 9 දක්වා) ලබා ගන්නා වැඩසටහනක් විය යුතු අතර N 1නම් N ^ NEg ප්‍රතිදානය N නම් 1, 4N නම් 2, 27N නම් 3, N නම් , 387420489N නම්9 , , ආදිය.

9 ^ ට වැඩි අංක අවශ්‍ය නොවේ, මන්ද 10 ^ 10 බොහෝ භාෂාවේ සුපුරුදු නිඛිල පරාසයෙන් පිටත ය.

උදාහරණයක්

ඔබේ ආරම්භක වැඩසටහන නම්

My_Program!
Exit();

එවිට එය N ලබාගෙන N + N ප්‍රතිදානය කිරීමේ හැකියාව තිබිය යුතුය.

මීට අමතරව, වැඩසටහන

MMyy__PPrrooggrraamm!!

EExxiitt(());;

N ගත යුතු අතර N × N ප්‍රතිදානය කළ යුතුය.

අවසාන වශයෙන්, වැඩසටහන

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

N ගත යුතු අතර N ^ N ප්‍රතිදානය කළ යුතුය.

හතර ගුණයකින් යුත් චරිත වැඩසටහන් සහ ඉන් ඔබ්බට අවශ්‍ය නොවේ.

නීති

• ආදානය සහ ප්‍රතිදානය සරල, සාමාන්‍යයෙන් ආකෘතිගත කළ දශම සංඛ්‍යා විය යුතුය. ඔබේ කේතය පෙන්වීමට ඔබට වෙනත් පදනමක් භාවිතා කර පිළිතුරු දිය හැකි නමුත් ඔබේ පිළිතුර තරඟකාරී නොවේ.

• වින්ඩෝස් භාවිතා කරන්නන් \r\nඑක් චරිතයක් ලෙස සැලකිය \r\r\n\nහැකි බැවින් එය තේරුමක් නැති හෝ සමහර විට වැඩ නොකරයි.

• බයිට් වලින් කෙටිම ස්වදේශීය වැඩසටහන (N + N එක) ජය ගනී.

ජෙලි , බයිට් 12 යි

එන් + එන්

“(ẹ+)‘FQṖṪỌv

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

එන් × එන්

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv

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

එන් ^ එන්

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv

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

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

ජෙලි සතුව විවිධ වර්ගයේ වචනාර්ථ ඇත; ඒවා සියල්ලම ආරම්භ වන්නේ a “. වචනයේ පරිසමාප්ත අර්ථයෙන්ම එකකට වඩා තිබේ නම් “, නූල් අරාවක් ආපසු ලබා දෙනු ලැබේ, සහ“ නූල් එකිනෙකාගෙන් වෙන් කරයි.

උදාහරණයක් ලෙස, “abc“def”අස්වැන්න ['abc', 'def'].

වචනයේ පරිසමාප්ත අර්ථයෙන්ම (ඕනෑම එකක් ”«»‘’, «දැනට ක්‍රියාත්මක කර නොමැති), විවිධ වර්ගයේ සාහිත්‍යකරුවන් අතර තෝරා ගත හැකිය. මක්නිසාද යත් ‘, අපි අනුරූප යුනිකෝඩ් අක්ෂර වෙනුවට ජෙලිගේ කේත පිටුවේ කේත ලකුණු ලබා ගනිමු .

උදාහරණයක් ලෙස, “abc“def‘අස්වැන්න[[97, 98, 99], [100, 101, 102]].

වැඩසටහන් වල ඇති වචනාර්ථ තුනම පහත කේත ලක්ෂ්‍ය අරා වලට අනුරූප වේ.

“(ẹ+)‘           -> [40, 214, 43, 41]
““((ẹẹ++))‘      -> [[], [40, 40, 214, 214, 43, 43, 41, 41]]
“““(((ẹẹẹ+++)))‘ -> [[], [], [40, 40, 40, 214, 214, 214, 43, 43, 43, 41, 41, 41]]

එන් + එන්

“(ẹ+)‘FQṖṪỌv                          Main link. Argument: n

“(ẹ+)‘                                As before.
      F                               Flatten the array. Yields an integer array.
       Q                              Unique; deduplicate the integers.
                                      This yields [40, 214, 43, 41].
        Ṗ                             Pop; remove the last element.
         Ṫ                            Tail; extract the last element. 
                                      This yields 43, the Unicode code point of +.
          Ọ                           Unordinal; cast to character.
           v                          Eval; execute the character as a Jelly
                                      program with argument n.

එන් × එන්

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv              Main link. Argument: n

““((ẹẹ++))‘                           As before.
           ‘                          Increment all integers.
            FF                        Flatten the array. Yields an integer array.
              QQ                      Unique; deduplicate the integers.
                                      This yields [41, 215, 44, 42].
                ṖṖ                    Pop twice; remove the last two elements.
                  ṪṪ                  Tail; extract the last element.
                                      This yields 215, the Unicode code point of ×.
                    ỌỌ                Unordinal; cast to character.
                      v               Eval; execute the character as a Jelly
                                      program with argument n.
                       v              Eval; convert the return value (n×n) to a
                                      string and execute that string as a Jelly
                                      program with argument n. Since the string
                                      consists of a single integer literal, that
                                      integer is returned, ignoring the argument.

සටහන බව F, Q, Ṫ, සහỌ නෑ ශරීර ඇතියෙක් 1D අරා අනුපිටපත්, පුර්ණ සංඛ්යා, නිඛිල හා චරිත තොරව අරා (පිළිවෙළින්).

එන් ^ එන්

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv  Main link. Argument: n

“““(((ẹẹẹ+++)))‘                      As before.
                ‘‘                    Increment all integers twice.
                  FFF                 Flatten the array. Yields an integer array.
                     QQQ              Unique; deduplicate the integers.
                                      This yields [42, 216, 45, 43].
                        ṖṖṖ           Pop thrice; remove the last three elements.
                           ṪṪṪ        Tail; extract the last element.
                                      This yields 42, the Unicode code point of *.
                              ỌỌỌ     Unordinal; cast to character.
                                 v    Eval; execute the character as a Jelly
                                      program with argument n.
                                  vv  Eval twice. See N×N.

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

\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?

එය මාර්ගගතව උත්සාහ කරන්න: N + N , N * N , N ^ N. . STDIN ආදානය හරියටම එක් වර්‍ගයක් යැයි උපකල්පනය කරයි.

> <> 2D භාෂාවක් වන අතර, එබැවින් අපි උපදෙස් පහළට ක්‍රියාත්මක කරන්නේ නම් කේත අර්ථ නිරූපණයන් බොහෝ දුරට නොවෙනස්ව පවතින බව අපට භාවිතා කළ හැකිය - අමතර හිස් රේඛා කිසිදු විවරණයක් නොවේ. මෙයට ව්‍යතිරේකය වන්නේ කොන්දේසි විරහිත ට්‍රම්ප් ය ?. එය වටිනාකමක් නැති අතර ඊළඟ උපදෙස් මඟ හැරිය නොහැකි නම් මඟ හැරේ - අමතර නව රේඛා ?ඇතුළත් කර නොමැති නිසා අවුල් වනු ඇත , නමුත් ?අවසානයේ දී තැබීමෙන් අපට මෙය වටහා ගත හැකිය . තීරුවක් සහ එතීමෙන් වාසි ලබා ගැනීම.

ක්‍රියාත්මක කළ යුත්තේ 40.කුමන මෙහෙයුමද යන්න තීරණය කිරීම සඳහා, යතුර වන්නේ අයිපී ස්ථානගත කිරීම සඳහා සම්ප්‍රේෂණය කිරීමයි (4, 0). කේතයේ ප්‍රසාරණය හේතුවෙන්, x = 4තීරුව +මූලික වැඩසටහනට, *දෙගුණ කළ වැඩසටහනට සහ ^ත්‍රිත්ව වැඩසටහනට අනුරූප වේ . අවාසනාවට> <> on ාතීය භාවය ගොඩනගා නැති අතර එය වැඩසටහනේ වැඩි කොටසක් බවට පත් කරයි.

[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out

ටොව් ටොව් ටොව් ( චිකන් විකෘතියක්): බයිට් 810147050

පහත විස්තර කර ඇත්තේ යෝජිත විසඳුම් දෙකකි : බයිට් විශාල ප්‍රමාණයක් අවශ්‍ය වන ප්‍රශ්නයට එක් සම්පූර්ණ විසඳුමක් සහ දෙවන අර්ධ විසඳුම ( එන් + එන් සහ එන් * එන් කොටස් පමණක් විසඳීම , බයිට් 484 ක් පමණක් අවශ්‍ය වේ), සෑම එකක්ම වෙනස් ප්‍රවේශයක් සහ තමන්ගේම සිසිල් උපක්‍රම කට්ටලයක්! :)

1. සම්පූර්ණ විසඳුම (බයිට් 810147050)

භාවිතා කිරීමෙන් TovTovTov(TOV='hi',SEP=','), TOVමූලද්‍රව්‍ය අනුපිටපත් අනුපිටපත් වලින් ප්‍රතිශක්තී වේ (දෙකම "hihihi"සහ "hhiihhiihhii"ඒවායේ "hi"s තුනක් ඇත, සහ සියල්ල TovTovTovගැන සැලකිලිමත් වන්නේ TOVs අතර කොපමණ සංඛ්‍යාවක් දිස් වේ ද යන්නයි SEP).

අප භාවිතා කළේ නම් SEP=', ', සමස්ත වැඩසටහනම අනුපිටපත් වලට ප්‍රතිශක්තී වේ (එය සිසිල් නමුත් ප්‍රශ්නය විසඳන්නේ නැත). එබැවින් අපි භාවිතා කරමු SEP=','.

ඒ නිසා මෙම වැඩසටහන "hihihi,hi", උදාහරණයක් ලෙස, ints අරාවට සථායිතාව [3,1]අතර "hhiihhiihhii,,hhii"සථායිතාව කිරීමට [3,0,1]හා "hhiihhiihhii,,hhii"කිරීමට [3,0,0,1]. මෙයින් අදහස් කරන්නේ විධාන මඟින් අනුපිටපත් කිරීමෙන් පසුව ඒවායේ අර්ථය වෙනස් නොවන නමුත් සමස්ත දිග අක්ෂර අනුපිටපත් සමඟ වෙනස් වන බවයි. පහත විසඳුමක් වැඩසටහන දිග විමසුම් හා මුද්රණය කිරීම සඳහා ද යන්න තීරණය කිරීම මෙම භාවිතා N+N, N*Nහෝ N^N.

Ints array ලෙස යෝජිත සම්පූර්ණ විසඳුම: [6, 12, 9, 18, 9, 142, 11, 38, 8, 9, 260, 11, 73, 8, 22, 75, 7, 10, 14, 3, 1, 22, 24, 18, 15, 8, 10, 16, 3, 1, 22, 24, 18, 15, 8, 10, 45, 16, 7, 22, 3, 1, 22, 24, 18, 15, 8, 22, 3, 1, 22, 24, 18, 15, 8, 25, 3, 1, 22, 24, 18, 15, 8, 48, 3, 1, 22, 24, 18, 15, 8, 277, 3, 1, 22, 24, 18, 15, 8, 3146, 3, 1, 22, 24, 18, 15, 8, 46677, 3, 1, 22, 24, 18, 15, 8, 823564, 3, 1, 22, 24, 18, 15, 8, 16777237, 3, 1, 22, 24, 18, 15, 8, 387420510, 3, 1, 22, 24, 18, 15, 8]

නූලක් ලෙස, එය අක්ෂර 810147050 කින් සමන්විත ඉතා දිගු වැඩසටහනකි. hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. ප්‍රශ්නයේ N + N සහ N * N කොටස් පමණක් විසඳීම (බයිට් 484)

භාවිතා කිරීම TovTovTov(TOV='1',SEP=', '), මේ වතාවේ SEPඅනුපිටපත් වලට ප්‍රතිශක්තීකරණයක් ඇත ( ",, "තවමත් එහි ඇත්තේ එකක් ", "පමණි), එබැවින් පහත දැක්වෙන යෝජිත විසඳුමට සෑම විටම විධාන 33 ක් ඇත, අක්ෂර අනුපිටපත් කිරීමෙන් පසුවද:

1111, 111111111111111111111111111111111111111111111111, 1111111111, 1111111111, 1111111111, 111111, 111111111111, 111111111, 11111111111111, 111, 1, 1111111111111111111111, 111111111111111111111111, 111111111111111111, 111111111111111, 11111111, 111111111111, 1111111111111111, 111111111111111, 1111111111111111111111, 111111111111111111111111111111111111, 11, 1111111111111111111111111111, 111111, 111, 111111, 11111111111, 111111111111111111111111111, 1111, 1, 11111111, 1, 11111111

අනුරූප ints array ( ඉහත එක් එක් විධානයන් 33 TOVන් s ( 1ය) ගණන පහත පරිදි වේ:[4,48,10,10,10,6,12,9,14,3,1,22,24,18,15,8,12,16,15,22,36,2,28,6,3,6,11,27,4,1,8,1,8]

අක්ෂර අනුපිටපත් කිරීමෙන් සම්පූර්ණයෙන්ම වෙනස් විධාන 33 ක ලැයිස්තුවක් ලැබේ : [8,96,20,20,20,12,24,18,28,6,2,44,48,36,30,16,24,32,30,44,72,4,56,12,6,12,22,54,8,2,16,2,16]

මුල් ints අරාව ( N + N ගණනය කරන ) පරිස්සමින් නිර්මාණය කර ඇති අතර එමඟින් විධාන ඒවායේ අර්ථය වෙනස් කිරීමෙන් පසුවද, වැඩසටහන තවමත් අර්ථවත් වන නමුත් N * N ගණනය කරයි. නිදසුනක් ලෙස, අක්‍ෂර අනුපිටපත් කිරීමෙන් පසුව වෙනස් වන පළමු 4( TovTovTov“අක්ෂර වින්‍යාසය අක්‍ෂර කේතයක් ලෙස සලකන්න”) 8එය සම්පූර්ණයෙන්ම වෙනස් විධානයකි (“වැඩසටහන් කවුන්ටරය පළමු පොප් කළ අගයට වෙනස් කරන්න සිරස්ව, අගය වහාම සත්‍ය නම් ").

Befunge-98 , බයිට් 38 යි

vx:k:2-k*.@
20@
j3.
>^*
>:^
>:+.@

එය මාර්ගගතව උත්සාහ කරන්න: N + N , N * N , N ^ N.

ක්‍රියාත්මක කිරීමේ ආරම්භයේ දී ආදාන තොගයේ තිබිය යුතු බැවින් මෙම වැඩසටහන පිටතින් ක්‍රියාත්මක නොවේ. පළමු පේළිය පහත කේතය සමඟ ප්‍රතිස්ථාපනය කිරීමෙන් (බයිට් තුනක් එකතු කිරීමෙන්) එය stdin වෙතින් ආදාන ලබා ගනී (මෙය tryitonline.net හි ක්‍රියා නොකරන්නේ නම්, කනගාටුවට කරුණකි):

v
&x:k:2-

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

පිහිටුවීම

v       Redirect motion downward
02j     Jump over two instructions/spaces, executing the third
        If N=1, it will skip to the 6th line
        If N=2, it will skip to the 5th line
        If N=3, it will skip to the 4th line

N = 1

>       Move right
:+.@    Duplicate, add, print and exit

එන් = 2

>>::^^  Move right, duplicate twice, move up
*.@     Multiply, print and exit

එන් = 3

>>>^^^  Redirect motion
30x     Set instruction pointer delta to (3, 0), causing it to
        move right, executing every third instruction
:k:     Duplicate the number (we'll call it M) M+1 times
        The stack is now [M]*(M+2)
2-k*    Multiply things M-1 times (`k' is a quirky instruction)
.@      Print and exit