মুদ্রণ, বৃদ্ধি, হ্রাস, উপনাম - প্রিন্টিলের ব্যাখ্যা দিন


30

Prindeal (উচ্চারিত Prin-Dee-আল ) একটি নতুন গূঢ় : প্রোগ্রামিং ভাষা মাত্র চারটি কমান্ড আছে যা PR int- এ , মধ্যে crement , ডি crement , এবং আল আইএএস । এর ন্যূনতমতা থাকা সত্ত্বেও, চারটি কমান্ড চতুরতার সাথে একত্রিত করে প্রিনডিয়লে জটিল গাণিতিক ক্রিয়াকলাপ করা যেতে পারে।

এই কোড গল্ফ চ্যালেঞ্জের মধ্যে আপনার কাজটি হ'ল সংক্ষিপ্ততম প্রোগ্রামটি লিখুন যা প্রিনডিল কোড চালাতে পারে।

অনুমানটি দীর্ঘ তবে আমি যতটা সম্ভব পরিষ্কার করার চেষ্টা করেছি এবং আমি বিশ্বাস করি যে আপনি যদি প্রিনডিল শেখার চেষ্টা করেন তবে আপনি এটি বেশ মার্জিত বলে মনে করতে পারেন!


প্রিনডিলের ব্যাখ্যা দিচ্ছি

প্রাক-প্রক্রিয়াকরণ

একটি প্রিনডিল প্রোগ্রামের ব্যাখ্যা দেওয়ার আগে এই বিষয়গুলি থেকে এই ক্রম থেকে সরানো প্রয়োজন:

  1. #লাইনটি শেষ হওয়ার পরে কোনও চিহ্নের পরে এটি #নিজেই। (এগুলি মন্তব্য।)
  2. যে কোনও লাইনে শ্বেত স্পেস অনুসরণ করা।
  3. সম্পূর্ণ খালি লাইন।

উদাহরণস্বরূপ, প্রিনডিল প্রোগ্রাম

p cat #The next line has 7 trailing spaces.
p dog       

#p mouse

মধ্যে প্রিপ্রোসেস করা হবে

p cat
p dog

এখান থেকে আমরা ধরে নেব এই প্রাক-প্রসেসিং পদক্ষেপটি সম্পন্ন হয়েছে।

ভেরিয়েবল

ভেরিয়েবলগুলি কীভাবে ব্যবহৃত হয় তা দেখানোর আগে আমাদের দ্রুত সংজ্ঞা দেওয়া দরকার।

ভেরিয়েবল (এবং ভেরিয়েবলের রেফারেন্স) হ'ল প্রিনডিল কমান্ডের যুক্তিগুলিতে যা প্রেরণ করা হয়। চলকগুলি সর্বদা গ্লোবাল থাকে , সুতরাং ভেরিয়েবলের পরিবর্তনগুলি যেখানেই ঘটে না কেন, সর্বত্র প্রতিফলিত হয়।

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

- একটি পরিবর্তনশীল নাম কারাকাস এবং আন্ডারস্কোর কোন খালি নয় এমন স্ট্রিংটি কোনো সংখ্যা দিয়ে শুরু হয় না হতে পারে [a-zA-Z_][0-9a-zA-Z_]*Regex । এগুলি কেস সংবেদনশীল, তাই spiny_lumpsuck3rএবং Spiny_lumpsuck3rবিভিন্ন ভেরিয়েবল।

ফাঁসি

প্রিনডিল একটি অপরিহার্য প্রোগ্রামিং ভাষা। যখন একটি প্রিন্ডিল প্রোগ্রাম পরিচালিত হয় তখন এর স্টেটমেন্টগুলি উপরের থেকে নীচে থেকে ক্রমে কার্যকর হয় এবং তারপরে প্রোগ্রামটি শেষ হয়।

একটি প্রিন্ডিল প্রোগ্রামে প্রতিটি অ-ইন্ডেন্টেড লাইন হল একটি বিবৃতি যা একটি একক কমান্ড কার্যকর করতে জড়িত যা যুক্তি গ্রহণ করতে পারে বা নাও পারে।

ইনডেন্টড লাইনগুলি কেবলমাত্র ওরফে কমান্ডের পরে ঘটে । বিশেষত, একেক স্পেস সহ ঠিক তিনটি লাইন প্রতিটি উরফ কমান্ডের পরে ঘটে এবং এর একটি অংশ হিসাবে বিবেচিত হয়। সুতরাং ওরফে স্টেটমেন্টগুলি সত্যই চারটি লাইন দীর্ঘ। (এগুলি একটি লাইন হতে পারে, চারটি কেবল আরও বেশি পাঠযোগ্য))

অ- উরফ বিবৃতি

উপনাম বাদে, একটি প্রিন্ডিল প্রোগ্রামের প্রতিটি বিবৃতিতে ফর্ম রয়েছে:

[command name] [argument 1] [argument 2] [argument 3] ...

একটি স্বেচ্ছাসেবী যুক্তি থাকতে পারে (মোটেও কিছুই নয়)। প্রতিটি যুক্তি সর্বদা একটি পরিবর্তনশীল বা (যেমন আমরা ওরফে আলোচনা করার সময় দেখতে পাব ) একটি ভেরিয়েবলের একটি উল্লেখ

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

অন্তর্নির্মিত প্রিন্ট , ইনক্রিমেন্ট এবং হ্রাস হ'ল উপরের ফর্মের বিবৃতি। তারা যা করে তা এখানে:

  1. মুদ্রণটির কমান্ডের নাম রয়েছে pএবং এটি একটি যুক্তি গ্রহণ করে। এটি পাস করা ভেরিয়েবলের নাম মুদ্রণ করে এবং এর মান (দশমিকায়) "=" দ্বারা আলাদা হয়, তারপরে একটি নতুন লাইন। এটি সর্বদা সাফল্য হিসাবে চিহ্নিত করা হয় ।

    উদাহরণস্বরূপ, প্রিনডিল প্রোগ্রাম

    p _MyVariable_321
    p screaming_hairy_armadillo
    

    আউটপুট হবে

    _MyVariable_321 = 0
    screaming_hairy_armadillo = 0
    

    কারণ সমস্ত ভেরিয়েবল 0 থেকে শুরু হয় (সমান চিহ্নের আগে এবং পরে ফাঁকা স্থানগুলি আবশ্যক))

  2. বর্ধনের কমান্ডের নাম রয়েছে iএবং একটি আর্গুমেন্ট নেয়। এটি ভেরিয়েবলের মান 1 বৃদ্ধি করেছে 1. এটি সর্বদা একটি সাফল্য হিসাবে পতাকাঙ্কিত হয় ..

    উদাহরণস্বরূপ, প্রোগ্রাম

    i alpaca
    p alpaca
    i alpaca
    p alpaca
    

    আউটপুট হবে

    alpaca = 1
    alpaca = 2
    

    এর alpacaআগে কখনও অ্যাক্সেস না করা হলেও কীভাবে 0 থেকে 1 এ বাড়ানো হয়েছে তা দ্রষ্টব্য ।

  3. হ্রাসের কমান্ডের নাম রয়েছে dএবং এটি একটি যুক্তি নেয়। যদি ভেরিয়েবলটি পাস করা হয় ননজারো হয় তবে এর মান 1 দ্বারা হ্রাস হয় এবং বিবৃতিটিকে সাফল্য হিসাবে চিহ্নিত করা হয় । যদি ভেরিয়েবলটি 0 হয় তবে কিছুই করা হয় না এবং বিবৃতিটিকে ব্যর্থতা হিসাবে চিহ্নিত করা হয়

    উদাহরণস্বরূপ, প্রোগ্রাম

    i malamute
    p malamute
    d malamute    #success
    p malamute
    d malamute    #failure
    p malamute
    d akita       #failure
    p akita
    

    আউটপুট হবে

    malamute = 1
    malamute = 0
    malamute = 0
    akita = 0
    

    লক্ষ্য করুন যে মান 0 দিয়ে একটি ভেরিয়েবল হ্রাস হ'ল ব্যর্থতা তৈরির একমাত্র উপায় ।

ওরফে স্টেটমেন্ট ও বেনামে কমান্ড

ওরফে কমান্ড একটি বিশেষ সিনট্যাক্স এবং কারণ এটি নতুন কমান্ড সংজ্ঞায়িত করতে ব্যবহার করা যেতে পারে সবচেয়ে শক্তিশালী। ওরফে কমান্ড নাম aএবং ওরফে বিবৃতি ফর্ম আছে:

a [name of new command]
 [statement A]
 [statement B]
 [statement C]

যেখানে প্রত্যেকে যে [statement X]কোনও নন- ওরফে স্টেটমেন্ট উপস্থাপন করে, অর্থাত ফর্মের সাথে কিছু [command name] [argument 1] [argument 2] [argument 3] ...

অ্যালাইজড কমান্ডের নাম হ'ল [name of new command]বর্ণচিহ্নগুলি এবং আন্ডারস্কোরগুলির কোনও খালি খালি স্ট্রিং হতে পারে যা কোনও অঙ্কের সাথে শুরু হয় না - [a-zA-Z_][0-9a-zA-Z_]*রেজেক্সে।

(এটি ভেরিয়েবল হিসাবে একই নামের তবে অ্যালাইজড কমান্ড এবং ভেরিয়েবলগুলি বিভিন্ন জায়গায় ব্যবহৃত বিভিন্ন জিনিস A কোনও পরিবর্তনকে কোনও খারাপ পরিণতি না দিয়ে কমান্ড হিসাবে একই নামকরণ করা যেতে পারে))

যখন একটি উপনাম বিবৃতি কার্যকর করা হয়, মূল চারটি p i d aকমান্ডের সাথে একটি নতুন কমান্ড যুক্ত হয় । নতুন কমান্ডটি [command name]বিবৃতি হিসাবে ব্যবহার করা যেতে পারে এবং অন্যান্য নন- ওরফে কমান্ডের মতোই যুক্তি সহ কল ​​করা যেতে পারে ।

যখন কোনও এলিয়াসেড কমান্ড নাম সহ একটি বিবৃতি কার্যকর করা হয়, তখন এর আসল উপন্যাসের বিবৃতি থেকে আরও দুটি বিবৃতি চালিত হয়:

  • [statement A] সর্বদা চালানো হয়
  • [statement B]যদি চালানো হয় [statement A]একটি ছিল সাফল্য
  • [statement C][statement A]একটি ব্যর্থতা যদি রান হয়

এ, বি, এবং সি স্টেটমেন্টগুলি সর্বদা অলসভাবে চালানো হয় , অর্থাৎ তারা চালানোর সময় ফ্লাইয়ে মূল্যায়ন করা হয়।

মৃত্যুদন্ড কার্যকর করার পরে, এলিয়াসড কমান্ড একই সাফল্য বা ব্যর্থতা পতাকা হিসাবে বি বা সি, যে কোন একটি কার্যকর করা হয়েছিল হিসাবে পতাকা হিসাবে চিহ্নিত করা হয় । ( ওরফে স্টেটমেন্টগুলিকে পতাকাঙ্কিত করার দরকার নেই যেহেতু তারা নিজের মধ্যে ঘটতে পারে না))

এলিয়াস উদাহরণ 1

বলুন আমরা একটি নতুন কমান্ড চাই যা ভেরিয়েবলকে frogদুবার বাড়িয়ে দেয় । এই ওরফে বিবৃতি এটি অর্জন করে:

a increment_frog_twice
 i frog
 i frog
 d frog

বিবৃতি এ ( i frog) সবসময় চলতে হয় এবং সবসময় একটি হিসাবে পতাকাঙ্কিত সাফল্য তাই বিবৃতি বি ( i frog) সবসময় চালানো হয় এবং পরিবর্তনশীল frog এইভাবে 2. দ্বারা মান বৃদ্ধি হয় increment_frog_twiceকমান্ড সবসময় একটি হিসাবে পতাকাঙ্কিত করা হয় বিজয় কারণ বিবৃতি বি সবসময় চালানো হয় এবং B সবসময় একটি হল সাফল্য । বিবৃতি সি ( d frog) কখনও চালানো হয় না।

সুতরাং আউটপুট

a increment_frog_twice
 i frog
 i frog
 d frog
p frog
increment_frog_twice
p frog

হবে

frog = 0
frog = 2

আমরা এই উদাহরণটিকে সাধারণীকরণ করতে পারি যাতে কোনও ভেরিয়েবল অ্যালিজেড কমান্ডকে একটি যুক্তি দিয়ে দুবার বাড়ানো যায়।

একটি উপনামের বিবৃতিতে ইতিবাচক পূর্ণসংখ্যা 1, 2, 3, ইত্যাদি 1 ম, 2 য়, 3 য়, ইত্যাদি উপস্থাপন করে যুক্তিগুলি অ্যালাইজড কমান্ডে প্রেরণ করা হয়। (এই যুক্তিগুলি প্লেইন ভেরিয়েবল বা ভেরিয়েবলের রেফারেন্স হতে পারে)) এই সংখ্যাগুলি কেবলমাত্র একটি উপন্যাসের বিবৃতিতে A, B, এবং C এর বিবৃতিতে উপস্থিত হতে পারে । তাদের অন্য কোথাও উপস্থিত হওয়া কোনও অর্থবোধ করে না।

এলিয়াস উদাহরণ 2

এটি সর্বশেষ উদাহরণটিকে সাধারণীকরণ করে - যে কোনও ভেরিয়েবল পাস হয়েছে increment_twiceতা 2 দ্বারা বাড়ানো হবে কারণ 1এতে প্রথম আর্গুমেন্টে পাস হওয়া একটি রেফারেন্স:

a increment_twice
 i 1
 i 1
 d 1 #never reached
p toad
increment_twice toad
p toad

এই প্রোগ্রামের আউটপুট হবে

toad = 0
toad = 2

এরপরে আমরা আর একটি কমান্ড উপন্যাস করতে পারি যা দুটি যুক্তি গ্রহণ করে এবং increment_twiceতাদের উভয়কে কল করে:

a increment_twice
 i 1
 i 1
 d 1 #never reached
a increment_both_twice
 increment_twice 1
 increment_twice 2
 d 1 #never reached
increment_both_twice platypus duck
p platypus
p duck

এখানে আউটপুট হবে

platypus = 2
duck = 2

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

এলিয়াস উদাহরণ 3

set_to_zeroকমান্ড এক যুক্তি লাগে এবং 0 তার পরিবর্তনশীল সেট করে এবং একটি হিসাবে পতাকাঙ্কিত করা হয় বিজয় সম্পন্ন হলে ':

a set_to_zero
 d 1
 set_to_zero 1
 i _dummy_
i oryx
i oryx
i oryx
p oryx
set_to_zero oryx
p oryx

এই প্রোগ্রামের আউটপুট হবে

oryx = 3
oryx = 0

যা ঘটছে তা যখন set_to_zero oryxচালানো হয় তখন d 1সাফল্যের সাথে oryx3 থেকে 2 থেকে কমে যায়, তখন set_to_zero 1তাকে বলা হয়, যা set_to_zero oryxআবার কল করার মতো । সুতরাং প্রক্রিয়া পর্যন্ত পুনরাবৃত্তি করে d 1একটি হল ব্যর্থতা , পুনরাবৃত্তির বাঁধন এবং বাড়ায় _dummy_পরিবর্তনশীল তাই একটি সাফল্য উত্পাদিত হয়।


চ্যালেঞ্জ

একটি প্রোগ্রাম লিখুন যা প্রিনডিল কোড উপরোক্ত বর্ণিত ঠিক ঠিক সম্পাদন করতে পারে। স্টিডিন, কমান্ড লাইন বা একটি টেক্সট ফাইল হিসাবে প্রিন্ডিল কোডটি ধরুন। স্ট্যান্ডআউট বা আপনার ভাষার নিকটতম বিকল্পে প্রিন্ডিল প্রোগ্রামের আউটপুট প্রিন্ট করুন।

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

অতিরিক্ত হিসাবে, আপনি এটি ধরে নিতে পারেন:

  • ইনপুট প্রিনডিল কোডটিতে কেবলমাত্র নিউলাইন এবং মুদ্রণযোগ্য এএসসিআইআই এবং (বিকল্পভাবে) এটি খালি রেখার সাথে শেষ হবে।
  • ইনপুট কোডটি বৈধ প্রিনডিল হবে - ভালভাবে গঠিত এবং সিনট্যাক্টিক্যালি সঠিক।
  • কোডটি চালানো কোনও অসীম লুপ তৈরি করবে না বা নির্দেশিত হয়নি এমন আদেশগুলি বা অবৈধ যুক্তিগুলির কোনও অবৈধ রেফারেন্স তৈরি করবে না।
  • কমান্ড নাম p, i, d, এবং aওভার ওরফে করা হবে না। (আপনি ধরে নিতে পারবেন না যে ভেরিয়েবলগুলির এই নামগুলি থাকবে না))

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

পরীক্ষা প্রোগ্রাম

এখানে একটি বিশাল প্রিন্ডিল প্রোগ্রাম রয়েছে যা ডামি ভেরিয়েবলগুলি ( _কনভেনশন দ্বারা শুরু করে) এবং অনেক সহায়ক সহায়ক ব্যবহারের মাধ্যমে সংযোজন, গুণ এবং এক্সপেনসেন্টেশনের ক্রিয়াকলাপ তৈরি করে :

#Command Definitions:
a s             #flag as a success
 i _
 d _
 d _
a f             #flag as a failure
 d _
 d _
 d _
a z             #1 = zero
 d 1
 z 1
 s
a n             #1 = one
 z 1
 i 1
 s
a move          #2 += 1, 1 = zero
 moveH 1 2
 move 1 2
 s
a moveH         #move helper
 d 1
 i 2
 f
a dupe          #2 += 1, 3 += 1, 1 = zero
 dupeH1 1 2 3
 dupe 1 2 3
 s
a dupeH1        #dupe helper
 d 1
 dupeH2 2 3
 f
a dupeH2        #dupe helper
 i 1
 i 2
 s
a copy          #2 = 1
 z 2
 copyH 1 2
 s
a copyH         #copy helper
 dupe 1 2 _copy
 move _copy 1
 s
a addTo         #1 += 2
 copy 2 _add
 #testing comments #
 move _add 1#in weird places # just because #
 s
#it's a g##d idea
###
a add           #1 = 2 + 3
 #its a good idea
 z 1
 addH 1 2 3
 s
##

#
a addH          #add helper
#this is a comment
 addTo 1 2 #as is this
 addTo 1 3
 s
a mul           #1 = 2 * 3
 mulH1 1 2
 mulH2 1 3
 s
a mulH1         #mul helper
 z 1
 copy 2 _mul
 s
a mulH2         #mul helper
 mulH3 1 2
 mulH2 1 2
 s
a mulH3         #mul helper
 d _mul
 addTo 1 2
 f
a mulBy         #1 *= 2
 mul _mulBy 1 2
 copy _mulBy 1
 s
a pow           #1 = 2^3
 powH1 1 3
 powH2 1 2
 s
a powH1         #pow helper
 n 1
 copy 2 _pow
 s
a powH2         #pow helper
 powH3 1 2
 powH2 1 2
 s
a powH3         #pow helper
 d _pow
 mulBy 1 2
 f

#Running Tests:
p A
p B
p C
n A         #A = 1
n B         #B = 1
add C A B   #C = A + B = 1 + 1 = 2
p ____
p A
p B
p C
add B A C   #B = A + C = 1 + 2 = 3
p ____
p A
p B
p C
mul d B C   #d = B * C = 3 * 2 = 6
p ____
p d
mulBy d B   #d = d * B = 6 * 3 = 18
p ____
p d
d A         #A = A - 1 = 1 - 1 = 0
mulBy d A   #d = d * A = 18 * 0 = 0
p ____
p d
pow A C B   #A = C ^ B = 2 ^ 3 = 8
p ____
p A
p B
p C
pow A B C   #A = B ^ C = 3 ^ 2 = 9
p ____
p A
p B
p C
pow C A B   #C = A ^ B = 9 ^ 3 = 729
p ____
p A
p B
p C

(আপনি যদি এই কোডটি নিয়ে ঘুরে দেখেন তবে সচেতন হোন যে একই ভেরিয়েবলটিকে আর্গুমেন্ট হিসাবে একাধিকবার দেওয়া হলে অনেকগুলি কমান্ড ব্যর্থ হবে This এটি সহজেই ঠিক করা যায় তবে ফলাফল কোডটি দীর্ঘ is

আপনার প্রিনডিল ইন্টারপ্রেটার সঠিক আউটপুট উত্পাদন করতে সক্ষম হওয়া উচিত:

A = 0
B = 0
C = 0
____ = 0
A = 1
B = 1
C = 2
____ = 0
A = 1
B = 3
C = 2
____ = 0
d = 6
____ = 0
d = 18
____ = 0
d = 0
____ = 0
A = 8
B = 3
C = 2
____ = 0
A = 9
B = 3
C = 2
____ = 0
A = 9
B = 3
C = 729

স্কোরিং

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। টাইব্রেকার আগের জমাতে যায়।

ব্রাউনি বোনাস: প্রিনডিয়ালে একটি দুর্দান্ত প্রোগ্রাম লিখুন। আমি সংযোজন এবং গুণ প্রয়োগ করেছি, আপনি কি বিয়োগ বা বিভাগ করতে পারেন?


ওহ মানুষ, আমি মনে করি একবারের জন্য আমি পাইথকে একা ছেড়ে চলে যাব এবং একটি লিস্প বের করব! একটি প্রশ্ন - ফাংশন এবং ভেরিয়েবলগুলি সম্পূর্ণ আলাদা আলাদা নেমস্পেসে বাস করে, তাই না? সুতরাং আমি ইনক্রিমেন্ট করতে পারি pএবং তারপরে p p, কোনটি 1 টি প্রিন্ট করবে, তাই না?
orlp

@orlp সঠিক (সেখানে সে সম্পর্কে কিছু নোট রয়েছে))
ক্যালভিনের

2
আমি যখন ভাষাটির নাম দেখি তখন আমিই সেই ব্যক্তি হতে পারি না যিনি PRNDL ভাবেন।
ডাউনগোট

সর্বাধিক সংখ্যক যুক্তি রয়েছে যা একটি এলিয়াসেড কমান্ডে প্রেরণ করা হবে?
জাচ গেটস

@ জ্যাচগেটস নোপ
ক্যালভিনের

উত্তর:


9

পাইথ, 162 136 বাইট

JfTmchcd\#).zKHW<ZlJI!e=T@J~+Z1=@Tk)=k0 .x=J+]h=Nm.xL@Tskd@K=NhT+]+tN0>J~Z0,=Y.x@H=eT0?qN\pps[Td\=dYb)?xGN?qN\iXHThY?YXTH_1=k1XKT:JZ=+Z3

প্রদর্শন.

ভেরিয়েবল ইনলাইনিং থেকে পরিবর্তন করে আউট 26 অক্ষর Golfed Iএবং Eভিত্তিক নিয়ন্ত্রণ প্রবাহ থেকে ?এবং .xভিত্তিক নিয়ন্ত্রণ প্রবাহ।

প্রথমবারের মতো আমি পাইথের ভেরিয়েবলের বাইরে চলে এসেছি। পাইথের প্রতিটি একক ভেরিয়েবল ( bdkGHNTYএবং JK) ব্যবহারে ছিল এবং আমি bএকটি নতুন লাইন হিসাবে ব্যবহার করতে চাই । ভাগ্যক্রমে, আমি Nপ্রোগ্রামের বিভিন্ন অংশে দুটি সম্পূর্ণ ভিন্ন জিনিস বোঝাতে সক্ষম হয়েছি এবং তাই এটি এখনও কার্যকর হয়।

অবহেলিত (এম-এর সাথে চালানো):

JfTmchcd\#).z
KH
W<ZlJ
  I!e=T@J~+Z1
    =@Tk)
  =k0
     .x
      =J+]h=Nm.xL@Tskd@K=NhT+]+tN0>J~Z0
      ,
        =Y.x@H=eT0
        ?qN\p
          ps[Td\=dYb)
          ?xGN
            ?qN\i
              XHThY
              ?Y
                XTH_1
                =k1
            XKT:JZ=+Z3

3
আমি ভালবাসি কীভাবে আমি এখনও এটি বলতে পারি না যে এটি অসম্পূর্ণ এমনকি কী করে ...
জেরি যেরেমিয়া

ঠিক আছে, পাইথটি এই সিদ্ধান্তে পৌঁছেছে যে অ-
টিউরিং

8

পাইথন 2, 600 584 397 373 বাইট

এটি আমার নিজের গল্ফযুক্ত রেফারেন্স সমাধান। যে কেউ এটিকে উন্নত করতে বা তার যুক্তি অনুসরণ করতে স্বাগত জানায় যতক্ষণ অবধি দেওয়া হয়।

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

p=filter(len,[l.split('#')[0].split()for l in input().split('\n')]);m={};v={};i=0
while i<len(p):
 s=p[i]
 if'('in`s`:s=s[f]
 n,f=s[0],0
 if n in m:a,b,c=([s[int(g)]if g.isdigit()else g for g in t]for t in m[n]);p=[a,(b,c)]+p[i+1:];i=0;continue
 s=s[1]
 q=v.get(s,0)
 if'd'>n:m[s]=p[i+1:i+4];i+=3
 elif'i'<n:print s,'=',q
 elif'd'<n:v[s]=q+1
 elif q:v[s]-=1
 else:f=1
 i+=1

এটি এমন একটি প্রোগ্রাম যা উদ্ধৃত প্রোগ্রামগুলির স্ট্রিংয়ের সাথে নিউলাইনগুলি পলায়ন করে, যেমন
'p _MyVariable_321\np screaming_hairy_armadillo'

আমি এসপি এবং পিটুর উত্তরগুলি থেকে বিভিন্ন গল্ফিং সংকেত নিয়েছি । ধন্যবাদ বন্ধুরা :)


6

পাইথন 3, 345 336 335 328 বাইট

a=0
A={}
V={}
def f(l):
 if l[0]in"d p i":c,u=l;U=V[u]=V.get(u,0)+"pi".find(c);S=U<0;V[u]+=S;c<"p"or print(u,"=",U)
 else:d=lambda q:[w.isdigit()and l[int(w)]or w for w in A[l[0]][q]];S=f(d(1+f(d(0))))
 return S
for z in open("P"):
 l=z.split("#")[0].split()
 if"a "==z[:2]:a,s,*x=3,l[1]
 elif l*a:x+=l,;a-=1;A[s]=x
 elif l:f(l)

(-6 বাইটস @ অর্ল্পকে ধন্যবাদ)

এখনও গল্ফিং। ধরে নিই প্রোগ্রামটি একটি ফাইলের মধ্যে সংরক্ষিত আছে P

ল্যাম্বদার fভিতরে কলগুলি রাখলে dকয়েক বাইট সাশ্রয় হয় তবে এটি সর্বশেষ পরীক্ষার ক্ষেত্রে সর্বোচ্চ পুনরাবৃত্তির গভীরতায় আঘাত হানে।

কিছু প্রিন্ডিল প্রোগ্রাম

অকেজো বিয়োগ প্রোগ্রাম

এখানে একটি অকেজো বিয়োগ প্রোগ্রাম । এটি অকেজো কারণ কারণ এটি যথাযথভাবে বিয়োগ করা হলেও এটি সাফল্য / ব্যর্থতা অনুসারে ফিরে আসে না।

আউটপুটটি হওয়া উচিত:

a = 15
b = 6
__________ = 0
a = 9
b = 6

গননা

a helper
 p 1
 countup 1
 i success

a countup
 i 1
 helper 1
 d failure

countup n

উপরের দিকে গণনা করা এবং nচিরকালের জন্য মুদ্রণ করা। সম্ভবত দোভাষী গতির জন্য পরীক্ষা হিসাবে কাজ করতে পারে (কীবোর্ড বিঘ্নিত দীর্ঘ ট্রেসব্যাক থেকে সাবধান থাকুন)।


2
এই প্রশ্নের প্রত্যেকেই এই গল্ফটি মিস করেছে, কেন তা বুঝতে পারছি না। l[:(l+"#").find("#")]এবং এর সমস্ত প্রকরণগুলি একটি সরল দ্বারা প্রতিস্থাপন করা যেতে পারে l.split('#')[0]
orlp

@ অরলপ এতটা মনোযোগ দিয়েছিলেন findযে আমি ভুলে গিয়েছিলাম যে সেখানে না splitথাকলেও আপনি পারতেন #। ধন্যবাদ :)
Sp3000

6

জাভাস্ক্রিপ্ট (ES6), 273 258

স্থির বাগগুলি সম্পাদনা করুন এবং একটি আসল পরীক্ষার স্যুট যুক্ত করুন।

শীর্ষস্থানীয় স্থান এবং নিউলাইনগুলি গণনা করা হচ্ছে না।

অবশ্যই আরও কিছুটা গল্ফ করা যেতে পারে।

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

যে কোনও ইকামাস্ক্রিপ্ট comp অনুবর্তী ব্রাউজারে স্নিপেট চলমান পরীক্ষা করুন (উল্লেখযোগ্যভাবে ক্রোম এমএসআইই নয়। আমি ফায়ারফক্সে পরীক্ষা করেছি, সাফারি 9 যেতে পারে)

F=p=>(
  p=p.match(/^[^#\n]+/gm).filter(r=>r.trim(o='',v=[])),
  s={
    '':_=>1,
    p:a=>o+=a+` = ${v[a]||0}\n`,
    i:a=>v[a]=-~v[a],
    d:a=>v[a]&&v[a]--,
    a:(n,j)=>s[n]=(u,t,a)=>x(p[!x(p[j+1],0,a,1)+j+2],0,a,1)
  },
  p.map(x=(r,i,w,l,a=r.split(/ +/).slice(l).map(x=>-x?w[x]:x))=>s[a[0]](a[1],i,a)),
  o
)

// TEST

$('#O tr').each(function() {
  var $cells = $(this).find('td')
  var prg = $cells.eq(0).text()
  console.log(prg)
  var output = F(prg)
  $cells.eq(1).text(output)
})
#O td { vertical-align:top; white-space: pre; border: 1px solid #888; font-family:monospace }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<table>
<tr><th>Program</th><th>Outpout</th></tr>
<tbody id=O>  
<tr><td>p _MyVariable_321
p screaming_hairy_armadillo</td><td></td></tr>
<tr><td>i alpaca
p alpaca
i alpaca
p alpaca</td><td></td></tr>
<tr><td>i malamute
p malamute
d malamute    #success
p malamute
d malamute    #failure
p malamute
d akita       #failure
p akita</td><td></td></tr>
<tr><td>a increment_frog_twice
 i frog
 i frog
 d frog
p frog
increment_frog_twice
p frog</td><td></td></tr>
<tr><td>a increment_twice
 i 1
 i 1
 d 1 #never reached
a increment_both_twice
 increment_twice 1
 increment_twice 2
 d 1 #never reached
increment_both_twice platypus duck
p platypus
p duck</td><td></td></tr>
<tr><td>a set_to_zero
 d 1
 set_to_zero 1
 i _dummy_
i oryx
i oryx
i oryx
p oryx
set_to_zero oryx
p oryx</td><td></td></tr>
<tr><td>#Command Definitions:
a s             #flag as a success
 i _
 d _
 d _
a f             #flag as a failure
 d _
 d _
 d _
a z             #1 = zero
 d 1
 z 1
 s
a n             #1 = one
 z 1
 i 1
 s
a move          #2 += 1, 1 = zero
 moveH 1 2
 move 1 2
 s
a moveH         #move helper
 d 1
 i 2
 f
a dupe          #2 += 1, 3 += 1, 1 = zero
 dupeH1 1 2 3
 dupe 1 2 3
 s
a dupeH1        #dupe helper
 d 1
 dupeH2 2 3
 f
a dupeH2        #dupe helper
 i 1
 i 2
 s
a copy          #2 = 1
 z 2
 copyH 1 2
 s
a copyH         #copy helper
 dupe 1 2 _copy
 move _copy 1
 s
a addTo         #1 += 2
 copy 2 _add
 #testing comments #
 move _add 1#in weird places # just because #
 s
#it's a g##d idea
###
a add           #1 = 2 + 3
 #its a good idea
 z 1
 addH 1 2 3
 s
##

#
a addH          #add helper
#this is a comment
 addTo 1 2 #as is this
 addTo 1 3
 s
a mul           #1 = 2 * 3
 mulH1 1 2
 mulH2 1 3
 s
a mulH1         #mul helper
 z 1
 copy 2 _mul
 s
a mulH2         #mul helper
 mulH3 1 2
 mulH2 1 2
 s
a mulH3         #mul helper
 d _mul
 addTo 1 2
 f
a mulBy         #1 *= 2
 mul _mulBy 1 2
 copy _mulBy 1
 s
a pow           #1 = 2^3
 powH1 1 3
 powH2 1 2
 s
a powH1         #pow helper
 n 1
 copy 2 _pow
 s
a powH2         #pow helper
 powH3 1 2
 powH2 1 2
 s
a powH3         #pow helper
 d _pow
 mulBy 1 2
 f

#Running Tests:
p A
p B
p C
n A         #A = 1
n B         #B = 1
add C A B   #C = A + B = 1 + 1 = 2
p ____
p A
p B
p C
add B A C   #B = A + C = 1 + 2 = 3
p ____
p A
p B
p C
mul d B C   #d = B * C = 3 * 2 = 6
p ____
p d
mulBy d B   #d = d * B = 6 * 3 = 18
p ____
p d
d A         #A = A - 1 = 1 - 1 = 0
mulBy d A   #d = d * A = 18 * 0 = 0
p ____
p d
pow A C B   #A = C ^ B = 2 ^ 3 = 8
p ____
p A
p B
p C
pow A B C   #A = B ^ C = 3 ^ 2 = 9
p ____
p A
p B
p C
pow C A B   #C = A ^ B = 9 ^ 3 = 729
p ____
p A
p B
p C  
</td><td></td></tr>
</tbody>
</table>


আমি পরীক্ষা প্রোগ্রামে আরও কিছু মন্তব্য যুক্ত করেছি এবং দেখে মনে হচ্ছে তারা আপনার কোডটি কার্যকর না করে।
ক্যালভিনের শখ

@ ক্যালভিনের শখগুলি একটি প্রথম, দ্রুত প্যাচ
এডক65

3

সি # 6, 653 বাইট

পাইথনের সমুদ্রের মাঝে আমার প্রবেশ এখানে ...

class P{string[]l;string r="";Dictionary<string,int>v=new Dictionary<string,int>();Dictionary<string,int>s=new Dictionary<string,int>();public string R(string t){l=t.Split('\n');for(int i=0;i<l.Length;i++){var z=l[i].Split(' ');if(z[0]=="a"){s.Add(z[1],i);i+=3;}else E(i, null);}return r;}bool E(int n,string[]p){var z=l[n].Split(' ');var a=z.Skip(1).Select(x=>Char.IsDigit(x[0])?p[int.Parse(x)-1]:x).ToArray();if(a.Length>0&&!v.ContainsKey(a[0]))v[a[0]]=0;if (z[0]=="p")r+=$"{a[0]} = {v[a[0]]}\n";else if(z[0]=="i")v[a[0]]++;else if(z[0]=="d")if(v[a[0]]>0)v[a[0]]--;else return false;else{var y=s[z[0]];return E(y+1,a)?E(y+2,a):E(y+3,a);}return true;}}

সম্প্রসারিত এবং মন্তব্য করা হয়েছে:

class Prindeal
{
    string[] lines;
    string result = "";
    Dictionary<string, int> variables = new Dictionary<string, int>();
    Dictionary<string, int> statements = new Dictionary<string, int>();

    public string Run(string text)
    {
        lines = text.Split('\n');

        for (int i = 0; i < lines.Length; i++)
        {
            // Split on spaces to get the statement and any arguments
            var z = lines[i].Split(' ');

            // Are we defining a new statement?
            if (z[0] == "a")
            {
                // Add to the statements dictionary, step over definition statements
                statements.Add(z[1], i);
                i += 3;
            }
            else
            {
                // Execute the statement
                Execute(i, null);
            }
        }

        return result;
    }

    bool Execute(int lineNumber, string[] parameters)
    {
        // Split on spaces to get the statement and any arguments
        var z = lines[lineNumber].Split(' ');

        // Parse the arguments - if it's a number, get the corresponding 
        // parameter from the calling statement
        var arguments = z.Skip(1).Select(
            x => Char.IsDigit(x[0]) ? 
            parameters[int.Parse(x) - 1] : 
            x)
            .ToArray();

        // If the first argument isn't already in the variables dict, add it
        if (arguments.Length > 0 && !variables.ContainsKey(arguments[0])) variables[arguments[0]] = 0;

        // Print statement, using string interpolation
        if (z[0] == "p")
            result += $"{arguments[0]} = {variables[arguments[0]]}\n";
        // Increment statement
        else if (z[0] == "i")
            variables[arguments[0]]++;
        // Decrement statement
        else if (z[0] == "d")
            if (variables[arguments[0]] > 0)
                variables[arguments[0]]--;
            else
                return false;
        else
        {
            // Get the line number to jump to
            var y = statements[z[0]];

            // Execute A ? B : C
            return Execute(y + 1, arguments) ? Execute(y + 2, arguments) : Execute(y + 3, arguments);
        }

        // If we reach this point, it's from a 'p', 'i' or 'd' statement which has succeeded
        return true;
    }
}

এটি ব্যবহার করতে, ক্লাসটি কেবল ইনস্ট্যান্ট করুন এবং R()পদ্ধতিটি কল করুন , উদাহরণস্বরূপ:

string prindealText = new StreamReader("prindeal.txt").ReadToEnd();
Console.WriteLine(new P().R(prindealText));

3

সাধারণ লিপ, 758 646 619

(progn(set-macro-character #\#(get-macro-character #\;))(setf(readtable-case *readtable*):invert)(#3=defun v(s)(if(boundp s)(eval s)0))(#3# i(s)(set s(1+ (v s))))(#3# d(s)(and(plusp(v s))(set s(1-(v s)))))(#3# p(s)(format t"~A = ~A~%"s(v s)))(defmacro a(n . p)`(#3#,(cadr n)(&rest g)(if,@p)))(#3# k(s)(typecase s(integer`(nth,(1- s)g))(symbol `',s)(t(list*(car s)(mapcar 'k(cdr s))))))(#3# r()(prog(l p q)$(setf p()l(make-string-input-stream(or(read-line()()())(return))))@(when(setf p(read l()()))(push p q)(go @))(if q(return(k(reverse q)))(go $))))(do ((x(r)(r)))((not x))(eval(if(eq(car x)'a)`(,@x,(r),(r),(r))x))))

এটি রাখুন file.lispএবং উদাহরণস্বরূপ কল করুন sbcl --script file.lisp; ইনপুট স্ট্যান্ডার্ড ইনপুট স্ট্রিম থেকে পড়া হয়।

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

মন্তব্য করা সংস্করণ

;; copy-readtable is only used during development, so that I do not 
;; mess with my running environment. The real code starts with the
;; progn below, which is superfluous of course inside a let.
(let ((*readtable* (copy-readtable)))

  ;; I use PROGN in the golfed version so that I can have the whole
  ;; program as a unique tree. This allows me to define reader 
  ;; variables like #3=defun in order to gain a few bytes by writing
  ;; #3# instead of defun. Reader variables are removed in
  ;; this human-friendly version.
  (progn
    ;; Let # point to the same reader function as ;
    ;; Of course, ; is still usable as a comment delimiter
    (set-macro-character #\#
                         (get-macro-character #\;))

    ;; :invert does what is necessary to enable case-sensitive reading
    ;; and printing of symbols
    (setf (readtable-case *readtable*) :invert)

    ;; value of symbol, or zero
    (defun v(s)(if(boundp s)(eval s)0))

    ;; increment
    (defun i(s)(set s(1+ (v s))))

    ;; decrement
    (defun d(s)(and(plusp(v s))(set s(1-(v s)))))

    ;; print
    (defun p(s)(format t"~A = ~A~%"s(v s)))

    ;; alias: wrap an "if" inside a "defun".
    ;; YES, that means you can redefine ANY lisp function with "a" !
    ;; A safer version would properly intern symbols in a dedicated package.
    ;;
    ;; Notice the G variable.  We take advantage of the "unhygienic"
    ;; (what a bad adjective) nature of macros to create a context
    ;; where G is bound to the argument list. The same G is referenced
    ;; implicitely later.
    (defmacro a(n . p)`(defun,(cadr n)(&rest g)(if,@p)))

    ;; Canonicalize expressions:
    ;;
    ;; - if s is a symbol, return s quoted. All functions manipulate
    ;; symbols in order to allow the undeclared use of variables. With
    ;; symbols, we can check for boundness.
    ;;
    ;; - if s is an integer, then we are inside an alias definition. The
    ;; integer is replaced by an access to the s'th element of the
    ;; implicit argument list G using (nth (1- s) g). G will be bound
    ;; when the expressions is injected in the defun corresponding to
    ;; the alias, or else an error will be signaled: either because G
    ;; is unbound, or because you defined a variable named G which is
    ;; by construction not a list. Since we do not sanitize properly
    ;; the input, you could bind G globally to a list, but that would be
    ;; nasty.
    ;; 
    ;; - Finally, if s is a list, apply k to all but the first
    ;; elements of s.  The first element is a symbol but we do not
    ;; need to quote it because we want to call the function
    ;; associated with the symbol. Due to the Lisp-2-ness
    ;; of Common Lisp, functions and variables can coexist
    ;; with the same name.
    ;;
    (defun k(s)(typecase s
                 (integer`(nth,(1- s)g))
                 (symbol`',s)
                 (t(list*(car s)(mapcar #'k(cdr s))))))

    ;; Reader function
    (defun r()
      (prog (l ; current line, as an input-stream reading a string
             p ; current read form
             q ; whole line and return value, as a list
             )

         ;; PROG includes an implicit TAGBODY. Below, $ and @ are
         ;; labels for GO statements (gotos).

       $ (setf
          ;; emtpy p
          p ()

          ;; Read a whole line and if we do not fail, build an input
          ;; stream to read from it.
          l (make-string-input-stream
             (or (read-line()()()) ;; try to read a line,
                 (return)          ;; but return from prog if we reach
                                   ;; the end of file.
                 )))
       @ (when (setf p (read l()()))
           ;; Read a lisp expression, put it in p and if p is not nil
           ;; push it into q.  A nil could happen at the end of the
           ;; line or if someone (you know who) inserted an empty list
           ;; in the file being read.
           ;; 
           ;; Thanks to the readtable which now handles comments
           ;; and spaces for us, nothing needs to be done here to
           ;; preprocess the input.

           (push p q) (go @))

         ;; If we read an empty line, q can be nil. In this case, go
         ;; back to $ and read another line. If q is not nil, reverse
         ;; it (we pushed, remember), canonicalize it and return the
         ;; result.
         (if q (return(k(reverse q))) (go $)))
      )

    ;; Read/eval loop.  When reading "(a name)", we read the three
    ;; next lines and append them to the first so that it builds a
    ;; call the the alias definition macro a. Otherwise, just eval x.
    (do((x(r)(r))((not x))
      (eval (if (eq(car x'a))
                `(,@x,(r),(r),(r))
                x)))))

উদাহরণ

~$ sbcl --script file.lisp < testfile

A = 0
B = 0
C = 0
____ = 0
A = 1
B = 1
C = 2
____ = 0
A = 1
B = 3
C = 2
____ = 0
d = 6
____ = 0
d = 18
____ = 0
d = 0
____ = 0
A = 8
B = 3
C = 2
____ = 0
A = 9
B = 3
C = 2
____ = 0
A = 9
B = 3
C = 729

আমরা যদি রিড / এভাল লুপ evalদ্বারা প্রতিস্থাপন করি print, তবে আমরা দেখতে পাচ্ছি যা মূল্যায়ন করা হচ্ছে:

(a 's (i '_) (d '_) (d '_)) 
(a 'f (d '_) (d '_) (d '_)) 
(a 'z (d (nth 0 g)) (z (nth 0 g)) (s)) 
(a 'n (z (nth 0 g)) (i (nth 0 g)) (s)) 
(a 'move (moveH (nth 0 g) (nth 1 g)) (move (nth 0 g) (nth 1 g)) (s)) 
(a 'moveH (d (nth 0 g)) (i (nth 1 g)) (f)) 
(a 'dupe (dupeH1 (nth 0 g) (nth 1 g) (nth 2 g))
   (dupe (nth 0 g) (nth 1 g) (nth 2 g)) (s)) 
(a 'dupeH1 (d (nth 0 g)) (dupeH2 (nth 1 g) (nth 2 g)) (f)) 
(a 'dupeH2 (i (nth 0 g)) (i (nth 1 g)) (s)) 
(a 'copy (z (nth 1 g)) (copyH (nth 0 g) (nth 1 g)) (s)) 
(a 'copyH (dupe (nth 0 g) (nth 1 g) '_copy) (move '_copy (nth 0 g)) (s)) 
(a 'addTo (copy (nth 1 g) '_add) (move '_add (nth 0 g)) (s)) 
(a 'add (z (nth 0 g)) (addH (nth 0 g) (nth 1 g) (nth 2 g)) (s)) 
(a 'addH (addTo (nth 0 g) (nth 1 g)) (addTo (nth 0 g) (nth 2 g)) (s)) 
(a 'mul (mulH1 (nth 0 g) (nth 1 g)) (mulH2 (nth 0 g) (nth 2 g)) (s)) 
(a 'mulH1 (z (nth 0 g)) (copy (nth 1 g) '_mul) (s)) 
(a 'mulH2 (mulH3 (nth 0 g) (nth 1 g)) (mulH2 (nth 0 g) (nth 1 g)) (s)) 
(a 'mulH3 (d '_mul) (addTo (nth 0 g) (nth 1 g)) (f)) 
(a 'mulBy (mul '_mulBy (nth 0 g) (nth 1 g)) (copy '_mulBy (nth 0 g)) (s)) 
(a 'pow (powH1 (nth 0 g) (nth 2 g)) (powH2 (nth 0 g) (nth 1 g)) (s)) 
(a 'powH1 (n (nth 0 g)) (copy (nth 1 g) '_pow) (s)) 
(a 'powH2 (powH3 (nth 0 g) (nth 1 g)) (powH2 (nth 0 g) (nth 1 g)) (s)) 
(a 'powH3 (d '_pow) (mulBy (nth 0 g) (nth 1 g)) (f)) 
(p 'A) 
(p 'B) 
(p 'C) 
(n 'A) 
(n 'B) 
(add 'C 'A 'B) 
(p '____) 
(p 'A) 
(p 'B) 
(p 'C) 
(add 'B 'A 'C) 
(p '____) 
(p 'A) 
(p 'B) 
(p 'C) 
(mul 'd 'B 'C) 
(p '____) 
(p 'd) 
(mulBy 'd 'B) 
(p '____) 
(p 'd) 
(d 'A) 
(mulBy 'd 'A) 
(p '____) 
(p 'd) 
(pow 'A 'C 'B) 
(p '____) 
(p 'A) 
(p 'B) 
(p 'C) 
(pow 'A 'B 'C) 
(p '____) 
(p 'A) 
(p 'B) 
(p 'C) 
(pow 'C 'A 'B) 
(p '____) 
(p 'A) 
(p 'B) 
(p 'C)

Macroexpansion

যদি আমরা নিম্নলিখিত উপন্যাস সংজ্ঞাটি বেছে নিই:

(a 'powH2 (powH3 (nth 0 g) (nth 1 g)) (powH2 (nth 0 g) (nth 1 g)) (s))

... আমরা নামের সাথে একটি ভেরিয়েবলের রেফারেন্স দেখতে পাই gযা লেজিকাল স্কোপে পাওয়া যায় না। তবে ম্যাক্রোপেক্সেনশনের পরে, এখানে আসল কোডটি মূল্যায়ন করা হচ্ছে:

(defun powH2 (&rest g)
  (if (powH3 (nth 0 g) (nth 1 g))
      (powH2 (nth 0 g) (nth 1 g))
      (s))) 

এখন, gসংজ্ঞায়িত করা ফাংশনটির আর্গুমেন্ট তালিকাটিকে বোঝায়।


2

পাইথন 2, 486 বাইট

এটি সেই রেফারেন্স সমাধান যা আমি আরও গল্ফ করেছি (বর্তমানে -98 বাইট)।

import sys;sys.setrecursionlimit(2000)
def r(s):
 n=s[0]
 if n in A:f=lambda i:r([s[int(t)]if'0'<t[0]<':'else t for t in A[n][i]]);return f(1+(f(0)or 0))
 k=s[1]
 if'i'<n:print k,'=',V.get(k,0)
 elif'd'<n:V[k]=-~V[k]if k in V else 1
 elif'a'<n:
    if~-(k in V)or V[k]<1:return 1
    V[k]-=1
 else:A[k]=s[2:]
A={};V={};c=filter(bool,([l,l[:l.find('#')]]['#'in l]for l in input().split('\n')))
while c:
 s=c[0].split();c=c[1:]
 if'a'!=s[0]:r(s)
 else:r(['a',s[1]]+map(str.split,c[:3]));c=c[3:]

পরিবর্তনগুলি (যা আমি মনে করি):

  • স্বয়ংক্রিয় বুলিয়ান-সংখ্যার রূপান্তর ( [l,l[:l.find('#')]]['#'in l])।
  • এক বিবৃতিতে সেট বা বর্ধন ( V[k]=-~V[k]if k in V else 1)
  • দীর্ঘ অভিব্যক্তির আরও উপকরণ ( k=s[1])
  • মূল লুপে কোনও কাউন্টার নেই, পরিবর্তে ইনপুট তালিকা সাফ করে
  • printস্বয়ংক্রিয়ভাবে স্পেস যোগ করা ( print k,'=',V.get(k,0))
  • 1-9 অঙ্কগুলি পরীক্ষা করা ( '0'<t[0]<':')
  • গুলি rসংরক্ষণ করতে চারপাশের রিটার্ন মানগুলি উল্টিয়ে দেওয়াreturn
  • কাটা এবং বিভাজন পুনরাবৃত্তি অপসারণ ( map(str.split,c[:3])))

1

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

Golfed:

import re,sys;sys.setrecursionlimit(2000);F,L=filter,list
class P:
 N,O,F=0,{},{}
 def __init__(S,c):
  S.B,S.E={"p":S.P,"i":S.I,"d":S.D,"a":S.L},dict(enumerate(F(None,[i.split('#')[0].rstrip()for i in c.splitlines()])))
  while S.N in S.E:S.X(S.E[S.N])
 def V(S, v, y, z=0):
  if re.match("[\w_][\d\w_]*",v):
   if not v in y:
    if z is not None:y[v]=z
    else:return False
   return True
  return False
 def A(S):S.N+=1
 def P(S,v):
  if S.V(v,S.O):print("{0} = {1}".format(v, S.O[v]));return True
  return False
 def I(S,v):
  if S.V(v, S.O):S.O[v]+=1;return True
  return False
 def D(S,v):
  if S.V(v,S.O)and S.O[v]>0:S.O[v]-=1;return True
  return False
 def L(S,v):
  e=[]
  if S.V(v,S.F,e):
   for i in range(3):S.A();e.append(S.E[S.N].lstrip())
   return True
  return False
 def C(S,c,v):
  def R(Z,v):
   for i in re.findall("\s(\d+)", Z):Z=Z.replace(" %s"%i," %s"%v[int(i)-1])
   return Z
  Q,m,f=map(lambda l:R(l,v),S.F[c])
  if S.X(Q,False):return S.X(m,False)
  return S.X(f,False)
 def X(S,Z,C=True):
  u=re.match("\s?([\w_][\d\w_]*)\s?([\w_][\d\w ]*)?",Z)
  if u:
   c,v=map(lambda i:''if i is None else i,u.groups());v=L(F(None,v.split(' ')))
   if S.V(c,S.F,None):
    T=S.C(c, v)
    if C:S.A()
   elif S.V(c,S.B,None):
    T=S.B[c](*v)
    if C:S.A()
   else:return False
   return T
  return False

Ungolfed:

import re

class Prindeal:
    iline = 0
    local = {}
    udef = {}
    content  = {}

    def __init__(self, c):
        self.built = {
            "p": self.print,
            "i": self.increment,
            "d": self.decrement,
            "a": self.alias,
        }
        self.content = dict(enumerate(filter(None, [i.split('#')[0].rstrip()for i in c.splitlines()])))
        while self.iline in self.content:
            self.execute_line(self.content[self.iline])

    def validate_name(self, varname, stack, default=0):
        if re.match("[\w_][\d\w_]*", varname):
            if not varname in stack:
                if default is not None:
                    stack[varname] = default
                else:
                    return False
            return True
        return False

    def advance_stack(self):
        self.iline += 1

    def print(self, varname):
        if self.validate_name(varname, self.local):
            print("{0} = {1}".format(varname, self.local[varname]))
            return True
        return False

    def increment(self, varname):
        if self.validate_name(varname, self.local):
            self.local[varname] += 1
            return True
        return False

    def decrement(self, varname):
        if self.validate_name(varname, self.local) and self.local[varname] > 0:
            self.local[varname] -= 1
            return True
        return False

    def alias(self, aliasname):
        indexed_lines = []
        if self.validate_name(aliasname, self.udef, indexed_lines):
            for i in range(3):
                self.advance_stack()
                indexed_lines.append(self.content[self.iline].lstrip())
            return True
        return False

    def execute_alias(self, cmd, variables):
        def parse_args(line, variables):
            for i in re.findall("\s(\d+)", line):
                line = line.replace(" %s" % i, " %s" % variables[int(i) - 1])
            return line
        init, success, failure = map(lambda l: parse_args(l, variables), self.udef[cmd])
        if self.execute_line(init, False):
            return self.execute_line(success, False)
        return self.execute_line(failure, False)

    def execute_line(self, line, cont=True):
        valid_execution = re.match("\s?([\w_][\d\w_]*)\s?([\w_][\d\w ]*)?", line)
        if valid_execution:
            cmd, variables = map(lambda i: '' if i is None else i, valid_execution.groups())
            variables = list(filter(None, variables.split(' ')))
            if self.validate_name(cmd, self.udef, None):
                temp = self.execute_alias(cmd, variables)
                if cont:
                    self.advance_stack()
            elif self.validate_name(cmd, self.built, None):
                temp = self.built[cmd](*variables)
                if cont:
                    self.advance_stack()
            else:
                return False
            return temp
        return False

ব্যবহার:

P(c)

cপাঠ্য সামগ্রী কোথায় ।

উদাহরণ:

একক লাইন স্ট্রিং গ্রহণ করা হয়:

  • P("p cat")
  • P("p dog\ni dog\np dog")

বহু-রেখাযুক্ত স্ট্রিংগুলিও গৃহীত হয়:

P("""
p dog
i dog
p dog
""")

বা:

P("""p dog
i dog
p dog""")

প্রভৃতি

নোট:

এটি সমস্ত পরীক্ষার ক্ষেত্রে সঠিকভাবে কাজ করে তবে পুনরাবৃত্তির সীমাটিতে পৌঁছে যায়:

pow C A B   #C = A ^ B = 9 ^ 3 = 729

অতএব sys.setrecursionlimit(2000)


1
এটি কিছু বাইট ব্যবহার করবে তবে আপনি পাউস ওরফে সঠিকভাবে কাজ করতে sys.setrecursionlimit () ব্যবহার করতে পারবেন না?
করউইন

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

যথেষ্ট ফর্সা। যে অনুমান মধ্যে মিস। @ZachGates
Corwin

1

পাইথন - 695 688 বাইট

def p(v):print v,"=",w.get(v,0)
def i(v):w[v]=w.get(v,0)+1
def d(v):
 if v in w:
<TAB>w[v]-=1
<TAB>if not w[v]:del w[v]
 else:return 1
def a(n,b,d,h):
 def g(*a):
<TAB>i=1;f=b;s=d;t=h
<TAB>for v in a:v=q+v+q;k=q+j(i)+q;f=c(f,k,v);s=c(s,k,v);t=c(t,k,v);i+=1
<TAB>y=u(t,e)if u(f,e)else u(s,e);i=1;return y
 e[n]=g
q="'";w=x={};u=eval;e={'a':a,'d':d,'i':i,'p':p};import sys;l=sys.stdin.readlines();r="";j=str;c=j.replace;sys.setrecursionlimit(2000)
for h in l:
 h = h.strip()
 if not h:continue
 l = h.split();f=l[0];n=f+"("
 if "#" in f:continue
 for g in l[1:]:
<TAB>b=g.find("#")+1
<TAB>if b:g=g[:b-1]
<TAB>if g:n+="'%s',"%g
<TAB>if b:break
 if x:x-=1;d+='"%s)",'%n
 else:x=(f=="a")*3;d=n
 if not x:d+=")\n";r+=d
exec r in e

<TAB> একটি আক্ষরিক ট্যাব অক্ষর।


1

সি ++, 1111 বাইট

এটি হ'ল সি ++ - আমি যতটা মুশকিল তা তৈরি করতে পেরেছি।
এর অর্থ এটি আরও সি ​​++ - ইশ এবং কম সি-ইশ তৈরি করা।
এর অর্থ এটিও সমতুল্য সি প্রোগ্রামের চেয়ে বড়।
আমার মনে হয় সি ++ প্রতিদ্বন্দ্বী জাভা ভার্জোজ স্ট্যান্ডার্ড লাইব্রেরির জন্য।
এটি VS2013 এবং g ++ 4.9.2 (-std = c ++ 11 সহ) এর সাথে সংকলন করে

#include<array>
#include<iostream>
#include<map>
#include<regex>
#include<sstream>
#include<stack>
#define B std::
#define a first
#define b second
#define c(s);else if(x.a==s)
#define d(n)B getline(B cin,r##n)
#define e(n)r##n=B regex_replace(r##n,q,"$1");
#define f(n)do{d(n);e(n)}while(r##n.empty());
#define g B string
#define h B istream_iterator<g>
#define i p.top().a
#define j p.empty()
#define k B pair
#define u continue;
#define w B back_inserter
typedef B vector<g>s;typedef B array<g,3>A;typedef k<k<long,A>,s>t;B map<g,A>m;B map<g,long>n;B stack<t>p;B regex q("^ *(.*?) *(#.*)?$");int main(){g r0,r1,r2,r3;while(d(0)){e(0)if(r0.empty())u p.push(t{{0,{{r0,"",""}}},{}});bool z;while(!j){k<g,s>x;B istringstream ss(i.b[i.a]);ss>>x.a;B copy(h(ss),h(),w(x.b));s o;B transform(B begin(x.b),B end(x.b),w(o),[](g y){int v=atoi(y.c_str());return v>0?p.top().b[v-1]:y;});z=true;if(0)c("")c("p")B cout<<o[0]<<" = "<<n[o[0]]<<B endl c("i")n[o[0]]++c("d")n[o[0]]-=(z=n[o[0]])c("a"){f(1)f(2)f(3)m.insert(B make_pair(o[0],A{{r1,r2,r3}}));}else{p.push(t{{0,m[x.a]},o});u}while(!j&&i.a)p.pop();if(!j)i.a+=1+!z;}}}

নীচে মূল। যদি কেউ একই সাথে আরও বুদ্ধিমান এবং খাটো করার কোনও উপায় সম্পর্কে চিন্তা করতে পারে তবে দয়া করে আমাকে জানান।

#include <array>
#include <iostream>
#include <map>
#include <regex>
#include <sstream>
#include <stack>

typedef std::vector<std::string> List;
typedef std::pair<std::string, List> Statement;
typedef std::array<std::string, 3> Alias;
typedef std::pair<long, Alias> IndexedAlias;
typedef std::pair<IndexedAlias, List> Item;

std::map<std::string, Alias> aliases;
std::map<std::string, long> variables;
std::stack<Item> stack;
std::regex re("^ *(.*?) *(#.*)?$");

int main()
{
    std::string line, line1, line2, line3;
    while (std::getline(std::cin, line)) // control-Z to exit
    {
        line = std::regex_replace(line, re, "$1");
        if (line.empty()) continue;
        stack.push(Item{ { 0, { { line, "", "" } } }, {} });

        bool flag;
        while (!stack.empty())
        {
            Statement statement;
            std::istringstream ss(stack.top().first.second[stack.top().first.first]);
            ss >> statement.first;
            std::copy(std::istream_iterator<std::string>(ss), std::istream_iterator<std::string>(), std::back_inserter(statement.second));

            List arguments;
            std::transform(std::begin(statement.second), std::end(statement.second), std::back_inserter(arguments),
                [](std::string arg){ int i = atoi(arg.c_str()); return i > 0 ? stack.top().second[i - 1] : arg; });

            flag = true;
            if (statement.first == "")
                ;
            else if (statement.first == "p")
                std::cout << arguments[0] << " = " << variables[arguments[0]] << std::endl;
            else if (statement.first == "i")
                variables[arguments[0]]++;
            else if (statement.first == "d")
                variables[arguments[0]] -= (flag = variables[arguments[0]]);
            else if (statement.first == "a")
            {
                do { std::getline(std::cin, line1); line1 = std::regex_replace(line1, re, "$1"); } while (line1.empty());
                do { std::getline(std::cin, line2); line2 = std::regex_replace(line2, re, "$1"); } while (line2.empty());
                do { std::getline(std::cin, line3); line3 = std::regex_replace(line3, re, "$1"); } while (line3.empty());
                aliases.insert(std::make_pair(arguments[0], Alias{ { line1, line2, line3 } }));
            }
            else
            {
                stack.push(Item{ { 0, aliases[statement.first] }, arguments });
                continue;
            }

            while (!stack.empty() && stack.top().first.first) stack.pop();
            if (!stack.empty()) stack.top().first.first += 1 + !flag;
        }
    }

    std::cout << "-- Variables --" << std::endl;
    std::transform(std::begin(variables), std::end(variables), std::ostream_iterator<std::string>(std::cout, "\n"),
        [](std::map<std::string, long>::value_type pair){ std::ostringstream ss; ss << pair.first << " = " << pair.second; return ss.str(); });
    std::cout << "-- Aliases --" << std::endl;
    std::transform(std::begin(aliases), std::end(aliases), std::ostream_iterator<std::string>(std::cout, "\n"),
        [](std::map<std::string, Alias>::value_type pair){ std::ostringstream ss; ss << pair.first << " = [1]:" << pair.second[0] << " [2]:" << pair.second[1] << " [3]:" << pair.second[1]; return ss.str(); });
    std::cout << "---------------" << std::endl;

    return 0;
}

0

হাস্কেল, 1009

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

import qualified Data.Map as M
import Control.Monad.State.Lazy
import Data.List
type A=M.Map String
data P=P(A Int)(A([String]->StateT P IO Int))
a f=evalStateT f(P M.empty$M.fromList[("i",\(b:_)->(+1)%b),("d",\(b:_)->pred%b),("p",\(b:_)->i b>>= \v->liftIO(putStrLn$b++"="++show v)>>q 1)])
e(k:l)=do{(P v a)<-get;put.P v$M.insert k(m l)a;q 1}
g t s f= \a->t a>>= \b->if b>0then s a else f a
f%k=f<$>i k>>= \v->if v<0then k#0>>q 0else k#v>>q 1
i k=get>>= \(P v _)->q$M.findWithDefault 0 k v
k#v=get>>= \(P b a)->put$P(M.insert k v b)a
l k=get>>= \(P _ a)->q$a M.!k
f s=let(f:a)=r s in($a)<$>l f>>=id
m(t:s:f:_)=g(k t)(k s)(k f)
k s=let(f:b)=r s in\a->($(map((\y z->if all(\c->c>'/'&&c<':')z then y!!(read z-1)else z)a)b))<$>l f>>=id
n=dropWhileEnd(==' ').takeWhile(not.(=='#')).dropWhile(==' ')
o[]=[]
o(l:ls)|(head.r$l)=="a"=(l:take 3 ls):(o$drop 3 ls)|1>0=[l]:o ls
p s|length s>1=e$(n.tail.head$s):tail s|1>0=f.head$s
q=return
main=join$a.(\s->mapM_ p(o.filter(not.null).map n.lines$s))<$>getContents
r=words
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.