টিউরিং সম্পূর্ণতার জন্য সবচেয়ে স্বল্প (স্বতন্ত্র) অক্ষর


107

সারাংশ:

যে কোনও ভাষার জন্য, আপনার ভাষার টুরিং-কমপ্লিট হওয়ার জন্য স্বতন্ত্র পরিমাণের স্বল্প পরিমাণটি কী?

চ্যালেঞ্জ:

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


উদাহরণ:

  • জাভাস্ক্রিপ্ট: +!()[]( http://www.jsfuck.com )

  • ব্রেইনফাক: +<>[](একটি মোড়কের ঘরের আকার ধরে)

  • পাইথন 2: ()+1cehrx(যেমন স্ক্রিপ্ট থেকে তৈরি exec(chr(1+1+1)+chr(1)))

স্কোরের:

এই চ্যালেঞ্জটি বাইট নয়, অক্ষরগুলিতে তৈরি । উদাহরণস্বরূপ, উদাহরণগুলির জন্য স্কোরগুলি 6, 5 এবং 9।


নোট:

  • এই চ্যালেঞ্জটি অন্যদের থেকে এই পার্থক্যকে পৃথক করে যে আপনি কেবল আপনার ভাষা টিউরিং-সম্পূর্ণ হতে হবে (অগত্যা ভাষার প্রতিটি বৈশিষ্ট্যই ব্যবহার করতে সক্ষম হবেন না))

  • যদিও আপনি পারেন, দয়া করে ব্যবহৃত অক্ষরগুলি হ্রাস না করে উত্তর পোস্ট করবেন না। উদাহরণ: 8 টি অক্ষরযুক্ত ব্রেনফাক (যেহেতু প্রতিটি অন্যান্য চরিত্রই ডিফল্টরূপে একটি মন্তব্য))

  • আপনার উপসেটটি কেন টিউরিং-সম্পূর্ণ as


90
ইউনারি , 1 টি চরিত্র। দীর্ঘশ্বাস ফেলুন
ডেনিস

4
@ ডেনিস এটি আকর্ষণীয় সংখ্যা তত্ত্বের সমস্যার জন্য জেলি বা 05AB1E এর অন্তর্নির্মিত থেকে আলাদা নয়। এই চ্যালেঞ্জটি এখনও কোনও ভাষায় একটি আকর্ষণীয় এবং অপ্রচলিত অপ্টিমাইজেশান সমস্যার মতো মনে হচ্ছে যা তার্পিটি হিসাবে ডিজাইন করা হয়নি।
মার্টিন এন্ডার

7
@ মার্টিনএন্ডার আমি জাভা বা সি এর মতো ভাষাগুলিতে উত্তরগুলি দেখতে বিশেষভাবে আগ্রহী
জুলিয়ান লাচনিট

9
দয়া করে esolangs এ সমাধান পোস্ট করবেন না যেখানে সমাধান ভাষায় প্রতিটি বৈধ অক্ষর। এটি ইন্টারেস্টিং বা চালাক নয়।
পাভেল

20
@ পাভেল আকর্ষণীয় বা চতুর নয় এটির অর্থ এটি উত্সাহিত হওয়া উচিত নয়, তবে অবশ্যই এটি পোস্ট করা উচিত নয়।
ডেনিস

উত্তর:


77

হাস্কেল, চারটি চর

()=;

সঙ্গে ()=আমরা এস, কে এবং আই সংজ্ঞা পারেন দ্বারা পৃথক করা আবশ্যক সংজ্ঞায়িত করতে পারবেন ;বা এন এল।

আমরা (==)এস হিসাবে সংজ্ঞায়িত করি (দ্বিতীয় লাইনটি আরও পাঠযোগ্য সংস্করণ দেখায়):

((=====)==(======))(=======)=(=====)(=======)((======)(=======))
( a     == b      ) c       = a      c       ( b       c       )

(===) কে হিসাবে:

(=====)===(======)=(=====)
 a     === b      = a

এবং (====)আমি হিসাবে:

(====)(=====)=(=====)
(====) a     = a 

সৌভাগ্য যে (==), (===), (====), ইত্যাদি বৈধ ফাংশন / প্যারামিটার নাম।

@ আইস ৫২৩ টি যেমন উল্লেখ করেছে, এসকেআই হ্যাস্কেলের মতো দৃ strongly়ভাবে টাইপ করা ভাষায় যথেষ্ট নয়, সুতরাং আমাদের একটি ফিক্সপয়েন্ট সংযুক্তকারী যুক্ত করতে হবে (=====):

(=====)(======)=(======)((=====)(======))
(=====) f      = f      ((=====) f      )

17
এই নির্মাণ সরাসরি কাজ করে না; এসকেআই হ্যাস্কেলের মতো শক্তভাবে টাইপ করা ভাষায় টিউরিং সম্পূর্ণ করছে না। যাইহোক, আমি বিশ্বাস করি আপনি সংজ্ঞায়িত একই কৌশল ব্যবহার করতে পারেন fix, এবং স্কি + + fix হয় টুরিং সম্পূর্ণ, একটি শক্তিশালী ভাবে টাইপ ভাষায় এমনকি।

ওহ, সুতরাং আপনি প্রতিটি প্রোগ্রামের শুরুতে এই সংজ্ঞাটি উপসর্গ করেন?
পাইরুলেজ

@ পাইরুলেজ: হ্যাঁ আমাদের ডিফল্ট হিসাবে আমি ধরে নিয়েছি যে প্রদত্ত চরিত্রের সেট দিয়ে ফাংশনগুলি তৈরি করতে সক্ষম হওয়াই যথেষ্ট - একটি সম্পূর্ণ প্রোগ্রামের প্রয়োজন নেই।
নিমি

1
আপনার সম্ভবত এটি প্রতিস্থাপন করা উচিত (==)যাতে এটি ডিফল্ট সমতা অপারেটরের সাথে সংঘাত না ঘটে
গর্বিত হাসেলেলার

@ প্রফেসহেস্কিলার: হ্যাঁ, আপনি যদি প্রোগ্রামটি করতে চান (==)তবে নাম পরিবর্তন করা ভাল , তবে উপরের কোডটি কেবলমাত্র টুরিং সম্পূর্ণতার প্রমাণ prove
নিমি

61

জাভাস্ক্রিপ্ট (ES6), 5 টি অক্ষর

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

[]+=`

এটি মোটামুটি সুপ্রতিষ্ঠিত যে কোনও জাভাস্ক্রিপ্ট প্রোগ্রাম অক্ষর ( []()+!) দিয়ে লেখা যেতে পারে তবে 5 টি অক্ষরই যথেষ্ট নয় । তবে যথেচ্ছ জাভাস্ক্রিপ্ট লেখার বিষয়ে এটি কোনও চ্যালেঞ্জ নয়। টিউরিং-সম্পূর্ণ ভাষা লেখার বিষয়ে এটি একটি চ্যালেঞ্জ, এবং ট্যুরিং-সম্পূর্ণ ভাষাগুলির DOM অ্যাক্সেস বা এমনকি ইন্টারেক্টিভ I / O এর প্রয়োজন নেই এটি ব্যবহার করে দেখা যাচ্ছে যে প্রয়োজনীয় সমস্ত কার্যকারিতা সহ আমরা একটি প্রোগ্রাম লিখতে পারি can এমনকি কোনও evalবা সমমান চালানোর কোনও ক্ষমতা ছাড়াই ।

বেসিক বুটস্ট্র্যাপিং

জাভাস্ক্রিপ্ট প্রকারের সাথে খুব নমনীয়। সুতরাং উদাহরণস্বরূপ, []একটি খালি অ্যারে, তবে +[]0 এবং []+[]এটি নাল স্ট্রিং। উল্লেখযোগ্যভাবে, আমরা এই অক্ষর সেটটি দিয়ে 0 টি উত্পাদন করতে পারি তা গোষ্ঠীকরণের জন্য প্রথম বন্ধনীগুলির প্রভাব অনুকরণ করা সম্ভব করে; (a)হিসাবে লেখা যেতে পারে [a][+[]]। আমরা এই ধরণের কৌশলটি ব্যবহার করে বিভিন্ন অক্ষর তৈরি করতে পারি কেবলমাত্র +[]:

  • [][+[]]হয় undefined(একটি খালি অ্যারের প্রথম উপাদান হচ্ছে); সুতরাং
  • []+[][+[]]হ'ল "undefined"(এর স্ট্রিংফিকেশন undefined); সুতরাং
  • [[]+[][+[]]]is ["undefined"](এটি একটি অ্যারে মোড়ানো); সুতরাং
  • [[]+[][+[]]][+[]]হয় "undefined"(তার প্রথম উপাদান); সুতরাং
  • [[]+[][+[]]][+[]][+[]]হ'ল "u"(এটির প্রথম চিঠি)।

uতৈরি করা সহজতম চরিত্রগুলির মধ্যে একটি, তবে অনুরূপ কৌশলগুলি আমাদের অন্যান্য অক্ষরগুলির একটি পরিসীমা তৈরি করতে দিন। একই লিংক আগের মত আমাদের সাথে প্রবেশযোগ্য অক্ষরের নিম্নলিখিত তালিকা দেয় +[](এই জন্য হিসাবে একই তালিকা রয়েছে +[](), ব্যতীত ,কারণ এটি শুধুমাত্র নির্মাণ গোষ্ঠীবদ্ধ / প্রাধান্য ছাড়া অন্য কোনো উদ্দেশ্যে প্রথম বন্ধনী ব্যবহার করে এর):

0123456789acdefinotuvyIN (){}.

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

এখন পর্যন্ত, সবচেয়ে গুরুত্বপূর্ণ শব্দটি যা আমাদের বানান করতে দেয় যা আমরা আগে করতে পারিনি, সেটি constructor। এখন, জাভাস্ক্রিপ্টটিতে একটি বৈশিষ্ট্য অ্যাক্সেস সিনট্যাক্স রয়েছে যা দেখতে এটির মতো দেখাচ্ছে:

object.property

তবে আপনি এটি এটি এইভাবে লিখতে পারেন:

object["property"]

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

object["c"+"o"+"n"+"s"+"t"+"r"+"u"+"c"+"t"+"o"+"r"]

(উপরে বর্ণিত হিসাবে উত্পন্ন বর্ণগুলি সহ; কোডটি খুব দীর্ঘ হয়ে যায়!); এটি এর সমতুল্য object.constructor, যা আমাদের স্বেচ্ছাচারিত বস্তুর নির্মাণকারীদের অ্যাক্সেস করতে দেয়।

আমরা এর সাথে করতে পারি বেশ কয়েকটি কৌশল। দুনিয়া থেকে চমত্কার:

  • কোনও অবজেক্টের কনস্ট্রাক্টর একটি ফাংশন। উল্লেখযোগ্যভাবে, এটির একটি নাম রয়েছে, এবং সেই নামটি ফাংশনের স্ট্রিংফিকেশনের অংশ। সুতরাং উদাহরণস্বরূপ, আমরা [[]+[]][+[]]["constructor"]স্ট্রিংয়ের জন্য কন্সট্রাক্টর পেতে যা করতে পারি যার নাম স্ট্রিং, এবং তারপরে এটি Sঅক্ষরে অক্ষরে পৌঁছে দিতে string এটি আমাদের বর্ণমালা কিছুটা প্রসারিত করে এবং আমাদের পরে নতুন কয়েকটি অক্ষর প্রয়োজন।
  • সমস্ত অ্যারে একই কনস্ট্রাক্টর রয়েছে; []["constructor"] == []["constructor"]is true(বিপরীত [] == [], যা মিথ্যা)। এটি ছোটখাটো বলে মনে হতে পারে তবে এটি অত্যন্ত গুরুত্বপূর্ণ, কারণ এটি আমাদেরকে অবিচ্ছিন্নভাবে মানগুলি সংরক্ষণ করার একটি পদ্ধতি দেয়; আমরা কন্সট্রাক্টর এ এলোমেলো সম্পত্তি সেট করতে পারি এবং পরে এটি আবার পড়তে পারি। (এই কারণে আমরা ব্যবহার করছি এক =অন্য উপায়ে জেনারেট করতে এক বিশেষ করে, বরং trueএবং falseআমরা মূল্যায়ন করতে পারেন।) উদাহরণস্বরূপ, [[]["constructor"]["a"]=[]]পড়ুন, এবং পরে []["constructor"]["a"]এবং আমরা সেখানে সঞ্চিত একই অ্যারে ফিরুন।

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

  • এটি আমাদের কোনও ফাংশনের জন্য কনস্ট্রাক্টর পেতে দেয় (আমাদের সীমিত বর্ণমালা দিয়ে আমরা প্রচুর ফাংশন ব্যবহার করতে পারি; []["find"]যেমন অ্যারে.ফাইন্ড, এটি খুব সহজেই অ্যাক্সেসযোগ্য তবে অন্যগুলি রয়েছে)। কেন এটি দরকারী? ঠিক আছে, আমরা আসলে এটি কোনও নির্মাণকারীর উদ্দেশ্যে উদ্দেশ্যে ব্যবহার করতে পারি এবং ফাংশনগুলি তৈরি করতে পারি! দুর্ভাগ্যক্রমে, আমাদের অক্ষর সেট সহ, আমরা ফাংশন কনস্ট্রাক্টরকে একটি গণিত স্ট্রিং পাস করতে পারি না। যাইহোক, এর ব্যবহারটি `আমাদের এটিকে একটি স্ট্রিং আক্ষরিক (উদাহরণস্বরূপ []["find"]["constructor"]`function body goes here`) দিতে দেয়; এর অর্থ হ'ল আমরা যখন কার্যকর হই তখন যে কোনও আচরণের সাথে ফাংশন প্রকারের কাস্টম মানগুলি সংজ্ঞায়িত করতে পারি, যতক্ষণ না আমরা সেই আচরণটি সম্পূর্ণরূপে ব্যবহার করতে পারি []+=। উদাহরণস্বরূপ, []["find"]["constructor"]`[]+[]`একটি মোটামুটি বিরক্তিকর ফাংশন যা নাল স্ট্রিংটি গণনা করে, এড়িয়ে যায় এবং প্রস্থান করে; যেফাংশন দরকারী নয়, তবে আরও জটিলগুলি হবে। মনে রাখবেন যে ফাংশনগুলি প্যারামিটারগুলি নিতে বা মানগুলি ফেরত নিতে না পারে, সেগুলি বাস্তবে সমস্যা হয় না কারণ আমরা এক ফাংশন থেকে অন্য ফাংশনে যোগাযোগের জন্য কনস্ট্রাক্টর-সম্পত্তি স্টোরেজটি ব্যবহার করতে পারি। আর একটি বিধিনিষেধ হ'ল আমরা `কোনও ফাংশনের শরীরে ব্যবহার করতে পারি না ।

    এখন, আমরা কাস্টম ফাংশনগুলি সংজ্ঞায়িত করতে পারি, তবে এই মুহুর্তে আমাদের কী আটকাচ্ছে তা হ'ল তাদেরকে ডাকতে আমাদের যে সমস্যা হয় । প্রোগ্রামের শীর্ষ স্তরে, আমরা একটি ফাংশন সহ কল ​​করতে পারি ``, তবে কেবল শীর্ষ স্তর থেকে ফাংশনগুলি কল করতে সক্ষম হওয়া আমাদের কোনও ধরণের লুপ করতে দেয় না। বরং একে অপরকে কল করতে আমাদের ফাংশন প্রয়োজন।

    আমরা বরং একটি নিফটি কৌশল দ্বারা এটি সম্পন্ন। Sপূর্বে যে মূলধনটি উত্পন্ন হয়েছিল তা মনে আছে? এটি আমাদের বানান করতে দেয় "toString"। আমরা এটিকে ডাকব না; আমরা জিনিসগুলিকে স্ট্রিংয়ে যুক্ত করে রূপান্তর []করতে পারি। বরং, আমরা এটি প্রতিস্থাপন করতে যাচ্ছি । আমরা প্রায় স্থির থাকা অ্যারেগুলি সংজ্ঞায়িত করতে কনস্ট্রাক্টর স্টোরেজ ব্যবহার করতে পারি। তারপরে আমরা অ্যারেগুলির toStringপদ্ধতিগুলিতে আমাদের তৈরি ফাংশনগুলি নির্ধারণ করতে পারি এবং সেই কার্যাদিও প্রায় কাছাকাছি থাকবে। এখন, আমাদের যা করতে হবে তা +[]অ্যারেতে একটি সাধারণ এবং হঠাৎ করেই, আমাদের কাস্টম-সংজ্ঞায়িত ফাংশনটি চলবে। এর অর্থ হ'ল আমরা অক্ষরগুলি ব্যবহার করতে পারি+=[]ফাংশনগুলি কল করতে এবং তাই আমাদের ফাংশনগুলি একে অপরকে - বা নিজেরাই কল করতে পারে। এটি আমাদের পুনরাবৃত্তি দেয় যা আমাদের লুপ দেয় এবং হঠাৎ আমাদের কাছে ট্যুরিং-সম্পূর্ণতার জন্য প্রয়োজনীয় সমস্ত কিছু রয়েছে।

এখানে বৈশিষ্ট্যগুলির একটি সেটটির একটি রিডাউন রয়েছে যা টুরিং-সম্পূর্ণতা দেয় এবং কীভাবে এটি প্রয়োগ করা হয়:

  • আনবাউন্ডেড স্টোরেজ : কনস্ট্রাক্টর স্টোরেজে নেস্টেড অ্যারে
  • নিয়ন্ত্রণ প্রবাহ : ব্যবহার করে ifপুনরাবৃত্তি:
    • if: বুলিয়ানকে একটি সংখ্যায় রূপান্তর করুন এবং সূচকটিকে 2-এলিমেন্ট অ্যারে রূপান্তর করুন; একটি উপাদান thenস্ট্রিংফাইড হওয়ার পরে কেসটির জন্য ফাংশনটি চালায়, অন্য উপাদান elseস্ট্রিংফাইড হওয়ার পরে কেসটির জন্য ফাংশনটি চালায়
    • পুনরাবৃত্তি : কনস্ট্রাক্টর স্টোরেজের উপযুক্ত উপাদানটিকে স্ট্রাইফাই করুন
  • কমান্ড সিকোয়েন্সিং : [a]+[b]+[c]মূল্যায়ণ a, bএবং cবাম-থেকে-ডান (অন্তত ব্রাউজার আমি চেক দিকে)

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


16
যদি এটির নাম না দেওয়া হয় তবে আমি জে 5 এইচ * টি প্রস্তাব করি।
ক্যালকুলেটরফলাইন

1
একটি ভাল উদাহরণ প্রোগ্রাম কি হবে? প্রাইম টেস্ট? ওহে বিশ্ব?
ক্যালকুলেটরফলাইন

3
আমার, এই তাই ওয়াত সুস্বাদু উত্তর, একটি ভাল ভয়াবহ ছবিতে মত ...।
পাল্টে যাওয়া বন্ধ করে দেওয়া হয়েছে

4
আমি ভেবেছিলাম অ্যাঙ্গুলার 1 এর toString()নির্ভরতা ইনজেকশনের জন্য ব্যবহারটি ফাংশনটি ব্যবহারের সর্বাধিক সৃজনশীল উপায়। এখন আমি আমার মন পরিবর্তন।
সানি পুন

1
এখানে একটি উদাহরণ রয়েছে: পেস্টবিন.
com

55

ইউনারি , 1 টি চরিত্র

0

চরিত্রের পছন্দটি আসলেই কিছু যায় আসে না; প্রোগ্রামটির দৈর্ঘ্য ব্রেনফাক প্রোগ্রামটিকে সংজ্ঞা দেয় যা এতে স্থানান্তরিত হয়। যদিও বৈশিষ্টটি 0অক্ষরগুলি নির্দেশ করে , বেশিরভাগ পরিবহনকারীরা এটি চেক করে বলে মনে হয় না।


44
আমাদের সম্ভবত ট্রান্সপ্লারদের সাথে অনুমানটি যাচাই করে নেওয়া উচিত, এটি একটি খুব গুরুতর সমস্যা serious
ক্যাপ্টেন ম্যান

5
আমি হতবাক। আমার এটি 20 মিনিটের দরকার ছিল এটি একটি রসিকতা কিনা tell
পিটার এ স্নাইডার

3
@ পিটারএ.স্নাইডার কিছু গুগলিং দেখতে পাবেন যে কেউ আসলে তাত্ত্বিকভাবে এইভাবে একটি কুইন বাস্তবায়ন করেছিলেন, যদিও 0 এর ফলাফলযুক্ত স্ট্রিং সম্ভবত আমি সবচেয়ে বেশি সংখ্যক যা আমি কখনও ব্যবহারিক প্রসঙ্গে দেখেছি এবং কখনই বাস্তব মেশিনে প্রয়োগ করা যায়নি।
ড্যারেন রিঞ্জার

12
সেই শূন্যের স্ট্রিংটি হ'ল আমি যে কোনও প্রসঙ্গে যা দেখেছি তা সর্বনিম্ন সংখ্যা।
ম্যাথু

1
LOL, আচ্ছা, আপনি যদি একটি মাত্র প্রতীককে একটি সংযোজনীয় পরিচয় হিসাবে সংজ্ঞায়িত করার মতো নির্বোধ কিছু করেন ...: পি
ড্যারেন

37

vim, 9 8 7 6 টি অক্ষর

<C-v><esc>1@ad

আমরা নিম্নলিখিত হিসাবে একটি নির্বিচারে উইমস্ক্রিপ্ট প্রোগ্রামটি তৈরি করতে এবং চালিত করতে পারি:

  1. aa<C-v><C-v>1<esc>dd@1<esc>ddddএকটি <C-a>রেজিস্টার পেতে ক্রম ব্যবহার করুন 1

  2. এর সাথে সন্নিবেশ মোড প্রবেশ করুন a, তারপরে একটি সন্নিবেশ করুন a, যা পরে কোনও ম্যাক্রোতে সন্নিবেশ মোডে পুনরায় প্রবেশ করতে ব্যবহৃত হবে।

  3. কাঙ্ক্ষিত উইমস্ক্রিপ্ট প্রোগ্রামের প্রতিটি চরিত্রের জন্য,

    1. ব্যবহার <C-v><C-v>1<esc>আক্ষরিক ক্রম সন্নিবেশ করতে <C-v>1,

    2. ব্যবহার @1(যা <C-a><cr>, যা চূড়ান্ত <cr>কোন সমিতি গত লাইনে হচ্ছে কারণে) যতবার বাড়াতে প্রয়োজনীয় হিসাবে 1পর্যন্ত আকাঙ্ক্ষিত চরিত্র ASCII মান এসে যাবে,

    3. এবং সন্নিবেশ মোড পুনরায় প্রবেশ করুন a

  4. লাইন মুছুন মধ্যে (একটি trailing রাখুন NEWLINE সহ) 1সঙ্গে রেজিস্টার <esc>dd

  5. আগের পদক্ষেপটি থেকে অনুসরণ করে নতুন লাইনের মাধ্যমে প্রবেশ করা লাইনটি মুছতে @1, ব্যবহার করে ভিএম কীস্ট্রোক হিসাবে ফলাফলটি কার্যকর করুন <esc>dd

  6. বাইটগুলির ফলে স্বেচ্ছাসেবী ক্রম চালান dd@1। এটি যদি একটি দিয়ে শুরু হয় :, এটি ভিমস্ক্রিপ্ট কোড হিসাবে ব্যাখ্যা করা হবে এবং এটি নতুন ট্র্যাকিংয়ের পরে চালানো হবে dd

আমি নিশ্চিত নই যে এটি একটি ন্যূনতম চরিত্রের সেট, তবে টুরিং-সম্পূর্ণ হিসাবে প্রমাণ করা বেশ সহজ।


2
আপনি কি i<C-v>1<ESC>লিখতে পারবেন না <C-a>এবং তারপরে ddআপনি @1কোনও সংখ্যা বাড়ানোর জন্য ব্যবহার করতে পারবেন এবং ফলস্বরূপ ব্যবহার না করতে হবে <C-a>?
গরু

4
বাহ, এই উত্তরটি অবিশ্বাস্য! +1 টি!
ডিজেএমসিএমহেম

@ ক্রিতিক্সিলিথোস যা কিছুটা পুনর্গঠনের পরে কাজ শেষ করে, ধন্যবাদ!
ডুরকনবব

2
@ mbomb007 প্রকৃতপক্ষে ... একটি আকর্ষণীয় প্রয়োগের বিশদের কারণে, <C-v>10\ n (জিজ্ঞাসা করবেন না) এর পরিবর্তে একটি এনএইউএল প্রবেশ করান। যাইহোক, হ্যাঁ, টুরিং-সম্পূর্ণতার সাথে এটি কোনও ব্যাপার নয়।
ডুরনবব

1
এটি কি খাটো হতে পারে? golf.shinh.org/p.rb?Hello+broken+keyboard#Vim
mbomb007

33

পার্ল, 5 টি অক্ষর

<>^es

অন্যান্য স্ক্রিপ্টিং ভাষার মতো, ধারণাটিও evalস্বেচ্ছাসেবী স্ট্রিংগুলি। তবে, আমাদের চরিত্রের সেটটিতে কোটস বা কনটেনটেশন অপারেটর অন্তর্ভুক্ত নেই, তাই স্বেচ্ছাচারী স্ট্রিংগুলি তৈরি করা আরও জটিল be নোট করুন যে eval^"এটি মোকাবেলা করতে অনেক সহজ হবে, তবে আরও একটি চরিত্র রয়েছে।

আমাদের মূল সরঞ্জামটি s<^><CODE>ee, যা প্রদর্শিত হয় CODE, তারপরে তার আউটপুটকে দেখায়। eপ্রত্যাশিত প্রভাব সহ আরও যোগ করা যায়।

আমরা স্ট্রিংগুলি ব্যবহার করে পাই <>, যা গ্লোব অপারেটর যখন না হয় তখন বাদে। প্রথম অক্ষরটি হতে পারে না <(অন্যথায় এটি <<অপারেটরের মতো দেখায় ), কোণ বন্ধনীগুলি ভারসাম্যপূর্ণ হওয়া দরকার, এবং কমপক্ষে একটি অক্ষরযুক্ত অক্ষর থাকতে হবে (অন্যথায় এটি পঠন অপারেটর হিসাবে ব্যাখ্যা করা হয়)।

এই স্ট্রিংগুলিকে একসাথে রেখে, আমরা ^B^V^S(*-/9;<>HJMOY[`\^begqstvযতক্ষণ না কিছু চারপাশে আবর্জনা গ্রহণের বিষয়টি গ্রহণ করি ততক্ষণ আমরা যে কোনও অক্ষরের সংমিশ্রণ পেতে পারি (এর মধ্যে প্রথম তিনটি নিয়ন্ত্রণ অক্ষর)।

উদাহরণস্বরূপ, ধরুন আমরা পেতে চাই "v99"। পাওয়ার একটি উপায় v99হ'ল "><<" ^ "e>>" ^ "see" ^ "^^^"তবে আমরা সীমাবদ্ধতার কারণে সেই স্ট্রিংগুলিকে প্রতিনিধিত্ব করতে পারি না <>। সুতরাং পরিবর্তে, আমরা ব্যবহার:

<^<<^>><>>^<^^^^^<>>^<^^^^^^e>^<^^^^^^^>^<^^^^^e>^<^^^^e^>^<e^^es>^<^ee^^>^<^<^^^^^>>^<^<>^^^^>^<^^^^^^^e>^<^^^^^^^^>

উপরের ফলন Y9;v99;, যা, যখন ইওল-এড হয়, সমভূমি হিসাবে একই ফলন করে v99(যেমন, ASCII কোড 99 সহ অক্ষর)।

এইভাবে আমরা ^B^V^S(*-/9;<>HJMOY[`\^begqstvআমাদের নির্বিচারে স্ট্রিং তৈরি করতে পুরো চরসেটটি ব্যবহার করতে পারি , তারপরে এটি উপরের রূপে রূপান্তর করতে এবং এটি s<><CODE>eeeeকার্যকর করতে একটিতে আটকে থাকি stick দুর্ভাগ্যক্রমে, এই চরসেটটি এখনও খুব সীমাবদ্ধ, কোনভাবে স্পষ্টভাবে উপস্থাপনের উপায় ছাড়াই।

তবে ভাগ্যক্রমে, এতে তারা রয়েছে। এটি আমাদের লিখতে দেয় *bযা স্ট্রিংয়ের মূল্যায়ন করে "*main::b"। তারপরে, *b^<^B[MMH^V^SY>(^ বি, ^ ভি এবং ^ এস আক্ষরিক নিয়ন্ত্রণের অক্ষর) আমাদের দেয় (6, $&);, যা আবার যখন ইওল-এড হয়, তখন পার্লের ম্যাচ ভেরিয়েবলের মান প্রদান করে $&,। এটি আমাদেরকে সীমিত আকারের সংমিশ্রণ ব্যবহার করতে দেয়: আমরা বারবার $_ব্যবহারে জিনিসগুলি আগে থেকে প্রস্তুত করতে পারি s<^><THINGS>e, এবং তারপরে s<\H*><*b^<^B[MMH^V^SY>>eeeবিবর্তনের জন্য ব্যবহার করতে পারি $_( \Hঅনুভূমিক শ্বেতস্থান ছাড়া অন্য কোনও কিছুর সাথে মেলে; আমরা এটি বিন্দুর পরিবর্তে ব্যবহার করি, যা আমাদের অক্ষরে নেই)।

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

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

say$$

আমরা এটিকে ভি-স্বরে রূপান্তর করি:

s<><v115.v97.v121.v36.v36>ee

আমরা এটি ব্যবহার করে কেবল ^B^V^S(*-/9;<>HJMOY[`\^begqstvএটিই আবার লিখি (সাদা স্থান কেবল পঠনযোগ্যতার জন্য এবং আউটপুটকে প্রভাবিত করে না):

s<^><
    s<^><9*9-9-9-9-9-9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><9*9-9-9-9-9-9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><99-99/-9-99/-9>e;
    s<^><v>;
    s<v\H\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><99-9/9-9/9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><999/9-9/-9-9/-9-9/-9-9/-9>e;
    s<^><v>;
    s<v\H\H\H><*b^<^B[MMH^V^SY>>eee;
    s<\H*><*b^<^B[MMH^V^SY>>eee;
>eee;

শেষ পর্যন্ত, আমরা উপরের প্রোগ্রামটিকে কেবল <>^es: পেস্টবিনে রূপান্তর করি । দুঃখের বিষয়, এটি পার্লকে দিয়ে ক্র্যাশ করে Excessively long <> operator, তবে এটি কেবল একটি প্রযুক্তিগত সীমাবদ্ধতা এবং এটি বিবেচনায় নেওয়া উচিত নয়।

ভাই, বেশ যাত্রা ছিল। কেউ 5 টি চরিত্রের সেট নিয়ে এসেছেন যা জিনিসগুলি আরও সহজ করে তোলে তা দেখতে খুব আকর্ষণীয় হবে।

সম্পাদনা: কিছুটা ভিন্ন পদ্ধতির ব্যবহার করে আমরা দৈর্ঘ্যের সীমাটি আঘাত করা এড়াতে পারি <>। সম্পূর্ণরূপে ক্রিয়াকলাপ ব্রেণফাক কেবলমাত্র ব্যাবহারকারী <>^es: এটি অনলাইনে ব্যবহার করে দেখুন! <>^esট্রান্সপ্লায়ার থেকে স্বয়ংক্রিয় পার্ল : পেস্টবিন


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

@ আরজান জোহেনসেন হ্যাঁ, ভাল কাজ তা খুঁজে পেয়েছে। আমি এখনই একটি সমাধান নিয়ে কাজ করছি।
গ্রিমি

আপনি এই সঙ্কুচিত উদাহরণটিকে টিআইও লিঙ্ক বানাতে পারেন অনলাইনে চেষ্টা করে দেখুন!
janrjan জোহানসেন

7
অনুরোধ: এই "কিছুটা ভিন্ন পদ্ধতির" ব্যাখ্যা করুন
ক্যালকুলেটরফালাইন

32

পাইথন 2, 7 টি অক্ষর

exc="%\n

যে কোনও পাইথন 2 প্রোগ্রাম এই 7 টি অক্ষর ( \nনতুন লাইন) ব্যবহার করে এনকোড করা যেতে পারে ।

নির্বিচারে স্ট্রিং নির্মাণ

আমরা %একক স্ট্রিংয়ে বারবার সাবস্টিটিউশন অপারেটর প্রয়োগ করে কনট্যাকটেশন করতে পারি । উদাহরণস্বরূপ, যদি a=1, b=2, c=3, "%d%%d%%%%d" % a % b % cআমাদের স্ট্রিংটি দেয় "123"। সৌভাগ্য যে, অক্ষর execআমাদের অ্যাক্সেস দিতে %xএবং %cযা মূলত হয় hex()এবং chr()। এর সাহায্যে %c, আমরা যতক্ষণ না প্রয়োজনীয় অক্ষরগুলি উপস্থাপন করে প্রয়োজনীয় সংখ্যক স্ট্রিং তৈরি করতে পারি। এরপরে আমরা execকীওয়ার্ডটি ব্যবহার করে পাইথন কোড হিসাবে এই স্ট্রিংটি চালাতে পারি ।

সংখ্যা তৈরি করুন

আমরা তুলনা ( ) এর সাথে ব্যাটে সরাসরি প্রবেশ করতে 0এবং পেয়ে যেতে পারি । সংক্ষিপ্ত অঙ্ক এবং মডুলোর সংমিশ্রণের মাধ্যমে, ASCII তে প্রতিনিধিত্ব করে এমন সংখ্যাটি তৈরি করা সম্ভব । এটি আমাদের কোডের জন্য আমাদের প্রয়োজনীয় সংখ্যাগুলি তৈরি করতে সহায়তা করে।1==43+

একসাথে রেখে

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

import sys

var = {
    43: 'e',
    'prog': 'x', # the program will be stored in this variable
    'template': 'c',
    0: 'ee',
    1: 'ex',
    2: 'ec',
    4: 'xe',
    8: 'xx',
    16: 'xc',
    32: 'ce',
    64: 'cc',
    'data': 'cx', # source program will be encoded here
}

unpacker = 'exec"".join(chr(eval(c))for c in {}.split())'.format(var['data'])

source = sys.stdin.read()
charset = sorted(list(set(source+unpacker)))
codepoints = map(ord, charset)

output = (
    # create template for joining multiple characters
    '{}="%c%%c%%%%c%%%%%%%%c"\n'.format(var['template']) +

    # create 1
    '{0}={1}=={1}\n'.format(var[1], var['template']) +

    # create 0
    '{}={}==""\n'.format(var[0], var['template']) +

    # create 3
    # store it at var[43] temporarily
    (
        'exec"{0}=%x%%x"%{2}%{2}\n' +
        'exec"{0}%%%%%%%%=%x%%x%%%%x"%{1}%{2}%{1}\n'
    ).format(var[43], var[0], var[1]) +

    # create 4
    # this step overwrites the value stored at var[0]
    (
        'exec"{1}=%x%%x"%{0}%{1}\n' +
        'exec"{1}%%%%=%x%%x"%{2}%{0}\n'
    ).format(var[43], var[0], var[1]) +

    # create 43
    'exec"{0}=%x%%x"%{1}%{0}\n'.format(var[43], var[0])
)

# create powers of 2
for i in [2, 4, 8, 16, 32, 64]:
    output += 'exec"{0}={1}%c{1}"%{2}\n'.format(var[i], var[i/2], var[43])

for i, c in enumerate(codepoints):
    # skip if already aliased
    if c in var:
        continue

    # generate a new name for this variable
    var_name = ''
    if i < 27:
        for _ in range(3):
            var_name += 'exc'[i%3]
            i /= 3
    else:
        i -= 27
        for _ in range(4):
            var_name += 'exc'[i%3]
            i /= 3
    var[c] = var_name

    # decompose code point into powers of two
    rem = c
    pows = []
    while rem:
        pows.append(rem&-rem)
        rem -= rem&-rem

    # define this variable
    front = 'exec"{}={}'.format(var[c], var[pows.pop()])
    back = '"'
    for i, p in enumerate(pows):
        front += '%'*(2**i) + 'c' + var[p]
        back += '%' + var[43]
    output += front + back + '\n'

# initialise the unpacker
output += 'exec"""{}=""\n"""\n'.format(var['prog'])
i = 0
length = len(unpacker)
while i < length:
    if (length-i) % 4 == 0:
        # concat 4 characters at a time
        w, x, y, z = [var[ord(unpacker[i+j])] for j in range(4)]
        output += 'exec"{}%c={}%%{}%%{}%%{}%%{}"%{}\n'.format(var['prog'], 
                    var['template'], w, x, y, z, var[43])
        i += 4
    else:
        output += 'exec"""{}%c="%%c"%%{}"""%{}\n'.format(var['prog'],
                    var[ord(unpacker[i])], var[43])
        i += 1

# encode source data
output += var['data'] + '="""'
output += '\n'.join(var[ord(c)] for c in source)
output += '"""\n'

# execute the program
output += 'exec"exec%c{}"%{}'.format(var['prog'], var[32])

print output

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


ইনপুট প্রোগ্রামটি ইতিমধ্যে প্রয়োজনীয় অক্ষরগুলির মধ্যে সীমাবদ্ধ কিনা তা দেখতে আপনি কিছু চেক যোগ করতে পারেন এবং যদি তাই হয় তবে কেবল বিড়াল।
mbomb007

26

গণিত, 5 4 অক্ষর

I[]

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

এই ব্যবহার করে, আমরা বাস্তবায়ন করতে পারে S, Kএবং Icombinators সমন্নয়ের যুক্তি:

I -> II↦II
K -> II↦III↦II
S -> II↦III↦IIII↦II[IIII][III[IIII]]

এগুলির সাথে একটি সিনট্যাক্টিক সমস্যা হ'ল এটি খুব কম নজরে রয়েছে যা আমরা যদি এই সংযুক্তকারীগুলির সাথে যুক্তিগুলি চেষ্টা করার চেষ্টা করি তবে সমস্যা হবে। আপনি সাধারণত Cবন্ধনীগুলিতে যেমন একটি সংযুক্তকারী মোড়ানো দ্বারা এটি ঠিক করতে হবে (C), কিন্তু আমাদের বন্ধনী নেই। তবে আমরা ব্যবহার করতে পারি Iএবং অন্য কোনও যাদুতে []মোড়াতে Cপারি যা পর্যাপ্ত উচ্চ নজরে রয়েছে যা আমরা পরে এটি ব্যবহার করতে পারি:

I[C][[I[[]]I]]

অবশেষে, একটি অ্যাপ্লিকেশন লিখতে A x y z(যেখানে Aএকটি combinator "parenthesised" হিসাবে উপরে দেখানো হয়, এবং x, y, zবা parenthesised নাও হতে পারে পারে, অথবা বড় এক্সপ্রেশন হতে পারে), আমরা লিখতে পারেন:

A[x][y][z]

এটি বন্ধনী-সমতুল্য আসলে কীভাবে কাজ করে তা প্রশ্ন ছেড়ে দেয়। আমি এটিটি যে ক্রমটি সামনে এলাম তা মোটামুটিভাবে ব্যাখ্যা করার চেষ্টা করব।

তাই আমাদের যে জিনিসটি সিন্টেক্সিকভাবে কিছুতে গ্রুপ করতে হয়েছে তা হ'ল বন্ধনী []। গাণিতিকগুলি ম্যাথমেটিকায় দুটি উপায়ে প্রদর্শিত হয়। হয় ফাংশন আমন্ত্রণ হিসাবে f[x], বা একটি সূচক অপারেটর হিসাবে f[[i]](যা সত্যিই কেবল সংক্ষিপ্ত Part[f, i]) hand বিশেষত এর অর্থ হ'ল বৈধ বাক্য গঠন নয় [C]nor [[C]]আমাদের সামনে কিছু দরকার। তাত্ত্বিকভাবে যে কোনও কিছু হতে পারে। আমরা যদি Iইতিমধ্যে আমাদের ব্যবহার করি তবে আমরা I[C]উদাহরণস্বরূপ পেতে পারি । এটি অবমূল্যায়িত থেকে যায়, কারণ Iএটি অযৌক্তিক ফাংশন নয় (এটি কোনও ক্রিয়া নয়)।

তবে এখন Cআবার উত্তোলনের জন্য আমাদের কিছু উপায়ের প্রয়োজন , কারণ অন্যথায় যখন আমরা xএটির সাথে কোনও যুক্তি দেওয়ার চেষ্টা করি তখন এটির মূল্যায়ন করা হবে না ।

এটি এখানে কার্যকর হয় যা কেবল তালিকাগুলি নয়, f[[i]]ইচ্ছামত প্রকাশের জন্য ব্যবহার করা যেতে পারে f। ধরে নিই যে সে fনিজেই ফর্মের head[val1,...,valn], তারপর f[[0]]দেয় head, f[[1]]দেয় val1, f[[-1]]দেয় valnইত্যাদি and সুতরাং আমাদের হয় পেতে হবে 1বা আবার -1এক্সট্র্যাক্ট Cকরা, কারণ হয় হয় I[C][[1]]বা I[C][[-1]]মূল্যায়ন C

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

কিন্তু এটি একটি চূড়ান্ত সমস্যা ছেড়ে দেয়: আমরা আসলে কীভাবে Iনিজেই গুণ করব ? আমরা কেবল লিখতে পারি না IIকারণ এটি একটি একক প্রতীক হিসাবে পার্স হয়ে যায়। ক) এর মান পরিবর্তন না করে আমাদের এই টোকেনগুলি আলাদা করতে হবে এবং খ) কোনও নতুন অক্ষর ব্যবহার করে।

একটি যাদুবিদ্যার চূড়ান্ত বিট হ'ল অননুমোদিত আচরণের একটি অংশ: f[[]](বা সমতুল্য Part[f]) বৈধ বাক্য গঠন এবং fনিজেই ফিরে আসে । সুতরাং পরিবর্তে গুণ Iদ্বারা I, আমরা I[[]]দ্বারা গুণ I। বন্ধনী সন্নিবেশ করানোর ফলে ম্যাথেম্যাটিকাকে পরে একটি নতুন টোকেন সন্ধান I[[]]Iকরতে হবে -1এবং প্রয়োজনীয় হিসাবে মূল্যায়ন করুন । এবং এইভাবেই আমরা শেষ করি I[C][[I[[]]I]]

নোট করুন যে আমরা ব্যবহার করতে পারি না I[]। এটি ফাংশনটির একটি যুক্তিহীন প্রার্থনা I, তবে যেমনটি আমি আগে বলেছি Iকোনও ফাংশন নয়, সুতরাং এটি অপরিবর্তিত থাকবে।


আশ্চর্য উত্তর।
প্যাট্রিক স্টিভেন্স

23

পাইথন 2, 8 টি অক্ষর

exc'%~-0

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

একটি ডাবল উদ্ধৃতি চিহ্নের পাশাপাশি শূন্য ব্যতীত যে কোনও একক অঙ্কও ব্যবহার করা যেতে পারে। (এখন আমি এটা সম্পর্কে কি মনে করে যে, 1নিশ্চিতরুপে ভালর যেহেতু আপনি ব্যবহার করতে পারে হবে, খাটো প্রোগ্রাম ফলে, 1, 11, এবং 111, পাশাপাশি।)

প্রোগ্রামটি এখানে print:

exec'%c%%c%%%%c%%%%%%%%c%%%%%%%%%%%%%%%%c'%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0

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

বেস প্রোগ্রাম প্রয়োজন

exec''

xপ্রোগ্রামে যুক্ত প্রতিটি চরিত্রের জন্য প্রয়োজনীয় (চর গণনা):

  • % - 2**(n-1)
  • c - 1
  • - - ord(x)*2
  • ~ - ord(x)*2
  • 0 - 1

এর ব্যতিক্রম হ'ল এনকোডযুক্ত প্রোগ্রামকে ছোট করার জন্য নির্দিষ্ট অপ্টিমাইজেশন / শর্টকাট নেওয়া যেতে পারে যেমন 48 এর পরিবর্তে %'0'অক্ষরের জন্য ব্যবহার করা ইত্যাদি etc.0-~

ব্যবহারিক ব্যবহার (একে একে গল্ফিং): আমি অতিরিক্ত প্রতিবন্ধক চরিত্রটি ব্যবহার না করেই এই চ্যালেঞ্জটি সমাধান করার জন্য এই কৌশলটি ব্যবহার করেছি।

অক্ষর তালিকা এবং একটি এনকোডার প্রোগ্রামের জন্য ক্রেডিট: এখানে

ফলাফলের আকারের (অপ্টিমাইজেশন ছাড়াই) আকারের নিম্ন সীমা নির্ধারণের তথ্যের জন্য, এই মন্তব্যটি দেখুন

প্রয়োজনীয় বাইটের সংখ্যা বেড়ে যায় O(2**n), তাই গল্ফ করার জন্য এই পদ্ধতিটি সুপারিশ করা হয় না। এই উত্স সীমাবদ্ধতা ব্যবহার করে একটি কুইন অত্যন্ত দীর্ঘ be


যদি কেবল অপারেটর অগ্রাধিকার কার্যকর হয় +বা এর -আগে %, আমরা একটি অক্ষর মুছে ফেলতে পারি।
mbomb007

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

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

@ এমমাচেনরি পাইথন তার নিজস্ব সংকলক এবং দোভাষী ব্যবহার করছে । এটি অন্য একটি পৃথক ভাষা ব্যবহার করছে না। এবং পাইথনে একটি ব্রেইনফাক ইন্টারপ্রেটার তৈরি করা হয়েছে, সুতরাং এটি ট্যুরিং কমপ্লিট। সেই জ্ঞানটি ব্যবহার করে আপনার যুক্তিটি মিথ্যা।
mbomb007

@ mbomb007 আমার যুক্তিটি মিথ্যা নয়। পাইথন হ'ল স্পষ্টতই, একটি টার্নিং সম্পূর্ণ ভাষা। অভ্যন্তরীণ কলের জন্য আপনি যে কোনও অক্ষর চান তা ব্যবহার করে পাইথন থেকে পাইথন ইন্টারপ্রেটারকে কল করে গণনা করা হচ্ছে। আপনি যে ভাষাটিতে প্রোগ্রামটি নির্দিষ্ট করছেন তা হ'ল একটি এনকোডিং, কোনও প্রোগ্রামিং ভাষা নয়। এটি ব্যবহার করে, 0 এবং 1 বর্ণগুলি ব্যবহার করে এবং উত্স ফাইলগুলি বাইনারি হিসাবে দেখে আক্ষরিকভাবে প্রতিটি প্রোগ্রামিং ভাষা টিউরিং সম্পূর্ণ করতে তুচ্ছ Comp প্রশ্নের স্পিরিটটি যদিও আসল ভাষার একটি সিন্ট্যাক্টিক উপসেট খুঁজে পাওয়া যায়।
mmachenry

23

সি (অপরিবর্তনীয়), 24 18 13 টি অক্ষর

aimn[]={};,1+

এটি ফর্মের সমস্ত প্রোগ্রামকে অন্তর্ভুক্ত করে

main[]={<sequence of constants>};

... যেখানে ধ্রুবকের ক্রম (ফর্ম 1 + 1 + 1 ...) তে আপনার প্রোগ্রামটির মেশিন কোড উপস্থাপনা রয়েছে। এটি অনুমান করে যে আপনার পরিবেশটি সমস্ত মেমরি বিভাগগুলিকে সম্পাদন করার অনুমতি দেয় (টিসিসি [ধন্যবাদ ডেনিস ধন্যবাদ!] এবং এনএক্স বিট ছাড়াই কিছু মেশিনের জন্য দৃশ্যত সত্য)। অন্যথায়, লিনাক্স এবং ওএসএক্সের জন্য আপনাকে কীওয়ার্ডটি প্রেন্ডিং করতে হতে পারে constএবং উইন্ডোজের জন্য আপনাকে #pragmaস্পষ্টভাবে খণ্ডটিকে এক্সিকিউটেবল হিসাবে চিহ্নিত করতে হবে।

উদাহরণ হিসাবে, Hello, World!x86 এবং x86_64- এ লিনাক্স এবং ওএসএক্স-এর উপরোক্ত স্টাইলের মুদ্রণে নিম্নলিখিত প্রোগ্রামটি লেখা হয়েছে ।

main[]={111111111+111111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+11111+11111+11111+11111+11111+11111+11111+11111+111+11+11+11+11+11+11+1+1,1111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+11111+11111+11111+11111+11111+11111+1111+1111+1111+111+111+111+111+111+111,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+1+1+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+111+11+11+11+11+11+11+1+1+1+1,111111111+111111111+111111111+111111111+111111111+1111111+1111111+1111111+1111111+111111+111111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+11+11+11+11+1+1+1+1,111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+1111+1111+1111+111+111+111+111+111+11+11+11+11+11+11+1+1+1+1+1+1,111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+111+111+11+11+11+11+11+11+11+1,1111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+1111+1111+1111+1111+1111+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+1+1+1+1+1+1+1+1+1,1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+111111+111111+111111+111111+11111+11111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+11+11+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+1111+1111+1111+1111+1111+111+11+1+1+1+1+1,1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+1+1+1+1+1+1+1,1111111111+1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+11+1+1+1,1111111111+111111111+111111111+111111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+1+1+1+1+1+1,111111+111111+11111+11111+11111+11111+11111+11111+11111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+11+11+11+11+11+11+11+11+11+11,11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+11+11+11+11+11+11+11+1+1+1,111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+11+11+11+1,111111111+111111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+11+11+1+1+1+1+1,11111+11111+11111+11111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+1+1+1+1+1};

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


2
@ জিবি: জিরোর কমপক্ষে x86 মেশিন কোড ব্যবহার করা এড়াতে মোটামুটি সহজ (এটি কোনও ভয়ঙ্কর গুরুত্বপূর্ণ নির্দেশ নয়), বিশেষত কারণ যদি আপনার পরপর চারটি শূন্য বাইট থাকে তবে সমস্যাটি ঘটে।

2
@ জিবি 32 বিট 0==1111111111+1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+111+11+11+11+11+11+11+11+1
ইনট

3
tcc আপনাকে ছাড়াই ছাড়তে দেয় consttio.run/nexus/…
ডেনিস

8
@ জিবি আমি সবেমাত্র 0 1==11
টির

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

20

রেটিনা , 6 টি অক্ষর

$%`{¶

পাশাপাশি লাইনফিডস (0x0A)।

একদিকে আমি অবাক হয়েছি যে আমি এটিকে এতো কম করতে পেরেছি। অন্যদিকে, আমি অন্তর্ভুক্তিতে খুব অসন্তুষ্ট । প্রতিটির $`{দুটি বা এমনকি তিনটি উদ্দেশ্যে পুনরায় ব্যবহার করা হয় তবে একসাথে কেবলমাত্র একটি উদ্দেশ্য পরিবেশন করা হয়। এটি তাদেরকে বরং অপব্যয়যুক্ত বলে মনে করে এবং পদ্ধতির কমনীয়তাটিকে সামান্যভাবে নষ্ট করে। আমি আশা করি যে এই নির্মাণকে পরাস্ত করার উপায় আছে।

প্রমাণ পর্যন্ত। আমি উপরের অক্ষরগুলি ব্যবহার করে রেটিনার কাছে চক্রীয় ট্যাগ সিস্টেমগুলি অনুবাদ করার একটি সহজ উপায় বর্ণনা করতে চলেছি ।

প্রথমত, আমরা ব্যবহার হবেন `এবং {পরিবর্তে বাইনারি বর্ণমালা জন্য 0এবং 1। এগুলি সুবিধাজনক, কারণ তাদের একটি রেজেক্সে পালানোর দরকার নেই, তবে তাদের রেটিনা বা বিকল্প প্রতিস্থাপনের অর্থ রয়েছে। আমি ব্যাবহার করছি` জন্য 0এবং এর {জন্য1 তবে এই পছন্দটি নির্বিচারে। তদতিরিক্ত, আমরা স্মৃতিতে স্ট্রিংটি (এবং প্রযোজনাগুলি) বিপরীত করব, কারণ শেষ চরিত্রটির সাথে কাজ করা আমাদের ব্যবহার করতে দেয় $এবং $`পরিবর্তে ^এবং $', সর্বোচ্চ অক্ষরের পুনরায় ব্যবহার করতে দেয়।

যদি প্রাথমিক শব্দটি দ্বারা চিহ্নিত করা হয় Sএবং ith (বিপরীত) উত্পাদন বলা হয় , ফলস্বরূপ প্রোগ্রামটি দেখতে এরকম হবে:pi


S
{`

{$
¶p1$%``
``$

{$
¶p2$%``
``$

{$
¶p3$%``
``$

...

এই নির্মাণটি প্রতিবারই যখন কোনও উত্পাদন প্রয়োগ করা হয় তখন স্মৃতিতে অনিবার্যভাবে বেড়ে যায়, এবং এটি সমাপ্ত হওয়ার সম্ভাবনা নেই - আসলে, যেখানে চক্রাকার ট্যাগ সিস্টেমটি শেষ হয়ে যায় (যখন কার্যকারী স্ট্রিং ফাঁকা হয়ে যায়), ফলস্বরূপ রেটিনা প্রোগ্রামের আচরণটি হয়ে যায় মূলত অপরিবর্তিত

প্রোগ্রামটি কী করে তা দেখুন:


S

আমরা ওয়ার্কিং স্ট্রিংটি প্রাথমিক শব্দটির সাথে শুরু করে শুরু করি।

{`

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

প্রতিটি উত্পাদন দুটি পর্যায়ে প্রক্রিয়াজাত করা হয়। প্রথমে আমরা কেসটি মোকাবিলা করি যে নেতৃস্থানীয় (বা আমাদের ক্ষেত্রে চলমান) প্রতীক {, সেই ক্ষেত্রে আমরা উত্পাদনটি ব্যবহার করি:

{$
¶pi$%``

স্ট্রিংটি শেষ হলেই রেজেক্সগুলি মেলে {। যদি এটি হয় তবে আমরা এটির সাথে প্রতিস্থাপন করব:

  • একটি লাইনফিড ( )। আমরা কেবলমাত্র ওয়ার্কিং স্ট্রিংয়ের শেষ লাইনের সাথে কাজ করব, সুতরাং এটি কার্যকরভাবে স্ট্রিংটিকে এতদূর ছাড়িয়ে যায় (যার কারণে প্রোগ্রামটির মেমরির ব্যবহার বৃদ্ধি পাবে)।
  • বর্তমান উত্পাদন (pi ), যা আমরা এখানে কার্যক্ষম স্ট্রিংয়ের (যেখানে চক্রযুক্ত ট্যাগ সিস্টেম এটি সংযোজন করে) জন্য প্রস্তুতি নিচ্ছি।
  • পূর্ববর্তী অবশিষ্ট ওয়ার্কিং স্ট্রিং ( $%`)। এজন্য আমাদের সন্নিবেশ করা দরকার : $%`ম্যাচের বাকি সমস্ত জিনিস তুলেছে, তবে কেবল একই লাইনে। সুতরাং, এটি আগের প্রযোজনাগুলি থেকে ফেলে আসা সমস্ত আবর্জনা দেখতে পাবে না। এই কৌশলটি আমাদের মতো ওয়ার্কিং স্ট্রিংয়ের শুরুতে কিছু জাতীয় কিছু ব্যবহার না করে ওয়ার্কিং স্ট্রিংয়ের শেষে কিছু মিলিয়ে দেয় এবং এটি আমাদের প্রয়োজনীয় অক্ষরের উল্লেখযোগ্য পরিমাণে ফুটিয়ে তুলতে দেয়।(.+)$1
  • একক ব্যাকটিক ( `) এটি কার্যকরভাবে {(( 1সাইমবোল) এর সাথে আমরা একটি `( 0-সেম্বল) এর সাথে মিলেছি যাতে পরবর্তী পর্যায়ে এটি জানতে হবে যে আমরা ইতিমধ্যে বর্তমান উত্পাদন প্রক্রিয়াজাত করেছি কিনা তা প্রতিস্থাপন করে ।

প্রতিটি উত্পাদনের দ্বিতীয় অংশটি তখন তুচ্ছ ঘটনা যেখানে উত্পাদনটি বাদ যায়:

``$

আমরা কেবল একটি ট্রিলিং মুছি ``আমাদের প্রথম লাইনে দু'জনের দরকার কারণ হ'ল রেটিনা প্রথম ব্যাকটিকটিকে কনফিগারেশন এবং রেজেক্সের মধ্যে বিভাজক হিসাবে বিবেচনা করে। এটি কেবল এটিকে একটি খালি কনফিগারেশন দেয় যাতে আমরা রেগেক্সে নিজেই ব্যাকটিক্স ব্যবহার করতে পারি।


20

জাভা 7, 18 17 টি অক্ষর

\bcdefu0123456789

সমস্ত জাভা উত্স কোড ইউনিকোড কোড পয়েন্টে হ্রাস করা যেতে পারে। "এ" প্রয়োজন হয় না কারণ এটি কেবলমাত্র ব্যবহৃত হয় *:jJzZ। অ্যাসিরিস্টকটি গুণ বা ব্লক মন্তব্যের জন্য ব্যবহৃত হয়। গুণগুলি কেবল পুনরাবৃত্ত সংযোজন এবং আপনি পরিবর্তে একক লাইন মন্তব্য ব্যবহার করতে পারেন (বা কেবল সেগুলি বাদ দিতে পারেন)। কোলনটি টার্নারি অপারেটরগুলির জন্য ব্যবহৃত হয়, যা আপনি পরিবর্তে যদি একটি বিবৃতি ব্যবহার করতে পারেন, এবং অগ্রণী লুপগুলি ব্যবহার করতে পারেন, যা লুপগুলির জন্য স্বাভাবিকের সাথে প্রতিস্থাপন করা যেতে পারে। j এবং z জাভাতে কোনও কীওয়ার্ডের অংশ নয়।

অন্য কোনও অক্ষর অপসারণের চেষ্টা করার জন্য জাভা বয়লার প্লেটে প্রয়োজনীয় অক্ষরগুলির মধ্যে কমপক্ষে একটি যোগ করা প্রয়োজন class a{public static void main(String[]a){}}। নিচে দেখ:

1 -> a (which has already been removed)
2 -> r (required for "String")
3 -> S (required for "String")
4 -> t (required for "static")
5 -> S (required for "String")
6 -> v (required for "void")
7 -> g (required for "String")
8 -> ( (required for "main(String[]a)"
9 -> i (required for "static")
b -> { (required for "class a{")
c -> l (required for "class")
d -> } (required for "(String[]a){}}")
e -> n (required for "main")
f -> o (required for "void")

একটি হ্যালো ওয়ার্ল্ড প্রোগ্রাম সহ এখানে একটি উদাহরণ এখানে চেষ্টা করুন!

জাভা 8, 16 টি অক্ষর

\bdefu0123456789

এটি নির্দেশ করার জন্য ais523 কে ধন্যবাদ। জাভা 8 ইন্টারফেসকে স্থিত পদ্ধতিগুলি রাখার অনুমতি দেয় যার অর্থ আমরা "গ" ড্রপ করতে পারি কারণ "ক্লাস" এর "এল" এর জন্য আমাদের এটির প্রয়োজন নেই। "সি" এর জন্য ব্যবহৃত হয় ,<lL\|তাই আমরা "ক" অপসারণ করার চেয়ে কিছুটা বেশি জাভা কার্যকারিতা হারাতে পারি তবে আমাদের এখনও টুরিং সম্পূর্ণ হওয়ার মতো যথেষ্ট পরিমাণ রয়েছে। এটি অনলাইন চেষ্টা করুন!


3
অবশ্যই, কোন হেক্সাডেসিমাল অঙ্ক বাদ দেওয়া যায় তা নির্ধারণ করা জাভাতে এটি সমাধান করার আকর্ষণীয় অংশ? :)
মার্টিন এন্ডার

নিবন্ধন করুন আমি এই আরো অনেক কিছুতে কাজ করার পরিকল্পনা যখন আমি কিছু সময়ের পেতে
অকর্মা

6
এবং আমি যে কিছু লিখতে প্রস্তুত ছিলাম Java, 127 characters... খুব ভাল, পোকে;)
অলিভিয়ার গ্রাগোয়ার

আমার উত্তরে প্রয়োজনীয় অক্ষরের উপর ভিত্তি করে , আমি বিশ্বাস করি না যে অন্য কোনও হেক্স সংখ্যা মুছে ফেলা যায়।

3
আপনি যদি জাভা 8 এ চলে যান, আপনি 16 এ এটি করতে পারেন; জাভা 8 ইন্টারফেসগুলিকে স্থিতিশীল পদ্ধতিতে আপনাকে ড্রপ করার অনুমতি দেয় c(এতে থাকা সমস্ত বর্ণগুলি interfaceএখনও আপনার হেক্সাসের সাথে না aবা অ্যাক্সেসযোগ্য c)।

19

ভোল্টেজ , 5 অক্ষর

~{}

প্লাস লাইনফিডস (0x0A) এবং স্পেসস (0x20)।

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

এই হ্রাস জুড়ে একটি গুরুত্বপূর্ণ আক্রমণকারীটি হ'ল যে প্রতিটি প্রোগ্রাম (বা সাবপ্রগ্রাম) এর ফলে একই লাইনে শুরু হওয়া এবং শেষ হওয়া একটি ল্যাবরেথ প্রোগ্রাম (বা সাবপ্রগ্রাম) প্রদর্শিত হবে এবং একাধিক কলামও বিস্তৃত হবে।

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

কক্ষের মানগুলিকে অনুমতি দেওয়ার পরিবর্তে 0এবং 1আমরা ব্যবহার করছি 0এবং -1যা আমরা ~(বিটওয়াইজ অবহেলা) এর মাধ্যমে টগল করতে পারি । টুরিং-সম্পূর্ণতার উদ্দেশ্যে সঠিক মানগুলি বিবেচনা করে না। আমাদের স্ট্যাকের মানের দুটি অনুলিপিই পরিবর্তন করতে হবে, যা আমাদের আবার সম-দৈর্ঘ্যের অনুবাদ দেয়: *হয়ে যায় ~}~{

যা কন্ট্রোল ফ্লো কমান্ড ছেড়ে দেয় []। ল্যাবরেথের স্পষ্ট নিয়ন্ত্রণ প্রবাহ নেই, তবে পরিবর্তে নিয়ন্ত্রণ প্রবাহ কোডের বিন্যাস দ্বারা নির্ধারিত হয়। এই লেআউটিংটি করার জন্য আমাদের স্পেস এবং লাইনফিডের প্রয়োজন।

প্রথমত, দ্রষ্টব্য যে ~~এটি কোনও বিকল্প নেই, কারণ দু'জন ~কার্যকরভাবে বাতিল করে। কোডটিতে নির্বিচারে দীর্ঘ পথ পেতে আমরা এটি ব্যবহার করতে পারি, যতক্ষণ তার দৈর্ঘ্য সমান হয়। আমরা এখন AA[BB]CCল্যাবরেথ অনুবাদ করতে নিম্নলিখিত নির্মাণগুলি ব্যবহার করতে পারি (আমি ডাবল অক্ষর ব্যবহার করছি যাতে ল্যাবরেথের প্রতিটি স্নিপেটের আকার সমান হয়, যেমন আক্রমণকারী দ্বারা নিশ্চিত করা হয়):

      ~~~~
      ~  ~~~
AA~~..~~~~ ~CC
   ~     ~
   ~     ~
   ~     ~
   ~~~BB~~

এখানে, প্রস্থের সাথে মেলে ..এমন একটি উপযুক্ত সংখ্যা ।~BB

আবার, নোট করুন যে নির্মাণের প্রস্থ এমনকি সমান হয়।

এই লুপটি কীভাবে কাজ করে তা আমরা এখন যেতে পারি। কোডটির মাধ্যমে প্রবেশ করানো হয়েছে AA। প্রথমটি ~~কিছুই করে না এবং আমাদের জংশনে পৌঁছাতে দেয়। এটি মোটামুটি এর সাথে মিলে যায় [:

  • যদি বর্তমান ঘরের মান শূন্য হয়, আইপি সরাসরি এগিয়ে চলে, যা শেষ পর্যন্ত এড়িয়ে চলে BB..অংশ এখনও একটি নো-অপ হয়। তারপরে আমরা ~অন্য জংশনে একটিতে পৌঁছে যাই । আমরা এখন জানি যে বর্তমান মানটি শূন্য নয়, সুতরাং আইপি পালাটি উত্তরে নিয়ে যায়। এটি শীর্ষে বাঁকের চারপাশে যায়, যতক্ষণ না এটি ছয়টির পরে অন্য জংশনে পৌঁছায় ~। সুতরাং সেই মুহুর্তে বর্তমান মানটি এখনও শূন্য নয় এবং আইপি আবার ঘুরতে পূর্ব দিকে দিকে অগ্রসর হয় CC। নোট করুন যে তিনটি বর্তমান মানটি ফেরত দেওয়ার ~আগে , লুপটি এড়িয়ে যাওয়ার সময় হওয়া উচিত।CC0
  • লুপের শুরুতে বর্তমান সেল মানটি যদি শূন্য হয় না, আইপিটি বাঁকটি দক্ষিণে নেয়। এটি ~পৌঁছানোর আগে আরও ছয়টি চালায় BB(যা কিছুই করে না) এবং তার ~পরের জংশনে পৌঁছানোর আগে আরও ছয়টি চলে। এই মোটামুটিভাবে অনুরূপ ]
    • যদি বর্তমান ঘরটি শূন্য হয়, আইপি উত্তর দিকে অগ্রসর হয়। পরবর্তীটি ~মানটি শূন্য করে তোলে, যাতে আইপি এই দ্বিতীয় জংশনটি নেয়, যা লুপটিকে পুরোপুরি বাদ দেওয়া হয়েছিল এমন ক্ষেত্রে পথটি একত্রিত করে। আবার তিনটি ~মান পৌঁছানোর আগে শূন্যে ফিরে আসে CC
    • যদি বর্তমান ঘরটি শূন্য নয়, আইপিটি টার্নটি পশ্চিমে নেয়। ~পরবর্তী জংশনের আগে রয়েছে , যার অর্থ এই মুহুর্তে বর্তমান মান শূন্য যাতে আইপি পশ্চিম দিকে যেতে থাকে। তারপরে ~আইপি আবার প্রাথমিক জংশনে পৌঁছানোর আগে একটি বিজোড় সংখ্যা থাকবে , যাতে মানটি ফিরে আসে -1এবং আইপি দক্ষিণে পরবর্তী পুনরাবৃত্তির দিকে চলে যায়।

প্রোগ্রামটিতে যদি কোনও লুপ থাকে তবে প্রথমে প্রথমে AAপ্রোগ্রামের শীর্ষে প্রসারিত করা প্রয়োজন যাতে আইপি শুরু হওয়ার জন্য সঠিক ঘরটি খুঁজে পায়:

~     ~~~~
~     ~  ~~~
AA~~..~~~~ ~CC
   ~     ~
   ~     ~
   ~     ~
   ~~~BB~~

এটাই ঐটা. নোট করুন যে এই হ্রাসের ফলে প্রাপ্ত প্রোগ্রামগুলি কখনই শেষ হবে না, তবে এটি টুরিং-সম্পূর্ণতার প্রয়োজনীয়তার অংশ নয় (101 এর নিয়ম বা ফ্র্যাক্ট্রান বিবেচনা করুন)।

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

লেআউট কমান্ড হিসাবে, আমি বিশ্বাস করি যে লাইনফিডগুলি প্রয়োজনীয়, কারণ একক লাইনে দরকারী নিয়ন্ত্রণ প্রবাহ অসম্ভব। তবে ফাঁকা স্থান প্রযুক্তিগতভাবে প্রয়োজনীয় নয়। তত্ত্বগতভাবে এমন একটি নির্মাণ নিয়ে আসা সম্ভব হতে পারে যা পুরো গ্রিডটি ~{}(বা =()বা =-~) দিয়ে পূর্ণ করে বা একটি র‌্যাগড লেআউট ব্যবহার করে যেখানে লাইনগুলি একই দৈর্ঘ্য নয় are যাইহোক, এর মতো কোডটি লেখা অবিশ্বাস্যভাবে কঠিন, কারণ লাইব্রের্নথ তখন প্রতিটি একক কক্ষকে একটি জংশন হিসাবে বিবেচনা করবে এবং আপনি যখন চান না তখন কোডটি শাখা থেকে রক্ষা করার জন্য আপনাকে সত্যই যত্নবান হওয়া দরকার। ট্যুরিং-সম্পূর্ণতার পক্ষে যদি জায়গাটি বাদ দেওয়া সম্ভব হয় বা কেউ প্রমাণ করতে পারে বা অস্বীকার করতে পারে তবে আমি এর জন্য একটি বিশাল আকারের অনুদান দিতে পেরে খুশি হব। :)


19

হাস্কেল, 5 7 টি অক্ষর

()\->=;

কার্যকরী ভাষা হিসাবে হাস্কেলের অবশ্যই ল্যাম্বডাস রয়েছে, সুতরাং ল্যাম্বডা ক্যালকুলাস অনুকরণ করা সহজ। ল্যাম্বডাসের সিনট্যাক্সটি তাই আমাদের কমপক্ষে অক্ষরগুলির প্রয়োজন । অতিরিক্তভাবে, স্বেচ্ছাসেবী ল্যাম্বদা এক্সপ্রেশন তৈরি করতে সক্ষম হতে আমাদের সীমাহীন পরিমাণের পরিবর্তনশীল চিহ্নগুলির প্রয়োজন। সৌভাগ্য যে আমরা এই জন্য কোনো নতুন অক্ষর প্রয়োজন হবে না, কারণ , , , ..., সকল বৈধ পরিবর্তনশীল নাম। প্রকৃতপক্ষে বন্ধনীর অভ্যন্তরের প্রতিটি সংমিশ্রণ একটি বৈধ পরিবর্তনশীল নাম, কেবলমাত্র এবং ব্যতীত , যা ল্যাম্বদা এক্সপ্রেশনগুলির জন্য সংরক্ষিত থাকে এবং যা একটি লাইন মন্তব্য শুরু করে।(\variable->body)argument()\->
(>)(>>)(>>>)\->\->--

উদাহরণ:

  • এস = (\(>)(\\)(-)->(>)(-)((\\)(-)))প্রকার(t2 -> t -> t1) -> (t2 -> t) -> t2 -> t1
  • কে = (\(>)(-)->(>))প্রকারt -> t1 -> t
  • আমি = (\(>)->(>))টাইপt -> t

সম্পাদনা: তবে, আইআইএস ৫৩৩ মন্তব্যগুলিতে যেমন উল্লেখ করেছে, এই নির্মাণটি টাইপড ল্যাম্বদা ক্যালকুলাস প্রয়োগ করে , যা নিজেই টুরিং-সম্পূর্ণ নয় কারণ এতে অসীম লুপগুলিতে প্রবেশের ক্ষমতা নেই। এটি ঠিক করতে, আমাদের কিছু ফাংশন প্রয়োজন যা পুনরাবৃত্তি করে। এখনও অবধি আমরা নামহীন ল্যাম্বডাস ব্যবহার করেছি, যেগুলি তাদের কল করতে পারে না, কারণ, ভাল, তাদের কোনও নাম নেই। সুতরাং আমরা অক্ষর যোগ করতে হবে =এবং ;একটি fixফাংশন বাস্তবায়ন করতে হবে:

(>)=(\(-)->(-)((>)(-)));   -- equivalent to: f =(\ x -> x ( f  x ));

এই ঘোষণার সাথে সাথে আমাদের ল্যাম্বদা ক্যালকুলাস টিউরিং সম্পূর্ণ হয়ে যায়, তবে যোগ করা হয়েছে =এবং ;, আমাদের আর ল্যাম্বডাসের দরকার নেই, আপনি নিমির উত্তরে দেখতে পারেন যা ন্যায় ব্যবহার করে ()=;


এটি কি সংকলনের সময়ে প্রযুক্তিগতভাবে সরানো হবে না main?
পাইরুলেজ

4
কেবল টাইপ করা এসকেআই কম্বিনেটর ক্যালকুলাস টিউরিং-সম্পূর্ণ নয়; তার জন্য আপনার একটি টাইপযুক্ত ল্যাম্বডা ক্যালকুলাস দরকার। দুর্ভাগ্যক্রমে, আপনার বিক্ষোভের উল্লেখ হিসাবে, হাস্কেল কোডটিতে টাইপড ব্যাখ্যাকে ডিফল্টভাবে রাখে।

@ পাইরুলেজ ডিফল্ট নিয়ম অনুসারে আমি ধরে নিয়েছি যে কার্যগুলি গ্রহণযোগ্য।
লাইকনি

@ আইস ৫৩৩ এসকেআই সংযুক্তকারীগুলি কেবলমাত্র একটি উদাহরণ, প্রদত্ত নোটেশনটি স্বেচ্ছাসেবী ল্যাম্বডা শর্তাদি ব্যবহার করে তৈরি করা যেতে পারে, যেমন গির্জার সংখ্যা এবং তাদের উপর ফাংশন।
লাইকনি

@ আইস ৫২৩ কত লম্বা ক্যালকুলাস টাইপ করা কম্বিনেটর সম্পূর্ণ হওয়া দরকার? আমার মনে হয় আপনার শুধু কম্বিনেটর দরকার, তাই না?
পাইরুলেজ

18

সিজেম, 3 টি অক্ষর

)মার্টিন ইন্ডারের পরামর্শ অনুসারে সরানো হয়েছে

'(~

উদাহরণ হিসাবে দেওয়া পাইথনের মতোই।

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

কেবল 2 + ​​2 ব্যবহার করে গণনা করা হচ্ছে '(~


অন্য চ্যালেঞ্জের জন্য, কেউ এমন একটি প্রোগ্রাম তৈরি করেছেন যা কোনও সিজাম প্রোগ্রাম নেয় এবং স্বয়ংক্রিয়ভাবে এটিকে এই উপসেটটিতে সংকলিত করে। আমি আশা করি এটি সন্ধান করতে পারি
Zwei

1
আমি 2 + 2 প্রোগ্রামটি উল্লেখযোগ্যভাবে গল্ফ করতে পেরেছি'~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((~'~(((((((((((((((((((((((((((((((~'~(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((~
Zwei

@ জুইউই দুর্দান্ত, এটি আপনার নামের সাথে খাপ খায়
ক্রোমিয়াম

18

মস্তিষ্ক-ফ্লাক , 6 টি অক্ষর

(){}[]

মস্তিষ্ক-ফ্ল্যাক কেবলমাত্র 8 টি উপলব্ধ অক্ষর সহ একটি সংক্ষিপ্ত ভাষা। তবে এটি প্রমাণিত হতে পারে যে ব্রেন-ফ্ল্যাকের একটি উপসেট রয়েছে যা কেবলমাত্র characters টি অক্ষর ব্যবহার করে টুরিং সম্পূর্ণ is

প্রথমটি যা আমরা করবো তা হ'ল ব্রেন-ফ্ল্যাকের একটি স্ট্যাক সহ একটি মিনস্কি মেশিন বাস্তবায়ন করা। যদি আমরা প্রমাণ করতে পারি যে একটি মিনস্কি মেশিন কেবলমাত্র একটি স্ট্যাক দিয়েই সম্ভব তবে আমরা দেখাতে পারি যে মস্তিষ্ক- ফ্ল্যাক টিউরিং সম্পূর্ণ <>এবং []নীলাড ছাড়াই সম্পূর্ণ । এটি অবিলম্বে কোনও অক্ষর সংরক্ষণ করবে না তবে ভবিষ্যতে যখন আমরা দেখাব যে <...>এটি প্রয়োজনীয় নয়।

একটি মিনস্কি মেশিন হ'ল এক ধরণের টুরিং সম্পূর্ণ অটোমেটনের সীমিত সংখ্যক আনবাউন্ডেড রেজিস্টার এবং দুটি চালিকা:

  • একটি রেজিস্টার বৃদ্ধি

  • যদি অ-শূন্য হ্রাস না হয় অন্যথায় একটি নির্দিষ্ট নির্দেশিকায় স্থানান্তর

মস্তিষ্ক-ফ্ল্যাঙ্কে একটি গোটো কাঠামো স্থাপন করতে আমরা নিম্নলিখিত স্নিপেট ব্যবহার করতে পারি:

(({}[()])[(())]()){(([({}{})]{}))}{}{(([({}{}(%s))]{}))}{}

এটি কাউন্টারকে হ্রাস করবে এবং %sশূন্য হলে চলবে । এই এক সাথে শৃঙ্খলাবদ্ধদের একগুচ্ছ আমাদের স্ট্যাকের উপর এমন একটি সংখ্যা রাখার অনুমতি দেবে যা নির্দেশ করবে যে আমরা কোন লাইনে যেতে চাই। এর মধ্যে প্রতিটি স্ট্যাকের শীর্ষকে হ্রাস করবে তবে তাদের মধ্যে কেবল একটিই কোডটি চালাবে।

আমরা আমাদের মিনস্কি মেশিনের সমস্ত নির্দেশাবলীর মোড়ক হিসাবে এটি ব্যবহার করি।

একটি নির্দিষ্ট রেজিস্টার বৃদ্ধি স্ট্যাক পরিবর্তন না করে বেশ সহজ। এটি এই স্ট্রিং সূত্র দিয়ে অর্জন করা যেতে পারে:

"({}<"*n+"({}())"+">)"*n

উদাহরণস্বরূপ, 3 য় রেজিস্টার বৃদ্ধি করার জন্য আমরা নিম্নলিখিত কোডটি লিখব:

({}<({}<({}<({}())>)>)>)

এখন আমাদের কেবল দ্বিতীয় অপারেশনটি প্রয়োগ করতে হবে। কোনও সংখ্যা শূন্য কিনা তা পরীক্ষা করা মস্তিষ্ক-ফ্লাকের ক্ষেত্রে খুব সহজ:

(({})){(<{}%s>)}{}

%sTOS শূন্য হলে কেবল কার্যকর করা হবে । এইভাবে আমরা আমাদের দ্বিতীয় অপারেশন করতে পারি।

যেহেতু মিনস্কি মেশিনগুলি সম্পূর্ণরূপে মস্তিষ্ক-ফ্ল্যাক টিউরিং করছে <>এবং []অপারেশনগুলি ব্যবহার না করেও টুরিং সম্পূর্ণ ।

তবে আমরা এখনো অক্ষরের সংখ্যা কমে নি কারণ <...>এবং [...]এখনও ব্যবহৃত হয়। এটি সহজ বিকল্প দিয়ে প্রতিকার করা যেতে পারে। যেহেতু <...>আসলে [(...)]{}সব ক্ষেত্রে সমতুল্য । সুতরাং ব্রেইন-ফ্ল্যাক টিউরিং সম্পূর্ণ হয় অক্ষর <এবং ব্যবহার >(প্লাস সমস্ত নো-অপ্স) ব্যবহার ছাড়াই সম্পূর্ণ complete


"কারণ <...>এবং [...]এখনও ব্যবহারে রয়েছে" " তবে, আপনি সরান নি [...]। ঠিক করুন
ক্যালকুলেটরফলাইন

প্রশ্ন: [...]আসলেই কি দরকার? 0 টি পুশ করা দিয়ে শুরুতে করা যেতে পারে ({})(তবে এটি খালি স্ট্যাকের উপর নির্ভর করে, তাই 0s সাবধানে বদলাতে হবে) মূল সমস্যাটি অ্যাক্সেস ছাড়াই স্ট্যাকের নিচে যেতে সক্ষম হচ্ছে <...>(যা আর সিমুলেটেড করা যায় না)
ক্যালকুলেটরফলাইন

16

> <> , 3 টি অক্ষর

> <> 3 এর সাথে 1p-করণীয়, যা করে:

1          Push 1
p          Pop y, x, c and put the char c in cell (x, y) of the codebox
-          Subtraction: pop y, x and push x-y

pকোডবক্সে অক্ষর রেখে 2D উত্স কোড সংশোধন করে প্রতিবিম্ব সরবরাহ করে। এর সাহায্যে 1-আপনি যে কোনও সংখ্যা স্ট্যাকের উপরে ঠেলাতে পারেন যেহেতু 1-একটিতে বিয়োগ করে এবং 111-1--( x-(1-1-1) = x+1) একটি যোগ করে।

সমস্ত 1p-কমান্ড কার্যকর হয়ে গেলে , নির্দেশ পয়েন্টারটি প্রায় আবৃত হয়, এটি "আসল" কোডটি কার্যকর করতে দেয়।

একটি উদাহরণস্বরূপ প্রোগ্রাম যা ফিবোনাচি সংখ্যা গণনা করে ( এই উত্তর থেকে ):

111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1-1--1p

এটি অনলাইন চেষ্টা করুন! সমস্ত 1p-কমান্ড কার্যকর হয়ে গেলে , কোডবক্সটি দেখতে এরকম দেখাচ্ছে:

01aa+v1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1- ...
@+&1->:?!;&:nao:

vপ্রথম লাইনে সমস্ত কিছু বাদ দিয়ে , এটি একটি স্ট্যান্ডার্ড ফিবোনাচি> <> প্রোগ্রাম।


13

বাশ, 9 টি অক্ষর

01456\$ '

বাশের $'\nnn'অক্ষর প্রবেশের জন্য তাদের অষ্টাল আসকি মানগুলির সাথে একটি বাক্য গঠন রয়েছে । আমরা evalএই বিন্যাসে কমান্ডটি প্রবেশ করতে পারি $'\145\166\141\154'। আমরা প্রথমে কাঙ্ক্ষিত ফলাফলটিকে তার অষ্টাল মানগুলিতে পরিণত করি। তারপরে আমরা 0, 1, 4, 5, এবং 6 $(())বাদে অন্য অঙ্কগুলি ব্যবহার করে যে কোনও অক্টাল মানকে রূপান্তর করতে রূপরেখায় রূপান্তর করি যা অষ্টাল মানগুলি ব্যবহার করে এবং বিয়োগফলকে evalসামনে বিবেচনা করে said আমাদের চূড়ান্ত পদক্ষেপে আমরা অন্যটি যুক্ত করি evalএবং প্রথম বন্ধনী এবং বিয়োগ চিহ্নটি তাদের অষ্টাল মানগুলিতে রূপান্তর করি। এই পদ্ধতিটি ব্যবহার করে আমরা যে কোনও বাশ কমান্ড কার্যকর করতে পারি, সুতরাং এই উপসেটটি টিউরিংয়ের সম্পূর্ণ।

উদাহরণ:

dc হয়ে

$'\144\143' যা হয়ে যায়

$'\145\166\141\154' \$\'\\144\\$((144-1))\' যা হয়ে যায়

$'\145\166\141\154' $'\145\166\141\154' $'\$\\\'\\\\144\\\\$\050\050144\0551\051\051\\\''


12

ঘটনা , 2 অক্ষর

আপনি কোন দুটি অক্ষর বাছাই করে তা বিবেচ্য নয়; দুটি অক্টেটের যে কোনও সংমিশ্রণ হ'ল ঘটনাটিতে টুরিং-সম্পূর্ণ।

বাস্তবে এটি প্রমাণ করা আপনার প্রত্যাশার চেয়ে অনেক বেশি কঠিন এবং লেখার সময়, ঘটনার বিষয়ে ইসোলাংয়ের আলোচনার পৃষ্ঠাটি সমস্যার জন্য নিবেদিত। যদিও আমি নীচে সবচেয়ে সহজ জ্ঞাত প্রমাণের সংক্ষিপ্তসার দেওয়ার চেষ্টা করব।

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

এবং এখন, এখানে প্রমাণের সংক্ষিপ্তসার রয়েছে (যা এষোলংয়ের বাসিন্দা গণিতবিদ Ørjan দ্বারা পাওয়া গিয়েছিল)। ধারণাটি হ'ল আমরা 1অন্য চরিত্রের একটি বড় সাগরে (বলুন ) দুটি অক্ষর (বলুন ) ব্যবহার করে একটি টোকনকে এনকোড করেছি 0। মধ্যে দূরত্ব 1গুলি প্রতিটি টোকেন জন্য পৃথক, কিন্তু সবসময় 4 একটি একাধিক তারপর টোকেন মধ্যে প্যাডিং জন্য, আমরা একটি অতিরিক্ত তালিকা ব্যবহার করতে 0একটি সঙ্গে গুলি 1মাঝখানে কিন্তু প্রতিটি পাশ দিয়ে 0 সেঃ সংখ্যা 1হয় 4 এর একাধিক নয় , বরং প্রোগ্রামের সেই বিশেষ ঘটনার সাথে অনন্য একটি সংখ্যা যা প্রোগ্রামের অন্য কোথাও উপস্থিত হয় না। তার মানে প্রতিটি1 ...1প্যাডিংয়ের মধ্যে কেবল কখনও দু'বার প্রদর্শিত হতে পারে, সুতরাং এটি কোনও টোকেনের অংশ হবে না; প্রতিটি উদ্দিষ্ট টোকনে হ'ল দুটি 1 টি থাকে এবং কোনও বোগাস টোকনে একের বেশি থাকতে পারে না 1। তারপরে আমরা কয়েকটি বা প্যাডিং যুক্ত করে থাকি যার মধ্যে কমপক্ষে চারটি অনুলিপি যুক্ত করে এক 1বা শূন্য গুলিযুক্ত সমস্ত সম্ভাব্য টোকেনগুলি সরিয়ে ফেলা 1যায়।


11

রেটিনা , 3 টি অক্ষর

{`

এবং নিউলাইন।

প্রথমে, আমাদের বিকল্পগুলি করতে সক্ষম হওয়ার জন্য আমাদের নিউলাইন প্রয়োজন (প্রয়োজনীয় না হলে আমরা পুরো প্রোগ্রামটিকে একটি রেজেক্সে ফিট করতে না চাই, যার জন্য আরও অক্ষরের প্রয়োজন হবে); এবং `এবং {অন্তত চরিত্র নিবিড় লুপ করতে উপায়। দেখা যাচ্ছে আমাদের আর কিছু লাগবে না।

বাস্তবায়নের জন্য আমাদের টার্গেট ল্যাঙ্গুয়েজ থু-র একটি নির্ধারিত রূপ (টিউরিং-সম্পূর্ণতার জন্য অ-নিরঙ্কুশতা প্রয়োজন হয় না; মূল্যায়ন ক্রমটি ব্যবহার করা যাই হোক না কেন সঠিকভাবে কাজ করার জন্য একটি থ্রু প্রোগ্রাম লেখা সম্ভব))। প্রাথমিক ধারণাটি সংকলন pattern::=replacementকরা

`pattern
replacement

(যা থ্রুটির সরাসরি রেটিনা অনুবাদ; বিকল্পভাবে, আপনি যদি রেটিনা জানেন তবে থু না, আপনি এটি কীভাবে কাজ করে তা শেখার পদ্ধতি হিসাবে ব্যবহার করতে পারেন); ব্যতিক্রম হিসাবে, এর {`পরিবর্তে একেবারে প্রথম প্যাটার্নটি তৈরি করা হয় (পুরো প্রোগ্রামটি একটি লুপে রাখার জন্য; কোনও বিকল্পগুলি সম্ভব না হওয়া পর্যন্ত এই প্রোগ্রামগুলি চলতে থাকে এবং এর ফলে রেটিনা একইভাবে কাজ করে)।

অবশ্যই, এর অর্থ এই যে আমাদের কেবল {এবং `নিদর্শন এবং প্রতিস্থাপনের মাধ্যমে থু টুরিং-সম্পূর্ণ প্রমাণ করা দরকার , তবে এটি যথেষ্ট সহজ; আমরা ASCII কোড একটি অক্ষর প্রতিস্থাপন এন সঙ্গে `, এন + 1 {, এবং অন্য `। কোনও প্যাটার্নের পক্ষে কোথাও কোথাও চরিত্রের সীমানা মেলে এটি অসম্ভব, সুতরাং এটি আসল প্রোগ্রাম হিসাবে একই জিনিসটি শেষ করবে।


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

1
আহ ঠিক. অবশ্যই এটি টিউরিং-সম্পূর্ণতা প্রভাবিত করে না (কারণ এমন একটি অসীম লুপ যা অভ্যন্তরীণ অবস্থাকে পরিবর্তন করে না কোনও প্রোগ্রামের গণনামূলক শ্রেণিতে অবদান রাখতে পারে না)।

10

ব্র্যাচল্যাগ , 5 টি অক্ষর

~×₁↰|

অক্ষরের এই উপসেটটি আমাদের ফ্র্যাক্ট্রানের একটি সংস্করণ প্রয়োগ করতে সহায়তা করে যাতে কেবলমাত্র সংখ্যাগুলি প্রদর্শিত হতে পারে তা পুনঃরূপের পণ্যগুলি (অর্থাত্ সংখ্যার পণ্য যা কেবলমাত্র দশমিক 1 ব্যবহার করে দশমিকায় লিখিত হতে পারে)। (সাবস্ক্রিপ্ট হিসাবে একটি পূর্ণসংখ্যা সহ) বর্তমান মানটিকে সেই পূর্ণসংখ্যার দ্বারা ভাগ করে তবে কেবলমাত্র যদি এটি ঠিক ভাগ করে দেয় (অন্যথায় এটি "ব্যর্থ" হয় এবং চালানোর জন্য অন্য কেস অনুসন্ধান করে; |কেসগুলি পৃথক করে)। ×আমাদের একটি পূর্ণসংখ্যা দিয়ে গুণ করতে দেয়। সুতরাং ব্যবহার করে ~×₁|আমরা একটি ফ্র্যাক্ট্রান কার্যকরকরণের এক ধাপ বাস্তবায়ন করতে পারি। তারপরে আমাদের পুনরাবৃত্তি করা যাক, পুরো প্রোগ্রামটি আবার নতুন বর্তমান মানটিতে চালানো running এখানে ব্র্যাচল্যাজে 11111111111111111111111/111অনুবাদ করা খুব সাধারণ ফ্র্যাক্ট্রান প্রোগ্রামের একটি উদাহরণ রয়েছে ।

সুতরাং এই টুরিং সম্পূর্ণ? ফ্র্যাক্ট্রান টিউরিং সম্পূর্ণরূপে আমাদের যা করা দরকার তা হ'ল পর্যাপ্ত পরিমাণে মূল সংখ্যা (ফ্র্যাক্ট্রান নিজেই টুরিং সম্পূর্ণ ভাষার জন্য দোভাষী লিখতে যথেষ্ট)। সেখানে পাঁচজন প্রমাণিত এবং চারজন সন্দেহজনকসম্ভবত সম্ভবত, পুনরুদ্ধার করা প্রাইমগুলি এখনও আবিষ্কার করা যায় নি। এ ক্ষেত্রে আমাদের প্রয়োজনের চেয়ে বেশি এটি more প্রোগ্রামটি বাম থেকে ডান সম্ভাবনাগুলি পরীক্ষা করে, সুতরাং আমরা একটি নির্দেশ নির্দেশক হিসাবে একটি প্রধানকে এবং আরও দুটি কাউন্টার হিসাবে ব্যবহার করতে পারি, কেবল তিনটি প্রাইম দিয়ে টুরিংয়ের সম্পূর্ণতা প্রদর্শন করি (একটি ভাল জিনিসও, কারণ এটি আমাদের ২, ১৯ সহ পুনর্নির্মাণগুলি ব্যবহার করতে দেয় , এবং 23 সংখ্যা, 317 বা 1031 সংখ্যা সহ প্রমাণিত-তবে-বিরক্তিকর-বৃহত পুনরাবৃত্তিগুলির অবলম্বন না করে, উত্স কোডটি লিখতে মোটামুটি শক্ত করে তোলে)। এটি দুটি কাউন্টার (টুরিং-সম্পূর্ণতার জন্য যথেষ্ট) সহ একটি মিনস্কি মেশিন বাস্তবায়ন সম্ভব করে তোলে।

সংকলনটি কীভাবে বিশেষভাবে কাজ করে তা এখানে। আমরা আমাদের মিনস্কি মেশিন বাস্তবায়নের জন্য নিম্নলিখিত দুটি কমান্ড ব্যবহার করব (এটি টুরিং সম্পূর্ণ হিসাবে পরিচিত) এবং প্রতিটি কমান্ডের লেবেল হিসাবে পূর্ণসংখ্যা থাকবে:

  • লেবেল এল: যদি কাউন্টার {এ বা বি zero শূন্য হয় তবে গোটো এক্স Otherwise
  • লেবেল এল: বর্ধনের পাল্টা {A বা B}, তার পরে গোটো জেড

সর্বনিম্ন শক্তির প্রথমে ১১ টির ক্ষমতা রাখার মাধ্যমে আমরা কোন আদেশটি নির্বাচন করব; 11 এর এক্সপোজনটি হ'ল কমান্ডের লেবেল। এইভাবে, প্রথম ভগ্নাংশটি মেলে এটি বর্তমানে সম্পাদনকারী কমান্ড হবে (কারণ পূর্ববর্তীগুলি সমস্ত 11 টি দ্বারা ভাগ করতে পারে না)। হ্রাস কমান্ডের ক্ষেত্রে, আমরা যথাক্রমে এ বা বি কাউন্টারের জন্য, ডিনোমিনেটরে 11111111111111111111111 বা 1111111111111111111111111 এর একটি ফ্যাক্টর রাখি এবং এটিকে ফ্যাক্টর ছাড়াই অন্য একটি আদেশ দিয়ে অনুসরণ করি; "হ্রাস" কেস প্রথম কমান্ড দ্বারা প্রয়োগ করা হবে, দ্বিতীয় দ্বারা "শূন্য" কেস। এদিকে, "গোটো" অঙ্কের 11 টির উপযুক্ত শক্তি দ্বারা পরিচালিত হবে, এবং সংখ্যায় 111111111111111111111 বা 111111111111111111111111111 এর একটি ফ্যাক্টরের মাধ্যমে "বৃদ্ধি" করা হবে hand


কোনও বিশেষ কারণে আপনি জোড়াযুক্ত কপিরাইট পুনরায় ব্যবহার করতে পারবেন না?
ক্যালকুলেটরফলাইন

@ ক্যালকুলেটরফালাইন: না, তবে ইতিমধ্যে আমি তাদের নির্মাণের সন্ধান না হওয়ার আগে পর্যন্ত আমি সেগুলি সম্পর্কে ভাবিনি। এটি অবশ্যই এই চরিত্রের সেট দিয়ে লেখা গল্ফিং প্রোগ্রামগুলিতে সহায়তা করবে।

এছাড়াও, সমস্ত পুনরাবৃত্তি> 1 জোড়াযুক্ত কপিরাইট হয় (এটি সম্পর্কে চিন্তা করুন)
ক্যালকুলেটরফলাইন

@ ক্যালকুলেটরফলাইন: না তারা নেই। 111 এবং 111111 উভয়ই 3 দ্বারা বিভাজ্য, মোটামুটি স্পষ্টতই।

* কোনও পুনরুক্তি অন্য পুনরাবৃত্তি ভাগ করে না
ক্যালকুলেটরফালাইন

10

Befunge-98, 3 টি অক্ষর

যতদূর আমি জানি, বেফুঞ্জ -98 সম্পূর্ণ টিউরিংয়ের কথা বলে মনে করা হচ্ছে, সুতরাং আমাদের কেবল মাত্র তিনটি অক্ষর ব্যবহার করে কোনও বেফুঞ্জ -98 প্রোগ্রাম কীভাবে তৈরি করা যায় তা দেখাতে হবে। আমার প্রাথমিক সমাধানটি নিম্নলিখিত চারটি অক্ষরের উপর নির্ভর করেছে:

01+p

কমান্ডের 1সাথে একাধিক মান যুক্ত করে আমরা স্ট্যাকের উপর কোনও ধনাত্মক পূর্ণসংখ্যা পেতে পারি +এবং শূন্যের জন্য আমরা কেবল ব্যবহার করি 0। একবার আমাদের যে কোনও সংখ্যার ধাক্কা দেওয়ার ক্ষমতা থাকলে আমরা তারপরে pবেফঞ্জ প্লেফিল্ডের যে কোনও স্থানে কোনও ASCII মান লিখতে (পুট) কমান্ডটি ব্যবহার করতে পারি।

তবে, Sp3000 হিসাবে উল্লেখ করা হয়েছে, আপনি কেবলমাত্র তিনটি অক্ষর দ্বারা পেতে পারেন:

1-p

যে কোনও নেতিবাচক সংখ্যাটি শুরু করে 1এবং তারপরে বারবার বিয়োগ করে গণনা করা যেতে পারে 1(উদাহরণস্বরূপ, -3 হবে 11-1-1-1-)। তারপরে যেকোন ধনাত্মক সংখ্যাটি 1 থেকে 1-এন বিয়োগ করে প্রতিনিধিত্ব করা যায়, যেখানে 1-n একটি নেতিবাচক সংখ্যা যা আমরা ইতিমধ্যে জানি কিভাবে কীভাবে পরিচালনা করতে হয় (উদাহরণস্বরূপ, 4 = 1 - (- 3), যা হবে 111-1-1-1--)।

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

উদাহরণস্বরূপ, এখানে এমন একটি বুটলোডার রয়েছে যা বেফঞ্জ কোডটি 2 + 2 যোগ করার জন্য প্রয়োজনীয় ফলাফল উত্পন্ন করে ফলাফল আউটপুট দেয়: 22+.@

এবং আরও জটিল উদাহরণের জন্য এটি হ্যালো ওয়ার্ল্ড " "!dlroW olleH"bk,@


এটি বহুবিবাহ, এটি একই বর্ণগুলি> <> এবং এর ডেরাইভেটিভগুলির জন্য ব্যবহার করা যেতে পারে। চমৎকার কাজ!
সোক

2
বেফুঞ্জ -98 1p-পাশাপাশি 3 এ
করণীয়

@ Sp3000 অবশ্যই হ্যাঁ! আমি নিশ্চিত ছিলাম এটি 3 অক্ষরে নামার কোনও উপায় নিশ্চয়ই ছিল। ধন্যবাদ।
জেমস হোল্ডারেন্স

9

রুবি, ৮ টি চর

eval"<1+

পাইথন উত্তর দ্বারা অনুপ্রাণিত

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

  • eval একটি স্বেচ্ছাসেবী স্ট্রিং কার্যকর করতে ব্যবহার করা যেতে পারে।
  • "<1+ হ'ল যে কোনও স্ট্রিং তৈরি করতে প্রয়োজনীয় ন্যূনতম সেট

রুবিতে একটি স্ট্রিং শুরুর পয়েন্ট হিসাবে খালি স্ট্রিং ব্যবহার করে তৈরি করা যেতে পারে এবং এতে আসকি অক্ষর যুক্ত করা যায়, উদাহরণস্বরূপ:

eval ""<<111+1<<11+11+11+1<<111<<11+11+11+1

আসলে সমতুল্য

eval ""<<112<<34<<111<<34

যা স্ট্রিংকে মূল্যায়ন করে

p"o"

8

ওক্যামল, 9 টি অক্ষর

fun->()`X

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

এস সমন্বয়কারী:

fun(f)(u)(n)->f(n)(u(n)) টাইপ সহ ('a -> 'b -> 'c) -> ('a -> 'b) -> 'a -> 'c

কে সম্মিলক:

fun(f)(u)->u টাইপ সহ 'a -> 'b -> 'b

আমি সমন্বয়কারী:

fun(f)->f টাইপ সহ 'a -> 'a

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

জেড কম্বিনেটর:

fun(f)->(fun(`X(x))->(x)(`X(x)))(`X(fun(`X(x))y->f(x(`X(x)))y))

টাইপ সহ (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b


2
কেবল টাইপ করা এসকেআই কম্বিনেটর ক্যালকুলাস টিউরিং-সম্পূর্ণ নয়; তার জন্য আপনার একটি টাইপযুক্ত ল্যাম্বডা ক্যালকুলাস দরকার। দুর্ভাগ্যক্রমে, আপনার বিক্ষোভের উল্লেখ হিসাবে, ওক্যামল ডিফল্টরূপে কোডটিতে একটি টাইপযুক্ত ব্যাখ্যা রাখে।

1
তারপরে পলিমারফিক বৈকল্পিকের ব্যবহারের অনুমতি দেওয়ার জন্য আমার আরও কয়েকটি অক্ষর প্রয়োজন যা ওয়াই-কম্বিনেটর (এবং একইভাবে জেড-সংযুক্তকারী) এনকোডিংয়ের অনুমতি দেবে।
ডেভিন লেহম্যাচার

জেড কম্বিনেটর কী?
ক্যালকুলেটরফলাইন

@ ক্যালকুলেটরফ্লাইন এটি ওয়াই-কম্বিনেটরের একটি কঠোর রূপ। ওসিএএমএল এ এটি প্রয়োজনীয় কারণ ওসি ক্যামেল অলস নয়। এখানে উইকিপিডিয়া পৃষ্ঠার লিঙ্কটি রয়েছে: en.wikedia.org/wiki/…
ডেভিন লেহম্যাচার

8

স্ট্যাক-ভিত্তিক কনটেস্টেটিভ ভাষা, 4 টি অক্ষর

Underload

():^

GolfScript

{}.~

CJam

{}_~

GS2

  • ব্যাকস্পেস, ট্যাব,, @স্থান (আমি জানতাম যে জিএস 2 প্রচুর পরিমাণে ছাপছাড়া ব্যবহার করেছে, তবে এটি হাস্যকর…)

ডিসি (@seshoumara দ্বারা প্রস্তাবিত)

[]dx

আন্ডারলোড কেবলমাত্র ():^(এসোলাংয়ের বাসিন্দা গণিতবিদ আরজানকে ধন্যবাদ দিয়ে) ব্যবহার করে টুরিং-সম্পূর্ণ প্রমাণিত হয়েছে । প্রমাণটি এখানে ব্যাখ্যা করার জন্য অনেক দীর্ঘ, তবে আপনি যদি আগ্রহী হন তবে আপনি এটি সম্পর্কে এখানে পড়তে পারেন ।

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


আমি বুঝতে পারি আপনি সেগুলি দিয়ে স্ট্যাক অপারেশন করতে পারেন, তবে গাণিতিক গণনা করার জন্য আপনার কি সেই স্ট্যাকটি গড়ে তোলার জন্য কমপক্ষে সংখ্যার প্রয়োজন নেই? বা যারা 4 টির মধ্যে একটি ব্যবহার করে একা হয়ে গেছে?
শৈশুমারা

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

আমি নিজেই ডিসিতে একটি উত্তর জমা দেওয়ার কথা ভাবছিলাম, এটিও একটি স্ট্যাক ভিত্তিক ভাষা, তবে ৪ টির চেয়ে বেশি অক্ষরের সাথে যুক্ত অন্য একটি পদ্ধতি ব্যবহার করে ডিসির কোন কনটেন্টেশন অপারেটর নেই, তবে এতে আপনার উল্লিখিত সমতুল্য রয়েছে: [] ডি এক্স। ডিসি কি আপনার তালিকায় ফিট করতে পারে?
শৈশুমারা

@ সেশৌমারা: হ্যাঁ, এটির সমস্ত কার্যকারিতা প্রয়োজনীয় বলে মনে হচ্ছে। আমি এটি যুক্ত করেছি এবং আপনাকে জমা দিয়েছি।

হতে পারে আপনি ফ্লগস্ক্রিপ্ট সন্ধান করতে পারেন
mbomb007

7

হোয়াইটস্পেস, 3 টি চর

STL

Sস্থান Tহল, ট্যাব, এবং Lনতুন লাইন।


এটি কি পুরো ভাষা, না এটি একটি উপসেট? টুরিং সম্পূর্ণতার প্রমাণ কোথায়?
ব্রায়ান মিন্টন

2
@ ব্রায়ানমিন্টন এটি সম্পূর্ণ ভাষা, ইওসোলং উইকি এটির উপর হালকা আলো রয়েছে esolangs.org/wiki/Wwitepace তবে আফিক, এটি সম্পূর্ণ উত্তেজনাপূর্ণ
ক্রুঙ্কার

7

র‌্যাকেট (স্কিম), 4 টি অক্ষর

(λ)

কেবলমাত্র λ, প্রথম বন্ধনী এবং স্পেস ব্যবহার করে আমরা সরাসরি স্কিমের ল্যাম্বদা ক্যালকুলাস উপসেটে প্রোগ্রাম করতে পারি। আমরা নির্ধারিতভাবে সংখ্যক অনন্য শনাক্তকারী সরবরাহ করতে একত্রে সম্মিলিত হয়ে সমস্ত শনাক্তকারীদের জন্য λ ​​চরিত্রটি পুনরায় ব্যবহার করি।

উদাহরণস্বরূপ, এখানে ক্লাসিক ওমেগা সংযুক্তকারী রয়েছে, যা চিরকালের জন্য লুপ হয়ে যায়।

((λ (λλ) (λλ λλ)) (λ (λλ) (λλ λλ)))

6

পাইথন 3, 9 টি অক্ষর

exc('%1+)

একটি প্রাথমিক ব্যাখ্যার জন্য আমার পাইথন 2 উত্তর দেখুন । এই উত্তরটি এটির উপর ভিত্তি করে।

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

exec('%c'%stuff)

তবে আমরা +পরিবর্তে ব্যবহার করে প্রোগ্রামের দৈর্ঘ্য হ্রাস করি -এবং তারপরে আমরা এর পরিবর্তে ~ব্যবহার করে মুছে ফেলতে পারি । আমরা তখন যোগ করতে পারেন , এবং প্রয়োজনীয় ASCII মান জন্য।10111111

প্রোগ্রামটি print()তার সংক্ষিপ্ততম সময়ে নিম্নলিখিত হয়ে যায়:

exec('%c%%c%%%%c%%%%%%%%c%%%%%%%%%%%%%%%%c%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%c%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%c'%(111+1)%(111+1+1+1)%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)%(11+11+11+11+11+11+11+11+11+11)%(111+1+1+1+1+1)%'('%')')

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

আপনি নিজেই ভাবছেন, একজন কীভাবে এনএলইউ বাইট তৈরি করবেন 0? ভয় নেই, তৃণমূল! কারণ আমাদের কাছে %গণিতের জন্যও ব্যবহার করার ক্ষমতা রয়েছে, এর সাথে শূন্য তৈরি করা 1%1


আপনি কেন কখনও আপনার প্রোগ্রামে একটি NUL বাইট চান?
নিয়েজেজেকোব

@ নিডজেজেকোব এই সাইটে, "কেন" এর উত্তর সর্বদা "কারণ আমরা পারি" to এই ক্ষেত্রে, যদিও এটি করতে না পারলে পাইথনের সম্পূর্ণ বাস্তবায়ন হবে না, এমনকি যদি এটি কেবল একটি ত্রুটি দেয়।
mbomb007

টিউরিং সম্পূর্ণতার জন্য আপনার NU বাইটের প্রয়োজন হবে না; বিএফ দোভাষী একটি ছাড়া লেখা যেতে পারে
মিল্কিওয়ে 90

@ মিলকিওয়াই 90 সত্য, তবে আপনি যদি এটি করতে পারেন তবে এটির জন্য অ্যাকাউন্ট করবেন না কেন?
mbomb007

6

পিএইচপি 7, 6 টি অক্ষর

'().;^

ধারণাটি হ'ল নিম্নলিখিত নির্মাণ ব্যবহার করে স্বেচ্ছাসেবক কোড কার্যকর করা সম্ভব:

('create_function')('','<code>')();

eval এখানে কাজ করবে না, কারণ এটি একটি ভাষা নির্মাণ এবং ভেরিয়েবল ফাংশন ব্যবহার করে বলা যায় না।

create_function এবং কোডটি উপলভ্য অক্ষরের বিটওয়াইজ এক্সওআরগুলির সংমিশ্রণ হিসাবে লেখা যেতে পারে:

(<char1_1>^<char1_2>^...).(<char2_1>^<char2_2>^...)...

().;^জন্য ব্যবহার করে <charX_Y>, আমরা পেতে পারি

()./:;<=JKLMXY^_bcdepqvw

এবং কিছু ছাপানো অক্ষর। এটি যথেষ্ট নয়, তবে এখন আমরা 'eXp'()কিছু সংখ্যক অক্ষরও কল করতে পারি এবং তা পেতে পারি :

''.'eXp'('eXp'('')) -> 1
''.'eXp'('eXp'('eXp'(''))) -> 2.718281828459
''.'eXp'('eXp'('eXp'('eXp'('eXp'(''))))) -> 3814279.1047602

এটা তোলে আমাদের দেয় 1, 2এবং 3(অন্যান্য অক্ষর, XOR যাও দ্বারা উপেক্ষিত হবে যদি অন্য স্ট্রিং একটি অক্ষর দীর্ঘ)। থেকে ().;^123আমরা এখন সমস্ত ASCII অক্ষরেট তৈরি করতে পারি।

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


5

পাইকে, 5 টি অক্ষর

0h.CE

এটি একটি স্ট্রিনে রূপান্তরিত করে এবং তারপরে পাইকে কোড হিসাবে মূল্যায়ন করতে অসীম সংখ্যক উত্পাদন করতে সক্ষম।

কোডের ব্যাখ্যা:

0- স্ট্যাক 0 যোগ করুন। এটি একটি নম্বর শুরু করা প্রয়োজন

h- আগে সংখ্যা বৃদ্ধি। এটিকে নির্বিচার পরিমাণে পুনরাবৃত্তি করে আপনি এমন সংখ্যা তৈরি করতে পারেন যা অসীম বড়। পাইথন বিগানুমগুলিকে সমর্থন করে যেমন এটি পাইথনে লেখা আছে, যা সেগুলি ডিফল্ট হিসাবে ব্যবহার করে।

.C- নিম্নলিখিত অ্যালগরিদম ব্যবহার করে একটি সংখ্যাকে একটি স্ট্রিংয়ে পরিণত করুন: ( গিথুব লিঙ্ক )

def to_string(num):
    string = ""
    while num > 256:
        num, new = divmod(num, 256)
        string = chr(new) + string
    string = chr(num) + string
    return string

এই মুহুর্তে, আমরা পাইকেতে স্বেচ্ছাচারিত মান সহ স্বতন্ত্র পরিমাণে স্ট্রিং এবং প্রাকৃতিক সংখ্যা তৈরি করতে পারি। রেজেক্সের সাথে সম্পর্কিত আকারে নম্বর তৈরি করা যেতে পারে 0(h)*এবং স্ট্রিংগুলি দিয়ে তৈরি করা যেতে পারে 0(h)*.C। স্ট্রিং এবং পূর্ণসংখ্যার একটি স্বেচ্ছাসেবী মিশ্রণ তৈরি করতে এগুলিকে একে অপরের সাথে সংযুক্ত করা যেতে পারে।

E- পাইক কোড হিসাবে একটি স্ট্রিং মূল্যায়ন করুন। এটি পাইক কোডের মতো একই পরিবেশটি ইতিমধ্যে চলছে তাই ইনপুটটির মতো জিনিসগুলি ভাগ করে দেবে।

পাইক টিউরিং সম্পূর্ণ At

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

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

string containing brainf*ck code
string containing brainf*ck interpreter

এর অর্থ পাইক স্ট্যাকটি সর্বশেষে শেষ হওয়ার কারণে কোডটি বিপরীত আকারে থাকতে হবে।

এখন মজাদার অংশের জন্য: মস্তিষ্কের * সি কে ইন্টারপ্রেটার একটি তীব্র 216 বাইট সহ!

Q~B"><ht.,".:=B;Z]1=L;W~Bo@D=c"ht"{I~c~LZ@EZ]1~LR3:=L)~c\,qIz.oZ]1~LR3:=L)~c\.qI~LZ@.CpK)~c"<>"{I~c"<>""th".:ZE=ZZ1_qI0=Z~L0"":0]10:=L)Z~LlqI~L~Ll"":1_]10:=L))~c\[qI~LZ@0qI\]~B~o>@~o+h=o))~c\]qI~o\[~B~o<_@-t=o)~o~BlN

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

আপনি যদি অর্ধ-সম্পন্ন তবে সম্পাদনাযোগ্য ফর্মটিতে কোডটি দেখতে চান তবে এখানে চেষ্টা করে দেখুন!

একটি স্ট্রিং থেকে একটি সংখ্যায় রূপান্তর করতে, আপনি নিম্নলিখিত পাইথন কোডটি ব্যবহার করতে পারেন:

def conv(string, t=0):
    t *= 256
    t += ord(string[0])
    if len(string) != 1:
        return conv(string[1:], t)
    return t

(প্রায়) চূড়ান্ত সমাধান এখানে চেষ্টা করা যেতে পারে !

ব্রেইনফ * সি কে ইন্টারপ্রেটারের ব্যাখ্যা

প্রথমে প্রোগ্রামটি অংশগুলিতে আলাদা করতে দিন:

  • সূচনা:

Q~B"><ht.,".:=B;Z]1=L; - The initialisation part
Q~B"><ht.,".:          - input.replace("><+-.,[]", "><ht.,")
                       - replace the characters in brainf*ck with some modified ones. 
                       - this means we can `eval` the add and subtract bits easily.
             =B;       - set `B` to this.
                       - The `B` variable contains the instructions
                Z]1=L; - set `L` to [0]
                       - `L` contains the stack, initialised with 0
  • প্রধান লুপ:

اور

W~Bo@D=c !code! ~o~BlN - The main loop
W                      - do
 ~Bo@D=c               -  c=B[o++]
                       -  the c variable is used to store the current character.
                ~o~BlN - while
                ~o     -   o 
                     N -  ^ != V 
                  ~Bl  -   len(B)
                       -  this stops the program running once it's finished.
  • নির্দেশনা
    • বর্ধিত / হ্রাস:+-

اور

"ht"{I~c~LZ@EZ]1~LR3:=L) - The bit that does incrementing and decrementing
"ht"{I                 ) - if c in "ht"
        ~LZ@             -  L[Z]
                         -  `Z` contains the current stack pointer
      ~c    E            -  eval current character with ^ as an argument
                         -  returns the contents of `Z` either incremented or decremented
             Z]1~LR3:=L  - L[Z] = ^
  • ইনপুট ,:

اور

~c\,qIz.oZ]1~LR3:=L) - The code for output 
~c\,qI             ) -  if character == ",":
      z.o            -    ord(input)
         Z]1~LR3:=L  -   L[Z] = ^
  • আউটপুট .:

اور

~c\.qI~LZ@.CpK) - The code for input 
~c\.qI        ) - if c == ".":
      ~LZ@      -    L[Z]
          .C    -   chr(^)
            pK  -  print(^)
  • বামে / ডানদিকে <>:

اور

~c"<>"{I~c"<>""th".:ZE=Z - main part 
~c"<>"{I                 - if "<>" in c:
        ~c"<>""th".:     -  c.replace("<>", "th")
                    ZE=Z -  Z = eval(char, Z)

Z1_qI0=Z~L0"":0]10:=L) - lower bound check
Z1_qI                ) - if Z == -1:
     0=Z               -  Z = 0
        ~L0"":         -  L.insert("", 0)
              0]10:=L  -  L[0] = 0

Z~LlqI~L~Ll"":1_]10:=L) - upper bound check
Z~LlqI                ) - if Z == len(L):
        ~Ll"":          -  L.insert("", len(L))
      ~L      1_]10:=L  -  L[-1] = 0
  • শর্তসাপেক্ষ [:

اور

~c\[qI~LZ@0qI\]~B~o>@~o+h=o)) - Code for `[`
~c\[qI                      ) - if c == "[":
      ~LZ@0qI              )  -  if L[Z] == 0:
               ~B~o>          -     B[o:]
             \]     @         -    ^.find("]")
                     ~o+h=o   -   o = o + ^ + 1

- এবং ]:

اور

~c\]qI~o\[~B~o<_@-t=o) - Code for `]`
~c\]qI               ) - if c == "]":
          ~B~o<_       -    reversed(B[:o])
        \[      @      -   ^.find("[")
      ~o         -t=o  -  o = o - ^ -1

5

সজ্জিত, 5 টি চর

{!n:}

এটি আশ্চর্যজনকভাবে সংক্ষিপ্ত। যদি স্ট্যাকড প্রতিটি এসকেআই সমন্বয়গুলি প্রয়োগ করতে পারে তবে তা টিউরিং সম্পূর্ণ uring সংক্ষিপ্তবৃত্তি:

  • I সংযুক্তকারী - পরিচয় ফাংশন। x -> x
  • K সংযুক্তকারী - ধ্রুবক ফাংশন। x -> y -> x
  • S সংযুক্তি - বিকল্প ফাংশন। (x, y, z) -> x(z)(y(z))

আমি সংযুক্তকারী: {!n}

এখন, সজ্জিত বিশদ জন্য। {! ... }একটি এন-ল্যাম্বদা এটি একটি আনরি ফাংশন যার যুক্তি সুস্পষ্টভাবে n। তারপরে, শেষ প্রকাশটি ফাংশন থেকে ফিরে আসে। সুতরাং, {!n}একটি ফাংশন যা আর্গুমেন্ট নেয় nএবং ফলন দেয় n

কে সংযুক্তকারী: {!{:n}}

এখন, {:...}এমন একটি ফাংশন যা কোনও যুক্তি গ্রহণ করে না এবং ফেরত দেয় ...। এটি আমাদের এন-ল্যাম্বদা গঠনের সাথে একত্রিত করে আমরা পেয়েছি (স্পষ্টতার জন্য সাদা স্থান যোগ করে):

{! { : n } }
{!         }   n-lambda. arguments: (n)
   { : n }     lambda.   arguments: ()
       n       yields n.

এস সমন্বয়কারী: {n!nn!nnn:nnn{!n}!nn!nnn{!n}!n!!}

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

{n nn nnn:nnn{!n}!nn!nnn{!n}!n!!}

এই ল্যামডা তিন আর্গুমেন্ট ই তোলা যায় n, nnএবং nnn। এর সঙ্গে এই প্রতিস্থাপন করা যাক x, yএবং zস্বচ্ছতার জন্য:

{x y z:z{!n}!y!z{!n}!x!!}

দুটি {!n}!আবার হোয়াইটস্পেস এড়াতে কেবল পরিচয়ের ফাংশন, !যার অর্থ "চালানো"। সুতরাং, আবার, হ্রাস:

{x y z:z y!z x!!}

একটি ব্যাখ্যা সহ:

{x y z:z y!z x!!}
{x y z:         }  three arguments
       z y!        apply `y` to `z` -- `y(z)`
           z x!    apply `x` to `z` -- `x(z)`
               !   apply `x(z)` to `y(z)` -- `x(z)(y(z))`

এবং অতএব, এটি এস সংযুক্তকারী।


{n nn nnn:nnn{!n}!nn!nnn{!n}!n!!}স্পেস থাকে
ক্যালকুলেটরফলাইন

আপনি কি এর আগে বাক্যটি পড়েছেন? ঠিক আছে, এটি কিছুটা জটিল দেখায়। সুতরাং, একটি ল্যাম্বডা অ-সনাক্তকারী অক্ষর দ্বারা পৃথক করে যুক্তিগুলি গ্রহণ করে। সুতরাং, শিরোলেখের ল্যাম্বদা সমান:
কনর ও'ব্রায়ান

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