99 এর জন্য একটি দোভাষী লিখুন

Question

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

যেহেতু এই প্রশ্নটি স্বাভাবিকের চেয়ে কিছুটা গভীরতর, এবং আমি ভাল উত্তর দেখতে আগ্রহী, তাই আমি আমার প্রিয় উত্তরের (অগত্যা বিজয়ী নয়) একটি 250 প্রতিবেদনের অনুদান প্রদান করব।

99 স্পেক

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

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

সুতরাং এই প্রোগ্রাম:

   9      BLAH        99   9a9bb9c9
9 this line and the next have 6 trailing spaces 9      
      

এই প্রোগ্রামে অভিন্ন:

 9 99 9999
9 9

ভেরিয়েবল

99 এ চলকগুলির সকলেরই নাম রয়েছে যা এক বা একাধিক 9স্ট্রিং একসাথে ( 9+রেজেক্সে) থাকে। উদাহরণস্বরূপ, 9, 99, এবং 9999999999সব স্বতন্ত্র ভেরিয়েবল। স্বাভাবিকভাবেই, অসীম অনেকগুলি রয়েছে (মেমরির সীমাবদ্ধতা ব্যতীত)।

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

আমি Vনীচে একটি নির্বিচারে পরিবর্তনশীল নাম উল্লেখ করতে ব্যবহার করব ।
প্রত্যেকটি উদাহরণস্বরূপ Vদিয়ে প্রতিস্থাপিত করা যেতে পারে 9, 99, 999, 9999, ইত্যাদি

বিবৃতি

99 টিতে পাঁচটি পৃথক বিবৃতি প্রকার রয়েছে । একটি 99 প্রোগ্রামের প্রতিটি লাইনে ঠিক একটি বিবৃতি থাকে।

এখানে বর্ণিত সিনট্যাক্সটি ধরে নিয়েছে যে সমস্ত বহিরাগত অক্ষর মুছে ফেলা হয়েছে, সমস্ত অনুমানযোগ্য স্থান সরিয়ে ফেলা হয়েছে এবং একাধিক স্পেসের সমস্ত ক্রম একক স্পেসে প্রতিস্থাপন করা হয়েছে।

1. কোন অপারেশন

খালি লাইনটি কোনও অপ-অপশন । এটি কিছুই করে না (নির্দেশের পয়েন্টার বাড়ানোর পাশাপাশি)।

2. আউটপুট

V

Vএকটি লাইনের একক ভেরিয়েবল প্রিন্ট করে যা স্টডআউটে পরিবর্তনশীল।

যদি Vএর বিজোড় সংখ্যার 9(( 9, 999ইত্যাদি) থাকে তবে V9 দ্বারা বিভক্তের পূর্ণসংখ্যা মানটি মুদ্রণ করা হবে (দশমিক ক্ষেত্রে)।

যদি Vএকটি এমনকি সংখ্যা হয়েছে 9( 'গুলি 99, 9999ইত্যাদি,) তাহলে হওয়া ASCII কোড দিয়ে চরিত্র V9 দ্বারা বিভক্ত, গেলিক ভাষার 128 প্রিন্ট করা হবে। (এটি (V / 9) % 1280 থেকে 127 পর্যন্ত একটি মান))

উদাহরণ : প্রোগ্রাম

9
9999

মুদ্রণ হবে 1W। প্রথম লাইন প্রিন্ট করে 1কারণ 9/9 হয় 1. দ্বিতীয় লাইন প্রিন্ট Wকারণ 9999/9 1111, এবং 1111 মড 128 87, এবং 87 এর জন্য অক্ষর কোড W।

নোট করুন লাইন বিরতি আউটপুট টোকেনগুলির মধ্যে মুদ্রিত হয় না। \nএকটি লাইন বিরতির জন্য স্পষ্টভাবে মুদ্রণ করা দরকার।

3. ইনপুট

 V

শীর্ষস্থানীয় স্থান সহV একটি লাইনে একক ভেরিয়েবল স্টিডিনের কাছ থেকে ইনপুট নেয় এবং এটিকে ভেরিয়েবলে সঞ্চয় করে।

এর যদি Vএকটি বিজোড় সংখ্যার সংখ্যা থাকে 9তবে ব্যবহারকারী যে কোনও স্বাক্ষরিত পূর্ণসংখ্যায় টাইপ করতে পারেন, এবং Vসেই মানটি 9 বার সেট করা হবে।

যদি Vএর এমনকি সংখ্যার সংখ্যা থাকে 9তবে ব্যবহারকারী যে কোনও এএসসিআইআই অক্ষর টাইপ করতে পারেন এবং Vতার চরিত্রের কোডটি 9 বার সেট করা হবে।

উদাহরণ : প্রদত্ত -57এবং Aইনপুট হিসাবে, এই প্রোগ্রাম

 9
9
 99
99

আউটপুট হবে -57A। অভ্যন্তরীণভাবে, ভেরিয়েবলের 9মান -513 এবং 99মান 585 হবে।

আপনার দোভাষীটি অনুমান করতে পারে যে ইনপুটগুলি সর্বদা সিনট্যাক্টিকভাবে বৈধ থাকে।

৪. অ্যাসাইনমেন্ট

এই বিবৃতিটি নির্বিচারে দীর্ঘ হতে পারে। এটি একটি লাইনে দুটি বা তত বেশি ভেরিয়েবল, স্পেস দ্বারা পৃথক করে:

V1 V2 V3 V4 V5 ...

এই নির্ধারণ সব সমষ্টির 'এমনকি সূচকের সঙ্গে গুলি, বিয়োগ এর সমষ্টি ' অদ্ভুত সূচকের (ব্যতীত সঙ্গে গুলি )। অ্যাসাইনমেন্টগুলি মান দ্বারা হয়, রেফারেন্স দ্বারা নয়।V1VVV1

এটি বেশিরভাগ ভাষায় অনুবাদ করা যেতে পারে ।V1 = V2 - V3 + V4 - V5 + ...

সুতরাং, যদি কেবল দুটি ভেরিয়েবল থাকে তবে এটি সাধারণ অ্যাসাইনমেন্ট:

V1 V2 → V1 = V2

যদি সেখানে তিনটি থাকে, তবে এটি বিয়োগ:

V1 V2 V3 → V1 = V2 - V3

এবং +/ -সাইন প্রতিটি অতিরিক্ত ভেরিয়েবলের সাথে পিছনে পিছনে স্যুইচ করে চলে:

V1 V2 V3 V4 → V1 = V2 - V3 + V4

উদাহরণ : এই প্রোগ্রামটি আউটপুট দেবে 1110123:

999           Prints triple-nine divided by nine (111).
999 9 9       Assigns triple-nine to zero (nine minus nine).
999           Prints triple-nine divided by nine (0)
9 999 9       Assigns single-nine to negative nine (zero minus nine).
999 999 9     Adds nine to triple-nine (really subtracts negative nine).
999           Prints triple-nine divided by nine (1).
999 999 9     Adds nine to triple-nine (really subtracts negative nine).
999           Prints triple-nine divided by nine (2).
999 999 9     Adds nine to triple-nine (really subtracts negative nine).
999           Prints triple-nine divided by nine (3).

৫. গোটো (সমস্ত শূন্য হলে লাফ দিন)

এই বিবৃতিটিও ইচ্ছামত দীর্ঘ হতে পারে। এটি একটি লাইনে দুটি বা তত বেশি ভেরিয়েবল, একটি শীর্ষস্থানীয় স্থান সহ স্পেস দ্বারা পৃথক করে :

 V1 V2 V3 V4 V5 ...

যদি কিছু মান মান -শূন্য হয়, তবে এটি ঠিক কোনও অপ-এর মতো আচরণ করে। নির্দেশ পয়েন্টারটি যথারীতি পরবর্তী লাইনে সরানো হয়।V1

তাহলে সব মূল্যবোধের ব্যতীত হয় শূন্য, তারপর নির্দেশ পয়েন্টার নম্বর লাইন চলে যায় । লাইনগুলি শূন্য-সূচকযুক্ত, সুতরাং যদি শূন্য হয়, তবে পয়েন্টারটি শীর্ষ লাইনে চলে যায়। Termin ণাত্মক বা সর্বোচ্চ সম্ভাব্য সূচকের (লাইন বিয়োগের সংখ্যা) এর চেয়ে বড় হলে প্রোগ্রামটি সমাপ্ত হয় (সাধারণত ত্রুটি ছাড়াই )।V1 V1V1V1

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

উদাহরণ:

এই প্রোগ্রামটি 1চিরকাল মুদ্রণ করবে:

9          Prints single-nine divided by nine (always 1).
99 9 9     Assigns double-nine to zero.
 99 99     Jumps to line zero (top line) if double-nine is zero.

এই প্রোগ্রাম

99999999                                              Print G.
999 99                                                Set triple-nine to ninety-nine.
9999999999 9999999999 9999999999 99 99 9 9 999 999    Set 10-nine to zero.
99999999999 9999999999                                Set 11-nine to zero.





999                                                   Print triple-nine's value divided by nine. (This is the ninth line.)
99999999                                              Print G.
999 999 9                                             Subtract nine from triple-nine.
 99999 999                                            Jump to line 5-nines if triple-nine is zero (ends program).
 9 99999999999 9999999999                             Jump to line nine if 10-nine and 11-nine are zero (always jumps).

হ্রাস ক্রমে 11 থেকে 1 সংখ্যা আউটপুট দেবে, এর চারপাশে ঘিরে G:

G11G10G9G8G7G6G5G4G3G2G1G

অতিরিক্ত তথ্য

আদর্শ দোভাষীটি আর্গুমেন্ট হিসাবে 99 প্রোগ্রামের ফাইল নাম সহ কমান্ড লাইন থেকে চালিত হবে । আই / ও কমান্ড লাইনের ফ্লাইতেও করা হবে।

তবে আপনি কেবল একটি ইন্টারপ্রেটার ফাংশন লিখতে পারেন যা প্রোগ্রামটিকে স্ট্রিং হিসাবে গ্রহণ করে এবং ইনপুট টোকেনগুলির একটি তালিকা (যেমন ["-57", "A"])। ফাংশনটি আউটপুট স্ট্রিং প্রিন্ট বা ফিরে আসতে হবে।

আপনার ভাষায় এই বিকল্পগুলি অসম্ভব হলে দোভাষা চালানো এবং I / O পরিচালনা করার সামান্য বিভিন্ন উপায় ভাল fine

---

বোনাস: 99 তে কিছু শীতল লিখুন এবং আমি আনন্দের সাথে উদাহরণ হিসাবে এটি এই পোস্টে রাখব।

• এখানে ম্যাকের উত্তর থেকে একটি ঝরঝরে "বিয়ারের 99 টি বোতল" প্রোগ্রামটির একটি পাস্তবিন রয়েছে ।

---

^{আশা করি আপনি আমার 99 তম চ্যালেঞ্জ উপভোগ করেছেন ! : ডি}

Comments

আমি upvoting বিবেচনা, কিন্তু আপনার বর্তমান স্কোর 9 ...

— wchargin

@ ডাব্লুচারগিনকে দেখে মনে হচ্ছে এখন আপনি এটি 99 পাওয়ার চেষ্টা করতে হবে

— ট্রেল্কলি

নিশ্চয় এতে স্ব-হোস্টিং (ক লেখার জন্য একটি বোনাস এর 99 দোভাষী 99 ), না?

— গ্যাবে

@ গ্যাবে এর মতো একটি উত্তর সম্ভবত অনুগ্রহ পাবে, তবে যদি সেই উত্তরটি একমাত্র হয়, তবে দোভাষীর অর্থ কী হবে? ;)

— ক্যালভিনের শখ

@ অপ্টিমাইজার এটি কাজ করে: পেস্টবিন.

— coredump

Answer 1

সিজেম, 157 বাইট

{:I;_N" 9"+--N/:P:,$W=){1a*Ab}%:V;{PT):T(=:LS%_{LS#\:,_,({(\{V=}%@{V-1@{2$*+0@-\}*\;t:V;}{:|T@V=9*?:T;}?}{~\{_V=\1&!{128%c}*o}{VIW):W=it:V;}?}?}R?Tg)TP,<*}g}

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

• I / O পরীক্ষা
• G11G10G9G8G7G6G5G4G3G2G1G
• 99 বোতল বিয়ার (এই কোডটি কোনও ইউআরএল ফিট করতে খুব দীর্ঘ, তাই কোডটি অনুলিপি করুন এবং ম্যানুয়ালি ইন্টারপ্রেটারে পেস্ট করুন )

ব্যাখ্যা

এটিকে যথাযথ ইনডেন্টেশন এবং মন্তব্যে ফর্ম্যাট করার চেষ্টা করা সম্ভবত চিরকালের জন্য লাগে, তাই আমি কেবল একটি অ্যালগোরিদমিক সংক্ষিপ্তসার দেব।

কোডটি একটি ব্লক, বেনামে ফাংশনগুলির জন্য সিজেমের এনালগ। ব্লকটি কার্যকর করা হলে স্ট্রাকের ইনপুটগুলির প্রোগ্রাম স্ট্রিং এবং তালিকার প্রত্যাশা করে।

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

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

Comments

+1 টি। বেশ ছোট. এখন, আপনি কি 99 তে একটি সিজেএম ইন্টারপ্রেটার লিখতে পারেন ? ;-)

— coredump

@ কর্ড্প্প *

— রানার 1112

অভিশাপ, আমি কেবল 195 পেতে পারি এবং তারপরে আমি আশা হারিয়ে

— অপ্টিমাইজার

নেতিবাচক মানগুলি মুদ্রণের সময় এটি সঠিক মডুলো নেয় না। এটি প্রতিস্থাপনের 128%মাধ্যমে স্থির করা যেতে পারে 128,=।

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

Answer 2

পাইথন 3, 421 414 410 404 388 395 401 বাইট

Golfed:

import sys,re
v,i,c,g,L={},0,[re.sub('( ?)[^9]+','\\1',l).rstrip().split(' ')for l in open(sys.argv[1])],lambda i:v.get(i,int(i)//9),len
while-1<i<L(c):
 d=c[i];l=L(d);e,*f=d;i+=1
 if l>1:
  x,*y=f
  if e:w=list(map(g,f));v[e]=sum(w[::2])-sum(w[1::2])
  elif l==2:j=input();v[x]=int(j)if L(x)%2 else ord(j)
  elif~-any(g(j)for j in y):i=g(x)*9
 elif e:w=g(e);print(w if L(e)%2 else chr(w%128),end='')

Ungolfed:

import sys, re

# Intialise variable table.
vars_ = {}
get_var = lambda i: vars_.get(i, int(i)//9)

# Parse commands.
commands=[re.sub('( ?)[^9]+','\\1',l).rstrip().split(' ') for l in open(sys.argv[1])]

# Run until the current instruction index is out of bounds.
index=0
while 0 <= index < len(commands):
    # Get the current command and increment the index.
    command = commands[index]
    l = len(command)
    first = command[0]
    index += 1

    if l > 1:
        # Handle the "assignment" command.
        if first:
            operands = [get_var(i) for i in command[1:]]
            vars_[first] = sum(operands[0::2]) - sum(operands[1::2])
        # Handle the "input" command.
        elif l==2:
            inp = input()
            vars_[command[1]] = int(inp) if len(command[1]) % 2 else ord(inp)
        # Handle the "goto" command.
        elif not any(get_var(i) for i in command[2:]):
            index = get_var(command[1]) * 9
    # Handle the "output" command.
    elif first:
        val = get_var(first)
        print(val if len(first) % 2 else chr(val % 128),end='')

চমত্কারভাবে বেশ কিছুটা আক্ষরিক বাস্তবায়ন, যত তাড়াতাড়ি আমি তা পেতে পারি g

একমাত্র আর্গুমেন্ট হিসাবে একটি 99 উত্স-কোড ফাইল সরবরাহ করে কমান্ড লাইন থেকে চালান (উদাহরণস্বরূপ ওপি থেকে শেষ উদাহরণ):

> python3 ninetynine.py countdown.txt
G11G10G9G8G7G6G5G4G3G2G1G
>

একটি যোগ বোনাস হিসাবে, এখানে (বরং দরিদ্র) এ "99 বোতল" বাস্তবায়ন এর 99 : http://pastebin.com/nczmzkFs

Comments

@ ডিএলকাস: আপনার প্রথম পয়েন্টটি সম্পর্কে: আমিও যদিও এর elseপরে একটি সংখ্যা অপসারণ করা যেতে পারে তবে আমি আগে এটি চেষ্টা করার সময় একটি সিনট্যাক্স ত্রুটি পেয়েছিলাম। আপনার অন্যান্য টিপস যদিও অনেক প্রশংসা করা হয়!

— ম্যাক

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

— ম্যাক

না elseনিজেই, এটা মাত্র স্থান। যেমন 3*n+1if n%2else n//2।

— ডিএলস

@ডলকস: দুঃখিত, আমি ভুল উচ্চারণ করেছি - আমি প্রকৃতপক্ষে স্থানটি বোঝাতে চেয়েছি, না else। উদাহরণস্বরূপ, আমি এর print(w if L(e)%2 else chr(w%128))সাথে প্রতিস্থাপনের চেষ্টা করেছি print(w if L(e)%2else chr(w%128))এবং একটি সিনট্যাক্স ব্যতিক্রম পেয়েছি।

— ম্যাক

অদ্ভুত - আমি আইডোন.কম এ পরীক্ষা করেছি এবং এটি কাজ করেছে তবে আপনি ঠিক বলেছেন, এটি আসল পাইথন 3 ইন্টারপ্রেটারে (উবুন্টুতে 3.4.0) কাজ করে না। এই টিপস পোষ্ট সুস্পষ্ট: একটি সংখ্যা একটি বর্ণানুক্রমিক টোকেন দ্বারা অনুসরণ সাধারণ কাজ করে, কিন্তু না দিয়ে শুরু টোকেন জন্য eবা E, এবং (মন্তব্য থেকে) না করার জন্য 0orহয়।

— ডিএলস্ক

Answer 3

কমন লিস্প, 1180 857 837 836 বাইট

আমি জানি এটি জিততে পারে না, তবে আমি এইটিকে গল্ফ করতে মজা পেয়েছি। আমি 343 বাইট অপসারণ করতে সক্ষম হয়েছি, যা সিজেমে লিখিত দুটি 99 টি অনুবাদকের চেয়ে বেশি ।

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

(defmacro g(g &aux a(~ -1)> d x q(m 0)r v(n t)c(w 0)? u z)(flet((w(n p)(intern(format()"~a~a"p n))))(#1=tagbody %(case(setf c(ignore-errors(elt g(incf ~))))(#\  #2=(when(> w 0)(pushnew w v)(if u()(setq ?(oddp w)))(#5=push(w w'V)u)(setf w 0))(setf z t))(#\9(incf w)(setf >(or >(and n z))z()n()))((#\Newline())#2#(#5#(when u(setf u(reverse u)a(pop u))(if >(if u`(when(every'zerop(list,@u))(setf @,a)(go ^))`(setf,a,(if ?'(read)'(char-code(read-char)))))(if u`(setf,a,(do(p m)((not u)`(-(+,@p),@m))(#5#(pop u)p)(#5#(if u(pop u)0)m)))`(princ,(if ? a`(code-char(mod,a 128)))))))r)(incf m)(setf ?()u()z()>()n t)))(if c(go %))$(decf m)(setq d(pop r))(if d(#5# d x))(when(=(mod m 9)0)(#5#(w #3=(/ m 9)'L)x)(#5#`(,#3#(go,(w #3#'L)))q))(if(>= m 0)(go $)))`(let(@,@(mapcar(lambda(n)`(,(w n'V),(/(1-(expt 10 n))9)))v))(#1#,@x(go >)^(case @,@q)>))))

• লেজিকাল বিশ্লেষণ এবং কোড জেনারেশন আন্তঃলিবিযুক্ত: আমি অভ্যন্তরীণ উপস্থাপনা সঞ্চয় করি না, তবে প্রতিটি লাইনটিতে সরাসরি প্রক্রিয়া করি।

• tagbody2 টি লুপ সঞ্চালনের জন্য একক রয়েছে :

   (... (tagbody % ... (go %) $ ... (go $)) result)
  

• স্থানীয় ভেরিয়েবলগুলি ঘোষিত হয় &aux

• কোনও ক্লোজার তৈরি করবেন না, তবে সরাসরি ব্যাখ্যা করা কোড inter
• প্রভৃতি

অসমাপ্ত, মন্তব্য করেছেন

(defmacro parse-99
    (string &aux
              (~ -1) ; current position in string
              a      ; first variable in a line 
              >      ; does current line starts with a leading space?
              d      ; holds a statement during code generation
              x      ; all statements (labels + expressions)
              q      ; all generated case statements 
              (m 0)  ; count program lines (first increases, then decreases) 
              r      ; list of parsed expressions (without labels)
              v      ; set of variables in program, as integers: 999 is 3
              (n t)  ; are we in a new line without having read a variable? 
              c      ; current char in string 
              (w 0)  ; currently parsed variable, as integer 
              ?      ; is first variable odd? 
              u      ; list of variables in current line, as integers
              z)     ; is the last read token a space?
  (flet((w(n p)
          ;; produce symbols for 99 variables
          ;; e.g. (10 'V) => 'V10
          ;;      (4 'L)  => 'L4
          (intern(format()"~a~a"p n))))
    (tagbody
     parse
       (case (setf c
                   ;; read current char in string,
                   ;; which can be NIL if out-of-bounds
                   (ignore-errors(aref string (incf ~))))

         ;; Space character
         (#\Space
          #2=(when(> w 0)
               (pushnew w v)            ; we were parsing a variable, add it to "v"
               (if u()(setq ?(oddp w))) ; if stack is empty, this is the first variable, determine if odd
               (push(w w'V)u)           ; add to stack of statement variable
               (setf w 0))              ; reset w for next variable

          ;; Space can either be significant (beginning of line,
          ;; preceding a variable), or not. We don't know yet.
          (setf z t))

         ;; Nine
         (#\9
          (incf w) ; increment count of nines
          (setf >(or >(and n z)) ; there is an indent if we were
                                 ; starting a newline and reading a
                                 ; space up to this variable (or if we
                                 ; already know that there is an
                                 ; indent in current line).
                ;; reset z and n
                z()n()))

         ;; Newline, or end of string
         ((#\Newline())
          #2#  ;; COPY-PASTE the above (when(> w 0)...) statement,
               ;; which adds previously read variable if necessary.

          ;; We can now convert the currently read line.
          ;; We push either NIL or a statement into variable R.

          (push(when u
                     (setf u (reverse u) ; we pushed, we must reverse
                           a (pop u))    ; a is the first element, u is popped
                     (if >
                         ;; STARTS WITH LEADING SPACE
                         (if u
                             ;; JUMP
                             `(when(every'zerop(list,@u))(setf @,a)(go ^))

                             ;; READ
                             `(setf,a,(if ?'(read)'(char-code(read-char)))))

                         ;; STARTS WITH VARIABLE
                         (if u

                             ;; ARITHMETIC
                             `(setf,a,(do(p m) ; declare p (plus) and m (minus) lists

                                         ;; stopping condition: u is empty
                                         ((not u)
                                          ;; returned value: (- (+ ....) ....)
                                          `(-(+,@p),@m))

                                        ;; alternatively push
                                        ;; variables in p and m, while
                                        ;; popping u

                                        (push(pop u)p)

                                        ;; first pop must succeed, but
                                        ;; not necessarly the second
                                        ;; one.  using a zero when u
                                        ;; is empty covers a lot of
                                        ;; corner cases.

                                        (push(if u (pop u) 0) m)))

                             ;; PRINT
                             `(princ,(if ? a`(code-char(mod,a 128)))))))
               r)
          ;; increase line count
          (incf m)
          ;; reset intermediate variables
          (setf ?()u()z()>()n t)))

       ;; loop until end of string
       (if c (go parse))


     build
       ;;; Now, we can add labels in generated code, for jumps

       ;; decrease line count M, which guards our second loop
       (decf m)

       ;; Take generated statement from R
       (setq d(pop r))

       ;; we pop from R and push in X, which means X will eventually
       ;; be in the correct sequence order. Here, we can safely
       ;; discard NIL statements.

       ;; We first push the expression, and THEN the label, so that
       ;; the label ends up being BEFORE the corresponding statement.
       (if d(push d x))

       ;; We can only jump into lines multiple of 9
       (when (=(mod m 9)0)
         ;; Push label
         (push(w #3=(/ m 9)'L)x)
         ;; Also, build a case statement for the jump table (e.g. 2(go L2))
         (push`(,#3#(go,(w #3#'L)))q))
       ;; loop
       (if(>= m 0)(go build)))

    ;; Finally, return the code
    `(let(@ ; target of a jump instruction

          ;; other variables: V3 represents 999 and has a default value of 111
          ,@(mapcar(lambda(n)`(,(w n'V),(/(1-(expt 10 n))9)))v))

       ;; build a tagbody, inject statements from X and case statements from Q
       ;; label ^ points to jump table : we go to ^ each time there is a JUMP
       ;; label > is the end of program

       ;; note that if the case does not match any authorized target
       ;; address, we simply end the programs.
       (tagbody,@x(go >)^(case @,@q)>))))

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

99 টি প্রোগ্রাম চলাকালীন ইনপুটগুলি পুরোপুরি ভালভাবে স্যানিটাইজ করা হয় না : এটি ধারণা করা হয় যে ব্যবহারকারী কী ধরণের মান প্রত্যাশিত তা জানে।

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

ম্যাক থেকে চতুর অবজ্ঞানের ভিত্তিতে যে আমাদের প্রত্যেকবার 9 টি ভাগ এবং গুন করার দরকার নেই, বর্তমান সংস্করণ কার্যকর করার সময় কখনও বিভাজন বা 9 দ্বারা গুণিত করতে পারে না ।

উদাহরণ

যদি আমরা এর defmacroদ্বারা প্রতিস্থাপন করি তবে আমরা defunউত্পন্ন কোডটি দেখতে পাই। উদাহরণ স্বরূপ:

(g
"99999999                                              Print G.
999 99                                                Set triple-nine to ninety-nine.
9999999999 9999999999 9999999999 99 99 9 9 999 999    Set 10-nine to zero.
99999999999 9999999999                                Set 11-nine to zero.





999                                                   Print triple-nine's value divided by nine. (This is the ninth line.)
99999999                                              Print G.
999 999 9                                             Subtract nine from triple-nine.
 99999 999                                            Jump to line 5-nines if triple-nine is zero (endsprogram).
 9 99999999999 9999999999                             Jump to line nine if 10-nine and 11-nine are zero (alwa

")

ফলাফল ফলাফল এখানে:

(LET (@
      (V5 11111)
      (V11 11111111111)
      (V1 1)
      (V10 1111111111)
      (V2 11)
      (V3 111)
      (V8 11111111))
  (TAGBODY
   L0
    (PRINC (CODE-CHAR (MOD V8 128)))
    (SETF V3 (- (+ V2) 0))
    (SETF V10 (- (+ V3 V1 V2 V10) V3 V1 V2 V10))
    (SETF V11 (- (+ V10) 0))
   L1
    (PRINC V3)
    (PRINC (CODE-CHAR (MOD V8 128)))
    (SETF V3 (- (+ V3) V1))
    (WHEN (EVERY 'ZEROP (LIST V3)) (SETF @ V5) (GO ^))
    (WHEN (EVERY 'ZEROP (LIST V11 V10)) (SETF @ V1) (GO ^))
    (GO >)
   ^
    (CASE @ (0 (GO L0)) (1 (GO L1)))
   >))

কার্যকর করা হলে, "G11G10G9G8G7G6G5G4G3G2G1G" মুদ্রণ করে

কমান্ড-লাইন

আমরা একটি কোর ডাম্প করে এবং toplevelফাংশনটি নির্দিষ্ট করে একটি এক্সিকিউটেবল তৈরি করতে পারি । boot.lispআপনি যে ফাইলটি রেখেছিলেন তার নাম নির্ধারণ করুন defmacroএবং তারপরে নিম্নলিখিতটি লিখুন:

(defun main()(parse-99 <PROGRAM>))
(save-lisp-and-die "test-99" :executable t :toplevel #'main)

চলমান sbcl --load boot.lispনিম্নলিখিত আউটপুট দেয়:

$ sbcl --load boot.lisp 
This is SBCL 1.2.8.32-18c2392, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into test-99:
writing 5824 bytes from the read-only space at 0x20000000
writing 3120 bytes from the static space at 0x20100000
writing 55771136 bytes from the dynamic space at 0x1000000000
done]

তারপরে, সংকলিত 99 প্রোগ্রামটি চালাচ্ছেন :

$ time ./test-99
G11G10G9G8G7G6G5G4G3G2G1G
real    0m0.009s
user    0m0.008s
sys     0m0.000s

99 বোতল

আপনি যদি আগ্রহী হন তবে এখানে ম্যাকের উত্তরে লেখা 99 বোতল প্রোগ্রামের সংকলিত কোডটি রয়েছে : http://pastebin.com/ZXe839CZ (এটি আমাদের পুরানো সংস্করণ যেখানে আমাদের রয়েছে jmpএবং endলেবেলগুলি, একটি পার্শ্ববর্তী ল্যাম্বদা এবং সুন্দর পাটিগণিত)।

এটি এখনও কার্যকর হয় তা প্রমাণ করার জন্য এখানে নতুন সংস্করণ সহ একটি কার্যকর করা হয়েছে: http://pastebin.com/raw.php?i=h73q58FN

Answer 4

টিআই -৪৪ বেসিক (ক্যালকুলেটর স্ক্রিপ্ট), 376 373 377 381 বাইট

যদি এটি টিআই -৪৪ ক্যালকুলেটরটিতে চলে, আপনি এটি একটি মানক পরীক্ষায় ব্যবহার করতে সক্ষম হবেন ... সুতরাং এটি দরকারী;)

ন্যূনতম অপারেটিং সিস্টেম সংস্করণ - 2.53 এমপি (ম্যাথপ্রিন্ট) সামিট সিগমার কারণে

#Get input from STDIN
:Ans+":"->Str0
#Initialize instruction pointer
:1->I
#Initialize variable set
:DelVar L1999->dim(L1
#Strip out those pesky non-newline/space/9 characters
:For(J,1,length(Ans
:sub(Str0,J,1
:If not(inString(": 9",Ans
:sub(Str0,1,J-1)+sub(Str0,J+1,length(Str0)-J->Str0
:End
#Main interpreting loop
:While I<length(Str0
:sub(Str0,I+1,inString(Str0,":",I+1)-I-1->Str1
:DelVar A" "=sub(Ans,1,1->A
:inString(Str0,":",I+1->I
:If A
:sub(Str1,2,length(Str1)-1->Str1
:End
:length(Str1->L
#0 is Output, 1 is Input, 2 is Assignment, 3 is Goto
:2A+inString(Str1," ->B
:If not(Ans
:Disp L1(L
:If Ans=1
:Then
:Input C
:C->L1(L
:End
#Get those delimited variables
:If B>1
:Then
:"{"+Str1->Str2
:While inString(Ans," 
:inString(Ans," 
:sub(Str2,1,Ans-1)+sub(Str2,Ans+1,length(Str2)-Ans->Str2
:End
:log(expr(Ans)+1->L2
:End
:If B=2
#Gotta expand that -+ pattern
:Ans(2->L1(Ans(1
;Love that summation Σ
:If B=3 and Σ(L2(K),K,2,dim(L2
:Then
:DelVar IFor(K,0,9L2(1
:inString(Str0,":",I+1->I
:End
:End

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

আসল হেক্স ডাম্প (৩66 বাইট)

49 3f bb 54 5d 20 39 39 39 04 b5 5d 20 3f 72 04 aa 09 3f d3 4a 2b 31 2b bb 2b 72 3f bb 0c aa 09 2b 4a 2b 31 3f ce b8 bb 0f 2a 3e 29 39 2a 2b 72 3f bb 0c aa 09 2b 31 2b 4a 71 31 11 70 bb 0c aa 09 2b 4a 70 31 2b 72 71 4a 04 aa 09 3f d4 3f d1 49 6b bb 2b aa 09 3f bb 0c aa 09 2b 49 70 31 2b bb 0f aa 09 2b 2a 3e 2a 2b 49 70 31 11 71 49 71 31 04 aa 20 3f bb 54 41 2a 29 2a 6a bb 0c 72 2b 31 2b 31 04 41 3f bb 0f aa 09 2b 2a 3e 2a 2b 49 70 31 04 49 3f ce 41 3f bb 0c aa 20 2b 32 2b bb 2b aa 20 11 71 31 04 aa 20 3f d4 3f bb 2b aa 20 04 4c 3f 32 41 70 bb 0f aa 20 2b 2a 29 04 42 3f ce b8 72 3f de 5d 20 10 4c 11 83 39 3f ce 72 6a 31 3f cf 3f dc 43 3f 39 43 04 5d 20 10 4c 3f d4 3f ce 42 6c 31 3f cf 3f 2a 08 2a 70 aa 20 04 aa 01 3f d1 bb 0f 72 2b 2a 29 3f bb 0f 72 2b 2a 29 3f bb 0c aa 01 2b 31 2b 72 71 31 11 70 bb 0c aa 01 2b 72 70 31 2b bb 2b aa 01 11 71 72 04 aa 01 3f d4 3f c0 bb 2a 72 11 70 31 04 5d 01 3f d4 3f ce 42 6a 32 3f 72 10 32 04 5d 20 10 72 10 31 3f ce 42 6a 33 40 ef 33 5d 01 10 4b 11 2b 4b 2b 32 2b b5 5d 01 3f cf 3f bb 54 49 d3 4b 2b 30 2b 5d 01 10 31 3f bb 0f aa 09 2b 2a 3e 2a 2b 49 70 31 04 49 3f d4 3f d4 2e 76

# 1 সম্পাদনা করুন - ম্যাকের পর্যবেক্ষণ সম্পাদনাগুলি # 2 এবং # 3 ব্যবহার করে অনুকূলিত 3 বাইট - রানার 1112 দ্বারা চিহ্নিত স্থির বাগগুলি।

Comments

প্রমিত পরীক্ষা মত চাপ পরিস্থিতিতে ব্যবহার করা সহজ হচ্ছে ঠিক কি আমি পরিকল্পিত 99 জন্য।

— ক্যালভিনের

আমি কি মতামতের জন্য আলাদা চরিত্রটি ব্যবহার করার পরামর্শ দিতে পারি #? : (বিশেষ দ্রষ্টব্য প্রকৃত কোডে মন্তব্য শুধুমাত্র একটি বন্ধ না স্ট্রিং সঙ্গে একটি লাইন, যা উওর clobbers হিসাবে প্রয়োগ করা হয়)

— Riking

আপনি কি আসলে এটি চালানোর চেষ্টা করেছেন? আমার কাছে নেই, তবে এটি আরও কিছুটা দেখার চেয়ে আমি কমপক্ষে অর্ধ ডজন বাগ হিসাবে দেখেছি spot উদাহরণস্বরূপ: ভেরিয়েবলগুলি তাদের মানগুলির সাথে আরম্ভ হয় না, Ansইনপুট ওভাররাইট করা হয় সুতরাং Ans->Str0লাইন 6 এ ত্রুটি ঘটবে, এমন একাধিক উদাহরণ রয়েছে যেখানে কোনও sub()কমান্ডের দৈর্ঘ্য আর্গুমেন্ট শূন্য হতে পারে যার ফলে ত্রুটির ফলস্বরূপ, Ans11 লাইনে স্ট্রিং হবে সুতরাং Ans-Jত্রুটি ঘটবে ... এবং আমি কেবল প্রোগ্রামের প্রথমার্ধের দিকে চেয়েছিলাম।

— রানার 1212

@ টিমটেক যা এখনও অন্যান্য সমস্যাগুলি ফেলে দেয়। যেমনটি আমি উল্লেখ করেছি, অক্ষর I / O এর অভাব, পরিবর্তনশীল সূচনাকরণের অভাব এবং একাধিক উদাহরণ যেখানে একটি sub()কমান্ডের দৈর্ঘ্য শূন্য হতে পারে এবং ত্রুটি ছুঁড়ে ফেলতে পারে। এবং একবার sub()অনুরোধগুলি স্থির হয়ে গেলে , আমি ভয় করি যে এটি আরও সমস্যা প্রকাশ করতে পারে।

— রানার 1212

@ টিমটেক আমি এটি উল্লেখ করছিলাম: "ডিফল্টরূপে প্রতিটি ভেরিয়েবলকে তার নিজস্ব সংখ্যার উপস্থাপনার জন্য বরাদ্দ করা হয় So সুতরাং যদি এটি পুনরায় বরাদ্দ না করা হয় তবে ভেরিয়েবলের মান 99 নম্বর হয়, এবং ভেরিয়েবলের মান 9999 হয়, ইত্যাদি। " এবং দৈর্ঘ্যের 0 টি স্ট্রিংগুলি এর মাধ্যমে উত্পাদিত হতে পারে ""তবে এটি একটি বাগের মতো যা মূলত কোনও স্ট্রিং ম্যানিপুলেশন কমান্ড সহ খালি স্ট্রিং গ্রহণ করতে বা উত্পাদন করতে পারে না sub()।

— রানার 1212

Answer 5

সি 426 458 481 497

সম্পাদন করা হতে পারে আমি খুব বেশি দূরে যাচ্ছি, তবে এটি ভিজ্যুয়াল সি: fopen এবং getc এর জন্য ফাইল * এর পরিবর্তে int ব্যবহার করে stdio.h অপসারণ করে

সম্পাদনা 2 পুনর্ক্রমের সম্পাদন পদক্ষেপ, আরও বিশৃঙ্খলা, 32 অক্ষর সংরক্ষণ করা হয়েছে

B[99999],*r,*i[9999],V[999],v,w,m,n;unsigned p,s;
main(b,a)char*a[];{r=i[0]=B;m=fopen(a[1],"r");
do if(w=getc(m),n+=w==57,w<33){
if(n){for(v=1,b=n;--b;)v=v*10+1;V[n]=v;*r++=p?-n:n;b=n=0;};
w-32?(*r=p=0,b=i[++s]=++r):(p=b,b=0);}while(w>=0);
while(p<s)if(w=0,r=i[p++],v=*r++)
if(m=v>0,*r){for(;b=*r++;m=-m)w=w+m*V[b]|!m*V[b];m?V[v]=w:(p=w?p:9*V[-v]);
}else~v&1?!m?V[-v]=getchar():putchar(V[v]&127):m?printf("%d",V[v]):scanf("%d",V-v);
}

কনসোলের মাধ্যমে একা কনসোল প্রোগ্রাম, প্রোগ্রামের নাম কমান্ড লাইন এবং ইনপুট / আউটপুট নিয়ে নেওয়া হয়েছে।

পুরাতন স্টাইলের কে ও আর, বিশ্বব্যাপী ভার্স এবং পরামিতিগুলির জন্য ডিফল্ট টাইপ ইন্ট। ইওএফ -1 হিসাবে সংজ্ঞায়িত হিসাবে ধরে নেওয়া (এটি প্রতিটি সি প্রয়োগে যেমন আমি সচেতন)

ভিজ্যুয়াল স্টুডিও 2010 (উইন 32 কনসোল সি ++ প্রকল্প, সি হিসাবে সংকলন) সহ সতর্কতা সহ সংকলন আইডিয়নে সংকলন করে, তবে ফাইলের প্রয়োজন হওয়ায় চলতে পারে না।

প্রথম পদক্ষেপ, উত্স কোডটি পড়া এবং বিশ্লেষণ করা হয়, প্রতিটি লাইন 9 এস এর সংখ্যার ভিত্তিতে পূর্ণসংখ্যার ক্রম হিসাবে সংরক্ষণ করা হয়। যদি শীর্ষস্থানীয় ফাঁকা থাকে তবে প্রথম সংখ্যাটি negativeণাত্মক। সুতরাং: 9 BLAH 99 9a9bb9c9( 9 99 9999) হয়ে যায় -1,2,4 একটি শর্টকাট আছে - এত আইনী নয়: '' এর চেয়ে কম সমস্ত এসকি কোডগুলি নিউলাইন হিসাবে বিবেচিত হয়।

এই পদক্ষেপে সমস্ত ব্যবহৃত পরিবর্তনশীল পূর্বনির্ধারিত হয়।

এক্সিকিউশন পদক্ষেপটি স্পেসিফিকেশনগুলি অনুসরণ করে, কোনও ঝাঁকুনি না করে 9 দ্বারা বিভক্ত স্টোরিং নম্বরগুলি সংরক্ষণ করে।

আরও পঠনযোগ্য একই কোড (আমি আশা করি), স্পেস এবং নিউলাইন যুক্ত করা হয়েছে

B[99999],*r,*i[9999],V[999],v,w,m,n;
unsigned p,s;
main(b,a)char*a[];
{
  r=i[0]=B;
  m=fopen(a[1],"r");
  do if(w=getc(m),n+=w==57,w<33)
  {
     if(n){for(v=1,b=n;--b;)v=v*10+1;V[n]=v;*r++=p?-n:n;b=n=0;};
     w-32?(*r=p=0,b=i[++s]=++r):(p=b,b=0);
  }
  while (w>=0);
  while (p<s)
    if (w = 0, r = i[p++], v = *r++)
        if (m = v > 0, *r){
            for(; b = *r++; m = -m)
                w = w + m*V[b] | !m*V[b];
            m ? V[v]=w : (p = w ? p : 9*V[-v]);
        } else
            ~v & 1 
            ? !m ? V[-v] = getchar() : putchar(V[v] & 127)  
            : m ? printf("%d", V[v]) : scanf("%d", V - v);
}

Comments

জিসিসি 4.8.2 এর সাথেও কাজ করে। C99 হিসাবে সংকলন!

— এমবিলেম

Answer 6

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

import Data.List.Split
import System.Environment
a#b=takeWhile(/=a)b
(!)=map
main=do(f:_)<-getArgs;readFile f>>=e.(p!).lines
p l=(if ' '#l<'9'#l then[0]else[])++length!(wordsBy(/='9')l)
e l=(\x->div(10^x-1)9)%l where
 _%[]=return()
 v%([]:r)=v%r
 v%([n]:r)=putStr(if odd n then show(v n)else[toEnum$v n`mod`128])>>v%r
 v%([0,n]:r)=do i<-getLine;u n(if odd n then read i else fromEnum$head i)v%r
 v%((0:n:m):r)|any(/=0)(v!m)=v%r|v n<0=v%[]|1<2=v%drop(9*v n)l
 v%((n:m):r)=u n(sum$zipWith(*)(v!m)(cycle[1,-1]))v%r
u n i v= \x->if x==n then i else v x

উদাহরণ ফাইলের মধ্যে সংরক্ষণ করা "কাউন্টডাউন" প্রোগ্রামের সাথে চালানো i.99

$ ./99 i.99
G11G10G9G8G7G6G5G4G3G2G1G

অবরুদ্ধ সংস্করণ:

import Data.List.Split
import System.Environment

-- The main function takes the first command line argument as a file name,
-- reads the content, splits it into lines, parses each line and evaluates
-- the list of parsed lines.
main = do
 (f:_)<-getArgs
 readFile f >>= eval.map parse.lines

-- each line is coverted into a list of integers, which represent the number
-- of 9s (e.g. "999 99 9999" -> [3,2,4]). If there's a space before the first
-- 9, a 0 is put in front of the list (e.g. " 9 9 999" -> [0,1,1,3]).
parse l = (if takeWhile (/=' ') l < takeWhile (/='9') l then [0] else [])
   ++ map length (wordsBy(/='9') l)

-- The work is done by the helper function 'go', which takes two arguments
--   a) a functions which takes an integer i and returns the value of the
--      variable with i 9s (e.g: input: 4, output: value of 9999). To be
--      exact, the value divided by 9 is returned.
--   b) a list of lines to work on
-- 'eval' starts the process with a function that returns i 1s for every i and
-- the list of the parsed input. 'go' checks which statement has to be
-- executed for the next line and calls itself recursively
eval list = go (\x -> div (10^x-1) 9) list
   where
   go _ []                  = return ()
   go v ([]:r)              = go v r
   go v ([n]:r)             = putStr (if odd n then show(v n) else [toEnum (v n`mod`128)]) >> go v r
   go v ([0,n]:r)           = do i<-getLine ; go (update n (if odd n then read i else fromEnum$head i) v) r
   go v ((0:n:m):r)
      | any (/=0) (map v m) = go v r
      | v n < 0             = go v []
      | otherwise           = go v (drop (9*v n) list)
   go v ((n:m):r)           = go (update n (sum $ zipWith (*) (map v m) (cycle[1,-1])) v) r

-- updates a function for retrieving variable values.
-- n = position to update
-- i = new value
-- v = the function to update
update n i v = \x->if x==n then i else v x

Answer 7

জাভাস্ক্রিপ্ট (ES6) 340 352

2 পরামিতি সহ একটি ফাংশন

• মাল্টিলাইন স্ট্রিং হিসাবে প্রোগ্রাম কোড
• অ্যারে হিসাবে ইনপুট

তৃতীয় alচ্ছিক প্যারামিটার (ডিফল্ট 10 কে) হ'ল সর্বাধিক সংখ্যা পুনরাবৃত্তি - আমি চিরকাল চলমান কোনও প্রোগ্রাম পছন্দ করি না

জেএসফিডাল পরীক্ষা করার জন্য

I=(c,i,k=1e5,
  V=v=>v in V?V[v]:v/9 // variable getter with default initial value
)=>(c=>{
 for(p=o='';--k&&p<c[L='length'];)
   (v=(r=c[p++].split(' '))[S='shift']())? // no leading space
      r[r.map(t=>w-=(m=-m)*V(t),w=0,m=1),0]?V[v]=w // Assign
      :o+=v[L]&1?V(v):String.fromCharCode(V(v)&127) // Output
   : // else, leading space
    (v=r[S]())&&
       (r[0]?r.some(t=>V(t))?0:p=9*V(v) // Goto
       :(t=i[S](),V[v]=v[L]&1?t:t.charCodeAt()) // Input
    )
})(c.replace(/ (?=[^9])|[^9\s]/g,'').split('\n'))  // code cleaning
||o

Answer 8

কিউ / কে, 490 469

M:mod;T:trim;R:read0;S:set;s:" "
f:(rtrim')(f:R -1!`$.z.x 0)inter\:"9 \n"
k)m:{@[x;&M[!#x;2];-:]}
b:{}
k)p:{1@$$[1=M[#x;2];(K x)%9;"c"$M[(K x)%9;128]];}
k)i:{S[(`$T x);$[1=M[#T x;2];9*"J"$R 0;*9*"i"$R 0]]}
k)K:{$[#!:a:`$x;.:a;"I"$x]}
k)v:{(S).(`$*:;+/m@K'1_)@\:T's\:x}
k)g:{$[&/0=C:K'c:1_J:s\:T x;n::-1+K@*J;|/~0=C;;(d<0)|(d:*C)<#f;exit 0]}
k)r:{`b`p`i`v`g@*&(&/x=s;q&1=c;(e~s)&1=C;(q:e~"9")&1<c:#s\:x;((e:*x)~s)&1<C:#s\:1_x)}
k)n:0;while[~n>#o:(r')f;(o n)f n;n+:1]
\\

।

$ q 99.q countdown.txt -q
G11G10G9G8G7G6G5G4G3G2G1G

স্ক্রিপ্টটি q এবং k এর মিশ্রণ, সুতরাং প্রথমে আমি কয়েকটি কিওয়ার্ড সংজ্ঞায়িত করি যা আমি k ফাংশনে একাধিকবার ব্যবহার করতে চাই। (মূলত # নির্ধারিত ম্যাক্রো)

M:mod;T:trim;R:read0;S:set

f প্রোগ্রামটিতে পাস করা ফাইলটি পড়ে এবং অপ্রয়োজনীয় চরিত্রগুলি সরিয়ে দেয়

q)f
"99999999"
"999 99"
"9999999999 9999999999 9999999999 99 99 9 9 999 999"
"99999999999 9999999999"
""
""
""
""
""
"999"
"99999999"
"999 999 9"
" 99999 999"
" 9 99999999999 9999999999"

m একটি তালিকা / ভেক্টর নেয় এবং বিজোড় সূচকগুলি -1 দ্বারা গুণ করে

q)m 1 2 3 4 5
1 -2 3 -4 5

b কেবল একটি খালি ফাংশন, কোনও অপ-লাইন জন্য ব্যবহৃত হয়

p মুদ্রণ ফাংশন।

Kএকটি ফাংশন যা একটি চলক পরীক্ষা করে। যদি ভেরিয়েবলটি বিদ্যমান থাকে, তবে এটি ফিরিয়ে দেয়, অন্যথায় এটি কেবল আক্ষরিক প্রত্যাবর্তন করে।

//999 not defined, so just return 999
q)K "999"
999
//Set 999 to 9
q)v "999 9"
//K now returns 9
q)K "999"
9

v অ্যাসাইনমেন্ট ফাংশন।

g গেটো ফাংশন।

r একটি স্ট্রিং নেয় এবং সিদ্ধান্ত নেয় যে কোন অপারেশন প্রয়োগ করা দরকার।

এবং তারপরে অবশেষে, আমি কেবল পুনরুক্তি হিসাবে fস্ট্রিংগুলির তালিকা দিয়ে পুনরাবৃত্তি করব n। গোটো ফাংশন nপ্রয়োজনীয় হিসাবে আপডেট হবে ।

Answer 9

পার্ল, 273 266 255 244 238

স্পষ্টতার জন্য লাইন ব্রেকগুলি যুক্ত হয়েছে।

open A,pop;
for(@c=<A>){
y/ 9//cd;s/ +/ /g;s/ $//;
$p="((99)+|9+)";$a='+';
s/^ $p$/$1='$2'?ord<>:<>/;
s/^$p$/print'$2'?chr$1%128:$1/;
s/^ $p /\$_=$1*011unless/&&y/ /|/;
s/ /=/;s/ /$a=-$a/ge;
s!9+!${x.$&}=$&/9;"\$x$&"!eg}
eval$c[$_++]until/-/|$_>@c

কমান্ড লাইনে প্রোগ্রামের নাম নেওয়া হয়েছে:

$ perl 99.pl 99beers.99

প্রোগ্রামের প্রতিটি লাইন পার্ল কোডে রূপান্তরিত হয়, উদাহরণস্বরূপ:

print'$x99'?chr$x99999999%128:$x99999999
$x999=$x99
$x9999999999=$x9999999999-$x9999999999+$x99-$x99+$x9-$x9+$x999-$x999
$x99999999999=$x9999999999





print''?chr$x999%128:$x999
print'$x99'?chr$x99999999%128:$x99999999
$x999=$x999-$x9
$_=$x99999*011unless$x999
$_=$x9*011unless$x99999999999|$x9999999999

আরো বিস্তারিত

open A,pop; # open the source file
for(@c=<A>){ # read all lines into @c and iterate over them
y/ 9//cd; # remove all but spaces and 9's
s/ +/ /g;s/ $//; # remove duplicate and trailing spaces
$p="((99)+|9+)";$a='+';
s/^ $p$/$1='$2'?ord<>:<>/; # convert input
s/^$p$/print'$2'?chr$1%128:$1/; # convert output
s/^ $p /\$_=$1*011unless/&&y/ /|/; # convert goto
s/ /=/;s/ /$a=-$a/ge; # convert assignment
s!9+!${x.$&}=$&/9;"\$x$&"!eg} # initialize and convert variables
eval$c[$_++]until/-/|$_>@c # run (program counter is in $_)