තමාට වඩා කෙටි (අක්ෂර වලින්) වැඩසටහනකින් මුද්‍රණය කළ හැකි කුඩාම ධනාත්මක පදනම් 10 පූර්ණ සංඛ්‍යාව කුමක්ද?


184

මම හිතන්නේ ඉහත ප්‍රශ්නය පැහැදිලිය, නමුත් එසේ නම්:

  • ධනාත්මක පාදක 10 නිඛිලයක් මුද්‍රණය කරන සම්පූර්ණ වැඩසටහනක් (ශ්‍රිතයක් පමණක් නොවේ) ලියන්න , විකල්පයක් ලෙස තනි නව රේඛාවක් අනුගමනය කරන්න.

  • සුදුසුකම් ලැබීමේ වැඩසටහන් වනුයේ වැඩසටහනේ ප්‍රභව කේතයට වඩා දිගු ( බයිට් වලින් ) ප්‍රතිදානය බයිට් වලින් මනිනු ලබන අයයි (වැඩසටහන් ප්‍රභව කේතය සඳහා ASCII හෝ UTF-8 කේතීකරණය උපකල්පනය කරයි).

    එනම් කේතය ප්‍රති ing ලයක් ලෙස ඇති සංඛ්‍යාවේ සංඛ්‍යාවට වඩා කෙටි විය යුතුය.

  • ප්‍රමුඛ ශුන්‍යයන් සියලු තත්වයන් යටතේ තහනම් කර ඇත. ප්‍රමුඛ ශුන්‍යයන් ගණනය කිරීම ගැටළුව සුළු කරයි; ප්‍රමුඛ ශුන්‍යයන් නොසලකා හැරීම අනවශ්‍ය ලෙස ප්‍රශ්නය සංකීර්ණ කරයි.

  • ජයග්‍රාහී වැඩසටහන වනුයේ කුඩාම විශාලත්වයෙන් පූර්ණ සංඛ්‍යාව මුද්‍රණය කරන සුදුසුකම් ලැබීමේ වැඩසටහනයි.

ලීඩර්බෝඩ් ස්නිපටය


64
උණුසුම් ජාල ප්‍රශ්න වල අංක 1 . පළමු ප්‍රශ්නය සඳහා නරක නැත ...
ට්‍රයිකොප්ලැක්ස්

6
SKslkgh ට වඩා අඩුය, එසේ නොමැතිනම් ඒවායේ අවසාන අගය ව්‍යංගයෙන් මුද්‍රණය කරන වැඩසටහන් සඳහා ප්‍රශ්නය ඉතා සුළුය.
අරන්දූර්

7
1.0යනු පූර්ණ සංඛ්යාවකි?
හිස්ටොක්‍රැට්

26
යූටීඑෆ් -8 සඳහා සීමා කිරීම හාස්‍යජනක හා අහිතකර ය. කේතීකරණය කුමක් වුවත් බයිට් යනු බයිට් ය. අක්‍ෂර පදනම් නොවන (උදා: Minecraft, Piet, Folders) හෝ ඒවායේ “තාත්වික” ට වඩා දිගු UTF-8 බයිට් ගණන් ඇති භාෂාවන් දැනට පවතින බැවින් ඒවා වෙනස් කිරීමට මම තරයේ නිර්දේශ කරමි ( මෙම ප්‍රශ්නයට අනුව වලංගු වේ ) බයිට් ගණන් (උදා: APL, TI-BASIC, බරපතල ලෙස, ජෙලි).
lirtosiast

7
Ach සාක් ගේට්ස් එච්එන්කියු ලැයිස්තුව ක්‍රියා කරන ආකාරය නොවේ. ;)
මාටින් එන්ඩර්

Answers:


202

රෙටිනා , ලකුණු 1 යි


හිස් වැඩසටහන මඟින් ආදානයේ ඇති හිස් රිජෙක්ස් වල ගැලපුම් ගණන ගණනය කරයි (එය හිස් නූලයි). එය හරියටම ගැලපීම 1 ක් බැවින් එය මුද්‍රණය 1වේ.

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


40
... අපට ජයග්‍රාහකයෙක් සිටී.
අරන්දූර්

10
Btw, මම කියන්නේ තරඟ ගණන අනන්තය. හිස් නූලට අසීමිත වාර ගණනක් පුනරාවර්තනය කළ හැකි අතර අසීමිත ලෙස ගැලපේ.
nicael

53
Icnicael වාසනාවකට මෙන්, රීජෙක්ස් ක්‍රියා කරන්නේ එලෙස නොවේ. ;)
මාටින් එන්ඩර්

8
Re ඔබේ රීජෙක්ස් එන්ජිම මත රඳා පවතින මාටින්බට්නර්. ඔබ කවදා හෝ හිස් නූලට ගැලපීමට උත්සාහ කළහොත් එය අහෝසි වන පද්ධති මට අනිවාර්යයෙන්ම හමු විය.
ස්පාර්

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

76

පයිත් , 10

T

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


101
පයිත් භාවිතා කිරීමට ඔබ ගත් පළමු උත්සාහය ටී අකුර පමණක් වන්නේ කෙසේදැයි මම කැමතියි.
ඩීජෙක්ලින්

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

2
මෙය බහුඅස්රයකි, මෙය 05AB1E තුළද ක්‍රියාත්මක වේ. 05ab1e.tryitonline.net/#code=VA
මැජික්

60

bc, 10

A

වාසනාවකට මෙන්, bcඅවසාන ප්‍රකාශනයේ ප්‍රති result ලය පෙරනිමියෙන් මුද්‍රණය කරයි. Aහෙක්ස් ඉලක්කම් ලෙස අර්ථකථනය කර ඇති නිසා ප්‍රති results ල ලැබේ 10.


1
Aබොහෝ ගොල්ෆ් ක්‍රීඩා භාෂා A ලෙස 10 ලෙස අර්ථ දක්වා ඇති හෙයින් විසඳුම ඇතුළුව දැනටමත් (අවම වශයෙන්) සමාන පිළිතුරු 5 ක් ඇත
nicael

45
@nicael ඔව්, ඒක ඇත්ත. bcගොල්ෆ් භාෂාවක් නොවන නිසා මෙම පිළිතුර වෙනස් යැයි මම කියමි . ඇත්ත වශයෙන්ම එය ඔබට සොයාගත හැකි ඕනෑම සම්මත * නික්ස් පද්ධතියක පෙරනිමියෙන් ලබා ගත හැකි පොසික්ස්-නිර්වචනය කළ භාෂාවකි .
ඩිජිටල් කම්පනය

47

මසුන් ඇල්ලීම, ලකුණු 7,958,661,109,946,400,884,391,936 1,208,925,819,614,629,174,706,176

අවම කිරීමේ අභියෝගයකදී මෙතෙක් වාර්තා නොවූ ඉහළම ලකුණු ප්‍රමාණය මෙයද? (එය 84.8% කින් ගොල්ෆ් කර ඇතත්)

v+CCCCCCCCCC
  `32`nSSSSP

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

v              Sets the casting direction to down
 +             Increments the casting distance by 1
  CCCCCCCCCC   Casts the rod

`32`         Pushes a string "32" to the stack
    n        Converts the stack from a string to an integer
     SSSS    Repeated squaring of the stack
         P   Prints the stack

අංකය 32^16සහ ඉලක්කම් 25 ක් ඇත. කේතය දිග බයිට් 24 කි. පෙර පිළිතුර විය 6^32.


2
මගේ ඇසට කඳුළක් ගෙනාවා. ඔබගේ දායකත්වය වෙනුවෙන් ස්තුතියි.
අරන්දූර්

32
එය තවමත් ජාවා පරාජය කරනු ඇත ... බලාපොරොත්තු සහගතව.
ආක්ටුරස්

3
හොඳයි, එය C # ට පහර දෙයි ...
LegionMammal978

6 සහ 9 නොවන්නේ ඇයි?
user253751

mimmibis අභියෝගයේ පරමාර්ථය වන්නේ ලකුණු අවම කිරීමයි, එබැවින් එය බයිට් අවම කිරීම පමණක් නොවේ; 9 ට පෙර තැබීම අනවශ්‍ය ලෙස මගේ ලකුණු වැඩි කිරීමට ඉඩ තිබුණි.
ආක්ටුරස්

36

මැට්ලබ්, 1,000,000,000 (10 9 )

ඔක්ටේව් සමඟ ද ක්‍රියා කරයි

disp(1e9)

කිසි විටෙකත් esolangs පරාජය කිරීමට යන්නේ නැත, නමුත් විනෝදය සඳහා මෙය කළ හැකි කුඩාම MATLAB / Octave වේ, එබැවින් මම එය කෙසේ හෝ පළ කරනු ඇතැයි සිතුවෙමි.


18
Esolang පිළිතුරු වලංගු වුවත් තරමක් කම්මැලි ය. නැති දෙයක් දැකීම සතුටක්!
අරන්දූර්

1
say 1e9ඔබේ ගොල්ෆ් ලකුණු වැඩි දියුණු කිරීමට අවශ්‍ය නම් perl තරමක් කෙටි වේ. (මෙම ප්‍රවේශය ක්‍රියාත්මක වන කුඩා
නිඛිලයට එය කොතැනකවත් නැතත්

roderobert ඇත්ත. 1e1 මඟින් ගැටළු ප්‍රකාශය තෘප්තිමත් කර ලකුණු 10 ක් ලබා දෙනු ඇත (පහළ, වඩා හොඳ) (වර්‍ගයක් බයිට් 1 යැයි උපකල්පනය
කරමු

character dberm22 10(අක්ෂර 2) 1e1(අක්ෂර 3) ට වඩා දිගු නොවේ
SuperJedi224

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

29

TI-84 BASIC, 120

5!

ᴇ2මෝඩ UTF-8 අවශ්‍යතාවය සඳහා නොවේ නම් වඩා හොඳ ලකුණු ලබා ගනී. (එය කැල්කියුලේටරයේ ස්වදේශීය ටෝකනීකෘත කේතීකරණයේ බයිට් දෙකක් පමණි, නමුත් එය යූටීඑෆ් -8 හි 4 යි ...)


සමහර විට මට යමක්
මග හැරී ඇත

11
@ ජැස්පර් බ්‍රයන්ට්-ග්‍රීන් සහ Eඑකම චරිතයක් නොවේ. TI-BASIC හි විද්‍යාත්මක අංකනය වන අතර Eඑය විචල්‍යයකි.
SuperJedi224

4
ස්තූතියි :) චරිතය පූර්ණ උසකට වඩා කුඩා බව මා දැක තිබිය යුතුය…
jbg

කැමතිද 3!වඩා හොඳ ලකුණු?
dberm22

1
@NobodyNada මෙවර ප්‍රශ්නය කිසියම් හේතුවක් නිසා UTF8 හි ලකුණු ලබා ගැනීමට විශේෂයෙන් සඳහන් කර ඇත.
SuperJedi224

26

සී #, ලකුණු 10 ^ 72 10 ^ 70 10 ^ 64 10 ^ 63

class A{static void Main(){System.Console.Write($"1{0:D63}");}}

ඒ 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000. මම හිතන්නේ මම උත්සාහ කළා ...


1
සිත් ඇදගන්නාසුළු, ඇත්තටම.
අරන්දූර්

4
කැමතිද Write(new string('1',70))වඩා හොඳ?
ලින්

1
ඔබට එය 10 ^ 56 දක්වා කෙටි කරන class A{static void Main(){System.Console.Write(1e56);}}
නූලකට

@ ගොරික් එය ප්‍රතිදානය 1E+56කරයි.
LegionMammal978

24

ෂඩාස්රාකාර , ලකුණු 100100

කේතය:

d!!@

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

  d !
 ! @ .
  . .

වර්‍ගයේ අගය d100 කි. මෙය වර්‍ග අගය දෙවරක් මුද්‍රණය කර පසුව අවසන් වේ.

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


හුරුබුහුටි! ඔබගේ දායකත්වය වෙනුවෙන් ස්තුතියි.
අරන්දූර්

21
වඩා කියවිය හැකි ආකෘතිය? ඇත්තටම? xD
ආර්.කේ.

18

ප්ලැටිපාර් , 59

#

#සංඛ්‍යාත්මක පදනමක් -60 වචනානුසාරයෙන් ආරම්භ වන අතර ඉලක්කම් කිසිවක් සොයාගත නොහැකි බැවින් එය අවසන් වේ 59. මෙය ප්‍රීතිමත් අනතුරක් ලෙස ආරම්භ වූ නමුත් මම දැනටමත් මෙම දෝෂය වෙනත් පිළිතුරකින් භාවිතා කර ඇති බැවින් මම එය තබා ගතිමි.

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

මෙන්න තවත් ප්‍රවේශයක්, මෙම අභියෝගය සඳහා සෑම කෙනෙකුම සහ ඔවුන්ගේ ආච්චි භාවිතා කළ නීරස ආකාරය ගැන මගේ අදහස.

ප්ලැටිපාර් , 100000000 (ඉලක්කම් 9)

'18Md0+;

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

'1        ## push "1" (a string) to the stack
  8Md  ;  ## repeat 8 times
     0+    ## add a 0
          ## [implicitly] print the result

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


17

ජාවාස්ක්‍රිප්ට්, ලකුණු 100,000,000,000 (හෝ 1 * 10 11 )

alert(1e11)

මෙය ඇඟවීම් භාවිතා කරන්නේ නම්. කොන්සෝලය භාවිතා කරන්නේ නම් ඔබට 100 000 000 ගුණයකින් අඩු ලකුණු ලබා ගත හැකි වුවද:

1e3

ඔබට පෙනෙන පරිදි ලකුණු 1000, එය කොන්සෝලය භාවිතා කළත් මට විශ්වාස නැත.


එය ගණන් නොගන්නේ මන්දැයි මම නොදනිමි!
අරන්දූර්

6
@ අරන්දූර් මම අනුමාන කරන්නේ "එය ගණන් කරන බව මට විශ්වාස නැත" යන්නෙන් අදහස් කරන්නේ 1000 ට වඩා අඩු ලකුණු ප්‍රමාණයක් වන අතර, ඒ සඳහා සම්පූර්ණ වැඩසටහනක් නොව, REPL ලෙස කොන්සෝලය භාවිතා කිරීම අවශ්‍ය වේ.
ට්‍රයිකොප්ලැක්ස්

හරියටම, පැහැදිලි කිරීමක් කළා.
nicael

11
අනතුරු ඇඟවීම සඳහා +1, මම ස්වයංක්‍රීය කොන්සෝල ප්‍රතිදානයට ඉඩ
නොදෙමි

16

Brainf ** k , 11111111111111111111111111111111111 (~ 1e34)

තවත් අඩු කිරීමක්:

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

එය අඛණ්ඩව 1 ක් 35 ක් හෝ දළ වශයෙන් 1e34 ​​ක් ලබා දෙයි.


තව ටිකක් කුඩායි

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

1e35 ට වඩා 11% පමණ විශාල සංඛ්‍යාවක් වන 36 1 ලබා දෙයි.


මෙම කේතය සමඟ මුළු ප්‍රතිදානය 100 කින් අඩු කිරීමෙන් අක්ෂර කිහිපයක් තට්ටු කිරීම ගැන මාටින් බොට්නර්ට ස්තූතියි (අස්වැන්න 1e36):

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

මගේ පැරණි කේතය (1 + e38 ields ලදාව):

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

මම කම්මැලි කමින් esolangs අත්හදා බැලුවෙමි. බීඑෆ් හි මට කළ හැකි හොඳම දේ මෙයයි. එය කුඩා කිරීමට හැකි දැයි මම කල්පනා කරමි.

ඔබට එය අන්තර්ජාලය හරහා උත්සාහ කළ හැකිය .


මම මුල සිටම කෙටි පිළිතුරක් ලිව්වෙමි: සබැඳිය
ලින්

A මෞරිස් ආකර්ෂණීයයි!
ටොම් වඩු කාර්මික

16

සී, 10000000000000000000000000 (ඉලක්කම් 28)

main(){printf("1%027d",0);}

මගේ C ++ පිළිතුරට සමානව, #include <stdio.h> (ප්‍රකාශය අස්ථානගත වීම පිළිබඳ අනතුරු ඇඟවීම නොසලකා හරින්න printf. ස්තූතියි enn ඩෙනිස්)

නිව්ලයින් සඳහා ආකෘතිය භාවිතා කරමින් අමතර බයිට් 2 ක් අවශ්‍ය වේ 1%029d\n


14

ජැප් , ලකුණු 10 යි

A

ලකුණු පෙන්වන පරිදි, 10 මුද්‍රණය කරයි.


මෙය කේත ගොල්ෆ් නොවේ; ඉලක්කය කුඩාම අංකය මුද්‍රණය කිරීමයි, ඔබේ ලකුණු 10 යි.
pppery

pppp "වැඩසටහනට වඩා අංකය බයිට් වලින් දිගු විය යුතුය - කේතයට අක්ෂර වලට වඩා ඉලක්කම් තිබිය යුතුය" - OP දැන් සංස්කරණය කර ඇත.
nicael

2
ඔබ වරදවා වටහාගෙන නැත; ජැප්ට් වැඩසටහන A10 මුද්‍රණය කරන්නේ නම්, මෙය ලකුණු 10 ක් සහිත වලංගු වැඩසටහනකි.
අරන්දූර්

3
වෝහූ, මගේ භාෂාව <s> පළමු </ s> දෙවන ස්ථානය සඳහා බැඳී ඇත! රෙටිනා හි
දීප්තිය

4
පහත් කොට සැලකීමට කිසියම් හේතුවක් තිබේද?
nicael


10

PHP, ලකුණු 10,000,000

<?=1e7;

දැක ගත හැකි ලෙස මෙම 10000000 මුද්රණය කරයි එහි .


2
OP කුඩාම නිඛිලය ඉල්ලා සිටි හෙයින්, ඔබ හතක on ාතයක් තෝරාගත්තේ ඇයි? එය කොමාවකින් තොරව මුද්‍රණය වේද?
WGroleau

@WGroleau එය කිසිදු කොමාවකින් තොරව මුද්‍රණය කරයි, justachat.freevar.com/test.php
nicael

9

ලැබ්රින්ත් , ලකුණු 10,000,000

1!!!!>@

එක් විශාලත්වයකින් මෙය පහතට ගෙන ඒමට හැකි විය හැකි නමුත් මට දැන් කිසිවක් සොයාගත නොහැක.

පළමු 1!!!!මුද්රණ 1000. ඉන්පසු >ප්‍රභව කේතය වෙත මාරු කරයි

@1!!!!>

එය කල් ඉකුත්වීම වළක්වයි. එවිට අයිපී මළ කෙළවරකට පහර දී හැරේ. දැන් !!!!තවත් ශුන්‍ය හතරක් මුද්‍රණය @කර වැඩසටහන අවසන් කරයි.

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


9

සමාවු , 42

A

Aජීවිතය, විශ්වය සහ සෑම දෙයක්ම පිළිබඳ අවසාන ප්‍රශ්නයට පිළිතුර තල්ලු කරයි. එවිට තොගයේ මුදුන ස්වයංක්‍රීයව මුද්‍රණය වේ.


ඔබගේ
කැපවීමේ

4
O ඩෝර්ක්නොබ් commit මම පණිවිඩ යැවීමට දන්නේ නැත, එබැවින් මම අහඹු ඉමෝජි භාවිතා කරමි.
alephalpha

7
හරි, මෙන්න ඇත්ත ප්‍රශ්නය: Qතල්ලු කරන්නේ කුමක්ද?
සයෝස්

9

බ්‍රේන්ෆක්, 333333333333333333333333333 (25 threes)

මෙය "මුල සිටම" ලියා ඇති බැවින් වෙනම පිළිතුරක් පළ කිරීම සුදුසු යැයි මම සිතමි:

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

බයිට් 23 ක් දිගයි.


මම සලකා බැලුවේ bf විසඳුමක්, සංඛ්‍යා ලෙස පමණක් ප්‍රතිදානය කරන වර්තමාන පරිවර්තකයන් සිටීද?
රොහාන් ජුන්ජුන්වල

O රොහාන් ජුන්ජුන්වල මෙය 51 "3"වතාවක් (ඒ සඳහා ASCII කේතය ) 25 වතාවක් ප්‍රතිදානය කරයි.
ලෙවල් රිවර් ශාන්ත

E ලෙවල් රිවර්ස්ට් කියන්නේ, ඇසි ලෙස ආදානය නොකරන සහ පූර්ණ සංඛ්‍යා ප්‍රතිදානය පමණක් කරන bf පරිවර්තකයක් තිබිය හැකි බැවින් (-.) 255 ප්‍රතිදානය කරයි.
රොහාන් ජුන්ජුන්වල

9

ඩීසී , 10000

අක්ෂර 4 වැඩසටහන:

I4^f

ඉලක්කම් 5 ක ප්‍රතිදානය:

$ dc<<<'I4^f'
10000

3
+1. ඔව්, මම හිතන්නේ එය dc හි ප්‍රශස්තයි. අසාමාන්‍ය ලෙස bc කෙටි වේ.
ඩිජිටල් කම්පනය

මම හිතුවා මම හොඳට වැඩ කරනවා කියලා 6d^p(අස්වැන්න 46656), නමුත් ඔබට ඒ පහර තියෙනවා - හොඳින් කළා!
ටෝබි ස්පයිට්

8

3FNප්‍රතිදානය නොකරන්නේ ඇයි 6?
පීටර් ටේලර්

Et පීටර් ටේලර් සංඛ්‍යාව දිගින් වැඩි විය යුතුය, විශාලත්වයෙන් වැඩි නොවිය යුතුය.
ඇඩිසන් ක්‍රම්ප්

8

සී, 11111111111111111111111111111111111 (35 ක්)

main(c){while(c++<36)putchar(49);}

සමහර විට කෙටි ක්‍රමයක් තිබේ. සී හි විශාල සංඛ්‍යා මුද්‍රණය කිරීමට සරල ක්‍රමයක් නොමැතිකම එය ව්‍යාකූල කරයි.



7

ජාවා, 11111111111111111111111111111111111111111111111111111111111111111 (81)

interface A{static void main(String[]a){for(A i:new A[81])System.out.print(1);}}
                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ඇත්ත වශයෙන්ම මෙහි “විචල්‍ය” කොටස මම අවධාරණය කර ඇත්තෙමි. වැඩ කරන ජාවා වැඩසටහනක් සඳහා අනෙක් සියල්ල අත්‍යවශ්‍ය වේ.

අනුමාන වශයෙන් මෙය ජාවා සමඟ ගැටීමට වඩා කෙටි වේ BigInteger.


අනුමාන වශයෙන් ... - සමහර විට System.out.print(BigInteger.TEN.pow(10));- එම එක් චරිතයක් අඩු ද? කණගාටුයි - ප්‍රමාණවත් තරම් විශාල තැනක් නැත - .pow(10).pow(10)එය දිගු වේ.
OldCurmudgeon

ඔබ විස්ථාපනය කල හැකි interfaceසමග class.
LegionMammal978

2
නමුත් එසේ mainවිය යුතුය public.
ලින්

7
for for loop සඳහා මෙය කිරීමෙන් ඔබට අක්ෂර 2 ක් කපා දැමිය හැකිය: for (A a: new A [81])
Jack Ammo

LdOldCurmudgeon .pow(100)කිසියම් හේතුවක් නිසා ක්‍රියා නොකරන්නේද?
ETH නිෂ්පාදන

7

කියුබික්ස් , 100100

@'dOu

කියුබික්ස් යනු ද්විමාන, තොග මත පදනම් වූ esolang ය. කියුබික්ස් අනෙක් ද්විමාන භාෂා වලට වඩා වෙනස් වන්නේ ප්‍රභව කේතය ube නකයක් පිටත ඔතා ඇති බැවිනි.

එය මාර්ගගතව පරීක්ෂා කරන්න!

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

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

  @
' d O u
  .

දැන් කේතය ක්‍රියාත්මක වේ. අයිපී (උපදෙස් දර්ශකය) ආරම්භ වන්නේ වම් මුහුණේ සිට නැගෙනහිර දෙසට ය.

IP හමු වන පළමු වර්‍ගය නම් ', එය ඊළඟ බයිටය තොගයට තල්ලු කරයි; මෙම බයිට් එක d, හෝ 100. ඊළඟට O, ඉහළ අයිතමය (100) පූර්ණ සංඛ්‍යාවක් ලෙස ප්‍රතිදානය කරයි.

එවිට අයිපී පහර u, එය දකුණට හරවන අතර, එය ඉදිරියට ගෙන යයි, පසුව එය නැවත හරවයි. එය උතුරට යොමු වන පහළ මුහුණට මාරු වී නැගෙනහිර දෙසට භ්‍රමණය වේ. මෙය Oයළිත් වරක් ඔතා, 100 ප්‍රතිදානය කරමින්, පසුව @වැඩසටහන අවසන් කරයි.


6

MATL , 1000

1e3

සටහන: සම්පාදකයාගේ නවතම GitHub කැපවීම ඔක්ටේව්හි මෙන්ම මැට්ලැබ්හි ද ක්‍රියා කරයි.

මෙය විද්‍යාත්මක අංකනයෙහි ඇති අංකය අර්ථ නිරූපණය කරන අතර, එය ව්‍යංගයෙන් මුද්‍රණය කර ප්‍රතිදානය නිපදවයි

1000 යි


6

පර්ල්, 1000000000

print 1e9

කෙළින්ම.


1
භාවිතා කිරීමෙන් ඔබේ ලකුණු අඩු කළ sayනොහැකිද?
නීල්

ඒ සඳහා -Eධජය සක්‍රීය කිරීම අවශ්‍ය වනු ඇතැයි මම සිතමි. මෙම අභියෝගයේදී එය ගණනය කරන්නේ කෙසේදැයි මට විශ්වාස නැත.
ලින්

1
සිට " -M5.010, අවශ්ය විට, නොමිලේ" ඔබ සියලු එය ගණන් කිරීමට ඇති කළ යුතු නැහැ.
ThisSuitIsBlackNot


6

සී ++, 1e46

#include <stdio.h>
main(){printf("1%046d",0);}

"1% 048d \ n" ආකෘතිය භාවිතා කරමින් නව රේඛාවට අමතර බයිට් 2 ක් අවශ්‍ය වේ.


ආපසු පැමිණීමේ වර්ගය මඟ හැරීමට C ++ ඔබට ඉඩ දෙයි යැයි මම නොසිතමි main(). ඔටෝ, මෙය හොඳ සී පිළිතුරක් ලබා දෙනු ඇත ...
ටෝබි ස්පයිට්

5

ඕ, 10

A

පෙනෙන විදිහට ලකුණු යනු අප මුද්‍රණය කරන අංකයයි!


5

05AB1E , ලකුණු 10

කේතය

T

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

T         # Puts 10 onto the stack
          # Implicit, print the last item of the stack
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.