26

এই চ্যালেঞ্জের লক্ষ্য হ'ল (শেষ পর্যন্ত) আপনার পছন্দমতো একটি ভাষাতে প্রতিটি সম্ভাব্য থামানো প্রোগ্রাম আউটপুট । প্রথমে এটি অসম্ভব বলে মনে হতে পারে তবে কার্যকর করার আদেশের খুব সতর্কতার সাথে আপনি এটি সম্পাদন করতে পারেন।

এটি চিত্রিত করার জন্য নীচে একটি ASCII চিত্র রয়েছে। কলামগুলি প্রতিটি সম্ভাব্য প্রোগ্রামের একটি সংখ্যা উপস্থাপন করুক (প্রতিটি প্রোগ্রাম একটি সীমাবদ্ধ বর্ণমালা থেকে সীমাবদ্ধ সংখ্যার চিহ্ন)। প্রতিটি সারি সেই প্রোগ্রামটি কার্যকর করার জন্য একক পদক্ষেপের প্রতিনিধিত্ব করুন। একজন Xসেই সময়-পদক্ষেপে সেই প্রোগ্রামের দ্বারা সম্পাদিত সম্পাদনের প্রতিনিধিত্ব করে।

 step#  p1 p2 p3 p4 p5 p6
     1  X  X  X  X  X  X
     2  X  X  X  X  X  
     3  X  X     X  X
     4  X  X     X  X
     5  X  X     X
     6     X     X
     7     X     X
     8     X     X
     9     X     X
     ∞     X     X

যেমন আপনি বলতে পারেন, প্রোগ্রাম 2 এবং 4 থামায় না। আপনি যদি একবারে তাদের সম্পাদন করতে থাকেন তবে আপনার নিয়ামকটি 2 প্রোগ্রামের অসীম লুপটিতে আটকে যেতে পারে এবং কখনই প্রোগ্রাম 3 বা তার বেশি হবে না।

পরিবর্তে, আপনি একটি ডোভেটেলিং পদ্ধতির ব্যবহার করেন । চিঠিগুলি প্রথম 26 টি পদক্ষেপের জন্য কার্যকর কার্যকর আদেশের প্রতিনিধিত্ব করে। *গুলি জায়গায় যেখানে যে প্রোগ্রাম স্থগিত করেছে এবং outputted হয়। .গুলি পদক্ষেপ এখনো মৃত্যুদন্ড কার্যকর করা হয় নি হয়।

 step#  p1 p2 p3 p4 p5 p6
     1  A  C  F  J  N  R  V
     2  B  E  I  M  Q  *  Z
     3  D  H  *  P  U
     4  G  L     T  Y
     5  K  O     X
     6  *  S     .
     7     W     .
     8     .     .
     9     .     .
     ∞     .     .

লক্ষ্য ভাষার জন্য প্রয়োজনীয়তা

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

উদাহরণস্বরূপ, আপনি যদি ব্রেনফাক পরীক্ষা করতে চান, তবে কেবলমাত্র []-+<>উপসেটটি পরীক্ষা করা ভাল , যেহেতু ইনপুট সমর্থিত নয় এবং আউটপুট কেবল ফেলে দেওয়া হয়েছে (নীচে দেখুন)।

যখন "কন্ট্রোলার" প্রোগ্রামটি আসে (যা আপনি গল্ফ করছেন), কোনও বিশেষ প্রয়োজনীয়তা নেই। সাধারণ ভাষার সীমাবদ্ধতা প্রযোজ্য।

প্রোগ্রামগুলির অসীম তালিকা কীভাবে তৈরি করবেন

সীমাবদ্ধ বর্ণমালা থেকে বেশিরভাগ প্রোগ্রামিং ভাষার প্রতিনিধিত্ব করা যেতে পারে ite এই ক্ষেত্রে, দৈর্ঘ্য বৃদ্ধির জন্য প্রতিটি সম্ভাব্য প্রোগ্রামের একটি তালিকা গণনা করা তুলনামূলকভাবে সহজ। আপনি যে বর্ণমালাটি ব্যবহার করেন তা লক্ষ্য ভাষার প্রয়োজনীয়তার প্রতিনিধি হওয়া উচিত । বেশিরভাগ ক্ষেত্রে, এটি প্রিন্টযোগ্য এএসসিআইআই। যদি আপনার ভাষা ইউনিকোডকে অতিরিক্ত বৈশিষ্ট্য হিসাবে সমর্থন করে, আপনি ইউনিকোড অক্ষরের প্রতিটি সম্ভাব্য সংমিশ্রণটি পরীক্ষা করবেন না, কেবলমাত্র ASCII। যদি আপনার ভাষা কেবলমাত্র ব্যবহার করে []-+<>তবে "মন্তব্য" ASCII অক্ষরের বিভিন্ন সংমিশ্রণটি পরীক্ষা করবেন না। এপিএলের মতো ভাষার নিজস্ব বিশেষ বর্ণমালা থাকবে।

আপনার ভাষা যদি ফ্রেট্রান বা টিউরিং মেশিনের মতো কিছু অ বর্ণানুক্রমিক উপায়ে সর্বোত্তমভাবে বর্ণিত হয় তবে সমস্ত সম্ভাব্য বৈধ প্রোগ্রামগুলির একটি তালিকা উত্পন্ন করার জন্য অন্যান্য সমানভাবে বৈধ পদ্ধতি রয়েছে।

প্রোগ্রামগুলির ক্রমবর্ধমান তালিকাটির ব্যাখ্যা করা

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

তালিকায় একটি সীমাবদ্ধ প্রোগ্রাম যুক্ত করুন
একটি সীমাবদ্ধ সময়ের জন্য পৃথকভাবে তালিকার প্রতিটি প্রোগ্রামের ব্যাখ্যা করুন। এটি প্রতিটি জন্য একটি নির্দেশ পদক্ষেপ সম্পাদন করে সম্পন্ন করা যেতে পারে। সমস্ত রাজ্য সংরক্ষণ করুন।
তালিকা থেকে সমস্ত সমাপ্তি / ত্রুটি-নিক্ষেপকারী প্রোগ্রামগুলি সরান
পরিষ্কারভাবে থামানো * প্রোগ্রামগুলি আউটপুট করুন
তালিকায় আরও কিছু প্রোগ্রাম যুক্ত করুন
প্রতিটি প্রোগ্রামকে ঘুরে ফিরে সিমুলেট করুন, পুরানো প্রোগ্রামগুলি যেখানে ছেড়ে গিয়েছিল সেগুলি কার্যকর করা উচিত
তালিকা থেকে সমস্ত সমাপ্তি / ত্রুটি-নিক্ষেপকারী প্রোগ্রামগুলি সরান
পরিষ্কারভাবে থামানো * প্রোগ্রামগুলি আউটপুট করুন
পুনরাবৃত্তি

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

আরও নিয়ম

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

code-golf interpreter

— PhiNotPi
সূত্র

7

এটা তোলে পর্যন্ত খুব দীর্ঘ আমাকে গ্রহণ উপলব্ধি করা কেন"If your program outputs itself, it is probably wrong or a polyglot."

— trichoplax

1

আমরা কি ধরে নিতে পারি যে উপলব্ধ স্মৃতিটি সীমাহীন (আমি মনে করি এটি অন্যথায় সম্ভব)

— কেএসব

1

@ কেস্যাব হ্যাঁ, এবং অন্যথায় এটি অবশ্যই সম্ভব নয়।

— ফিনোটপিআই

1

ফলো-আপ চ্যালেঞ্জ ( আরও কঠিন): প্রতিটি অ-থামানো প্রোগ্রাম আউটপুট।

— মিলো ব্র্যান্ড্ট

1

একই প্রোগ্রামটিকে একাধিকবার আউটপুট দেওয়া কি গ্রহণযোগ্য?

9

পাইথন-এ 317 269 বাইট সাবেলক ওআইএসসি

import collections
g=0
P={}
while 1:
    P[g]=[[0],collections.defaultdict(int,enumerate(list(int(x)for x in reversed(str(g)))))]
    g+=1
    for o,[a,p]in P.items():
        i=a[0]
        p[i+p[i+1]]-=p[i+p[i]]
        if p[i+p[i+1]]<=0:a[0]+=p[i+2]
        else:a[0]+=3
        if a[0]<0:print o;del P[o]

https://esolangs.org/wiki/Subleq

একটি subleq প্রোগ্রামটি পূর্ণসংখ্যার (p) এবং একটি নির্দেশিকা পয়েন্টার (i) এর এক্সটেনসিবল তালিকা। এই subleq বৈকল্পিক আপেক্ষিক ঠিকানা ব্যবহার করে, যা উইকি আলাপ পৃষ্ঠার পরামর্শ দেয় সীমানা মানগুলির সাথে সম্পূর্ণতা টুরিয়ার জন্য প্রয়োজনীয়। প্রতিটি টিক, অপারেশন p[i+p[i+1]]-=p[i+p[i]]সঞ্চালিত হয়, এবং তারপরে i+=p[i+2]অপারেশনের ফলাফলটি <= 0 হয়, অন্যথায় i+=3। আমি যদি কখনও নেতিবাচক হয় তবে প্রোগ্রামটি বন্ধ হয়ে যায়।

এই বাস্তবায়ন প্রতিটি প্রোগ্রামের পরীক্ষা করে যার প্রাথমিক অবস্থাটি 0-র প্রাথমিক নির্দেশিকা পয়েন্টার সহ এক-অঙ্কের অ-নেতিবাচক পূর্ণসংখ্যার (0-9) নিয়ে গঠিত।

Output:
21 (which represents the program [1 2 0 0 0 0 0...]
121
161
221
271
351
352
461
462
571
572
681
682
791
792

গল্ফিং কারণে আউটপুট বিপরীত হয়। উপরের অনুমানটি বিপরীতে পুনরুদ্ধার করা যেতে পারে, তবে তা বাস্তবায়নে ব্যবহৃত কোডটির সাথে মেলে না, তাই আমি সেভাবে এটি বর্ণনা করি নি।

সম্পাদনা: প্রথম প্রোগ্রাম যা সাধারণ আনবাউন্ডেড বৃদ্ধি প্রদর্শন করে 14283, যা মেমরি অবস্থানের 6 এর মান হ্রাস করে এবং পরের নেতিবাচক কোষে প্রতি তিনটি টিকে একটি সুস্পষ্ট 0 (প্রতিটি কোষে অন্তর্নিহিত 0 এর বিপরীতে) লিখেন।

— Sparr
সূত্র

9

সিজেমে বিটওয়াইস সাইক্লিক ট্যাগ , 98 87 84 77 বাইট

L{Z):Z2b1>_,,1>\f{/([\:~]a2*}+{)~[\({1+(:X+\_0=Xa*+}{0+\1>}?_{]a+}{];p}?}%1}g

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

বিসিটি হ'ল সাইক্লিক ট্যাগ সিস্টেমগুলির একটি সংক্ষিপ্ত বিবরণ । একটি প্রোগ্রাম দুটি বাইনারি স্ট্রিং দ্বারা সংজ্ঞায়িত করা হয়: একটি (চক্র) নির্দেশাবলীর তালিকা এবং একটি প্রাথমিক অবস্থা। প্রোগ্রামগুলি মুদ্রণের সময় আমার জীবনকে আরও সহজ করার জন্য, আমি নিজের স্বরলিপিটি সংজ্ঞায়িত করেছি: প্রতিটি স্ট্রিং সিজাম-স্টাইলের পূর্ণসংখ্যার অ্যারে হিসাবে দেওয়া হয়, এবং পুরো প্রোগ্রামটি ঘিরে থাকে [[...]], যেমন

[[[0 0 1 1] [0 1 1 1 0]]]

আমি খালি প্রাথমিক অবস্থা বা খালি নির্দেশের তালিকাও বঞ্চিত করছি।

বিসিটি-র নির্দেশাবলী নীচে ব্যাখ্যা করা হয়েছে:

নির্দেশনাটি থাকলে 0, বর্তমান অবস্থা থেকে শীর্ষস্থানীয় বিটটি সরিয়ে ফেলুন।
নির্দেশনাটি থাকলে 1, নির্দেশের তালিকার বাইরে আরও কিছু পড়ুন, এটিকে কল করুন X। যদি বর্তমান অবস্থা থেকে শীর্ষস্থানীয় বিট হয় তবে বর্তমান অবস্থায় 1যুক্ত করুন X, অন্যথায় কিছুই করবেন না।

বর্তমান অবস্থা যদি কখনও খালি হয়ে যায়, প্রোগ্রামটি থেমে আছে।

প্রথম কয়েকটি থামার প্রোগ্রামগুলি

[[[0] [0]]]
[[[0] [1]]]
[[[0 0] [0]]]
[[[0] [0 0]]]
[[[0 0] [1]]]
[[[0] [0 1]]]
[[[0 1] [0]]]
[[[0] [1 0]]]
[[[0 1] [1]]]
[[[0] [1 1]]]

আপনি যদি আরও দেখতে চান তবে উপরে উল্লিখিত অনলাইন দোভাষীর সংস্করণটি দেখুন।

ব্যাখ্যা

কোডটি কীভাবে কাজ করে তা এখানে। দোভেটেলিংয়ের উপর নজর রাখার জন্য আমাদের সর্বদা স্ট্যাকের মধ্যে একটি অ্যারে থাকবে যাতে সমস্ত প্রোগ্রাম রয়েছে। প্রতিটি প্রোগ্রাম প্রোগ্রামের কোডের অভ্যন্তরীণ উপস্থাপনের (যেমন [[0 1 0] [1 0]]) পাশাপাশি প্রোগ্রামের বর্তমান অবস্থার জুটি । আমরা কেবল পরবর্তী গণনাটি ব্যবহার করব, তবে প্রোগ্রামটি বন্ধ হয়ে যাওয়ার পরে আমাদের প্রিন্ট করা উচিত remember প্রোগ্রামগুলির এই তালিকাটি খালি অ্যারে দিয়ে কেবল সূচনা করা হয় L।

কোডের বাকি অংশটি একটি অসীম লুপ {...1}gযা প্রথমে এই তালিকায় এক বা একাধিক প্রোগ্রাম যুক্ত করে এবং প্রতিটি প্রোগ্রামের এক ধাপ গণনা করে। থামানো প্রোগ্রামগুলি মুদ্রিত হয় এবং তালিকা থেকে সরানো হয়।

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

[[[0] [1 0 1 0]]]
[[[0 1] [0 1 0]]]
[[[0 1 0] [1 0]]]
[[[0 1 0 1] [0]]]

যেহেতু আমরা খালি নির্দেশাবলী বা রাজ্যগুলি চাই না, আমরা 4 এ কাউন্টার শুরু করি, যা দেয় [[[0] [0]]]। এই গণনাটি নিম্নলিখিত কোড দ্বারা সম্পন্ন হয়:

Z):Z    e# Push Z (initially 3), increment, and store in Z.
2b1>    e# Convert to base 2, remove initial digit.
_,      e# Duplicate and get the number of bits N.
,1>     e# Turn into a range [1 .. N-1].
\       e# Swap the range and the bit list.
f{      e# Map this block onto the range, copying in the bit list on each iteration.
  /     e#   Split the bit list by the current value of the range.
  (     e#   Slice off the first segment from the split.
  [     
    \:~ e#   Swap with the other segments and flatten those.
  ]     e#   Collect both parts in an array.
  a2*   e#   Make an array that contains the program twice, as the initial state is the
        e#   same as the program itself.
}
+       e# Add all of these new programs to our list on the stack.

বাকি কোডগুলি প্রোগ্রামগুলির তালিকার উপরে একটি ব্লক তৈরি করে, যা এই জোড়াগুলির দ্বিতীয়ার্ধে বিসিটি গণনার এক ধাপ সম্পাদন করে এবং যদি এটি থামে তবে প্রোগ্রামটি সরিয়ে দেয়:

)~     e# Remove the second half of the pair and unwrap it.
[      e# We need this to wrap the instructions and current state back in an array
       e# again later.
\(     e# Bring the instruction list to the top and remove the leading bit.
{      e# If it's a 1...
  1+   e#   Append a 1 again (the instructions are cyclic).
  (:X+ e#   Remove the next bit, store it in X and also append it again.
  \_0= e#   Bring the current state to the top, get its first bit.
  Xa*+ e#   Append X if that bit was 1 or nothing otherwise.
}{     e# Else (if it's a 0...)
  0+   e#   Append a 0 again (the instructions are cyclic).
  \1>  e#   Discard the leading bit from the current state.
}?
_      e# Duplicate the current state.
{      e# If it's non-empty...
  ]a+  e#   Wrap instructions and state in an array and add them to the program
       e#   pair again.
}{     e# Else (if it's empty)...
  ];p  e# Discard the instructions and the current state and print the program.
}?

— মার্টিন ইন্ডার
সূত্র

দুর্দান্ত (+1)। কিছুটা বাইটস এই সত্যটি ব্যবহার করে সংরক্ষণ করা যেতে পারে যে বিসিটি টিউরিং সম্পূর্ণ হচ্ছে প্রাথমিক ডেটাস্ট্রিং (আপনার "রাষ্ট্র") হিসাবে মাত্র 1 ব্যবহার করা সীমাবদ্ধ থাকলেও। উদাহরণস্বরূপ, বাইনারিটিতে প্রতিটি ধারাবাহিক ধনাত্মক পূর্ণসংখ্যা 1P হিসাবে ব্যাখ্যা করুন, তারপরে 1 পি কে নির্বাহ করুন এবং P যদি if এক্সিকিউশন সমাপ্ত হয় (আবার ডোভেটেলিং)। (অবশ্যই, কোনো পি যে 0 দিয়ে শুরু হয় তারপর তালিকায়, হতে থেকে যে অবিলম্বে প্রাথমিক datastring মুছতে হবে।)

— মাঝামাঝি

8

পাইথনে ব্রেইনফাক, ৫77 বাইট

একটি অপেক্ষাকৃত সহজ সমাধান, যেহেতু ব্রেইনফাক এর পক্ষে কোনও দোভাষী লিখতে খুব কষ্টের ভাষা।

ব্রেইনফাকের এই বাস্তবায়নের ডেটা পয়েন্টারটি 0 থেকে শুরু হচ্ছে, কেবলমাত্র একটি ইতিবাচক মান গ্রহণের অনুমতি দেওয়া হয়েছে (এটি 0 এর বামে যাওয়ার চেষ্টা করলে একটি ত্রুটি হিসাবে বিবেচিত)। ডেটা সেলগুলি 0 থেকে 255 পর্যন্ত মানগুলিকে নিতে পারে এবং মোড়ানো করতে পারে। 5 টি বৈধ নির্দেশাবলী ><+[]( -মোড়কের কারণে অপ্রয়োজনীয়)।

আমি মনে করি আউটপুটটি এখন সব ঠিক আছে, তবে এটি নিশ্চিত হওয়া কঠিন যে এটি প্রতিটি সম্ভাব্য সমাধান মুদ্রণ করছে তাই আমি কিছুটা মিস করতে পারি।

o="><+]["
A="[]if b%s1<0else[(p,a+1,b%s1,t+[0],h)]"
C="[(p,h[a]+1,b,t,h)if t[b]%s0else(p,a+1,b,t,h)]"
I=lambda s,i:i*">"if""==s else o[o.find(s[0])+i-5]+I(s[1:],i*o.find(s[0])>3)
s="";l=[]
while 1:
 s=I(s,1)
 r=[];h={}
 for i in range(len(s)):
    if s[i]=="[":r+=[i]
    if s[i]=="]":
     if r==[]:break
     h[r[-1]]=i;h[i]=r[-1];r=r[:-1]
 else:
    if r==[]:
     l+=[(s,0,0,[0],h)];i=0
     while i<len(l):
        p,a,b,t,h=l[i]
        if a>=len(p):print p;l[i:i+1]=[]
        else:l[i:i+1]=eval([A%("+","+"),A%("-","-"),"[(p,a+1,b,t[:b]+[(t[b]+1)%256]+t[b+1:],h)]",C%">",C%"=="][o.find(p[a])]);i+=1

প্রথম কয়েকটি আউটপুট:

>
+
>>
+>
><
>+
++
[]
>>>
+>>

এবং প্রথম 2000 এর একটি তালিকা: http://pastebin.com/KQG8PVJn

এবং অবশেষে []তাদের সাথে প্রথম 2000 আউটপুটগুলির একটি তালিকা : http://pastebin.com/iHWwJprs
(বাকিগুলি বৈধ হওয়ার পরেও তুচ্ছ)

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

— KSab
সূত্র

1

খালি [-]এবং [+]অবশ্যই উভয়ই উপস্থিত হওয়া উচিত কারণ লুপের বিষয়বস্তুগুলি কেবল এড়িয়ে যায় (কোনও মোড়কে জড়িত থাকে না)।

— ফিনোটপিআই

@ Sp3000 [-]এবং [+]এটি একটি বাগ ছিল যা এখন ঠিক করা উচিত এবং আমি সেটিংসের সাথে আপডেট করেছি

— কেএসব

1

আপনি সমর্থন করছেন কেন .? বিএফের টুরিং-সম্পূর্ণ উপসেটটির জন্য এটি প্রয়োজনীয় নয় এবং যাইহোক আউটপুট উপেক্ষা করা উচিত। এছাড়াও, যেহেতু আপনি ঘরের মানগুলি চারপাশে মুড়িয়ে রাখছেন, আমার মনে হয় আপনার কেবলমাত্র একটি -এবং এর প্রয়োজন +।

— মার্টিন ইন্ডার

@ মার্টিনবাটনার মনে হয় আমি প্রশ্নটি ভুল বুঝেছি; আমি 'টিউরিং সম্পূর্ণ উপসেট' অংশটি পড়িনি। তবে এটি চ্যালেঞ্জটিকে প্রায় (বেশিরভাগ) ভাষার চেয়ে বেশি সমান করে না? আপনি কেবল ব্রেইনফাকের সাথে 1 থেকে 1 প্রতিস্থাপন করতে পারেন নি (বা আরও সহজ কিছু হতে পারে) উদাহরণস্বরূপ সি কোডটি এখানে: en.wikedia.org/wiki/Brainfuck#Commss ।

— কেএসব

2

স্ট্যাকওভারফ্লো / প্রশ্নগুলি 10153931/… বিশেষ করে ওআইএসসি প্রবেশের দিকে একবার দেখুন । এছাড়াও, সিএ বিধি 110 এবং সাইক্লিক ট্যাগ সিস্টেমগুলি দেখুন। এই চ্যালেঞ্জটিতে একটি ট্যুরিং সম্পূর্ণ "ভাষা" সৃজনশীলভাবে বেছে নেওয়ার জন্য অনেকগুলি জায়গা রয়েছে।

— স্পার

5

পাইথনে স্ল্যাশ, 640 498 বাইট

g=2
P={}
while 1:
    b=bin(g)[3:]
    P[b]=[[0],['',''],[b]]
    g+=1
    for d,[a,b,c]in P.items():
        s=c[0]
        if a[0]:
            if s.count(b[0]):s=s.replace(b[0],b[1],1)
            else:a[0]=0
        else:
            if s[0]=='0':
                if len(s)==1:del P[d];continue
                s=s[2:]
            else:
                b[0]=b[1]=''
                a[0]=1
                t=p=0
                while t<2:
                    p+=1
                    if p>=len(s):break
                    if s[p]=='0':
                        if p+1>=len(s):break
                        b[t]+=s[p+1]
                        p+=1
                    else:t+=1
                if t<2:del P[d];continue
        c[0]=s
        if len(s)==0:print d;del P[d]

https://esolangs.org/wiki////

একটি স্ল্যাশ প্রোগ্রাম হ'ল স্ট্রিং, এই দোভাষীটিতে '/' এবং '\' অক্ষর সীমাবদ্ধ থাকে। এই বাস্তবায়নে পাইথনের বিন (এক্স) ব্যবহার করে কিছু গল্ফ করার অনুমতি দেওয়ার জন্য / '' 1 'এবং' 0 'হয়। দোভাষী যখন একটি \ এর মুখোমুখি হন, পরবর্তী অক্ষরটি আউটপুট হয় এবং উভয় অক্ষর মুছে ফেলা হয়। যখন এটি কোনও / এর মুখোমুখি হয়, তখন এটি নিদর্শনগুলির মধ্যে নিখরচায় থাকা অক্ষরগুলি (search প্রতিনিধিত্ব করে including এবং \ / প্রতিনিধিত্ব করে /) হিসাবে সন্ধান এবং প্রতিস্থাপন হিসাবে নিদর্শনগুলি সন্ধান এবং প্রতিস্থাপন করে। অনুসন্ধানের স্ট্রিংটি আর উপস্থিত না হওয়া পর্যন্ত সেই প্রতিস্থাপন অপারেশনটি বারবার স্ট্রিংয়ে সঞ্চালিত হয়, তারপরে আবার শুরু থেকে ব্যাখ্যাটি অব্যাহত থাকে। প্রোগ্রামটি যখন খালি থাকে তখন থামে। কোনও প্রোগ্রাম / নিদর্শনগুলির একটি নিরবিচ্ছিন্ন সেট বা এর পরে কোনও অক্ষর না থাকলে হত্যা করা হবে।

Example output and explanations:
01 outputs '1' and halts
00 outputs '0' and halts
0101 outputs '11' and halts
0100 ...
0001
0000
010101
010100
010001
010000 ...
101110 replaces '1' with '', leaving '00', which outputs '0' and halts

— Sparr
সূত্র

4

জাভাতে ট্রিহুগার , 1,299 1,257 1,251 1,207 1,203 1,2013 1,193 1,189 বাইট

import java.util.*;class I{static class N{N l,r;byte v;}static class T extends Stack<N>{{push(new N());}void p(){pop();if(size()==0)p();}int i,h;char[]s;}static void s(T t){if(t.i>=t.s.length){t.h=1;return ;}char c=t.s[t.i];if(c=='<'){if(t.peek().l==null)t.peek().l=new N();t.push(t.peek().l);}if(c=='>'){if(t.peek().r==null)t.peek().r=new N();t.push(t.peek().r);}if(c=='^')t.p();if(c=='+')t.peek().v++;if(c=='-')t.peek().v--;if(c=='['&&t.peek().v==0){int i=1;while(i>0){t.i++;if(t.s[t.i]==']')i--;if(t.s[t.i]=='[')i++;}return;}if(c==']'&&t.peek().v!=0){int i=1;while(i>0){t.i--;if(t.s[t.i]==']')i++;if(t.s[t.i]=='[')i--;}return;}t.i++;}static char[]n(char[]a){String b="<^>[+-]";int q=a.length;for(int i=q-1;i>=0;i--){int j=b.indexOf(a[i]);if(j<6){a[i]=b.charAt(j+1);return a;}a[i]='<';}a=Arrays.copyOf(a,q+1);a[q]='<';return a;}public static void main(String[]a){List<T>z=new ArrayList<T>();char[]c={};while(true){T t=new T();t.s=c;if(b(c))z.add(t);c=n(c.clone());for(T u:z)try{s(u);if(u.h>0){z.remove(u);System.out.println(u.s);break;}}catch(Exception e){z.remove(u);break ;}}}static boolean b(char[]c){int i=0;for(char d:c){if(d=='[')i++;if(d==']')i--;if(i<0)return 0>0;}return i==0;}}

— SuperJedi224
সূত্র

4

ব্র্যাচিয়েলগ → পোস্ট চিঠিপত্রের সমস্যা , 10 বাইট

≜;?{~c}ᵐ\d

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

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

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

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

ব্যাখ্যা

≜;?{~c}ᵐ\d
≜           Brute-force all numbers:
 ;?           Pair {the number} with {itself}
   {  }ᵐ      For each pair element:
    ~c          Brute-force a partition of that element into substrings
        \     such that the two elements each have the same number of substrings
        \     and group together corresponding substrings
         d    and remove duplicated pairs {to produce a possible output}

2

সিলোন, 662 সালে "I / O ছাড়াই বেগুনি"

import ceylon.language{l=variable,I=Integer,m=map,S=String}class M(S d){l value t=m{*d*.hash.indexed};l I a=0;l I b=0;l I i=0;I g(I j)=>t[j]else 0;value f=m{97->{a},98->{b},65->{g(a)},66->{g(b)},105->{i},49->{1}};value s=m{97->((I v)=>a=v),98->((I v)=>b=v),65->((I v)=>t=m{a->v,*t}),66->((I v)=>t=m{b->v,*t}),105->((I v)=>i=v)};I&I(I)x{throw Exception(d);}I h(I v)=>f[v]?.first else x;shared void p(){(s[g(i)]else x)(h(g(i+1))-h(g(i+2)));i+=3;}}shared void run(){value a='!'..'~';{S*}s=expand(loop<{S*}>{""}((g)=>{for(c in a)for(p in g)p+"``c``"}));l{M*}r={};for(p in s){r=[M(p),*r];for(e in r){try{e.p();}catch(x){print(x.message);r=r.filter(not(e.equals));}}}}

বেগুনি একটি স্ব-পরিবর্তনকারী এক-নির্দেশিকা ভাষা যা এখানে ব্যাখ্যা করতে বলা হয়েছিল । ইনপুট এবং আউটপুট এই কাজের জন্য প্রাসঙ্গিক নয় হিসেবে আমি মুছে oব্যাখ্যাকারী থেকে প্রতীক অর্থ, এই ধরনের যে (সম্ভাব্য) বৈধ প্রতীক মাত্র হয় a, b, A, B, iএবং 1(শেষ মাত্র পড়ার জন্য এক, লেখার জন্য নয়)।

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

(আপনি পরিবর্তে কমান্ড লাইন আর্গুমেন্ট হিসাবে অনুমোদিত অক্ষরের স্ট্রিং হিসাবে দোভাষীকে সংশোধন করতে পারেন - aনীচে সংজ্ঞায়িত মন্তব্য করা লাইনে স্যুইচ করুন Then তারপরে দৈর্ঘ্য 686 বাইটে পরিণত হয়))

আমার "সমান্তরাল" দোভাষী এইভাবে এই চরিত্রগুলি থেকে সমস্ত সীমাবদ্ধ স্ট্রিং তৈরি করে (দৈর্ঘ্য এবং শব্দকোষ ক্রমবর্ধমান) এবং তাদের প্রত্যেককে চেষ্টা করে।

যখন মৃত্যুদণ্ড কার্যকর করার জন্য টেপ থেকে পড়ার আদেশটি বৈধ হয় না তখন বেগুনি ত্রুটি ছাড়াই থামবে thus সুতরাং কোনও অবৈধ প্রোগ্রাম এবং অনেকগুলি, অনেকগুলি থামানো নেই। (বেশিরভাগ প্রথম পদক্ষেপে থামেও, 3 দৈর্ঘ্যের কিছু প্রোগ্রামের মধ্যে কেবল দ্বিতীয় ধাপে আসে (এবং তখন থামবে), প্রথম অ-থামানোগুলির দৈর্ঘ্য 6 হয়।

আমার মনে হয় যে আমার দোভাষী দ্বারা চেষ্টা করা আদেশের মধ্যে প্রথম অ-থামানো প্রোগ্রামটি হ'ল aaaiaa, যা প্রথম ধাপে aনিবন্ধকে 0 তে সেট করে (যা এটি ইতিমধ্যে ছিল), এবং দ্বিতীয় এবং পরবর্তী প্রতিটি পদক্ষেপ নির্দেশ পয়েন্টারটি 0-এ ফিরে আসে, এটি iaaআবার কার্যকর করার কারণ ।

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

এখানে একটি মন্তব্য করা হয়েছে এবং ফর্ম্যাট করা সংস্করণ:

// Find (enumerate) all halting programs in (a non-I/O subset of) Purple.
//
// Question:  /codegolf//q/51273/2338
// My answer: /codegolf//a/65820/2338

// We use a turing-complete subset of the Purple language,
// with input and output (i.e. the `o` command) removed.

import ceylon.language {
    l=variable,
    I=Integer,
    m=map,
    S=String
}

// an interpreting machine.
class M(S d) {
    // The memory tape, as a Map<Integer, Integer>.
    // We can't modify the map itself, but we
    // can replace it by a new map when update is needed.
    l value t = m {
        // It is initialized with the code converted to Integers.
        // We use `.hash` instead of `.integer` because it is shorter.
        *d*.hash.indexed
    };

    // three registers
    l I a = 0;
    l I b = 0;
    l I i = 0;

    // get value from memory
    I g(I j) =>
            t[j] else 0;

    // Map of "functions" for fetching values.
    // We wrap the values in iterable constructors for lazy evaluation
    //  – this is shorter than using (() => ...).
    // The keys are the (Unicode/ASCII) code points of the mapped
    // source code characters.
    value f = m {
        // a
        97 -> { a },
        // b
        98 -> { b },
        // A
        65 -> { g(a) },
        // B
        66 -> { g(b) },
        // i
        105 -> { i },
        // 1
        49 -> { 1 }
    };

    // Map of functions for "storing" results.
    // The values are void functions taking an Integer,
    // the keys are the ASCII/Unicode code points of the corresponding
    // source code characters.
    value s = m {
        // a
        97 -> ((I v) => a = v),
        // b
        98 -> ((I v) => b = v),
        // Modification of the memory works by replacing the map with
        // a new one.
        // This is certainly not runtime-efficient, but shorter than
        // importing ceylon.collections.HashMap.
        // A
        65 -> ((I v) => t = m { a->v, *t }),
        // B
        66 -> ((I v) => t = m { b->v, *t }),
        // i
        105 -> ((I v) => i = v)
    };


    // Exit the interpretation, throwing an exception with the machine's
    // source code as the message.  The return type is effectively `Nothing`,
    // but shorter (and fits the usages).
    I&I(I) x {
        throw Exception(d);
    }

    // accessor function for the f map
    I h(I v) =>
            f[v]?.first else x;

    // a single step
    shared void p() {
        (s[g(i)] else x)(h(g(i + 1)) - h(g(i + 2)));
        i += 3;
    }
}

// the main entry point
shared void run() {
    // the alphabet of "Purple without I/O".
    value a = '!'..'~';
    //// possible alternative to use a command line argument:
    // value a = process.arguments[0] else '!'..'~';

    // an iterable consisting of all programs in length + lexicographic order
    {S*} s =
            // `expand` creates a single iterable (of strings, in this case)
            // from an iterable of iterables (of strings).
             expand(
        // `loop` creates an iterable by applying the given function
        // on the previous item, repeatedly.
        // So here we start with the iterable of length-zero strings,
        // and in each iteration create an iterable of length `n+1` strings
        // by concatenating the length `n` strings with the alphabet members.
        loop<{S*}>{ "" }((g) =>
                {
                    for (c in a)
                        for (p in g)
                            p + "``c``"
                }));

    // This is a (variable) iterable of currently running machines.
    // Initially empty.
    l {M*} r = {};

    // iterate over all programs ...
    for(p in s) {
        // Create a machine with program `p`, include it
        //  in the list of running machines.
        //
        // We use a sequence constructor here instead of
        //  an iterable one (i.e. `r = {M(p, *r)}` to prevent
        // a stack overflow when accessing the deeply nested
        // lazy iterable.
        r = [M(p), *r];
        // iterate over all running machines ...
        for(e in r) {
            try {
                // run a step in machine e.
                e.p();
            } catch(x) {
                // exception means the machine halted.
                // print the program
                print(x.message);
                // remove the machine from the list for further execution
                r = r.filter(not(e.equals));
            }
        }
        // print(r.last);
    }
}

— পাওলো ইবারম্যান
সূত্র

2

এস কে combinator ক্যালকুলাস মধ্যে Haskell, , 249 বাইট

data C=H|S|K|C:$C deriving(Eq,Show)
n(a:$b)=m a*n b
n a=m a
m S=1
m K=1
m(S:$a)=n a
m _=0
f H=[S,K,S:$H,K:$H,S:$H:$H]
f a=[S:$b:$c:$d|b:$d:$(c:$e)<-[a],d==e,n b*n c*n d>0]++[K:$a:$H|n a>0]++do b:$c<-[a];[d:$c|d<-f b]++[b:$d|n b>0,d<-f c]
l=H:(f=<<l)

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

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

এসকে কম্বিনেটর ক্যালকুলাসের কল-বাই-ভ্যালু মূল্যায়নের নিয়মগুলি নিম্নরূপ:

(ক) এস xyz ↦ xz ( yz ), x , y , z এর জন্য সাধারণ আকারে;
(খ) কে xy ↦ x , এক্স এর জন্য , y স্বাভাবিক আকারে;
(সি) xy ↦ x ′ y , যদি x ↦ x ′;
(ঘ) XY ↦ XY ', জন্য এক্স স্বাভাবিক ফর্ম, তাহলে Y ↦ Y' ।

যেহেতু আমরা কেবল আটকানো আচরণে আগ্রহী তাই আমরা এইচ-এর প্রতীকটি সাধারণ আকারে প্রকাশ না করে কিছুটা প্রসারিত করি, তবে যা সাধারণভাবে সমস্ত রূপ "মূল্যায়ন" করে:

(ক) এস xyz ↦ xz ( yz ), x , y , z এর জন্য সাধারণ আকারে;
(খ ′) কে এক্স এইচ ↦ এক্স , সাধারণ আকারে এক্স এর জন্য ;
(সি) xy ↦ x ′ y , যদি x ↦ x ′;
(d) xy ↦ xy ′, এক্সের জন্য সাধারণ আকারে, যদি y ↦ y ′ ;
(ঙ) এস ↦ এইচ;
(চ) কে-এইচ;
(ছ) এসএইচ ↦ এইচ;
(জ) কেএইচ ↦ এইচ;
(i) এসএইচএইচ ↦ এইচ।

আমরা কোনও অ্যাপ্লিকেশন এইচ এক্সকে একটি রান-টাইম ত্রুটি হিসাবে বিবেচনা করে বিবেচনা করি যেন এটি অসীম লুপ, এবং আমরা মূল্যায়নের আদেশ দিই যে কোনও এইচ (ই) দ্বারা উত্পাদিত হয় না - (i) এমন একটি প্রেক্ষাপটে যেখানে এটি হবে উপেক্ষা (শীর্ষ স্তরের, কোনও কে এক্স ☐, যে কোনও উপেক্ষিত কে☐, কোনও সাধারণ উপায়ে x এর জন্য উপেক্ষিত এস এক্স ,, কোনও উপেক্ষা করা S☐H)। এইভাবে আমরা এইচ এর অভাবজনিত শর্তাদির থামার আচরণকে প্রভাবিত করি না

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

nকোনও শব্দটি স্বাভাবিক আকারে রয়েছে কিনা তা যাচাই করে, কোনও পদটির fসমস্ত সম্ভাব্য প্রাইমেজ খুঁজে পায় এবং lএটি এইচ থেকে প্রস্থ-প্রথম অনুসন্ধানের দ্বারা উত্পাদিত সাধারণকরণযোগ্য পদগুলির একটি অলস অসীম তালিকা is

— অ্যান্ডারস ক্যাসরগ
সূত্র

প্রতিটি থামানো প্রোগ্রাম আউটপুট (সমান্তরাল দোভাষী লিখুন)

লক্ষ্য ভাষার জন্য প্রয়োজনীয়তা

প্রোগ্রামগুলির অসীম তালিকা কীভাবে তৈরি করবেন

প্রোগ্রামগুলির ক্রমবর্ধমান তালিকাটির ব্যাখ্যা করা

আরও নিয়ম

পাইথন-এ 317 269 ​​বাইট সাবেলক ওআইএসসি

সিজেমে বিটওয়াইস সাইক্লিক ট্যাগ , 98 87 84 77 বাইট

ব্যাখ্যা

পাইথনে ব্রেইনফাক, ৫77 বাইট

পাইথনে স্ল্যাশ, 640 498 বাইট

জাভাতে ট্রিহুগার , 1,299 1,257 1,251 1,207 1,203 1,2013 1,193 1,189 বাইট

ব্র্যাচিয়েলগ → পোস্ট চিঠিপত্রের সমস্যা , 10 বাইট

ব্যাখ্যা

সিলোন, 662 সালে "I / O ছাড়াই বেগুনি"

এস কে combinator ক্যালকুলাস মধ্যে Haskell, , 249 বাইট

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

পাইথন-এ 317 269 বাইট সাবেলক ওআইএসসি