একটি স্ট্রলের একটি গুগল অনুলিপি আউটপুট করুন


63

আমি এমন প্রোগ্রামগুলি দেখতে আগ্রহী যেগুলি কোনও ইনপুট জিজ্ঞাসা করে না, কিছু অজানা স্ট্রিংয়ের একটি গুগল অনুলিপি প্রিন্ট করবে , কম হবে না, আর থাকবে না এবং তারপরে বন্ধ হবে। একটি গুগলকে 10 ^ 100 হিসাবে সংজ্ঞায়িত করা হয়, অর্থাৎ 1 এর পরে দশমিক একশ '0 হয়।

উদাহরণ আউটপুট:

111111111111111111111111111111111111111111111111111111111111111111111111...

অথবা

Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
...

স্ট্রিংটি পুরোপুরি সাদা স্থান বা বিশেষ চিহ্নগুলির সমন্বয়েও তৈরি করা যেতে পারে। কোনও নির্দিষ্ট স্ট্রিংয়ের অভিন্ন অনুলিপিগুলির ব্যতিক্রম কেবলমাত্র যদি আপনার ভাষা আউটপুটটিকে এমনভাবে সাজিয়ে তোলে যা প্রতিরোধ করা যায় না তবে প্রতিটি রেখায় একটি লাইন সংখ্যা প্রিপেন্ড করার মতো একটি মোড়ক স্ক্রিপ্টে তুচ্ছভাবে পূর্বাবস্থায় ফিরে যেতে পারে। এই জাতীয় ক্ষেত্রে মোড়ক স্ক্রিপ্ট সরবরাহ করার প্রয়োজন নেই।

আপনি ধরে নিতে পারেন যে আপনার কম্পিউটারটি কখনই শেষ হয়ে যাবে না, তবে এগুলি ছাড়া আপনার প্রোগ্রামটির অবশ্যই সংস্থানগুলির যথাযথ চাহিদা থাকতে হবে। এছাড়াও, আপনার পছন্দসই প্রোগ্রামিং ভাষাটি যে কোনও বিধিনিষেধ সৃষ্টি করেছে তা আপনাকে অবশ্যই সম্মান করতে হবে, উদাহরণস্বরূপ, আপনি এর পূর্ণসংখ্যার ধরণের জন্য অনুমোদিত সর্বোচ্চ মান অতিক্রম করতে পারবেন না এবং কোনও মুহুর্তে 4 গিগাবাইটের বেশি মেমরির প্রয়োজন হবে না।

অন্য কথায়, প্রোগ্রামটি আপনার কম্পিউটারে চালিয়ে নীতিগতভাবে পরীক্ষাযোগ্য হওয়া উচিত । তবে এই সংখ্যার ব্যাপ্তির কারণে আপনি প্রমাণ করতে পারবেন যে স্ট্রিংয়ের অনুলিপিগুলির ফলাফলটি হ'ল 10 ^ 100 এবং পরে প্রোগ্রামটি থেমে যায়। থামানো একটি ত্রুটির কারণে প্রস্থান করা বা বন্ধ বা এমনকি সমাপ্ত হতে পারে, তবে যদি তা হয় তবে ত্রুটিটি এমন কোনও আউটপুট তৈরি করতে পারে না যা প্রোগ্রামের আউটপুট থেকে সহজেই পৃথক হতে পারে না।

এটি , সুতরাং কয়েকটি বাইটের সাথে সমাধানটি জিততে পারে।

উদাহরণ সমাধান (সি, অলগল্ফড, 3768 বাইট)

#include <stdio.h>

int main() {
  int a00, a01, a02, a03, ..., a99;
  for(a00 = 0; a00 < 10; a00++)
  for(a01 = 0; a01 < 10; a01++)
  for(a02 = 0; a02 < 10; a02++)
  for(a03 = 0; a03 < 10; a03++)
  ...
  for(a99 = 0; a99 < 10; a99++)
    puts("1");
  return 0;
}

10
প্রথমবারের মতো স্যান্ডবক্সটি বিবেচনা করুন
বিড়াল

9
আপনি যখন একটি নতুন প্রশ্ন পোস্ট করেন, আপনাকে প্রথমে এটি স্যান্ডবক্সে পোস্ট করতে বলা হবে ।
flawr

1
@ ক্রিটিক্সিলিথোস এই ধারণাটি নিয়ে কাজ করে যাচ্ছিলেন তবে আমি দ্রুত কোনও নমুনা সমাধান নিয়ে আসতে পারিনি। একটি সিক্যুয়াল নির্দ্বিধায় বোধ করুন :-)
ভিও

3
আপনি কি নিশ্চিত যে এটি খুব বিস্তৃত? প্রচলিত জ্ঞান স্বয়ংক্রিয়ভাবে এটিকে "একটি অক্ষর 10 ^ 100 বার মুদ্রণ করতে" "একটি ননফটি স্ট্রিং 10 ^ 100 বার মুদ্রণ করুন" থেকে নীচে আনে।
dorukayhan

উত্তর:


34

জেলি , 6 4 বাইট

³Ȯ*¡

এই niladic লিঙ্ক (ণ আর্গুমেন্ট W / ফাংশন) যে ছাপে 10 200 স্ট্রিং কপি 100 , যার মানে হল এটা ছাপে 10 100 স্ট্রিংটি নিয়ে গঠিত কপি 10 100 স্ট্রিং কপি 100

এটি অনলাইন চেষ্টা করুন!

নোট করুন যে অনলাইন অনুবাদক ব্যবহারিক কারণে 100 কেবি আউটপুট কেটে দেয়। কোডটি একটি সম্পূর্ণ প্রোগ্রাম হিসাবেও কাজ করে তবে অন্তর্নিহিত আউটপুটের কারণে সেই প্রোগ্রামটি একটি অনুলিপি খুব বেশি মুদ্রণ করে।

কিভাবে এটা কাজ করে

³Ȯ*¡  Niladic link. No arguments.

³     Set the left argument and initial return value to 100.
 Ȯ    Print the current return value.
  *   Compute 100 ** 100 = 1e200.
   ¡  Call Ȯ 1e200 times. 

3
আচ্ছা ... বাহ ... মুদ্রণ 10^100মূল আউটপুট (কপি 10^100একটি স্ট্রিং কপি) এটি নিচ্ছে একটি সামান্য পর্যন্ত, এমনকি পুরো দুই বাইট জন্য। আপনি কি এখনও "স্কোরটি আউটপুট / প্রোগ্রাম-দৈর্ঘ্য, সর্বোচ্চ জয়" চ্যালেঞ্জটিতে জমা দিয়েছেন?
wizzwizz4

1
আপনি কোন চ্যালেঞ্জটি উল্লেখ করছেন তা নিশ্চিত নয় (আমাদের কাছে এই ধরণের কয়েকটি ছিল) তবে 3e200 সম্ভবত কোনওভাবেই প্রতিযোগিতামূলক নয়।
ডেনিস

2
@ wizzwizz4 আপনি যদি মানটি স্বরলিপিতে আপনার সংখ্যাটি প্রকাশ করতে পারেন তবে এটি সম্ভবত খুব কম।
orlp

1
"ফল ওভার" = ব্যর্থ / ক্র্যাশ
লরেেন পেচটেল

4
@ লোরেপেকটেল জেলি পাইথনে প্রয়োগ করা হয়েছে, যা সহজেই 656565-বিট পূর্ণসংখ্যার পরিচালনা করে।
ডেনিস

60

ফাজি অক্টোো গুয়াকামোল, 13 12 11 10 বাইট

9+ddpp![g] 

ব্যাখ্যা:

9+ddpp![g]
9+           # push 9 and increment, giving 10
  dd         # duplicate, twice. now you have [10,10,10]
    pp       # raise a 10 to the 10th power, then raise that to the 10th again. That ends up being 10^100.
      ![ ]   # for loop, `!` sets the counter to the top of stack
        g    # prints an ASCII art goat. 

ছাপানো ছাগলের নমুনা:

                  ___.
                 //  \\
                ((   ""
                 \\__,
                /6 (%)\,
               (__/:";,;\--____----_
                ;; :";,:";`;,";,;";`,`_
                  ;:,;;";";,;":,";";,-Y\
                   ;,;,;";";,;":;";"; Z/
                   / ;,";";,;";,;";;"
                  / / |";/~~~~~\";;"
                 ( K  | |      || |
                  \_\ | |      || |
                   \Z | |      || |
                      L_|      LL_|
                      LW/      LLW/

2
ছাগলের মাথা বুঝতে আমার কিছুটা সময় লেগেছে। এটি সহজেই সনাক্তযোগ্য নয়।
mbomb007

গৌত আমাকে ASCII শিল্প দিয়েছে, এ সম্পর্কে তাকে জিজ্ঞাসা করুন।

9
আপনি কী বলছেন তা আমার কোনও ধারণা নেই। +1 টি।
djechlin

15
@ জেজেলিন ডাউনগোট আমাকে ছাগল ছাপানোর জন্য একটি বিল্টিন যুক্ত করতে বলেছিল। আমি বাধ্য
আর

21

পাইথন, 28 বাইট

-1 বাইট জোনাথন অ্যালানকে ধন্যবাদ!

পাইথন 2:

i=10**100
while i:print;i-=1

পাইথন 3 (30 বাইট):

i=10**100
while i:print();i-=1

2
i=10**100নিউলাইন while i:print();i-=1একটি বাইট সংরক্ষণ করে। পাইথন 2 ব্যবহার করে আরও দুটি সংরক্ষণ করুনwhile i:print;i-=1
জোনাথন অ্যালান

@ জোনাথন অ্যালান -1 বাইটের জন্য ধন্যবাদ। পাইথন 2 সমাধান হিসাবে, আমি আপনার পোস্ট করার জন্য এটি ছেড়ে দেব :)
ফ্লিপট্যাক

প্রথম উত্তর! :)
ড্যানিয়েল

পাইথন আসলে 10 থেকে 100 পূর্ণসংখ্যায় সঞ্চয় করতে পারে?
আর্টুরো টরেস সানচেজ

7
@ আরতুরো টরেস সানচেজ হ্যাঁ, পাইথনে কোন আকারের উপরের সীমা নেই :)
ফ্লিপট্যাক

18

হাস্কেল, 28 বাইট

main=putStr$[1..10^100]>>"1"

স্ট্রিংয়ের 10 ^ 100 অনুলিপি সংযুক্ত করে "1"এবং এটি মুদ্রণ করে।


মুদ্রণ শুরুর আগে স্ট্রিং কনটেনটেশন করা হয়? যদি আমি মনে করি তবে এটি "4 গিগাবাইটের বেশি মেমরির" সম্পর্কে
নিয়ম ভাঙবে না

8
@ ডানিরো: হাস্কেলের আলস্য মুদ্রণ অবিলম্বে শুরু হওয়ার জন্য ধন্যবাদ। আমার কম্পিউটারে প্রোগ্রামটির 2MB মেমরির কম প্রয়োজন (রান টাইম সিস্টেম আরটিএস সহ)।
নিমি

কি s=[1..10^100]>>"1"একটি অনুমোদিত উত্তর বিন্যাস?
ব্যবহারকারী 253751

অসীম পূর্ণসংখ্যা? অন্যথায় এটি 10 ​​^ 100 এ পড়ে
লরেন পেচটেল

@ এমমিবিস: চ্যালেঞ্জটি বলে "মুদ্রণ", যার অর্থ সাধারণত "প্রিন্ট টু স্টাডাউট"। sআপনার উদাহরণ থেকে মুদ্রণ করে না - অথবা আপনি REPL ঘিরে ব্যবহার করেন 1সঙ্গে "। আমি অনুমান করি ঠিক putStr$[1..10^100]>>"1"না করেই ঠিক main=হয়ে যাবে তবে আমি একটি সম্পূর্ণ প্রোগ্রাম জমা দিতে চেয়েছিলাম।
নিমি

17

Brainfuck, 480 188 114 106 98 বাইট

এটি করা প্রয়োজন শুধু কারণ।

মোড়ক সহ 8-বিট সেল অনুমান করে। 250 255 এনএলইউ বাইট মুদ্রণ করে , যা 10 100 গুণ 10 155 গুণ 25 255 নুল বাইট হয়।

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

ব্যাখ্যা:

>>>>>> কাজের জায়গাটি কিছুটা রেখে দিতে হবে।

- 255 উত্পাদন করে।

[[->>>+<<<]------>>>-] এটিকে এমন 250 টি মানের 255 অনুলিপিগুলিতে পরিণত করে, এমন টেপ দেয় যা দেখে মনে হয়:

0 0 0 0 0 0 250 0 0 250 0 0 ... 250 0 0 [0]

<<<[<<<]+ ডেটা পয়েন্টারটি পিছনে সরিয়ে দেয় এবং প্রাথমিক ডেটা শেষ করে:

0 0 0 [1] 0 0 250 0 0 250 0 0 ...

তারপরে লুপটি আসে: [+...-]শুরুতে 1 টি 2 থেকে 2 সেট করে যা লুপের শেষে 1 এ ফিরে আসে। লুপটি ইতিমধ্যে 2 থেকে 1 সেট করলে লুপটি সমাপ্ত হয়।

এখন, সংখ্যা 250 2 250 250 250 ... 250 একটি বেস প্রতিনিধিত্ব করে 250 বেস, প্রতিটি প্রতিনিধিত্ব করে যে সংখ্যাটি এটি প্রতিনিধিত্ব করে তার চেয়ে বড় এক সঙ্গে।

  • [>>>]<<<সমস্ত পথে ডান দিকে সরান। যেহেতু প্রতিটি অঙ্ক একটি শূন্য-সংখ্যা দ্বারা প্রতিনিধিত্ব করা হয়, এটি তুচ্ছ।

  • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-কাউন্টারটি হ্রাস করে ১. শেষ অঙ্ক দিয়ে শুরু করে: সংখ্যাটি হ্রাস পায়। যদি এটি ইতিবাচক থেকে যায়, আমরা শেষ করেছি। যদি এটি শূন্যে পরিণত হয়, এটি 250 এ সেট করুন এবং আগে অঙ্কটি দিয়ে চালিয়ে যান।

  • [<<<].>>>বাম-সর্বাধিক অঙ্কের আগে পয়েন্টারটি পিছনে সরিয়ে দেয়, এবং এটি একটি NUL বাইট মুদ্রণের জন্য একটি দুর্দান্ত মুহূর্ত। তারপরে সঠিকভাবে বাম-সর্বাধিক অঙ্কে পুনরায় অবস্থান করুন, দেখুন আমাদের কাজ শেষ হয়েছে কিনা।

শুদ্ধি যাচাই করতে প্রাথমিক পরিবর্তন করেন, -করতে +250 প্রিন্ট করতে 1 , NUL বাইট ++250 জন্য 2 , ইত্যাদি


16

সি, 51 বাইট

ফাংশনটি g()পুনরাবৃত্ত ফাংশনকে f()গভীরতার 99 তে কল করে ।

এর মধ্যে f()এবং g()স্পষ্টতার জন্য যুক্ত হওয়া অপ্রয়োজনীয় নিউলাইনকে বাদ দেয় ।

f(n,i){for(i=10;i--;)n?f(n-1):puts("");}
g(){f(99);}

//call like this
main(){g();}

1E100 নিউলাইনগুলি মুদ্রণ করে।

সি এর সমস্ত সংস্করণে কাজ করার গ্যারান্টিযুক্ত না iহওয়ার দ্বিতীয় প্যারামিটার হিসাবে ঘোষণা f()আমার নিজের মেশিনে পরীক্ষিত (সাইগউইনের উপর জিসিসি) এবং আইডোন.কম (আমি বিশ্বাস করি তারা জিসিসিও চালায়) তবে স্পষ্টতই (99) পর্যন্ত নয় কারণ কী!


1
এটি কি 4 জিবিবি মেমরির সীমা মেনে চলে?
ডেনিস

3
@ ডেনিস এটি করা উচিত, এটি কেবল স্ট্যাকের উপর f, n এবং i এর গভীরতার 99 পুনরাবৃত্তি সঞ্চয় করে, সি 100 টি সংখ্যার দশমিক সংখ্যা হ্যান্ডেল করতে পারে না এই বিষয়টি প্রায় কাছাকাছি। আমি f()প্রায় 1980 বাইট প্রতিটি উদাহরণের জন্য প্রায় 20 বাইটের অনুমান করব । putsAPI- এ নতুন লাইন ডাম্প এবং API আউটপুট উচিত এবং প্রয়োজনীয় হিসাবে বাফার ফ্লাশ।
স্তর নদী সেন্ট

3
এটি স্থানীয়ভাবে পরীক্ষিত হয়েছে এবং মেমরির ব্যবহার এমনকি 1 এমআইবি ছাড়িয়ে যায় না।
ডেনিস

সি এর সমস্ত সংস্করণে কাজ করার গ্যারান্টিযুক্ত না (এফ) এর দ্বিতীয় প্যারামিটার হিসাবে i এর ঘোষণা : এটি স্ট্যাক-আরগস কলিং কনভেনশন দিয়ে ভেঙে যেতে পারে যেখানে কলি স্ট্যাকটি থেকে আর্গগুলি পপ করে (বা যদি fস্থানটি স্ট্যাক করতে লিখেন যে কলার ছিল না এটি আশা করে না)। ঝাঁকুনি "'চ' 'তে ডাকে খুব কম আর্গুমেন্ট' সম্পর্কে সতর্ক করে -std=c89এবং বলে -std=c99, সুতরাং সংজ্ঞাটি একটি নির্দিষ্ট সংখ্যক আরোগুলির সাহায্যে ঘোষণা হিসাবে কাজ করে। তবে আমি ভুলে যাই; আমি মনে করি এর অর্থ এই হতে পারে যে সংকলকটি জানে যে ফাংশনটি 2 টি আর্গের প্রত্যাশা করে এবং সর্বদা ২ য় আর্গের জন্য স্থান ছেড়ে যায়।
পিটার কর্ডস

1
@ ফ্যালিক্সডমব্যাক সম্প্রদায়টি কিছুক্ষণ আগে সিদ্ধান্ত নিয়েছে যে "প্রোগ্রাম" এর অর্থ আপনি "প্রোগ্রাম পুরোপুরি" স্পষ্টভাবে নির্দিষ্ট না করা পর্যন্ত আপনি কোনও প্রোগ্রাম বা ফাংশন লিখতে পারবেন। meta.codegolf.stackexchange.com/a/6912/15599 । সুতরাং আমার জমা gএবং এর সহায়ক ফাংশন অন্তর্ভুক্ত fmainদীর্ঘ হবে। আপনি যদি কিছু দেখেন তবে এখানে আরও কয়েকটি ফাংশন জমা রয়েছে।
স্তর নদী সেন্ট

14

কমোডোর ভিআইসি 20 মেশিন কোড (40 বাইট)

... এখানে হেক্সাডেসিমাল হিসাবে দেখানো হয়েছে:

1040   A9[64]A2 00 9D 68 10 E8  E0[32]D0 F8 A9 00 9D 68
1050   10 A9[31]20 D2 FF A2 00  A9[64]DE 68 10 30 08 D0
1060   F0 9D 68 10 E8 D0 F3 60

(ব্যবহার শুরু হয়েছে SYS 4160:)

বন্ধনী মধ্যে বাইট অর্থ

  • 0x64 (দুইবার ঘটে) হ'ল বেস (100); (2 থেকে 127 পর্যন্ত মানগুলি কাজ করা উচিত)
  • 0x32 হ'ল (50) (কোনও শূন্যের মান (1-255) কাজ করা উচিত)
  • দ্রষ্টব্য যে 100 ^ 50 = 10 ^ 100; 100 ^ 50 বার প্রোগ্রামটি চালানো 10 ^ 100 বার করার চেয়ে বেশি র‍্যাম দক্ষ efficient
  • 0x31 মুদ্রিত হওয়া ASCII অক্ষর printed

এবং কোনও পর্যায়ে 4 জি বি এর বেশি মেমরির প্রয়োজন হবে না।

এটি কি টাইপিংয়ের ভুল?

আমরা 1981 সাল আছে।

একটি সাধারণ হোম কম্পিউটারে 1 থেকে 16 কে বি র‌্যাম থাকে! এবং আপনি খুব কমই পেশাদার মডেলগুলি পাবেন যেগুলির 1 এম বি বা তার বেশি রয়েছে।

(ঠিক আছে। একটি রসিকতা।)

অন্য কথায়, প্রোগ্রামটি আপনার কম্পিউটারে চালিয়ে নীতিগতভাবে পরীক্ষাযোগ্য হওয়া উচিত। তবে এই সংখ্যার ব্যাপ্তির কারণে আপনি প্রমাণ করতে পারবেন যে স্ট্রিংয়ের অনুলিপিগুলির ফলাফলটি হ'ল 10 ^ 100 এবং পরে প্রোগ্রামটি থেমে যায়।

প্রোগ্রামটি অন্যান্য ঘাঁটি এবং ঘাঁটিঘাঁটিগুলির সাথে পরীক্ষা করা হয়েছে। আমার সন্দেহ নেই যে এটি 100 এবং 50 দিয়ে কাজ করবে।

কমপক্ষে এটি এই সংখ্যার সাথে ক্রাশ হয় না (তবে পরিমাপযোগ্য সময়ে শেষ হয় না)।

মেমরির আকার 50 এবং 100 এর বেস্টের জন্য যথেষ্ট 127 এর চেয়ে কম তাই 100 এর বেসটি কোনও সমস্যা হওয়া উচিত নয়।

প্রাথমিক ধারণা

একটি 50-সংখ্যার কাউন্টার রয়েছে যা 100-সিস্টেমে গণনা করা হয়। বাইটস 0x01-0x64 0-99 অঙ্কের প্রতিনিধিত্ব করে। কাউন্টারে প্রথম বাইটটি সর্বনিম্ন অঙ্ক digit কাউন্টারে সর্বশেষ বাইট (সর্বোচ্চ সংখ্যা) 0x00 মান সহ একটি বাইট অনুসরণ করে।

কাউন্টারটির প্রাথমিক মান 100 ^ 50 রয়েছে।

একটি বহিরাগত লুপ "বর্তমান চ্যানেল" (আধুনিক সিস্টেমে "স্ট্যান্ডার্ড আউটপুট"; সাধারণত পর্দা) একটি বাইট লিখছে এবং তারপরে কাউন্টারটি হ্রাস করে।

হ্রাস হ্রাস একটি অভ্যন্তরীণ লুপ দ্বারা সম্পন্ন হয়: এটি একটি ডিজিট হ্রাস পায় এবং একটি আন্ডারফ্রোলের ক্ষেত্রে 1 থেকে 99 পর্যন্ত পরবর্তী অঙ্কে অগ্রসর হয়। কাউন্টার শেষে 0x00 বাইট হ্রাস পেলে প্রোগ্রামটি বন্ধ হয়ে যায়।

সমাবেশ কোড হয়

    ; Some constants
    base=10
    exponent=100
    character=0x32

    ; Initialize the content of the counter to 100^50
    ; (Fill the first 50 bytes with the value 100)
    lda  #base
    ldx  #0
initLoop:
    sta  counter,x
    inx
    cpx  #exponent
    bne  initLoop
    ; (The terminating 0 at the end of the counter)
    lda  #0
    sta  counter,x

    ; Now do the actual job
outerLoop:
    ; Output a character
    lda  #character
    jsr  (0xFFD2)
    ; Prepare for the inner loop
    ldx  #0
    lda  #base
innerLoop:
    ; Decrement one digit
    dec  counter,x
    ; Result is negative -> must have been the terminating
    ; NUL byte -> Exit
    bmi  progEnd
    ; Result is not zero -> Print the next byte
    bne  outerLoop
    ; Result is zero -> Was 0x01 before -> As 0x01 represents
    ; digit 0 this is an underflow -> set the digit to
    ; "exponent" (100) again (which represents digit 99)
    sta  counter,x
    ; Go to the next digit and...
    inx
    ; ... repeat the inner loop (decrement next digit)
    ; (Note that this conditional branch is ALWAYS taken)
    bne  innerLoop

progEnd:
    rts

counter:
    ; The memory used by the counter is here...

সম্পাদনা

প্রোগ্রামটি কমোডোর সি 64 তেও চলে!


আমি আমার x86-64 মেশিন-কোড প্রয়োগের জন্য @ লেভেলরিভারস্টের পুনরাবৃত্তি ধারণা ধার নিয়েছি , 30 বি তে এসেছি (মুদ্রণের জন্য লাইব্যাক থেকে পুটচার ব্যবহার করে)। আমি একটি বর্ধিত-নির্ভুলতা লুপ কাউন্টার হিসাবে বিবেচনা করেছি এবং এটি x86 এও কাজ করবে। (এবং একইভাবে বেশ সস্তাভাবে সূচনা করা যেতে পারে)। সম্ভবত আমি এটি কিছু সময় চেষ্টা করব ...
পিটার কর্ডেস

1
এলওএল বাহ, আমি .... <গল্ফ তালি> ... আমি 6502 আসলটি দেখিনি ... ভাল, অনেক দিন।
অ্যালেক্স হাওয়ানস্কি

12

নোড, 89 বাইট

for(i="0".repeat(100)+1;+i;i=i.replace(/0*./,x=>"9".repeat(x.length-1)+~-x))console.log()

আউটপুটস 100 100 নতুন লাইন। (তাত্ত্বিকভাবে, এটি; পরিবর্তে 10 1 নিউলাইনগুলিকে আউটপুট প্রতিস্থাপনের 100মাধ্যমে পরীক্ষা করুন ))1

এটি iস্ট্রিং এ সেট করে কাজ করে

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 শূন্য এবং একটি 1; একটি গুগল বিপরীত), তারপরে বারবার "1 টি বিয়োগ করে" একটি রেজেক্স প্রতিস্থাপন করে এবং স্ট্রিং সমস্ত শূন্য না হওয়া পর্যন্ত একটি নতুন লাইন আউটপুট দেয়।

সি ++ উত্তরের একটি বন্দরটি 49 বাইট হবে:

(f=n=>{for(i=10;i--;)n?f(n-1):console.log()})(99)

1
এই প্রতিভা! হয় বা আপনি রেটিনার বিশেষজ্ঞ, যা অগত্যা "প্রতিভা" বাতিল করে না ...
প্যাট্রিক রবার্টস

7

05 এ বি 1 ই , 6 বাইট

Tn°F1?

ব্যাখ্যা

Tn°    # push 10^100
   F   # 10^100 times do
    1? # print 1

5
@ মার্টিনরোসেনৌ: সৌভাগ্যক্রমে 05 এ বি 1 ই অজগর 3 পূর্ণসংখ্যার ব্যবহার করে যার সীমা নেই।
Emigna

1
@ জানডভোরাক: পাইথন 3 ডক্স অনুসারে পূর্ণসংখ্যার মানটির আর সীমা নেই
এমিগানা

1
@ জনডভোরাক: সত্যই। আমি ইস্যু ছাড়াই বেশ কয়েকটি বড় সংখ্যা ব্যবহার করেছি (যদিও এটি বড় নয়)। আমাদের কেবল এখানে 1e100 হ্যান্ডেল করা দরকার যদিও অজগর অবশ্যই এটি পরিচালনা করতে পারে :)
এমিগানা

1
@ জনডভোরাক পাইথন পূর্ণসংখ্যার সর্বাধিক আকার সম্পূর্ণ উপলব্ধ মেমরির পরিমাণের উপর নির্ভর করে।
মেগো

4
লম্বা সংখ্যা অবলম্বনের চেষ্টা করার আগে আমি সীমাতে পৌঁছেছি। আমি যে মেশিনটি ব্যবহার করছিলাম এটি পূর্ণসংখ্যার ওভারফ্লো হওয়ার আগে 10 ^ 3000 এর চেয়ে বড় সংখ্যাগুলি পরিচালনা করতে সক্ষম হয়েছিল।
4:54 এ ফল ফলবান

6

রুবি, 20 বাইট

(10**100).times{p 1}

মুদ্রণগুলি 1 এর পরে একটি নিউলাইন 1E100 বার।

1E100 এটি যেমন কোনও ফ্লোটকে মূল্যায়ণ করে তেমন কাজ করে না, একটি স্বেচ্ছাসেবী নির্ভুল পূর্ণসংখ্যা নয়।


আপনি বন্ধনী সরাতে পারেন?
OldBunny2800

1
@ ওল্ডবুনি ২৮০০ নং পদ্ধতি অপারেটরদের তুলনায় অগ্রাধিকার গ্রহণ করে, সুতরাং এটি ব্যাখ্যা করা হবে10**(100.times{p 1})
লেভেল রিভার সেন্ট

1
যারা কৌতূহলী তাদের জন্য 1E100.to_iআমার কম্পিউটারে 10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104 এ মূল্যায়ন করেছেন।
অ্যান্ড্রু গ্রিম

6

/// , 36 ASCII অক্ষর (4 স্বতন্ত্র)

/t./.ttttt//.t/t\..........//t//t...

আউটপুট করে .চরিত্র 3 * 10 ^ 125 বার, যার মানে হল এটি 3 * 10 ^ 25 পুনরাবৃত্তির গঠিত স্ট্রিং আউটপুট .চরিত্র, 10 ^ 100 বার।

ব্যাখ্যা:

  1. /t./.ttttt/: বাকি সমস্ত প্রোগ্রামের t.সাথে প্রতিস্থাপন করুন .ttttt, কোনও নজির না t.থাকার আগ পর্যন্ত পুনরাবৃত্তি করুন । এটি 125 এস দ্বারা প্রতিস্থাপিত t...হয় ।...t
  2. /.t/t\........../: বাকি সমস্ত প্রোগ্রামের .tসাথে প্রতিস্থাপন করুন t.........., কোনও নজির না .tথাকার আগ পর্যন্ত পুনরাবৃত্তি করুন । এটি ...অনুসরণ করে 125 tএস, এবং এটি 125 tসেকেন্ডে 10 occ 125 এর পরে ঘটবে ...
  3. /t//: বাকি সমস্ত অপসারণ করুন t
  4. t...: এটি 3 * 10 ^ 125 .এস এর সাথে প্রতিস্থাপিত হয় । তাদের আউটপুট।

এখন, 3 * 10 ^ 25 এর 10 ^ 100 পুনরাবৃত্তিগুলি আউটপুট করা কোনও ধরণের প্রতারণার মতো অনুভব করে। এই প্রোগ্রামটি .45 এএসসিআইআই অক্ষর ব্যবহার করে অক্ষরটিকে ঠিক 10 ^ 100 বার আউটপুট করে :

/T/tttttttttt//.t/t..........//t//.TTTTTTTTTT

এটির ব্যাখ্যা:

  1. /T/tttttttttt/: প্রতিস্থাপন Tসঙ্গে ttttttttttপ্রোগ্রাম বাকি সর্বত্র। এটি TTTTTTTTTT100 টি পুনরাবৃত্তির সাথে প্রতিস্থাপন করে t
  2. /.t/t........../: প্রতিস্থাপন .tসঙ্গে t..........প্রোগ্রাম বাকি সর্বত্র। এটি .100 ts এর পরে নেয় এবং এটি 100 into tএর পরে 10 ^ 100 .s এ পরিণত হয়।
  3. /t//: বাকি সমস্ত অপসারণ করুন t
  4. .TTTTTTTTTT: এটি 10 ​​^ 100 .এর সাথে প্রতিস্থাপিত হয় । তাদের আউটপুট।

অবশেষে, এখানে একটি আপোস প্রোগ্রাম রয়েছে, যা .40 টি অক্ষর ব্যবহার করে অক্ষরটিকে 2 * 10 ^ 100 বার আউটপুট করে :

/t./.tttttttttt//.t/t\..........//t//t..

6

বেফঞ্জ 93, 33 বাইট

1>01g0`#@!# _01v
d^.1 **52p10-1g<

দুর্ভাগ্যক্রমে, বেফুঞ্জের পাওয়ার ফাংশন নেই, সুতরাং সেই কোডের প্রায় সমস্তটিই আমার একটি পাওয়ার ফাংশন বাস্তবায়ন করে। আমি এখনও এই নিয়ে কাজ করছি।

ব্যাখ্যা:

1 > 01g 0` #@!# _ 01g 1- 01p 25** 1. v
d ^                                  <

1: 1উপরের বাম দিক দিয়ে শুরু করুন যাতে আমরা যখন গুণ করি তখন আমরা 0প্রতিবার না পাই ।

01g: অবস্থানটিতে চরিত্রটি পান (0, 1), যা dএটির, যার ASCII কোডটি 100।

0`: দেখুন (0, 1) এ সঞ্চিত মান 0 এর চেয়ে বড় কিনা; এই মান পরিবর্তন হবে।

#@!# _: !আমরা শেষ পদক্ষেপ (0 বা 1) থেকে প্রাপ্ত মানের সাথে যৌক্তিক নয় , যাতে এটি 1 হয়, এখন আমাদের 0 আছে, এবং আমরা নোট করি #যে আপনি কোডটিতে পরবর্তী অক্ষরটি এড়িয়ে যান।

01g 1- 01p: (0, 1) এ সঞ্চিত মানটি আবার নিন, এটি থেকে 1 টি বিয়োগ করুন এবং এই নতুন মানটি (0, 1) এ সঞ্চয় করুন

25**: স্ট্যাকের শীর্ষ মানেরটি 10 ​​দ্বারা গুণিত করুন

1.: 1প্রতিবার এই লুপগুলি মুদ্রণ করুন

1 গুগল বার মুদ্রিত (তত্ত্বের ভিত্তিতে) হয়, তবে এটি যে পৃষ্ঠায় আমি এটি পরীক্ষা করেছিলাম তা বন্ধ হয়ে যায়।

আপনি এখানে বেফুঞ্জ 93 কোড চালাতে পারেন । কোনও কারণে, স্ট্যাকের শীর্ষ মানটি 1.0000000000000006e+100কখন হওয়া উচিত 1.0e+100। আমি জানি না যে এটি 6কোথা থেকে এসেছিল তবে আমি মনে করি না এটি হওয়া উচিত এবং এটি কোনও গোলাকার ত্রুটি বা এর মতো কিছু হতে পারে।


4

এবিসিআর , 56 বাইট

++++++++++AAAAAAAAAA7a*A!(x4bBBBBBBBBBB7b+B@(xa(Ax5b(Box

ট্যুরিং টার্পিটগুলি মজাদার, বিশেষত যখন তাদের কাছে সহজ গুণ বা ব্যয় হয় না। অন্যদিকে, আমার কেবল তিনটি কাতারে দুটি ব্যবহার করার দরকার ছিল!

ব্যাখ্যা:

++++++++++                                             Set register to 10
          AAAAAAAAAA                                   Queue 10 to queue A 10 times
                    7a*A!(x                            Sum up all of queue A by:
                    7     x                             While the register is truthy:
                     a*                                 Dequeue two elements of A, sum them...
                       A                                ...and queue the result back to A.
                        !(                              If there's only one element left,
                                                        i.e. !(A.len - 1),
                                                        break from the loop.  A now has 100, our exponent.

                             4                        While A's front is truthy:
                              bBBBBBBBBBB              Clone the front of B 10 (our base) times.  (The first iteration fills it up with ten 1s)
                                         7b+B@(x       Sum up all of queue B like we did with A
                                                a(A    Decrement a (so that the loop actually ends. Runs 101 times like it should) x   

                                                       B now contains 10^100 only.

                                                   5b(B x   10^100 times:
                                                       o     print the front of queue A (0)

4

ব্যাচ, 574 242 বাইট

@echo off
set t=for /l %%a in (2,1,33554432)do call:
set f=for /l %%a in (2,1,9765625)do call:
%t%a
:a
%t%b
:b
%t%c
:c
%t%d
:d
%f%e
:e
%f%f
:f
%f%g
:g
%f%h
:h
%f%i
:i
%f%j
:j
%f%k
:k
%f%l
:l
%f%m
:m
%f%n
:n
echo

প্রতিটি লুপ পড়ে তাই অতিরিক্ত পুনরাবৃত্তি চালিয়ে। 32-বিট পূর্ণসংখ্যার সীমাটির কারণে লুপগুলি ~ 2³² এ সীমাবদ্ধ। প্রথম চারটি লুপ প্রতিটি 2 count মোট 2 count হিসাবে গণনা করে বাকি দশটি লুপ প্রতিটি গণনা করে 5¹⁰ মোট 5¹⁰⁰ এর জন্য ¹⁰⁰

সম্পাদনা: @ কনরও'ব্রায়েনকে একটি অকল্পনীয় 58% ধন্যবাদ সংরক্ষণ করা হয়েছে।



1
@ কনরও'ব্রায়েন অপেক্ষা করুন, আপনি এটি করতে পারেন? আমার স্নাতকের!
নিল

4

টিআই-বেসিক, 20 বাইট

সহজবোধ্য। কেবলমাত্র আটটি লাইন একবারে প্রদর্শিত হয় এবং পূর্ববর্তী রেখাগুলি স্মৃতিতে থাকে না। ᴇ100অসমর্থিত কারণ , আমাদের এ থেকে লুপ -ᴇ99করতে হবে 9ᴇ99। তারপরে, যদি I!=0, স্ট্রিংটি প্রদর্শন করুন (যা, যাইহোক 3 হয়)। এইভাবে, আমরা একে একে ঠিক ᴇ100সময়ে মুদ্রণ করি ।

For(I,-ᴇ99,9ᴇ99:If I:Disp 3:End

আপনি কি নিশ্চিত যে পরিবর্তনশীল "আমি" 99 অঙ্কের সংরক্ষণের জন্য যথেষ্ট সঠিক?
মার্টিন রোজেনা

ঠিক আছে, হ্যাঁ, এটি ধরে রাখার জন্য আমার যথেষ্ট হওয়া উচিত, যদিও এটি "ডিস্ক" ব্যবহার করে কেবল 14 পর্যন্ত প্রদর্শিত হবে, তবে আমরা আসলে এটি আউটপুট দেই না, কেবল এটি শূন্যের সমান নয় কিনা তা পরীক্ষা করে দেখুন। এছাড়াও, আপনি প্রতীক সম্পর্কে ঠিক বলেছেন, কিন্তু আমি বুঝতে পেরেছিলাম যে আপনি কী বোঝাতে চেয়েছিলেন তা বুঝতে পারবেন। আমি এখন আমার পোস্টে এটি অনুলিপি করব।
টিমটেক

আমি অসীম পূর্ণসংখ্যার সাথে বেসিকের কোনও সংস্করণের মুখোমুখি হই নি তবে আপনার লুপটি প্রায় পর্যাপ্ত সময় কার্যকর করে না বলেও এটি গুরুত্বপূর্ণ নয়।
লরেন পেচটেল

1
হুম, এখানে অসীম পূর্ণসংখ্যা নেই। পূর্ণসংখ্যার অবশ্যই + -10 ^ 100 এর মধ্যে থাকতে হবে
টিমটেক

4

x86-64 মেশিন কোড ফাংশন, 30 বাইট।

@ লেভেল রিভার সেন্ট দ্বারা সি উত্তর হিসাবে একই পুনরাবৃত্তি যুক্তি ব্যবহার করে । (সর্বোচ্চ পুনরাবৃত্তির গভীরতা = 100)

puts(3)Libc থেকে ফাংশনটি ব্যবহার করে , যা সাধারণ এক্সিকিউটেবলের সাথে যে কোনওভাবে লিঙ্কযুক্ত। এটি x86-64 সিস্টেম ভি এবিআই ব্যবহার করে কল করা যায়, লিনাক্স বা ওএস এক্স-এর সি থেকে, এবং এটি মনে করা হয় না এমন কোনও রেজিস্টারগুলি ক্লোবার করে না।


objdump -drwC -Mintel আউটপুট, ব্যাখ্যা সহ মন্তব্য

0000000000400340 <g>:  ## wrapper function
  400340:       6a 64                   push   0x64
  400342:       5f                      pop    rdi       ; mov edi, 100  in 3 bytes instead of 5
  ; tailcall f by falling into it.

0000000000400343 <f>:  ## the recursive function
  400343:       ff cf                   dec    edi
  400345:       97                      xchg   edi,eax
  400346:       6a 0a                   push   0xa
  400348:       5f                      pop    rdi       ; mov edi, 10
  400349:       0f 8c d1 ff ff ff       jl     400320 <putchar>   # conditional tailcall
; if we don't tailcall, then eax=--n = arg for next recursion depth, and edi = 10 = '\n'

  40034f:       89 f9                   mov    ecx,edi   ; loop count = the ASCII code for newline; saves us one byte


0000000000400351 <f.loop>:
  400351:       50                      push   rax       ; save local state
  400352:       51                      push   rcx
  400353:       97                      xchg   edi,eax   ; arg goes in rdi
  400354:       e8 ea ff ff ff          call   400343 <f>
  400359:       59                      pop    rcx       ; and restore it after recursing
  40035a:       58                      pop    rax
  40035b:       e2 f4                   loop   400351 <f.loop>
  40035d:       c3                      ret    
# the function ends here

000000000040035e <_start>:

0x040035e - 0x0400340 = 30 bytes

# not counted: a caller that passes argc-1 to f() instead of calling g
000000000040035e <_start>:
  40035e:       8b 3c 24                mov    edi,DWORD PTR [rsp]
  400361:       ff cf                   dec    edi
  400363:       e8 db ff ff ff          call   400343 <f>
  400368:       e8 c3 ff ff ff          call   400330 <exit@plt>    # flush I/O buffers, which the _exit system call (eax=60) doesn't do.

দিয়ে নির্মিত yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o । আমি আসল এনএএসএম উত্সটি পোস্ট করতে পারি, তবে এএসএম নির্দেশাবলী যেহেতু বিচ্ছিন্নতার মধ্যে রয়েছে ঠিক তেমন বিশৃঙ্খলার মতো বলে মনে হয়েছিল।

putchar@pltএর থেকে 128 বাইটেরও কম দূরে jl, তাই আমি লাফের কাছে 6-বাইটের পরিবর্তে 2 বাইট শর্ট জাম্প ব্যবহার করতে পারতাম, তবে এটি কেবলমাত্র একটি ছোট্ট এক্সিকিউটেবলের ক্ষেত্রেই সত্য, বড় প্রোগ্রামের অংশ হিসাবে নয়। সুতরাং আমি মনে করি না যে আমি লিবিসির পুটগুলি বাস্তবায়নের আকারটি গণনা না করে ন্যায্যতা প্রমাণ করতে পারি যদি আমি এটিতে পৌঁছানোর জন্য একটি সংক্ষিপ্ত জেসিসি এনকোডিংয়েরও সুবিধা গ্রহণ করি।

পুনরাবৃত্তির প্রতিটি স্তরে 24 বি স্ট্যাক স্পেস ব্যবহার করা হয় (2 টি পুশ করে এবং ফিরে আসার ঠিকানা সিএলএল দ্বারা চালিত)। অন্য সমস্ত গভীরতা putcharস্ট্যাকের সাথে কল করবে কেবল 16 দ্বারা নয়, 8 দ্বারা প্রান্তিক, তাই এটি এবিআই লঙ্ঘন করে না। স্ট্যাকের এক্সএমজি রেজিস্টারগুলিকে ছড়িয়ে দেওয়ার জন্য সারিবদ্ধ স্টোর ব্যবহার করা একটি স্টিডিও বাস্তবায়ন ত্রুটিযুক্ত হবে। তবে গ্লিবিসি এটি putcharকরে না, সম্পূর্ণ বাফারিং সহ একটি পাইপে লিখন বা লাইন বাফারিং সহ একটি টার্মিনালে লিখিত। উবুন্টু 15.10 এ পরীক্ষা করা হয়েছে। .loopপুনরাবৃত্তির কল করার আগে স্ট্যাকটিকে আরও 8 দ্বারা অফসেট করতে, এটি একটি ডামি পুশ / পপ দিয়ে ঠিক করা যেতে পারে ।


প্রমাণ যে এটি নতুন লাইনের সঠিক সংখ্যাটি মুদ্রণ করে:

   # with a version that uses argc-1  (i.e. the shell's $i)  instead of a fixed 100
$ for i in {0..8}; do echo -n "$i: "; ./golf-googol $(seq $i) |wc -c; done
0: 1
1: 10
2: 100
3: 1000
4: 10000
5: 100000
6: 1000000
7: 10000000
8: 100000000
... output = 10^n newlines every time.

আমার এটির প্রথম সংস্করণটি 43 বি ছিল এবং puts()এটি 9 টি নতুন লাইন (এবং একটি সমাপ্তি 0 বাইট) এর বাফারে ব্যবহৃত হয়েছিল, সুতরাং পুটগুলি 10 তম সংযোজন করবে। এই পুনরাবৃত্তি বেস-কেস সি অনুপ্রেরণার আরও কাছাকাছি ছিল।

10 ^ 100 থেকে আলাদাভাবে ফ্যাক্টরিং করা বাফারটি সংক্ষিপ্ত করে দিতে পারে, সম্ভবত 4 টি নতুন লাইন, 5 বাইট সাশ্রয় করতে পারে, তবে পুটচার ব্যবহার এতদূর ভাল। এটির জন্য কেবল একটি পূর্ণসংখ্যার অর্গ প্রয়োজন, পয়েন্টার নয় এবং কোনও বাফার নেই। সি স্ট্যান্ডার্ড বাস্তবায়নের অনুমতি দেয় যেখানে এটি ম্যাক্রোর জন্য putc(val, stdout), তবে গ্লিবিসি-তে এটি একটি আসল ফাংশন হিসাবে উপস্থিত থাকে যা আপনি এসএমএস থেকে কল করতে পারেন।

10 এর পরিবর্তে কলটিতে কেবলমাত্র একটি নিউলাইন মুদ্রণ করার অর্থ হ'ল 10 নতুন লাইনের আরও একটি ফ্যাক্টর পেতে আমাদের পুনরাবৃত্তির সর্বোচ্চ গভীরতা 1 দ্বারা বাড়িয়ে নেওয়া দরকার। যেহেতু 99 এবং 100 উভয়ই সাইন-প্রসারিত 8-বিট তাত্ক্ষণিকভাবে প্রতিনিধিত্ব করতে পারে, push 100এখনও মাত্র 2 বাইট।

আরও ভাল, 10একটি রেজিস্টার থাকা একটি বাইট সংরক্ষণ করে একটি নতুন লাইন এবং লুপ কাউন্টার হিসাবে কাজ করে।

বাইটস সংরক্ষণের জন্য ধারণা

একটি 32-বিট সংস্করণটি একটি বাইট সংরক্ষণ করতে পারে dec edi, তবে স্ট্যাক-আরগস কলিং কনভেনশন (পুটচারের মতো লাইব্রেরি ফাংশনগুলির জন্য) লেজ-কলকে সহজেই কম করে তোলে এবং সম্ভবত আরও জায়গায় আরও বাইট লাগবে। আমি প্রাইভেটের জন্য একটি রেজিস্টার-আরগ কনভেনশন ব্যবহার করতে পারতাম f(), কেবলমাত্র তাকে ডেকে আনা হয়েছিল g()তবে আমি পুটচারকে টেল-কল করতে পারি না (কারণ চ () এবং পুতচর () আলাদা স্ট্যাক-আরগ নিতে পারে)।

কল করা অবস্থায় সংরক্ষণ / পুনরুদ্ধার না করে কল (চ) কলারের অবস্থা সংরক্ষণ করা সম্ভব হবে be এটি সম্ভবত সফল হয়, কারণ এটি সম্ভবত শাখার প্রতিটি দিকে পৃথকভাবে পেতে প্রয়োজন হবে, এবং টেলকেলিংয়ের সাথে সামঞ্জস্যপূর্ণ নয়। আমি চেষ্টা করেছিলাম কিন্তু কোনও সঞ্চয় পাইনি।

স্ট্যাকের উপর একটি লুপ কাউন্টার রাখা (লুপে আরসিএলকে ধাক্কা / পপ করার পরিবর্তে) কোনও উপকারে আসেনি। এটি যে সংস্করণটি রাখে তার সাথে এটি 1 বি আরও খারাপ ছিল এবং সম্ভবত এই সংস্করণটির সাথে আরও বেশি ক্ষতি হয়েছে যা আরসিএক্সকে আরও সস্তায় সেট করে।


2
সমাবেশের উত্তরের জন্য হুর! :)

4

পিএইচপি, 44 বাইট

for($i=bcpow(10,1e2);$i=bcsub($i,print 1););

এই স্নিপেট 1গুগল বার আউটপুট দেবে । এটি স্মৃতিশক্তি শেষ হবে না, তবে এটি মারাত্মক ধীর। আমি দীর্ঘ পূর্ণসংখ্যা পরিচালনা করতে সক্ষম হতে বিসিমাথ ব্যবহার করছি।

কিছুটা ভাল পারফর্মিং, তবে ছোট নয় (74 বাইট):

for($m=bcpow(10,100);$m;$m=bcsub($m,$a))echo str_repeat(a,$a=min(4e9,$m));

চিঠি aগুগল বার আউটপুট দেবে । এটি একবারে প্রায় 4e9 টি অক্ষরের আউটপুট করে প্রায় 4GB মেমরি গ্রহণ করবে consume


যদি কেবল একটি 'এ' প্রায় 4 গিগাবাইট নেয়, তবে 'আ' কী করবে? এটি আরও কোড নেবে তবে ob_flush () সহ; আপনি আরও অনেক কিছু এগিয়ে যেতে পারেন
মার্টিজন

আহ, এটি এক নয় a, এটি 4 * 10 ^ 9 aএস এর স্ট্রিং । আপনি যদি aসেখানে 3 বারের মতো 3 গুণ রাখেন তবে 4 জিবি ছাড়ার কোনও উপায় নেই। এটির সাথে ওব_ফ্লাশের কোনও সম্পর্ক নেই, দ্বিতীয় উদাহরণের মূল বিষয় হ'ল প্রতিটি বারে স্বল্প পরিমাণে অক্ষর আউটপুট না করে একবারে বড় স্ট্রিং আউটপুট করা, যার ফলস্বরূপ প্রোগ্রামটি আরও কিছুটা দ্রুত গতিতে চালিত হয়, আরও মেমরির ব্যবহার ব্যয় করে।
চকোচোস

যতদূর আমি জানি "> =" বড় পূর্ণসংখ্যার পরিচালনা করতে সক্ষম নয়, আপনার বিসিপি কম্পিউটার ব্যবহার করা উচিত
ক্রিপ্টো

আপনি সঠিক, স্ট্রিংগুলির সাথে তুলনা করার সময় এটি সঠিক ফলাফল দেয় না। আমি এক মিনিটের মধ্যে এটি ঠিক করব।
চকোচোস

কিছুটা ভিন্ন তবে কার্যক্ষম সমাধান সহ সম্পাদনা করুন :)
চকোচোস

3

হাস্কেল, 45 43 বাইট

r 0=[]
r i='1':r(i-1)
main=putStr.r$10^100

3

পাইকে, 6 5 বাইট

TTX^V

এখানে চেষ্টা করুন!

এটি আমার ব্রাউজারটিকে ক্র্যাশ করার সাথে সাথে অচিহ্নিত। প্রথম 4 টি অক্ষর 10 ^ 100 উত্পন্ন করে এবং Vএটি অনেকগুলি নতুন লাইনের মুদ্রণ করে। সঙ্গে পরীক্ষা 100V


3

রেকেট 36 বাইট

(for((i(expt 10 100)))(display "1"))

আউটপুট:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

3

জাইআইএসবিএল , 4 বাইট

˖Q

ক্রোম সমস্ত চিহ্নগুলি পড়তে পারে না এবং আমি অন্যান্য ব্রাউজারগুলি সম্পর্কে নিশ্চিত নই, সুতরাং এখানে একটি চিত্র রয়েছে:

ব্যাখ্যা:

# \# enable verbose parsing #\
10^100       \# [0] push 10^100 onto the stack #\
for          \# [1] start for loop #\
    space    \# [2] print a space #\

খুব সহজ .... কেবল একটি গুগল স্পেস প্রিন্ট করে। তিনটি নির্দেশনা, তবে গুগল ধ্রুবক দুটি বাইট।

(সংস্করণ 3.0.5 এ লিখিত)


এটি 6 ইউটিএফ -8 বাইট। আপনি কোন এনকোডিংটি ব্যবহার করছেন?
কনর ও'ব্রায়েন

"বাইটস" এর সাথে লিঙ্ক দেয় ...
সকরাটিক ফিনিক্স

গাহ, দুঃখিত। আমার কাছে একটি ব্যবহারকারীলিপি রয়েছে যা লিঙ্কগুলিকে নিয়মিত পাঠ্যের মতো করে তোলে।
কনর ও'ব্রায়েন

ওহ, আমি জানি না যে এটি সম্ভব ছিল, ঠিক আছে :)
সকরাটিক ফিনিক্স

@ কনরও'ব্রায়েন উম, কেন?
সাইওস

3

জাভাস্ক্রিপ্ট ES6, 85 83 বাইট

ETH প্রডাকশনগুলির জন্য 2 বাইট সংরক্ষণ করা!

eval([...Array(i=100)].map(_=>`for($${--i}=0;$${i}++<10;)`).join``+"console.log()")

এটি 1e100 নিউলাইনগুলি মুদ্রণ করে।

অভ্যন্তরীণ অংশটি এই প্রোগ্রামটি উত্পন্ন করে, যা পরে মূল্যায়ন করা হয়।

for($0=0;$0++<10;)for($1=0;$1++<10;)for($2=0;$2++<10;)for($3=0;$3++<10;)for($4=0;$4++<10;)for($5=0;$5++<10;)for($6=0;$6++<10;)for($7=0;$7++<10;)for($8=0;$8++<10;)for($9=0;$9++<10;)for($10=0;$10++<10;)for($11=0;$11++<10;)for($12=0;$12++<10;)for($13=0;$13++<10;)for($14=0;$14++<10;)for($15=0;$15++<10;)for($16=0;$16++<10;)for($17=0;$17++<10;)for($18=0;$18++<10;)for($19=0;$19++<10;)for($20=0;$20++<10;)for($21=0;$21++<10;)for($22=0;$22++<10;)for($23=0;$23++<10;)for($24=0;$24++<10;)for($25=0;$25++<10;)for($26=0;$26++<10;)for($27=0;$27++<10;)for($28=0;$28++<10;)for($29=0;$29++<10;)for($30=0;$30++<10;)for($31=0;$31++<10;)for($32=0;$32++<10;)for($33=0;$33++<10;)for($34=0;$34++<10;)for($35=0;$35++<10;)for($36=0;$36++<10;)for($37=0;$37++<10;)for($38=0;$38++<10;)for($39=0;$39++<10;)for($40=0;$40++<10;)for($41=0;$41++<10;)for($42=0;$42++<10;)for($43=0;$43++<10;)for($44=0;$44++<10;)for($45=0;$45++<10;)for($46=0;$46++<10;)for($47=0;$47++<10;)for($48=0;$48++<10;)for($49=0;$49++<10;)for($50=0;$50++<10;)for($51=0;$51++<10;)for($52=0;$52++<10;)for($53=0;$53++<10;)for($54=0;$54++<10;)for($55=0;$55++<10;)for($56=0;$56++<10;)for($57=0;$57++<10;)for($58=0;$58++<10;)for($59=0;$59++<10;)for($60=0;$60++<10;)for($61=0;$61++<10;)for($62=0;$62++<10;)for($63=0;$63++<10;)for($64=0;$64++<10;)for($65=0;$65++<10;)for($66=0;$66++<10;)for($67=0;$67++<10;)for($68=0;$68++<10;)for($69=0;$69++<10;)for($70=0;$70++<10;)for($71=0;$71++<10;)for($72=0;$72++<10;)for($73=0;$73++<10;)for($74=0;$74++<10;)for($75=0;$75++<10;)for($76=0;$76++<10;)for($77=0;$77++<10;)for($78=0;$78++<10;)for($79=0;$79++<10;)for($80=0;$80++<10;)for($81=0;$81++<10;)for($82=0;$82++<10;)for($83=0;$83++<10;)for($84=0;$84++<10;)for($85=0;$85++<10;)for($86=0;$86++<10;)for($87=0;$87++<10;)for($88=0;$88++<10;)for($89=0;$89++<10;)for($90=0;$90++<10;)for($91=0;$91++<10;)for($92=0;$92++<10;)for($93=0;$93++<10;)for($94=0;$94++<10;)for($95=0;$95++<10;)for($96=0;$96++<10;)for($97=0;$97++<10;)for($98=0;$98++<10;)for($99=0;$99++<10;)console.log()

এখন, সঠিকতার প্রমাণের জন্য, আমরা কিছু অন্তর্ভুক্তি ব্যবহার করব। এর অন্যান্য মানের জন্য প্রাথমিক 100 প্রতিস্থাপন, জেনেরিক যাক এন । আমি দাবী করে যে ঢোকাতে এন 10 সমর্পণ করা হবে এন নতুন লাইন। আসুন এর ফলাফলটি পাইপ করুন wc -l, যা ইনপুটটিতে নতুন লাইনের সংখ্যা গণনা করে। আমরা এই পরিবর্তিত কিন্তু সমতুল্য স্ক্রিপ্ট যে ইনপুট নেয় ব্যবহার করব এন :

eval([...Array(+process.argv[2])].map(_=>`for($${i}=0;$${i++}++<10;)`,i=0).join``+"console.log()")

এখন, এখানে কিছু আউটপুট:

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1 | wc -l
10

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 2 | wc -l
100

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 3 | wc -l
1000

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 4 | wc -l
10000

আমরা দেখতে পারি যে, এই রূপান্তরিত ইনপুট এন 10 ছোট মানের জন্য এন নতুন লাইন।

এখানে এন = 1 এর একটি উদাহরণ আউটপুট :

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1











C:\Users\Conor O'Brien\Documents\Programming
λ

খুশী হলাম। একটি দম্পতি বাইট সংরক্ষণ করুনeval([...Array(i=100)].map(_=>`for($${--i}=0;$${i}++<10;)`).join``+"console.log()")
ETH প্রোডাকশনগুলি

@ ইথ প্রডাকশন ধন্যবাদ! : ডি
কনর ও'ব্রায়েন

PS আমি 83 বাইট গণনা করি;)
ETH প্রোডাকশনগুলি

এখানে আরও একটি উদাহরণ । এটি অন্য কারও কাছে উপকারী কিনা তা নিশ্চিত নই, তবে আমি কীভাবে এটি কাজ করতে এবং খোলার সুবিধার জন্য একটি মোড়ক ফাংশনটি কীভাবে রচনা করেছি তা নিশ্চিত ছিলাম না। আপনি প্রোগ্রামটি 10 ​​^ n তে গণনা করে পরিষ্কারভাবে দেখতে পাবেন, যেখানে এনটি লুপের মূল্যায়ন। আমি একটি রিটার্ন শর্ত সেট করেছি তাই এটি গুগলের আগে ভালভাবে ভেঙে যায়; বিভিন্ন লুপ স্তরের মাধ্যমে গণনা করতে সেই অবস্থাতে ব্যবহৃত চলকটি পরিবর্তন করুন। এছাড়াও, একটি নিটপিক: আপনার দ্বিতীয় কোডের নমুনাটি বাইরের লুপটি 0 ডলার হিসাবে দেখায়, নীচে $ 99 এ চলেছে; এটি বিপরীত হওয়া উচিত, $ 99 এর বাহ্যিক লুপ হওয়া।
মাইকেলস

@ মিশেলস সত্য পরের সুযোগটি আমি এটি পরিবর্তন করব।
কনর ও'ব্রায়েন

3

গণিত, 48 30 25 বাইট by

For[n=1,n++<Echo@1*^100,]

আউটপুট:

>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
etc.

এখনই পরীক্ষা করা যায় না, তবে কেমন For[n=0,n++<10^100,Echo[]]?
মার্টিন ইন্ডার

আমি >>আউটপুট এর নেতৃস্থানীয় অংশ বিবেচনা করব । আপনি Echoকনসোলে ব্যবহার করলে সেগুলি মুদ্রিত হয় ।
মার্টিন ইন্ডার

@ মার্টিনইেন্ডার ওফস, ফিক্সড
লেজিওনম্যামাল 978

Echo@0&~Array~10^100;21 বাইট জন্য কিভাবে ?
গ্রেগ মার্টিন

3

ফোর্টরান 95, ফ্রি-ফর্ম, রিকার্সিভ, 117 বাইট

Program M
Call R(99)
END
Recursive Subroutine R(L)
IF(L)3,1,1
1 DO 2 I=1,10
2 Call R(L-1)
RETURN
3 PRINT*,0
END

সমন্বিত লাইনগুলির একটি গুগল মুদ্রণ করে

          0

ফোর্টরান 90, রিকার্সিভ, 149 বাইট

     CallR(99)
     END
     RecursiveSubroutineR(L)
     IF(L)3,1,1
   1 DO2I=1,10
   2 CallR(L-1)
     RETURN
   3 PRINT*,0
     END     

পুনরাবৃত্তভাবে 100 টি নেস্টেড লুপগুলিতে কল করা, প্রতিটি 10 ​​টি পুনরাবৃত্তি, ঠিক একটি গুগল করে। এন, এল এবং লুপের কাউন্টারগুলি সমস্ত বাইট-আকারের পূর্ণসংখ্যায় ফিট করে।

99 কে 1, 2, 3, 4, 5 দিয়ে প্রতিস্থাপন করে পরীক্ষিত হয়েছে যে প্রতিটি ক্ষেত্রে "ডাব্লুসি" থেকে ফলাফলের রেখার গণনাতে এন + 1 জিরো রয়েছে।

ফোর্টরান II, IV, 66 বা 77, 231 বাইট:

      N=2*10**9
      DO1I0=1,5**10
      DO1I=1,N
      DO1J=1,N
      DO1K=1,N
      DO1L=1,N
      DO1M=1,N
      DO1I1=1,N
      DO1J1=1,N
      DO1K1=1,N
      DO1L1=1,N
      DO1M1=1,N
1     PRINT2
2     FORMAT(X)
      END

নতুন লাইনের একটি গুগল মুদ্রণ করে।

এই সমস্ত প্রোগ্রাম 32-বিট মেশিনে চলবে; আসলে, পুনরাবৃত্তি সংস্করণগুলি 16 বিট মেশিনে ঠিক কাজ করবে just একটি 60 টি-বিট পূর্ণসংখ্যার সাথে পুরানো ক্রেটিতে চালিয়ে ব্রুট-ফোর্স সংস্করণে কেউ কম লুপ ব্যবহার করতে পারে। এখানে, 5 ^ 10 (9765625) এর একটি লুপের মধ্যে 2 * 10 ^ 9 এর দশটি নেস্ট করা লুপগুলি 10 ^ 100 মোট পুনরাবৃত্তির সমান।

সংস্করণগুলির কোনওটিই নিজের অবজেক্ট কোড, কাউন্টারগুলি, আউটপুট স্ট্রিংয়ের একটি অনুলিপি এবং পুনরাবৃত্ত সংস্করণে একটি 100-স্তরের রিটার্ন স্ট্যাক ছাড়া অন্য কোনও কথা বলতে মেমরি ব্যবহার করে না।

তুলনা করে কারণগুলি পরীক্ষা করুন

bc<<<2000000000\^10*5\^10
bc<<<10\^100

3

টুরিং মেশিন সিমুলেটর, 1082 বাইট

0 * 6 r 1
1 * E r 2
2 * C r 3
3 * 1 r 4
4 * B r 5
5 * C r 6
6 * F r 7
7 * 4 r 8
8 * 6 r 9
9 * 8 r A
A * 8 r B
B * 3 r C
C * 0 r D
D * 9 r E
E * G r F
F * H r G
G * 8 r H
H * 0 r I
I * 6 r J
J * H r K
K * 9 r L
L * 3 r M
M * 2 r N
N * A r O
O * D r P
P * C r Q
Q * C r R
R * 4 r S
S * 4 r T
T * E r U
U * E r V
V * G r W
W * 6 r X
X * D r Y
Y * E r Z
Z * 0 r a
a * F r b
b * E r c
c * 9 r d
d * F r e
e * A r f
f * H r g
g * D r h
h * E r i
i * 6 r j
j * 6 r k
k * D r l
l * G r m
m * H r n
n * 1 r o
o * 0 r p
p * 8 r q
q * C r r
r * 9 r s
s * G r t
t * 3 r u
u * 6 r v
v * 2 r w
w * 3 r x
x * E r y
y * 0 r z
z * 4 r +
+ * 5 r /
/ * A r =
= * 0 r -
- * H r \
\ * 7 r !
! * A r @
@ * 9 r #
# * 5 r $
$ * A r %
% * B r ^
^ * 5 r &
& * 9 r ?
? * 4 r (
( * C r )
) * E r `
` * 9 r ~
~ * 9 r _
_ * A * .
. 0 I l *
. 1 0 r <
. 2 1 r <
. 3 2 r <
. 4 3 r <
. 5 4 r <
. 6 5 r <
. 7 6 r <
. 8 7 r <
. 9 8 r <
. A 9 r <
. B A r <
. C B r <
. D C r <
. E D r <
. F E r <
. G F r <
. H G r <
. I H r <
. _ * r ]
< _ * r >
< * * r *
> _ = l [
> * * r *
[ _ * l .
[ * * l *
] _ * * halt
] * _ r *

টুরিং মেশিন সিমুলেটর

আমি জানি না যে এটি সঠিক আউটপুট হিসাবে গণ্য হয়েছে, যেহেতু এটির 82 টি শীর্ষস্থান রয়েছে।

আমি জানি না যে এটি 4 জিবি সীমাটি সম্মান করে, তাই, যদি এটি না ঘটে তবে এটি অ-প্রতিযোগিতামূলক এবং কেবল শো-শো-এর জন্য। আউটপুটটি 1e100 বাইট, যাতে মেমরি বাইট গণনা থেকে কেটে নেওয়া উচিত। চূড়ান্ত বাইট গণনাটি 82 বাইট।

এখানে একটি ব্যাখ্যা:

কোডের প্রথম 80 টি লাইনগুলি 80 টি বিভিন্ন রাজ্য যা বেস -19 1 লুপ কাউন্ট তৈরি করে 6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A

পরবর্তী 19 টি লাইনের কোডটি কাউন্টার রাজ্য, যা প্রতিবার কোনও অক্ষর মুদ্রণের সময় গণনা হ্রাস করে।

পরবর্তী 6 টি লাইন মুদ্রক রাষ্ট্র, যা একটি যুক্ত করে =

অবশেষে, শেষ 2 লাইনগুলি ক্লিনার রাষ্ট্র, যা কেবলমাত্র আউটপুট রয়েছে তা নিশ্চিত করার জন্য প্রয়োজনীয় =====...=====। শীর্ষস্থানীয় / পিছনের স্থানগুলি আউটপুট হিসাবে গণনা করে না, কারণ তারা অনিবার্য পার্শ্ব-প্রতিক্রিয়া।

প্রোগ্রামটি তখন থামে।

1 আমি এটির জন্য গণিত করেছি।


2

পাইথ, 7 বাইট

নতুন (প্রতিযোগিতা)

V^T*TTG

ব্যাখ্যা

G=The alphabet
Repeat 10^(10*10) times
    print(G)

পুরাতন (বিনা প্রতিযোগিতা) 7 বাইট

*G^T*TT

ব্যাখ্যা

G=The alphabet
G*(10^(10*10))==G*10^100

1
এটি 4 জিবিবি রিমরি সীমা মেনে চলে না।
ডেনিস

@Dennis আমি এটি সংশোধন করা হয়েছে
স্প্যামবিশিষ্ট - Dignissimus

একটি গল্ফিং পরামর্শ নয়, তবে আমি মনে করি না যে *TTসমভূমির চেয়ে কোনও খাটো 100
এরিক আউটগল্ফার

2

পাইথন 3, 32 বাইট

for i in range(10**100):print()

বিকল্প সমাধান, 33 বাইট:

[print()for i in range(10**100)]

পাইথন 2 এ এটি একটি বিশেষ দুর্দান্ত উত্তর।

1
এতটা নয়, @ লেলেবিক। পাইথন 2 এ, range(10**100)সংখ্যার একটি তালিকা তৈরি করে [1, 2, 3, 4, ...], যার ফলস্বরূপ OverflowError: range() result has too many items। এটি xrange()পরিবর্তে কল করার সাথে পাইথন 2 এ কাজ করবে এবং পাইথন 3 এ কাজ করবে যেহেতু xrange()নাম পরিবর্তন করে দেওয়া হয়েছিল range(), এবং range()যে তালিকাটি উত্পন্ন হয়েছে তার মূলটিকে অবমুক্ত করা হয়েছিল।
জেমস মার্ফি

2
@ জেমস মুরফাইব হ্যাঁ আমি এটি জানি। আমি কোডগল্ফ উত্তরগুলির নিষ্ক্রিয়তা সম্পর্কে মজার হওয়ার চেষ্টা করছিলাম।

1
দুঃখিত। আমার অনেকগুলি এসই মন্তব্যে হাস্যরস পড়তে সমস্যা হচ্ছে।
জেমস মার্ফি

2

জাভা, 198 179 155 বাইট

import java.math.*;class a{void A(a[]x){for(BigInteger b=BigInteger.ZERO;!(b=b.add(BigInteger.ONE)).equals(BigInteger.TEN.pow(100));)System.out.print(x);}}

ছাপে ( x== null? null: একটি স্ট্রিং, যাতে দিয়ে শুরু হয় [La;@বা ওই জাতীয় কিছু) 10 100 হে মধ্যে বার (চিরতরে) সময়।


3
আপনার একটি আছে class, তবে কোনও public static void main(String[]a)পদ্ধতি নেই। গল্ফিং টিপস হিসাবে: আপনি প্রতিস্থাপন করতে পারেন new BigInteger("0"), new BigInteger("1")এবং new BigInteger("10")সাথে BigInteger.ZERO, BigInteger.ONEএবং BigInteger.TEN; আপনি প্রতিস্থাপন করতে পারেন import java.math.BigInteger;সঙ্গে import java.math.*;
কেভিন ক্রুইজসেন

1
আমদানির দরকার নেই: এর সাথে অনুরূপ কিছু কাজ করা উচিত:java.math.BigInteger b=null;for(b=b.ZERO;!(b=b.add(b.ONE)).equals(b.TEN.pow(100);)System.out.print(x);
অলিভিয়ার গ্রাগোয়ার

@ অলিভিগ্রগ্রোয়েয়ার যা আমাকে একটি নুলারফেরান এক্সেপশন দেয়, সম্ভবত এটি নালার কারণে b
Xenderhall

@ এক্সান্দারহল আপনি সম্ভবত সি # এ চেষ্টা করেছেন (কারণ আপনি এনআরই বলেছেন, এনপিই নয়)। আমি এখনই জাভা সংস্করণটি পরীক্ষা করতে পারছি না তাই ভুল কি তা বলতে পারছি না। যাই হোক না কেন, আমি বলেছিলাম "কাজ করা উচিত", "কাজ করবে না"। গ্রহণ করার ধারণাটি হ'ল আপনার উদাহরণের উল্লেখগুলিতে স্থির পদ্ধতি কলগুলি এমনকি নালাগুলিও থাকতে পারে।
অলিভিয়ার গ্রাগোয়ার

@ অলিভিয়ারগ্রোগোয়ার আমি জাভাতে চেষ্টা করেছিলাম। আমি সি # তে কোড করি না।
Xenderhall

2

জাভা, 153 বাইট

import java.math.*;interface M{static void main(String[]a){for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);}}

আউটপুট: 1e100 1 এস

আমি জানি আরও একটি জাভা উত্তর আছে যা খুব কাছাকাছিও রয়েছে। মাইন একটি প্রধান পেয়েছে এবং এখনও কম।

এটি আমার প্রথম কোড-গল্ফ এন্ট্রি। টিপস প্রশংসা।


ল্যাম্বডা ব্যবহার করে এটি 117 বাইটে গল্ফ করা যায়। তবে আপনাকে এখনও আমদানি অন্তর্ভুক্ত করতে হবে। import java.math.*;()->{for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);};
শন ওয়াইল্ড

@ বাসালি অ্যালানটিউরিং আসলে আমার javacএই সংকলন করতে দেবে না।
নিক্লাস এম

আপনার জাভা আপডেট করুন। এছাড়াও, এটি সম্পূর্ণ সংকলনযোগ্য কোড নয়। খালি ন্যূনতম প্রবেশের জন্য অনুমোদিত।
শন ওয়াইল্ড

@ বাসালি অ্যালানটিউরিং জাভা ৮. আমার ধারণা, ওপি কর্তৃক ফাংশন অনুমোদিত নয়।
নিক্লাস এম

আমি আপনাকে যে কোডটি দিয়েছি তা কোনও সম্পূর্ণ প্রোগ্রাম নয় .. এটি বৈধ সিজি উত্তর হওয়ার দরকার।
শন ওয়াইল্ড

2

পাইথ, 8 7 বাইট

V^T100G

লিংক

সমাধানটি ছোট আউটপুট দিয়ে পরীক্ষা করা হয় তবে এটি abcdefghijklmnopqrstuvwxyz1e100 বার মুদ্রণ করা উচিত ।

কোনও কারণে p313133 (মালতেসেন) বলেছিল যে , বিনা প্রতিশ্রুতিবদ্ধ ছিল ।


পি দরকার কেন?
মালটিসেন

@ মালটিসেন আমি মনে করি 4 জিবি সীমাবদ্ধতার কারণে।
এরিক দি আউটগল্ফার

কেন? বাফার কিউজ? তা কি স্বয়ংক্রিয়ভাবে ফ্লাশ হয় না?
মালটিসেন

@ মাল্টেসেন আমি জানি না, অনলাইন অনুবাদকের তাত্ক্ষণিকভাবে আউটপুট কার্যকারিতা নেই। এটি
প্রবাহিত

স্থানীয়ভাবে এটি কাজ করছেp
মালটিসেন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.