স্ট্যাকাইলোগিক চালান

45

Stackylogic একটি যুক্তিবিজ্ঞান ভিত্তিক প্রোগ্রামিং ভাষা আমি যে নিতে গঠিত 0's এবং 1ইনপুট জন্য' s এবং একটি একক আউটপুট 0বা 1উপরে সমাপ্তির।

একটি স্ট্যাকাইলোগিক প্রোগ্রামটি এমন লাইনগুলি নিয়ে গঠিত যা কেবলমাত্র তিনটি অক্ষর 01?পাশাপাশি <লাইনগুলির একের শেষে হুবহু একটি ধারণ করে । লাইনস খালি রাখা হতে পারে এবং সঙ্গে সঙ্গতিপূর্ণ <অন্তত একটি থাকতে হবে 0, 1অথবা ?এটা আগে।

এখানে একটি নমুনা প্রোগ্রাম যা (আমি ব্যাখ্যা করব) দুটি বিটের NAND গণনা করে :

1
?<
11
?
0

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

এটি <, যা আমরা কার্সার বলব , স্ট্যাকাইলোগিক প্রোগ্রামটি চালু হওয়ার পরে স্ট্যাকটি শুরু করতে চিহ্নিত করে। একটি স্ট্যাকাইলোগিক প্রোগ্রামের সম্পাদন নীচে হিসাবে এগিয়ে যায়:

  1. কর্সারটি বর্তমানে নির্দেশ করছে এমন স্ট্যাকের বাইরে শীর্ষ অক্ষরটি পপ করুন।

    • চরিত্রটি যদি হয় ?তবে ব্যবহারকারীকে একটি 0বা একটির জন্য অনুরোধ করুন 1এবং অভিনয় করুন যেন এটি চরিত্র।
    • চরিত্রটি যদি হয় 0তবে কার্সারটিকে একটি স্ট্যাক আপ করে নিন (বর্তমান লাইনের উপরে লাইনে)।
    • চরিত্রটি যদি হয় 1তবে কার্সারটি একটি স্ট্যাককে নীচে সরান (বর্তমান লাইনের নীচে লাইনে)।

  2. যদি স্ট্যাকটি কার্সারটিতে চলে যায় তবে এটি ফাঁকা হয়, সর্বশেষ মানটি একটি স্ট্যাক (সর্বদা একটি 0বা 1) থেকে পপড আউটপুট করুন এবং প্রোগ্রামটি শেষ করুন।

  3. অন্যথায়, যদি স্ট্যাকটি কার্সারটি সরানো থাকে তবে এটি খালি নয়, পদক্ষেপ 1 এ ফিরে যান এবং প্রক্রিয়াটি পুনরাবৃত্তি করুন।

লক্ষ্য করুন যে স্ট্যাকাইলোগিক প্রোগ্রামগুলি সর্বদা শেষ হয় কারণ তাদের অবশ্যই শেষ পর্যন্ত তাদের স্ট্যাকগুলি অপসারণ করতে হবে।

নন্দ উদাহরণ

ন্যানড প্রোগ্রামে কার্সারটি একটি থেকে শুরু হয় ?:

1
?<
11
?
0

আমরা 1একবার ধরে নেব ব্যবহারকারী একবার ইনপুটগুলি ?পপ হয়ে গেলে , যার অর্থ কার্সারটি নীচে চলে যাবে, প্রোগ্রামটিকে এইরকম দেখায়:

1

11<
?
0

এখন একটি সমতল 1কার্সার স্ট্যাকের শীর্ষে। এটি যথাযথভাবে পপ করা হয় এবং কার্সারটি আবার সরে যায়:

1

1
?<
0

Now ব্যবহারকারী ইনপুট অনুমান 0জন্য ?কার্সার উপরে উঠানো হবে যার মানে:

1

1<

0

আবার, 1কার্সার স্ট্যাকের উপরে একটি রয়েছে যাতে কার্সার পপ হয় এবং নীচে চলে যায়:

1


<
0

অবশেষে কার্সার স্ট্যাকটি খালি, সুতরাং শেষ মানটি পপড, the 1, আউটপুট এবং প্রোগ্রামটি শেষ হয়।

এই NAND গেট কারণ জন্য সঠিক 1 NAND 0হয় 1। আপনি যদি পরীক্ষা করে দেখেন তবে অবশ্যই এটি অন্য তিনটি বিট বিট ইনপুটগুলির জন্য কাজ করে।

বা উদাহরণ

এই স্ট্যাকাইলোগিক প্রোগ্রামটি একটি ওআর গেট অনুকরণ করে :

?
?<

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

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

চ্যালেঞ্জ

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা স্ট্যাকাইলোগিক প্রোগ্রামটিকে স্ট্রিং হিসাবে গ্রহণ করে এবং এটি চালায়, মুদ্রণ করে বা ফলাফলটি ফেরত দেয় 0বা 1।

এর পরে ?, আপনি ব্যবহারকারীকে একটি 0বা 1ইনপুটের জন্য অনুরোধ করতে পারেন , বা0 ' ইনস ' এর প্রিসেট স্ট্রিং থেকে মানটি পড়তে পারেন 1যা আপনি ইনপুট হিসাবেও নেন । (এটি আপনার প্রোগ্রাম / ফাংশনে অন্য স্ট্রিং ইনপুট হতে পারে বা আপনি প্রোগ্রাম স্ট্রিংয়ের প্রথম বা শেষ লাইনটি ইনপুট স্ট্রিম হিসাবে ধরে নিতে পারেন)।

আপনি প্রোগ্রামটি ধরে নিতে পারেন এবং ইনপুটটি সর্বদা সুগঠিত থাকে। আপনি বৈকল্পিকভাবে ধরে নিতে পারেন ইনপুট প্রোগ্রামগুলি একটি একক পেছনের নতুন লাইনের সাথে এসেছে (যদিও মনে রাখবেন শেষে সর্বদা একটি অন্তর্ভুক্ত ফাঁকা স্ট্যাক থাকে)।

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

আরও নমুনা প্রোগ্রাম

ZERO
0<

ONE
1<

BUFFER
?<

NOT
1
?<
0

AND
?<
?

NAND
1
?<
11
?
0

OR
?
?<

NOR
1
?
00
?<
0

XOR(v1)
?
0
1?<
?
0

XOR(v2)
?
?<
11
?
0

XNOR(v1)
1
?
0?<
1
?

XNOR(v2)
1
?
00
?<
?

MEDIAN(v1)
1
???<
0

MEDIAN(v2)
?
1?<
??

মিডিয়ান প্রোগ্রামগুলির জন্য ধন্যবাদ মার্টিন ।

code-golf  interpreter  binary  logic-gates  logic 
— ক্যালভিনের শখ
সূত্র
আপনি যদি একটি 3-ইনপুট ফাংশন যোগ করতে চান, তাহলে এখানে মধ্যমা বাস্তবায়ন একটি উপায়: ?\1?<\??। বিকল্পভাবে, এখানে প্রতিসম 5-লাইন বাস্তবায়ন রয়েছে:?\?0\?<\?1\?
— মার্টিন ইন্ডার
ওহ, আমি একটি এমনকি neater বাস্তবায়ন পাওয়া যায়নি: 1\???<\0।
— মার্টিন ইন্ডার
2
@ মার্টিন ইন্ডিয়ার 3-ইনপুট মিডিয়ান ফাংশনটির (সমতুল্যভাবে, সংখ্যাগরিষ্ঠ-বিধিবিধানের ক্রিয়াকলাপ) সুষ্ঠুভাবে সাধারণকরণ সাধন করে। উদাহরণস্বরূপ, 7-ইনপুট সংখ্যাগরিষ্ঠ-বিধি কার্যটি 111\???????<\000।
— গ্রেগ মার্টিন
আসল প্রোগ্রামগুলির লাইনের ক্রমটিকে বিপরীত করে এবং 1s থেকে 0 এবং উপবৃত্তের সমস্ত পরিবর্তন (তবে? S এবং <একা রেখে) পরিবর্তিত হয়ে স্ট্যাকাইলোগিক প্রোগ্রাম $ পি the এর "বিজারো" প্রোগ্রামটি হয়ে উঠুন $ পিপি the দেখে মনে হচ্ছে ইনপুটগুলিতে $ বিপি of এর আউটপুট $ b_1, b_2, \ বিন্দু $ ইনপুটগুলিতে $ P of এর আউটপুট নয় b! B_1,! B_2, \ বিন্দু $ নোড এবং এনওআর এবং এক্সওএন / এক্সএনওআর এর দুটি সংস্করণ যেমন এন্ড এবং ওআর এর প্রদত্ত বাস্তবায়নগুলি এইভাবে উদ্ভট-সম্পর্কিত। কিছু প্রোগ্রাম হ'ল তাদের নিজস্ব বিজারো (বুফার, নট, মিডিয়ান (ভি 1))।
— গ্রেগ মার্টিন
1
@ গ্রেগমার্টিন ইয়েপ আমি বিশ্বাস করি প্রযুক্তিগত শব্দটি দ্বৈততা ।
— ক্যালভিনের

উত্তর:

15

রেটিনা , 79 78 73 68 66 65 63 62 55 44 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3
1<

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

এটি অনলাইন চেষ্টা করুন! (প্রথম দুটি লাইন একটি টেস্ট স্যুট সক্ষম করে, যেখানে প্রতিটি লাইন /লাইনফিডের পরিবর্তে আলাদা টেস্ট কেস হয় ))

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

ব্যাখ্যা

এর চূড়ান্ত সংস্করণটি মোটামুটি সহজ হয়ে শেষ হয়েছিল।

+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3

প্রথম পর্যায়ে কেবল লুপ ( +বিকল্পের কারণে ) যা ভাষার আসল ব্যাখ্যা করে। মঞ্চটি একটি একক রেজেক্সের বিকল্প, তবে বাস্তবে এটি তিনটি পৃথক প্রতিস্থাপন এক পর্যায়ে সঙ্কুচিত হয়ে যায়, এই সত্যটি ব্যবহার করে যে অব্যবহৃত শাখাগুলি থেকে গ্রুপগুলি ক্যাপচার করার পরিবর্তে স্থানান্তরকালে খালি বিবেচনা করা হয়।

  1. প্রক্রিয়াজাতকরণ ?:

    (.)([^_]*)\?<
$2$1<

    এটি সহজেই ইনপুটটির প্রথম অক্ষরটি গ্রহণ করে, তারপরে স্বেচ্ছাচারিত অক্ষরগুলির সাথে এটি মেলে ?<এবং এটি প্রথম অক্ষরটিকে <(মুছে ফেলার ?) সামনে রাখে ।

  2. প্রক্রিয়াজাতকরণ 0:

    (¶.*)0<
<$1

    এটি পূর্ববর্তী লাইনের সাথে মেলে 0<এবং এটি <অপসারণের পরে রাখে 0। (কার্যকরভাবে, এটি কেবল মুছে ফেলে 0এবং <এক লাইনটিকে উপরের দিকে সরায় ))

  3. প্রক্রিয়াজাতকরণ 1:

    1<(¶.+)
$1<

    খুব একই জিনিসটি বাদে, <একটি মুছে ফেলার সময় আমরা একটি লাইন নীচে সরিয়ে রেখেছি 1। লক্ষ্য করার জন্য একটি গুরুত্বপূর্ণ বিশদ হ'ল +পরিবর্তে এর ব্যবহার *, এটি হ'ল আমাদের পরবর্তী লাইনটি খালি না থাকা দরকার।

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

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

সামনে চরিত্র যদি <হয় 0, Regex সবসময় ম্যাচ হবে, যেহেতু সবসময়ই বর্তমান এক (যা সোর্স কোড থেকে ইনপুট পৃথক খালি লাইন হতে পারে) উপরে আরেকটি লাইন।

সামনে চরিত্র যদি <হয় 1, Regex যদি হয় আমরা শেষ লাইনটি (যেহেতু আছি ব্যর্থ হবে মেলে ব্যর্থ হবে) অথবা পরের লাইনে খালি হলে (যেহেতু .+মেলে ব্যর্থ হবে)। নোট করুন যে এই দুটি ক্ষেত্রেই পপিংয়ের পরে প্রোগ্রামটি সমাপ্ত করার সাথে মিলে যায় 1।

অবশেষে, এমন সম্ভাবনাও রয়েছে যা এর <আগে কারওর আগে নেই ?01। দেখা যাচ্ছে যে কেবলমাত্র একটি পপিং করে 0এবং খালি লাইনে উঠে আমরা এই পরিস্থিতিতে পৌঁছতে পারি , যাতে <এখন লাইনফিডের আগে।

সুতরাং, যখন প্রোগ্রামটি একটিতে শেষ হয় 1, <তখনও এর পরে থাকবে 1। তবে প্রোগ্রামটি যদি একটিতে শেষ হয় তবে 0এটি একটি ফাঁকা লাইনে চলে যাবে। আমরা সহজেই একটি সাধারণ ম্যাচের মঞ্চের সাহায্যে এই তথ্যটিকে পছন্দসই আউটপুটে পরিণত করতে পারি:

1<

এটি 1<স্ট্রিংয়ের ম্যাচগুলি কেবল গণনা করে । উপরের যুক্তি দ্বারা এটি 1যদি প্রোগ্রামটি একটিতে বন্ধ হয়ে যায় 1, এবং 0এটি যদি একটিতে বন্ধ হয় 0।

— মার্টিন ইন্ডার
সূত্র
3
আপনি স্যার, একটি উইজার্ড।
— GamrCorps
এ জাতীয় রেজেক্স এমচ ওয়া
— রোহান ঝুনঝুনওয়ালা
12

উত্তল , 102 95 বাইট

ভাল, স্ট্যাক-ভিত্তিক ভাষায় কোডেড একটি স্ট্যাক-ভিত্তিক ভাষা বেশ কঠিন বলে প্রমাণিত হয়েছিল। আমার শব্দগুলিকে চিহ্নিত করুন: আমি এটি 100 বাইট বা তারও কম পেয়ে যাব! সম্পাদনা: সাফল্য!

N/S\+{s)_'<={R:M;}{R):R;+}?}%'<-M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

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

প্রোগ্রাম ইনপুটটি কমান্ড-লাইন আরগগুলির মাধ্যমে হয়। ইনপুট 0এস এবং 1এস সাধারণত (টিআইও-তে, এর অর্থ "ইনপুট" বাক্সে নিউলাইন-পৃথক)।

ব্যাখ্যা:

সমস্ত কোড তিনটি ভাগে বিভক্ত করা যেতে পারে:

N/S\+

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

{s)_'<={R:M;}{R):R;+}?}%'<-

এই অংশটি নির্ধারণ করে কোন রেখাটি (বা স্ট্যাক) দিয়ে কার্যকর করা শুরু করবে। এটি প্রতিটি লাইন অনুসন্ধান করে এবং সঠিক স্ট্যাক নম্বরটি Mভেরিয়েবলের মধ্যে রাখে ।

M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

এই মজার বিট! এটি কেবলমাত্র একটি স্পেস ( " ") একটি ফাঁকা স্ট্যাকের প্রতীক হিসাবে) একটি লাইনে পৌঁছানো অবধি অবধি লুপ হয় । লাইনটি ফাঁকা না থাকলে নিম্নলিখিতটি করে:

  1. স্ট্যাক থেকে শেষ অক্ষর পপ করুন।
  2. বিবৃতি পরিবর্তন করুন:
    1. অক্ষরটি যদি একটি হয় তবে ?ইনপুট নিন এবং সেই অক্ষরটিকে লাইনে যুক্ত করুন।
    2. অক্ষরটি যদি একটি হয় 0তবে লাইন পয়েন্টারটিকে উপরে সরান।
    3. অক্ষরটি যদি একটি হয় 1তবে লাইন পয়েন্টারটিকে নীচে সরান।
    4. অক্ষরটি যদি একটি (স্পেস) হয় তবে সর্বাধিক-পপড আইটেম এবং শেষ প্রোগ্রামটি মুদ্রণ করুন।
— GamrCorps
সূত্র
6

32-বিট x86 মেশিন কোড, 70 বাইট

হেক্সে:

FC89E1565F31D28A07A8DF740B3C3C7511428D5C24FCEB0A5729142484C07405B20147EBE2578B3B8A17F6C2DF7414FF0B923C3F7501AC3C30750383C30883EB04EBE389CCC3

ইনপুট হ'ল একটি নাল-টার্মিনেটেড মাল্টি-লাইন স্ট্রিং (লাইনফিড-বিচ্ছিন্ন) ESI এর মধ্য দিয়ে গেছে। ব্যবহারকারীর ইনপুটটি প্রথম লাইন হিসাবে ধরে নেওয়া হয়। AL এ '0' / '1' প্রদান করে।

disassembly:

fc           cld
89 e1        mov    ecx,esp
56           push   esi
5f           pop    edi                  ;EDI=ESI
31 d2        xor    edx,edx              ;EDX=0
_loop0:
8a 07        mov    al,BYTE PTR [edi]    ;AL=*EDI
a8 df        test   al,0xf5              ;AL&~0x0a==0 => separator ('\n' or '\0')
74 0b        je     _stck
3c 3c        cmp    al,'<'
75 11        jne    _loop0end
42           inc    edx                  ;For "cursor" symbol adjust stack pointer offset
8d 5c 24 fc  lea    ebx,[esp-0x4]        ;and load EBX with the address where this pointer
eb 0a        jmp    _loop0end            ;is going to be stored in the next iteration
_stck:
57           push   edi                  ;Pointer to the separator
29 14 24     sub    DWORD PTR [esp],edx  ;adjusted to point to the top of the stack
84 c0        test   al,al                ;AL==0?
74 05        je     _loop0break          ;break
b2 01        mov    dl,0x1               ;EDX can be [0..2], resets to 1
_loop0end:
47           inc    edi                  ;++EDI
eb e2        jmp    _loop0
_loop0break:
57           push   edi                  ;*EDI==0, add lower implicit empty stack
_loop1:                                  ;The actual state machine code
8b 3b        mov    edi,DWORD PTR [ebx]  ;EDI=*EBX
8a 17        mov    dl,BYTE PTR [edi]    ;DL=*EDI
f6 c2 df     test   dl,0xf5              ;DL&~0x0a
74 14        je     _loop1break          ;ZF==1 => current stack is empty
ff 0b        dec    DWORD PTR [ebx]      ;--(*EBX): pop the stack
92           xchg   edx,eax              ;AL=DL
3c 3f        cmp    al,'?'
75 01        jne    _skplods             ;AL=='?' => substitute char from the input string
ac           lodsb
_skplods:
3c 30        cmp    al,'0'
75 03        jne    _0x31                ;EBX+=AL==0?4:-4
83 c3 08     add    ebx,0x8              ;But to avoid wasting 2 bytes for the jump after the 'add'
_0x31:                                   ;add 8 and fall through to subtract 4 back
83 eb 04     sub    ebx,0x4
eb e3        jmp    _loop1
_loop1break:
89 cc        mov    esp,ecx              ;Clear the stack
c3           ret                         ;Returns '0'/'1' in AL
— meden
সূত্র
5

জাভাস্ক্রিপ্ট (ES6), 136 138

প্রোগ্রামটিতে একটি সমাপ্তি নতুন লাইন ধরে নেওয়া

(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

কম গল্ফড

(p, i, j=0)=>{
  p=`\n${p}`
     .split`\n`
     .map(
       (x,i)=>
       (
         x = [...x],
         c = x.pop(),
         c == '<' ? k=i : x.push(c),
         x
       )
     )
  for(; a = p[k].pop(); k -= 1-c-c)
    c = 1/a ? a : i[j++];
  return c;
}

পরীক্ষা

F=(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

function run() {
  var pgm=P.value+'\n'
  var i=I.value
  O.textContent = F(pgm,i)
}

run()
#P { width:60%; height: 6em }
#I { width:50%;  }
Program<br>
<textarea id=P>1
?&lt;
11
?
0</textarea><br>
Input<br>
<input id=I value=01>
<button onclick='run()'>Run</button>
<br>Output
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
2

পাইথন 3, 147 146 145 144 বাইট

1 লাইটকে ধন্যবাদ 1 বাইট

def f(p):
 i=p[:p.find("<")].count("\n");p=p.split()
 try:
  while 1:*p[i],c=p[i];c=c>"<"and input()or c;i+=c<"<"and int(c)*2-1
 except:return c
— PurkkaKoodari
সূত্র
1

পাইথন 3, 318

def s(f,z):
 p=b="";g=0;a=[];n=a.append;n(p)
 for i in f:
  if i=="\n":n(p);p=''
  else:p+=i
 n(p);p=b;n(p)
 while g<len(a):
  if'<'in a[g]:q=g;a[q]=a[q][:-1]
  g+=1
 while 1:
  v=a[q]
  if v=='':print(b);break
  if v[-1]=='1':a[q]=v[:-1];q+=1;b=1
  elif v[-1]=="0":a[q]=v[:-1];q-=1;b=0
  else:a[q]=v[:-1]+z[0];z=z[1:]

এফ হচ্ছে প্রোগ্রাম, জেড ইনপুট হচ্ছে। হ্যাঁ, আমার পরিবর্তনশীল নামগুলি উন্মাদ।

— ধ্বংসাত্মক লেবু
সূত্র
1

ES6, 190 বাইট

f=(p,i)=>{
n=p.split`<`[0].split`\n`.length-1
p=p.split`\n`.map(o=>o.split``)
i=i.split``
p[n].pop()
while(p[n]&&p[n].length){
c=p[n].pop()
v=c=='?'?i.shift():Number(c)
n+=v*2-1
}
return v
}

মত ব্যবহার করুন f(program, input)

— হওয়া ASCII শুধুমাত্র
সূত্র
2
গল্ফিংয়ের কয়েকটি সাধারণ টিপস (কোথাও এর একটি তালিকা রয়েছে): [...o]পরিবর্তে ব্যবহার করুন o.split``এবং তার forপরিবর্তে ব্যবহার করুন, এর ফলে whileআপনি দুটি এক্সপ্রেশন forসংরক্ষণের দুটি বাইটে স্থানান্তর করতে পারবেন । কয়েকটি সুনির্দিষ্ট টিপস: আমি মনে করি আপনার Numberকাস্ট অপ্রয়োজনীয়, যেমনটি আপনার *2জন্য নিক্ষিপ্ত হবে, এবং আমি কেবল iব্যবহার করে পড়ব j=0এবং i[j++]যা আমার মনে হয় 11 বাইট সংরক্ষণ করে।
— নীল
1
আপনার প্রয়োজন নেই f=, বেনামে ফাংশন অনুমোদিত।
— gcampbell
0

জাভা, 256 255 231 219 215 213 বাইট

int f(char[][]p,char[]I){int l=p.length,d=0,j=-1,c=0,k=0,i[]=new int[l];while(++j<l)if(p[j][i[j]=p[j].length-1]==60)i[k=j]--;try{for(;;k+=c>48?1:-1)c=(c=p[k][i[k]--])>49?I[d++]:c;}catch(Throwable t){}return c-48;}

আইডিয়নে ডেমো।

প্রোগ্রাম এবং ইনপুটটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে ফলাফলটি পূর্ণসংখ্যার হিসাবে প্রদান করে।

— PurkkaKoodari
সূত্র
@ ল্যাকইনুন একটি forলুপে পরিবর্তন হয়েছে , তবে আপনার প্রথম মন্তব্যের অর্থ কী?
— পূর্বকুডারী
@ Pietu1998 LeakyNun মানে এটা হতে পারে int f(String[]I)...এবং আপনার এড়াতে পারেনString[]p=I.split("\n");
— বিড়াল
এর অর্থ আপনি ফাংশনটি এই হিসাবে ঘোষণা করতে পারবেনint f(String[]P)
— লিকি নুন
1
@ কেট নিনজা'র 7 সেকেন্ডের মধ্যে: /
— লিকি নুন
এছাড়াও, আপনি যদি জাভা 8-তে স্থির হন তবে আপনার মতো ল্যাম্বদা থাকতে পারে (আমার মনে হয়)->(String[]I){...
— বিড়াল
0

পিএইচপি (<7.0), 195 192 বাইট

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

<?php foreach(split("\n",$argv[++$t])as$l)$p[]=str_split($l);for($i=-1;end($p[++$i])!='<';);array_pop($p[$i]);for(;($v=array_pop($p[$i]))!==null;$i+=$n?:-1)($n=$v)=='?'&&$n=$argv[++$t];echo$n;
— user55641
সূত্র
0

সি, 264 249 244 242

সি স্ট্রিংগুলি ম্যানিপুলেটিংয়ের সাথে এতটা ভাল করে না, তবে এটি বেশ ছোট।

এটি কার্সার ( <) এর স্ট্রিং স্ক্যান করে , 1 টি জায়গায় পিছনে সরে গিয়ে, কমান্ডটি পড়ে, একটি tabঅক্ষর দিয়ে প্রতিস্থাপন করে এবং একটি লাইন এগিয়ে বা পিছনে সরিয়ে নিয়ে কাজ করে। ইনপুট সি সি অ্যারের আকারে রয়েছে, যেমন char array[]="1\n?<\n11\n?\n0";result = f(array);, যদিও গাড়ীর ফেরতের অনুমতিও রয়েছে।

ইনপুট স্ট্রিংটি পরিবর্তিত হলেও দৈর্ঘ্য পরিবর্তন করা হয়নি।

t;f(char*n){char*p=strchr(n,60);for(*p--=9;;){if(*p==63)scanf("%d",&t),*p=t+48;if(*p^49){for(*p--=9;p>n&&*p^10;--p);for(--p;p>n&&*p==9;--p);if(p<n||*p==10)return 0;}else{for(*p++=9;*p&&*p^10;++p);for(p+=!!*p;*p>10;++p);if(*--p<11)return 1;}}}

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

নতুন লাইনের জায়গায় একক ব্যাকস্ল্যাশ ব্যবহার করে প্রতিটি পরীক্ষার কেসকে পৃথক প্যারামিটার হিসাবে এই প্রোগ্রামটি চালান। পরীক্ষার কেসগুলি ফাঁকা রেখার দ্বারা পৃথক করা হবে।

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    while (*++argv)
    {
        char *input=malloc(strlen(*argv)+1),*p;
        strcpy(input,*argv);
        printf("testing %s\n",input);
        for (p=input;*p;++p)
            if (*p=='\\')
                *p=10;
        printf("result: %d\n\n",f(input));
        free(input);
    }
    return 0;
}
— owacoder
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.