এমন একটি প্রোগ্রাম যা প্রোগ্রামগুলি মুদ্রণ করে


13

চ্যালেঞ্জ

আপনার লক্ষ্য হ'ল এমন একটি প্রোগ্রাম লিখুন যা অন্য প্রোগ্রামটি প্রিন্ট করে। সেই মুদ্রিত প্রোগ্রামটির অন্য একটি প্রোগ্রাম মুদ্রণ করা উচিত এবং নতুন প্রোগ্রামটি শেষ অবধি অন্য প্রোগ্রামটি মুদ্রণ করা উচিত।

বিধি

  1. প্রতিটি প্রোগ্রামের 256 বাইটের চেয়ে কম হওয়া আবশ্যক। (যদি এটি পরিবর্তন করার প্রয়োজন হয় তবে একটি মন্তব্য দিন)
  2. শেষ প্রোগ্রামটি অবশ্যই একটি খালি প্রোগ্রাম হতে পারে।
  3. অবশ্যই একটি সীমাবদ্ধ প্রোগ্রাম থাকতে হবে, সুতরাং প্রোগ্রামটি একটি কুইন হতে পারে না।
  4. প্রোগ্রামগুলি অবশ্যই একই ভাষায় চালানো উচিত।
  5. কোনও ইনপুট অনুমোদিত নয়।
  6. বিজয়ী প্রোগ্রাম হ'ল এমন প্রোগ্রাম যা নিজেরাই গণনা করে যতটা সম্ভব প্রোগ্রাম প্রিন্ট করে।

শুভকামনা!


সর্বোচ্চ স্কোর হয় 2^2048, বা 3.2317e616
orlp

সহজে বড় স্কোরের তুলনা করতে হয় সেই বিষয়ে, ফর্ম আপনার স্কোর একটি পড়তা অন্তর্ভুক্ত করুন a*10^bযেখানে 1<=a<10এবং bএকটি প্রাকৃতিক সংখ্যা।
flawr

2
আসলে, আমার আগের গণনাটি ভুল ছিল। ধরে নিই প্রোগ্রামটি অবশ্যই বর্ধিত সর্বাধিক সম্ভাব্য স্কোরটি <মন্তব্যের জন্য দীর্ঘ সংখ্যা> বা 1.2673e614
orlp

উত্তর:


20

সিজেএম, 4.56 × 10 526 প্রোগ্রাম

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

নির্ভুল স্কোর: 254 219 + 254 192 + 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 3

ফাইলের আকার সীমা মেনে চলার জন্য সমস্ত প্রোগ্রামগুলিকে আইএসও -8859-1 এনকোডিং ব্যবহার করে সংরক্ষণ করতে হবে।

@ ক্রিসড্রোস্টকে ধন্যবাদ যিনি একটি বাগ নির্দেশ করেছেন এবং বাসা বাঁধার পদ্ধতির পরামর্শ দিয়েছেন।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

254 219 + 2 ≈ 4.56 × 10 526 প্রোগ্রাম

স্কোরের লাইন শেয়ারটি নিম্নলিখিত, আরও সাধারণ প্রোগ্রাম 1 দ্বারা অর্জন করা যেতে পারে ।

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

এই প্রোগ্রাম চালানো প্রোগ্রাম উত্পাদন করে

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

এবং 254 219 এর পরে - আরও 1 টি পুনরাবৃত্তি, প্রোগ্রাম

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

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

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

ধরুন স্ট্রিংটি ইতিমধ্যে স্ট্যাকের মধ্যে রয়েছে।

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

254 192 ≈ 5.35 × 10 461 আরও প্রোগ্রাম

জিনিসগুলি এখানে একটু ক্রেজি পায়।

প্রথম প্রোগ্রামটি অত্যন্ত সংকোচনের। একটি অনুরূপ প্রোগ্রাম লিখে, যা খালি প্রোগ্রামের পরিবর্তে শেষ পর্যন্ত উপরের অংশটি থেকে প্রথম প্রোগ্রাম তৈরি করে, আমরা 254 192 প্রোগ্রাম 3 দ্বারা স্কোরটি উন্নত করতে পারি ।

কার্যক্রম

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

পূর্ববর্তী বিভাগের প্রথম প্রোগ্রামের অনুরূপ, এবং 254 192 পুনরাবৃত্তির জন্য প্রাক্তন এবং এর আউটপুট চালানো পরবর্তী উত্পাদন করে।

ধরুন স্ট্রিংটি ইতিমধ্যে স্ট্যাকের মধ্যে রয়েছে:

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

মোয়ার প্রোগ্রাম

পূর্ববর্তী বিভাগের প্রথম প্রোগ্রামটি এখনও অত্যন্ত সংকোচनीय, তাই আমরা একটি অনুরূপ পদ্ধতি প্রয়োগ করতে এবং একটি প্রোগ্রাম লিখতে পারি যা 254 166 পুনরাবৃত্তির পরে , পূর্বোক্ত প্রোগ্রামটি উত্পাদন করে।

এই কৌশলটি বারবার পুনরাবৃত্তি করা পর্যন্ত আমরা 255 বাইট সীমা না আঘাত করা পর্যন্ত আমরা 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 1 ≈ 1.59 × 10 399 প্রোগ্রামগুলিতে যোগ করতে পারি পূর্ববর্তী বিভাগগুলির।


1 নিউলাইন স্পষ্টতার জন্য যুক্ত করা হয়েছে।
2 মেটাতে সম্মতি অনুযায়ী , এটি ডিফল্টরূপে অনুমোদিত।
3 বা 0.00000000000000000000000000000000000000000000000000000000001212%



5

জাভাস্ক্রিপ্ট, 1000 প্রোগ্রাম

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

এটি বৈধ কিনা তৃতীয় নিয়ম কীভাবে বোঝা যায় তার উপর নির্ভর করে।


এটি প্রযুক্তিগতভাবে কোনও কুইন নয়, কারণ এটি অভিন্ন অনুলিপিটির পরিবর্তে নিজস্ব উত্স কোডের একটি পরিবর্তিত সংস্করণ মুদ্রণ করে। এটি অবশ্যই কুইনের মতো কৌশল ব্যবহার করে ly আমি মনে করি @Turtle- এর থেকে আমাদের স্পষ্টতা দরকার।
জন

5
@ জন এবং ইপনিপেন এটি এমন কিছু যা আমি কল্পনা করেছিলাম। এইটা কাজ করে.
কচ্ছপ

6
আপনি এখনও কোড দৈর্ঘ্যের সীমা ছাড়িয়ে আছেন। আপনি 999 কে আরও বড় কিছুতে পরিবর্তন করবেন না কেন?
ড্যাঙ্কমেস

4

রুবি, 1.628 × 10 ^ 237 প্রোগ্রাম

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

আমার পার্ল উত্তর হিসাবে একই পদ্ধতির, কিন্তু রুবি ইতিমধ্যে বড় ints পরিচালনা করে, তাই এটি হেক্স হিসাবে সংরক্ষণ করা আরও সহজ।


রুবি, 9.277 × 10 ^ 90 প্রোগ্রাম

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

সুতরাং এই প্রয়াসটি পূর্ববর্তী কুইনের মতো-কিছুটা ভিন্ন ভিন্নতা, তবে সমস্ত অতিরিক্ত ক্রিয়াকলাপের কারণে আমি অন্যটির চেয়ে কাছে কোথাও নম্বর পাচ্ছি না ... তবে অন্য পদ্ধতির চেষ্টা করা আকর্ষণীয় ছিল!


4

পাইথন 2, 9.7 * 10 ^ 229 প্রোগ্রাম

O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]

সুন্দর, স্ট্রিং পুনরাবৃত্তি সম্পর্কে ভাবেন নি!
ডম হেস্টিংস

2

সি, 2.2 * 10 ^ 177 প্রোগ্রাম

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

এটি নিখুঁত নয়, তবে বেশ ভাল। আমার অর্থ এটি 255হ'ল লম্বা বাইট এবং একই দৈর্ঘ্যের প্রোগ্রাম উত্পন্ন করে। আপনি আরও কিছু প্রোগ্রাম পেতে সম্ভবত কিছুটা চারপাশে ঝাঁকুনি ফেলতে পারেন, তবে আমি এটি এখনকার মতো ছেড়ে দেব।

প্রোগ্রামটি একটি সাধারণ সি কুইন ভিত্তিক। অতিরিক্তভাবে একটি বেশ সাধারণ গণনা অ্যালগরিদম রয়েছে যা চর অ্যারের সমস্ত সম্ভাব্য মানের মধ্যে গণনা করে n। আমাদের কাছে স্ট্রিংয়ের ক্রমান্বয়ে যতগুলি প্রোগ্রাম রয়েছে n

চর পরিসরটি #(= 35) থেকে [= (91) পর্যন্ত সীমার মধ্যে সীমাবদ্ধ । এর কারণ আমি কোনও "বা \স্ট্রিং চাই না , কারণ তাদের পালাতে হবে।

চর অ্যারেতে থাকা সমস্ত মানগুলি হলে প্রোগ্রাম জেনারেশন শেষ nহয় [। তারপরে এটি একটি সাধারণ ডামি প্রোগ্রাম main(){}আউটপুট করে, যা নিজেই কিছুই আউটপুট করে।

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

এটি কাজ করা উচিত এমন একটি প্রদর্শন হিসাবে আমি কেবল সীমাটি পরিবর্তন করেছি, সুতরাং কেবলমাত্র ASCII- কোডের মধ্যে অক্ষর 35এবং 36ব্যবহৃত হয় এবং কেবল 4 টি অ্যারের উপাদান।

ফলাফল প্রোগ্রাম হয়

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

এটি 2^4 + 1 = 17বিভিন্ন প্রোগ্রাম আউটপুট করে।

সুতরাং উপরের প্রোগ্রামটি ((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177বিভিন্ন প্রোগ্রামকে আউটপুট করে। আমি পুরোপুরি নিশ্চিত নই যদি এটি গণনা করা হয়, বা আমার গণনাটি আরও সঠিক হয় কিনা


1
আপনি দয়া করে এটি অন্তর্ভুক্ত করতে পারেন 2.2 * 10^177(যারা তুলনা করতে চান তাদের জন্য)?
flawr

কীভাবে এটি গণনা করতে হবে তা জানতাম না, তবে আমি এটি অন্তর্ভুক্ত করেছি ;-)
মার্কডেফায়েন্ট


1

পার্ল, 1 × 10 ^ 163

তা না হলে এই একটি চমত্কার মৌলিক quine হয়, যতটা সম্ভব কয়েক অক্ষর যেমন নিচে সঙ্কুচিত যে বিপরীত থাকাকালীন শুধুমাত্র রান নয় 0

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e

1

কমন লিস্প, 10 113 -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))
  • 113 নাইন আছে।
  • পরবর্তী প্রোগ্রামে 112 টি নাইন রয়েছে তারপরে একটি 8 8
  • পরবর্তী প্রোগ্রামে 112 টি নাইন রয়েছে তারপরে একটি 7
  • ...

প্রিন্টারের দ্বারা চালু করা স্থানগুলিকে বিবেচনায় নিয়ে নাইনগুলির সংখ্যা কোডের সর্বোচ্চ আকার, 256 দ্বারা সীমাবদ্ধ ।


1

পার্ল, 1.4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

পাইথনের অনুরূপ পন্থা; একই ফলাফল!


0

> <> , 65534 (?) প্রোগ্রাম

আমি 65533 এর পরে একটি প্রশ্ন চিহ্ন যুক্ত করেছি যেহেতু এটি এখনও 65533 মুদ্রণ করতে পারে তা যাচাই করতে আমার কাছে নেই (যদিও আমার এটি বিশ্বাস করার কারণ আছে)। আমার আরও একবার সময় পেলে আমি এটি পরীক্ষা করার একটি উপায় বের করতে যাচ্ছি।

":?!;1-r00gol?!;a0.�

আপনি এটি এখানে অনলাইনে চেষ্টা করতে পারেন ।

এই প্রোগ্রামটির মূল বক্তব্যটি হ'ল এটি একেবারে শেষে অক্ষরের আউটপুট পরিবর্তন করে এবং তারপরে মুদ্রণের আগে এর সংখ্যাগত মান হ্রাস করে। আমি 65534 টি প্রোগ্রাম পেয়েছি কারণ কোডের শেষে অক্ষরের Ascii মান 65533, সুতরাং আমাদের কাছে প্রথম প্রোগ্রামটি গণনা করা হচ্ছে 65534 (আপনি যদি খালি প্রোগ্রামটি 65535 গণনা করেন)। শেষ প্রোগ্রাম "ফিরে" কিছুই নয়; অক্ষরের মান 0 হলে এটি সহজেই শেষ হয়।

আমি নিশ্চিত যে এটি সমস্ত পুনরাবৃত্তির জন্য একটি অক্ষর মুদ্রণ করতে সক্ষম হবে: আমি কয়টি অক্ষর> <> মুদ্রণ করতে পারি তার কোনও নির্দিষ্ট উত্স খুঁজে পাইনি, তবে সংখ্যার তুলনায় এখানে সরাসরি 65533 এর নীচে অক্ষর রয়েছে।

এই বাস্তবায়নে কোনও সমস্যা আছে কিনা আমাকে জানতে দিন; আমি আমার প্রবেশের বৈধতা সম্পর্কে কিছুটা অনিশ্চিত।


ব্যাখ্যা

আমি>> উইকি থেকে সিউডো-কুইন তৈরি করার জন্য একক উদ্ধৃতি চিহ্ন ব্যবহার করার ধারণাটি নির্লজ্জভাবে চুরি করেছি এবং আমি এখানে একবার দেখেছি এমন একটি মন্তব্য।

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop 

এটি যা করে তা হ'ল অক্ষর হিসাবে উদ্ধৃতি চিহ্নের পরে সমস্ত কিছু পার্স করা, তারপরে শেষটি হ্রাস করুন। সেখান থেকে এটি কেবল স্ট্যাকটি বিপরীত করে (যাতে সঠিক ক্রমে মুদ্রণ করা যায়), স্ট্যাকের উপর একটি উদ্ধৃতি চিহ্নটি চাপায় এবং তারপরে স্ট্যাকটি খালি না হওয়া পর্যন্ত মুদ্রণ করে।


0

পাইথন, 1 × 10 ^ 194 প্রোগ্রাম

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

এই ফাইল, থেকে চালানো হতে হবে না একটি ইন্টারেক্টিভ repl। এটি কোনও কুইন নয়।

@ টার্টলকে 3 বাট বাঁচাতে সাহায্য করার জন্য ধন্যবাদ, যা নাইনদের জন্য আরও জায়গা!
@ পোকে ধন্যবাদ আমাকে 2 বাইট সংরক্ষণ করতে সাহায্য করার জন্য, যা নাইনগুলির জন্য আরও জায়গা রয়েছে!


@ পনির প্রেমিকা if n!=0নিরর্থক। আপনি শুধু লিখতে পারেন if n
টার্টেল

আপনি দুটি স্পেস থেকেও মুক্তি পেতে পারেন; পরে if n:এবং replaceতর্ক মধ্যে।
অকর্মা

0

বাশ, 52 প্রোগ্রাম

একেবারে অপ্রয়োজনীয় এবং (আশাবাদী) দৃ last়ভাবে শেষ স্থানে।

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