25

এমন একটি প্রোগ্রাম লিখুন যা কেবলমাত্র অক্ষর .এবং সমন্বিত বিজোড় দৈর্ঘ্যের স্ট্রিংয়ের সাথে নিয়ে থাকে :। প্রাথমিকভাবে খালি স্ট্যাকের সহায়তায় , এই স্ট্রিং থেকে নিম্নলিখিত হিসাবে একটি সংখ্যা তৈরি করুন:

প্রত্যেক অক্ষরের জন্য গ স্ট্রিং (বাঁ দিক থেকে ডানদিকে যাচ্ছে) ...

যদি সি হয় .এবং স্ট্যাকের 2 টিরও কম উপাদান থাকে তবে স্ট্যাকের উপর 1 টি চাপুন।
যদি সি হয় .এবং স্ট্যাকের 2 বা ততোধিক উপাদান থাকে তবে দুটি শীর্ষ মানকে স্ট্যাকের বাইরে টানুন এবং তাদের যোগফলটি স্ট্যাকের উপরে চাপ দিন।
যদি সি হয় :এবং স্ট্যাকের 2 টিরও কম উপাদান থাকে তবে স্ট্যাকের উপর 2 টি চাপুন।
যদি সি হয় :এবং স্ট্যাকের 2 বা ততোধিক উপাদান থাকে তবে দুটি শীর্ষ মানকে স্ট্যাকের বাইরে টানুন এবং তাদের পণ্যটিকে স্ট্যাকের দিকে ঠেলে দিন।

ফলস্বরূপ সংখ্যাটি স্ট্যাকের শীর্ষে মান। আপনার প্রোগ্রামটি এই নম্বরটি স্টডআউটে মুদ্রণ করা উচিত (optionচ্ছিক ট্রেলিং নিউলাইন সহ)।

(একটি সামান্য বিশ্লেষণ দেখায় যে স্ট্রিংটির দৈর্ঘ্য না থাকলে কেবলমাত্র একটি সংখ্যা অবশিষ্ট থাকে, যার কারণেই আমরা সেগুলি উপেক্ষা করছি In বাস্তবে, স্ট্যাকের কখনই 2 টির বেশি উপাদান থাকে না))

উদাহরণস্বরূপ, সংখ্যাটি ::...:.:.9:

  2   1   2   2    /______ stack just after the character below is handled
2 2 4 4 5 5 7 7 9  \
: : . . . : . : .  <-- string, one character at a time

স্যানিটি পরীক্ষা হিসাবে, 1, 3 এবং 5 এর দৈর্ঘ্যের সমস্ত স্ট্রিংয়ের জন্য এখানে নম্বরগুলি:

. 1
: 2
... 2
..: 1
.:. 3
.:: 2
:.. 3
:.: 2
::. 4
::: 4
..... 3
....: 2
...:. 4
...:: 4
..:.. 2
..:.: 1
..::. 3
..::: 2
.:... 4
.:..: 3
.:.:. 5
.:.:: 6
.::.. 3
.::.: 2
.:::. 4
.:::: 4
:.... 4
:...: 3
:..:. 5
:..:: 6
:.:.. 3
:.:.: 2
:.::. 4
:.::: 4
::... 5
::..: 4
::.:. 6
::.:: 8
:::.. 5
:::.: 4
::::. 6
::::: 8

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

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

code-golf sequence stack

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

5

সর্বকালের সেরা মিনিমালিস্ট ইকুয়ালাইজার।

— dberm22

13

সিজেএম, 27 24 23 22 বাইট

q{i]_,+~3<-"1+2* "=~}/

অনেকটাই অকপট. আমি সিজামের স্ট্যাকটি প্রশ্নের মধ্যে উল্লিখিত স্ট্যাক হিসাবে ব্যবহার করি;)

অ্যালগরিদম

প্রথমে .এবং এর জন্য ASCII কোডটি দেখতে দিন :।

'.i ':ied

[46 58]

যেহেতু সিজেমে, সূচকগুলি চারপাশে গুটিয়ে যায়, আসুন আমরা এই মানগুলি পছন্দসই ক্রিয়াকলাপটি পেতে সরাসরি ব্যবহার করতে পারি কিনা তা দেখতে দিন ..

'.i4% ':i4%ed

[২ 2]

সুতরাং আমি কেবল 4 দৈর্ঘ্যের অপারেশন স্ট্রিংয়ে ASCII কোডগুলি ব্যবহার করতে পারি না। কিছু অন্যান্য মান চেষ্টা করুন

'.i 10% ':i 10%ed

[8 8]

যা একটি 4 দৈর্ঘ্যের স্ট্রিং এ নিচে ফোটে

[২ 0]

আমি এই Mod 10 অপারেশনটি ব্যবহার করতে পারি তবে এটির জন্য 2 বাইট লাগবে। অন্য কিছু চেষ্টা করুন

'.i5% ':i5%ed

[1 3]

সুন্দর !, এখন আমরা সূচকগুলি পেতে স্ট্যাক আকারের শর্তের জন্য কেবল 1 টি বিয়োগ করি 0, 1, 2 and 3এবং একটি স্যুইচ কেস হিসাবে একটি 5দৈর্ঘ্যের অ্যারে ( "1+2* ") ব্যবহার করি । শেষ স্থানটি দৈর্ঘ্য 5 তৈরির জন্য কেবল একটি ফিলার mod এটি মোডিং অপারেশনের তুলনায় এটি কেবল 1 অতিরিক্ত বাইট।

q{                  }/    e# parse each input character in this loop
  i]                      e# convert '. or ': into ASCII code and wrap everything
                          e# in stack in an array
    _,+                   e# Copy the stack array, take its length and add the length to
                          e# the stack array 
       ~3<                e# unwrap the stack array and check if stack size is less than 3
                          e# 3 because either . or : is also on stack
          -               e# subtract 0 or 1 based on above condition from ASCII code
           "1+2* "        e# string containing the operation to perform
                  =~      e# chose the correct operation and evaluate it

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

1 বাইট সংরক্ষিত কোসেকে ধন্যবাদ

— অপ্টিমাইজার
সূত্র

1

অপারেশনগুলির স্ট্রিংয়ের জন্য স্থান কী?

— পিটার টেলর

@ পিটারটেলর পোস্টে ব্যাখ্যা করেছেন।

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

9

> <> (ফিশ) , 33 বাইট

ib%1-i:1+?\~n;
5a*)?*+40.\b%1-0@i

সামান্য কৌশল / অপ্টিমাইজেশান সহ মোটামুটি সোজা।

ব্যাখ্যা:

তথ্য: i= পরবর্তী ইনপুট চরের কোডপয়েন্ট, -1যদি ইনপুটটির শেষে পৌঁছে; a= 10; b= 11; )=>
iপ্রথম ইনপুট চরের কোডপয়েন্ট,
b%1- top_of_stack mod 11 - 1মুখোশ 48 ('.') , 56 (':')করতে1 , 2
i:1+?\~n; ইনপুট শেষে পৌঁছে শেষ ফলাফল মুদ্রণ এবং সমাপ্ত
অন্যথায়:
b%1- মাস্ক ইনপুট 1 , 2
0@0দুটি সংখ্যা অধীনে ধাক্কা
i5a*)পরবর্তী ইনপুট পড়ুন এবং এর সাথে 0 , 1তুলনা করার জন্য এটি মাস্ক করুন50
যদি 1( ':') শীর্ষস্থানীয় দুটি উপাদান স্ট্যাক [0 টি পণ্য] তৈরি করে
সর্বদা দুটি [0 sum]বা স্ট্যাক তৈরি শীর্ষ দুটি উপাদান যুক্ত করুন[0+product=product]
40.লাফানো (লুপ) অবস্থান ফিরে (4,0), আমাদের পয়েন্ট 4,i:1+?\~n;

— randomra
সূত্র

8

হাস্কেল, 73 65 বাইট

স্ট্যাকের মধ্যে 2 টিরও বেশি উপাদান থাকে না তা ব্যবহার করে একটি সরল সমাধান।

[x,y]#'.'=[x+y]
[x,y]#_=[x*y]
s#'.'=1:s
s#_=2:s
f=head.foldl(#)[]

— alephalpha
সূত্র

5

সি, 104 বাইট

k[2],n;f(char*c){for(n=0;*c;)k[n]=*c++-58?n>1?n=0,*k+k[1]:1:n>1?n=0,*k*k[1]:2,k[1]=n++?k[1]:0;return*k;}

আচ্ছা, এটি অনেক দীর্ঘ।

— BrainSteel
সূত্র

5

পাইথ, 25 24 বাইট

eu?]?.xGHsGtG+GhHmqd\:zY

@ Isaacg এর সমাধান অধ্যয়ন করে একটি ধারণা পেয়েছেন। তবে আমি একটি স্ট্যাক ব্যবহার করছি।

অনলাইন বিক্ষোভ বা টেস্ট স্যুট

ব্যাখ্যা

প্রথম কাজটি হ'ল ইনপুট স্ট্রিংটিকে 0 এবং 1 এস তে রূপান্তর করা। একটি "."একটি রূপান্তরিত পরার 0, একটি ":"একটি মধ্যে 1।

mqd\:z   map each char d of input to (d == ":")

তারপরে আমি সংখ্যার এই তালিকাটি হ্রাস করব:

eu?]?.xGHsGtG+GhHmqd\:zY
 u                     Y   start with the empty stack G = []
                           for each H in (list of 0s and 1s), update G:
                              G = 
    ?.xGHsG                      product of G if H != 0 else sum of G
   ]                             wrapped in a list 
  ?        tG                 if G has more than 1 element else
             +GhH                G + (H + 1)
e                         take the top element of the stack

— Jakube
সূত্র

4

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

আমরা আমাদের স্ট্যাকের 2 টি ঘর ব্যবহার করি।

এস [0] এ একটি মান স্থাপন শুরু করুন।
তারপরে, ইনপুট স্ট্রিংয়ে প্রতিটি বিজোড় অবস্থান (0 থেকে গণনা করা) এ একটি মান রাখুন [1] put
প্রতিটি এমনকি পজিশনে একটি ক্যালক চালান (যোগ বা গুণ) এবং স্টোর ফলাফল [0]।

সুতরাং স্ট্যাকটি ভুলে যান এবং মাত্র 2 ভেরিয়েবল, এ এবং বি ব্যবহার করুন।

f=s=>[...s].map((c,i)=>(c=c>'.',i&1?b=1+c:i?c?a*=b:a+=b:a=1+c))|a

একটি দ্রুত পরীক্ষা

for(i=0;i<128;i++)
{
  b=i.toString(2).replace(/./g,v=>'.:'[v]).slice(1)
  if(b.length&1) console.log(b,f(b))
}

আউটপুট

"." 1
":" 2
"..." 2
"..:" 1
".:." 3
".::" 2
":.." 3
":.:" 2
"::." 4
":::" 4
"....." 3
"....:" 2
"...:." 4
"...::" 4
"..:.." 2
"..:.:" 1
"..::." 3
"..:::" 2
".:..." 4
".:..:" 3
".:.:." 5
".:.::" 6
".::.." 3
".::.:" 2
".:::." 4
".::::" 4
":...." 4
":...:" 3
":..:." 5
":..::" 6
":.:.." 3
":.:.:" 2
":.::." 4
":.:::" 4
"::..." 5
"::..:" 4
"::.:." 6
"::.::" 8
":::.." 5
":::.:" 4
"::::." 6
":::::" 8

— edc65
সূত্র

-2:f=s=>[(c=s[i]>'.',i&1?b=1+c:+i?c?a*=b:a+=b:a=1+c)for(i in s)]|a

— nderscore

কমপক্ষে আমার wণদাতায় কাজ করা যাবে না এমন @ কম্বল করে। কারণ (আমি গুলি) সূচিপত্র ছাড়াও অতিরিক্ত সম্পত্তি দেয়

— edc65

এটি ফায়ারফক্সে আমার জন্য কাজ করছে .0 37.০.২। এটি একটি পরিষ্কার ব্রাউজার ট্যাবে চালানোর চেষ্টা করুন। দেখে মনে হচ্ছে স্ট্যাকেক্সচেঞ্জ স্ট্রিংগুলিতে অতিরিক্ত বৈশিষ্ট্য যুক্ত করেছে (স্টুব.ইএনজেজে)

— nderscore

3

পাইথ, 27 বাইট

Jmhqd\:zu?*GhHteH+GhHctJ2hJ

এক গুচ্ছ? যার একটি স্ট্যাক দরকার।

                       Implicit: z is the input string.
Jmhqd\:z               Transform the string into a list, 1 for . and 2 for :
                       Store it in J.
u            ctJ2hJ     Reduce over pairs of numbers in J, with the
                       first entry as initial value.
 ?    teH               Condition on whether the second number is 1 or 2.
  *GhH                  If 1, update running total to prior total times 1st num.
         +GhH           If 2, update running total to prior total plus 1nd num.

প্রদর্শন.

— isaacg
সূত্র

1

জিনিয়াস। এবং ইতিমধ্যে আমি একটি স্ট্যাক প্রয়োগ করেছি (32 বাইট)। :-(

— জাকুব

3

রেটিনা , 105 75 73 বাইট

আমার প্রথম রেটিনা প্রোগ্রাম! (প্রথম স্থানটিতে ভাষা আবিষ্কারের কথা উল্লেখ না করে ২ বাইট সংরক্ষণের জন্য মার্টিন বাটনারকে ধন্যবাদ জানাই।)

প্রতিটি লাইন পৃথক ফাইলে যেতে হবে; অথবা, আপনি এগুলি সমস্ত একটি ফাইলে রেখে -sপতাকা ব্যবহার করতে পারেন । <empty>স্বরলিপি একটি খালি ফাইল / লাইন প্রতিনিধিত্ব করে।

^(a+;)?\.
$1a;
^(a+;)?:
$1aa;
;(a+;)\.
$1
(a+);aa;:
$1$1;
)`;a;:
;
;
<empty>
a
1

Mbomb007 এর উত্তর দ্বারা অনুপ্রাণিত , কিন্তু আমি কিছুটা ভিন্ন পদ্ধতির গ্রহণ করি। একটি প্রধান পার্থক্য হ'ল আমি ডট স্ট্রিংয়ের সামনে স্ট্যাকটি তৈরি করি (স্ট্যাকের শীর্ষটি ডানমুখী করে)। এটি প্রতীকগুলিকে যথাস্থানে সম্পর্কিত সংখ্যায় রূপান্তর করা সহজ করে তোলে। আমি এর aপরিবর্তে 1এটিকে কেবল শেষের দিকে অদলবদল করে, এর মতো সিকোয়েন্সগুলিতে পার্সিং অস্পষ্টতা এড়াতে ব্যবহার করি $1a। মত উত্তর যদি একটি aaaaaaঅবিচ্ছিন্ন সংখ্যা হিসাবে গ্রহণযোগ্য হয়, 4 টি বাইট সংরক্ষণ করতে শেষ দুটি লাইন / ফাইলগুলি মুছে ফেলা হতে পারে।

ব্যাখ্যা:

^(a+;)?\.
$1a;

স্ট্যাকের (0 (a+;)?) পিরিয়ড ( \.) এর পরে 0 বা 1 টি আইটেম থাকলে মিলছে ; যদি তা হয় তবে এটি পিরিয়ডটি প্রতিস্থাপন করে a;(অর্থাত্ 1 টি ধাক্কা দেয়)।

^(a+;)?:(.*)
$1aa;$2

কোলন অনুসরণ করে স্ট্যাকের মধ্যে 0 বা 1 টি আইটেম থাকলে মিলছে। যদি তা হয় তবে এটি কোলনকে প্রতিস্থাপন করে aa;(অর্থাত্ একটি 2 চাপায়)।

;(a+;)\.
$1

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

(a+);aa;:
$1$1;

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

)`;a;:
;

স্ট্যাকের দুটি আইটেম থাকলে রেজেক্স মেলে, যার শীর্ষটি 1 টি, তার পরে একটি কোলন থাকে। কোলন এবং 1 মুছে ফেলে অন্য সংখ্যাটি অপরিবর্তিত রেখে (অর্থাৎ 1 দ্বারা গুণিত)।

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

;
<empty>

বাম দিকের সেমিকোলন মুছে ফেলে।

a
1

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

— DLosc
সূত্র

লুপের শুরুটি কি প্রথম ফাইল হিসাবে ধরে নেওয়া হয়, তবে?

— mbomb007

@ mbomb007 হ্যাঁ আমি ডক্সে দেখেছি, তবে যতক্ষণ না মার্টিন আমাকে এটির কথা মনে করিয়ে দেয়। ;)

— DLosc

2

মরিচা, 170 টি অক্ষর

fn f(s:String)->i32{let(mut a,mut b)=(-1,-1);for c in s.chars(){if b!=-1{a=match c{'.'=>a+b,':'=>a*b,_=>0};b=-1}else{b=match c{'.'=>1,':'=>2,_=>0};if a==-1{a=b;b=-1}};}a}

গল্ফ করার ক্ষেত্রে মরিচা একেবারে ভয়ানক। পুরো অবারিত কোড:

#[test]
fn it_works() {
    assert_eq!(dotty_ungolfed("::...:.:.".to_string()), 9);
    assert_eq!(f("::...:.:.".to_string()), 9);
}

fn dotty_ungolfed(program: String) -> i32 {
    let (mut a, mut b) = (-1, -1);
    for ch in program.chars() {
        if b != -1 {
            a = match ch { '.' => a + b, ':' => a * b, _ => panic!() };
            b = -1;
        } else {
            b = match ch { '.' => 1, ':' => 2, _ => panic!() };
            if a == -1 { a = b; b = -1; }
        }
    }
    a
}

fn f(s:String)->i32{let(mut a,mut b)=(-1,-1);for c in s.chars(){if b!=-1{a=match c{'.'=>a+b,':'=>a*b,_=>0};b=-1}else{b=match c{'.'=>1,':'=>2,_=>0};if a==-1{a=b;b=-1}};}a}

আমি এখানে একটি আকর্ষণীয় কৌশল ব্যবহার করেছি। আপনি যদি / অন্য বিবৃতিতে একটি অক্ষর অবিলম্বে বাতিল করা মান ফিরিয়ে দেন তবে আপনি দুটি পরিবর্তে কেবল একটি সেমিকোলন প্রয়োজন।

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

if foo {
    a = 42;
} else {
    doSomething(b);
}

মধ্যে পরিবর্তন করা যেতে পারে

if foo {
    a = 42
} else {
    doSomething(b)
};

যা একটি সেমিকোলন শেভ করে একটি চরিত্র সংরক্ষণ করে।

— ডোরকনব
সূত্র

2

হাস্কেল, 88 81 79 বাইট

(h:t)![p,q]|h=='.'=t![p+q]|1<2=t![p*q]
(h:t)!s|h=='.'=t!(1:s)|1<2=t!(2:s)
_!s=s

দেখে মনে হচ্ছে যে কেউ আমাকে হাস্কেল সমাধানের চিহ্নটিতে মারধর করেছে, কেবল তা-ই নয়, তাদের দ্রবণটি আমার চেয়ে কম orter এটি খারাপ তবে আমি কী নিয়ে এসেছি তা পোস্ট করার কোনও কারণ দেখছি না।

— Ankh-morpork
সূত্র

2

এপিএল (50)

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

{⊃{F←'.:'⍳⍺⋄2>⍴⍵:F,⍵⋄((⍎F⌷'+×')/2↑⍵),2↓⍵}/(⌽⍵),⊂⍬}

অভ্যন্তরীণ ফাংশন বামদিকে একটি 'কমান্ড' নেয় এবং ডানদিকে একটি স্ট্যাক রাখে এবং স্ট্যাকটি ফিরিয়ে এনে এটি প্রয়োগ করে। বাইরের ফাংশনটি খালি স্ট্যাক দিয়ে শুরু করে স্ট্রিংয়ের ওপরে এটি হ্রাস করে।

ব্যাখ্যা:

(⌽⍵),⊂⍬: ওভার কমাতে প্রাথমিক তালিকা। ⊂⍬একটি বাক্সযুক্ত খালি তালিকা যা স্ট্যাকের প্রতিনিধিত্ব করে (⌽⍵)তা হ'ল ইনপুটটির বিপরীত। (তালিকার উপরে ডান থেকে বামে হ্রাস প্রয়োগ করা হয়েছে, সুতরাং স্ট্রিংটি ডান থেকে বামে প্রক্রিয়াজাত করা হবে before
{... }: অভ্যন্তরীণ ফাংশন। এটি ডানদিকে স্ট্যাক লাগে, বামে একটি অক্ষর এবং পরিবর্তিত স্ট্যাকটি ফেরত দেয়।
- F←'.:'⍳⍺: স্ট্রিংয়ের অক্ষরটির সূচক, .:এটি মানের উপর নির্ভর করে 1 বা 2 হবে।
- 2>⍴⍵:F,⍵: যদি 2 বর্তমান স্ট্যাকের আকারের চেয়ে বড় হয় তবে কেবল বর্তমান মানটিকে স্ট্যাকের সাথে যুক্ত করুন।
- ⋄: অন্যথায়,
  - 2↓⍵: স্ট্যাক থেকে শীর্ষ দুটি আইটেম সরান
  - (... )/2↑⍵: তাদের উপর একটি প্রদত্ত ফাংশন হ্রাস করুন এবং এটি স্ট্যাকের সাথে যুক্ত করুন।
  - ⍎F⌷'+×': ফাংশন হয় হয় +(সংযোজন) বা ×(গুণ), দ্বারা নির্বাচিত F।
⊃: অবশেষে, স্ট্যাকের শীর্ষতম আইটেমটি ফিরুন

— সামুদ্রিক
সূত্র

2

রুবি - 96 অক্ষর

এখানে বাছাই আকর্ষণীয় টুকরা eval।

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

x,m=$<.getc>?.?2:1
(b,f=m.split //
b=b>?.?2:1
x=f ?eval("x#{f>?.??*:?+}b"):b)while m=gets(2)
p x

Ungolfed:

bottom_of_stack = $<.getc > '.' ? 2 : 1 # if the first char is ., 1, else 2
two_dots = nil
while two_dots = gets(2) do # get the next 2 chars
  number_char, math_char = two_dots.split //
  number = number_char > '.' ? 2 : 1
  if math_char
    math = math_char > '.' ? '*' : '+'
    # so bottom_of_stack = bottom_of_stack + number ...
    # or bottom_of_stack = bottom_of_stack * number
    bottom_of_stack = eval("bottom_of_stack #{math} number")
  else
    # if there's no math_char, it means that we're done and 
    # number is the top of the stack
    # we're going to print bottom_of_stack, so let's just assign it here
    bottom_of_stack = number
  end
end
p bottom_of_stack  # always a number, so no need for `puts`

— চার্লস না
সূত্র

2

টিআই-বেসিক, 78 73 70 69 66 বাইট

Input Str1
int(e^(1=inString(Str1,":
For(A,2,length(Str1),2
Ans+sum({Ans-2,1,1,0},inString("::..:",sub(Str1,A,2
End
Ans

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

কৌশলগুলি অন্তর্ভুক্ত:

int(e^([boolean]পরিবর্তে 1+(boolean; একটি বাইট সংরক্ষণ করে
তালিকার টুকরো টুকরো করার পরিবর্তে একটি তালিকার আংশিক যোগফল (যার জন্য একটি তালিকাতে সংরক্ষণের প্রয়োজন হবে): 3 বাইট সংরক্ষণ করে

— lirtosiast
সূত্র

আনস থেকে ইনপুট নেওয়ার সাথে আপনার ভাল হওয়া উচিত, যেমন ".:.":prgmDOTTY4 বাইট সংরক্ষণ করুন।

— এমআই রাইট

@ রাইট আমি স্ট্যাকের মধ্যে নম্বরটি সংরক্ষণ করতে উত্তর ব্যবহার করি।

— লিটারোসিয়াসট

আমি শুরুতে বলতে 1+(":"=sub(Ans,1,1

— এমআই রাইট

1

আমাকে লুপে স্ট্র 1 ব্যবহার করতে হবে, যেখানে আনস নেওয়া হয়েছে, তাই আমি আনসগুলিতে স্ট্রিং রেখে দূরে যেতে পারব না। এটি আনসার থেকে স্ট্র 1 এ সংরক্ষণ করলে কোনও স্থান বাঁচবে না।

— lirtosiast

1

যান, 129 115 112 বাইট

func m(s string){a,b:=0,0;for c,r:=range s{c=int(r/58);if b>0{a=a*b*c+(a+b)*(c^1);b=0}else{b,a=a,c+1}};print(a)}

(কিছুটা) অবরুদ্ধ:

func m(s string){
    // Our "stack"
    a, b := 0, 0
    // abusing the index asignment for declaring c
    for c, r := range s {
        // Ascii : -> 58, we can now use bit fiddeling
        c = int(r / 58)
        if b > 0 {
            // if r is :, c will be 1 allowing a*b to pass through, c xor 1 will be 0
            // if r is ., c xor 1 will be 1 allowing a+b to pass through
            a = a*b*c + (a+b)*(c^1)
            b = 0
        } else {
            b, a = a, c+1 // Since we already know c is 0 or 1
        }
    }
    print(a)
}

এটি অনলাইনে এখানে চেষ্টা করুন: http://play.golang.org/p/B3GZonaG-y

— ক্রিস্টোফার স্যাল স্টারগার্ড
সূত্র

1

পাইথন 3, 74

x,*s=[1+(c>'.')for c in input()]
while s:a,b,*s=s;x=[x*a,x+a][-b]
print(x)

প্রথমত, 1 এর এবং 2 এর একটা ক্রম মধ্যে ইনপুট তালিকা রূপান্তরিত প্রাথমিক মান হিসাবে প্রথম মান গ্রহণ x। তারপরে, সামনের দিক থেকে একবারে দুটি উপাদান সরিয়ে sপ্রথম সংখ্যাটি গ্রহণ করে এবং হয় হয় দ্বিতীয় সংখ্যার 1 বা 2 এর ভিত্তিতে বর্তমান সংখ্যাটি যুক্ত বা গুণ করে lying

— xnor
সূত্র

1

ভাল এটি অপারেটিং সিস্টেমটি (ইচ্ছাকৃতভাবে) পরিশীলিত

এটা শুধু ...

প্রথম বন্ধনযুক্ত এক্সপ্রেশনটি পোস্টফিক্সড * / + অপারেশনে অনুবাদ করা

কোড: সি (৮০ বাইট)

int f(char*V){return*(V-1)?f(V-2)*(*V==58?*(V-1)/29:1)+(*V&4)/4**(V-1)/29:*V/29;}

এই ফাংশনটি স্ট্রিং টেল থেকে এইভাবে ডাকা উচিত: চ (ভি + 10) যেখানে ভি = ""::::: .. :: ""

ইনপুট

দৈর্ঘ্য = 2n + 1 ভেক্টর ভি টাইপের চর '।' বা ':'

আউটপুট

একটি পূর্ণসংখ্যা কে

ক্রিয়া

কে = (ভি [1] অপ (ভি [3]) ভি [2]) অপ (ভি [5]) ভি [4] ....

op (x): (x = '।') -> +, (x = ':') -> *

সিমুলেশন:

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

— Abr001am
সূত্র

আপনি কীভাবে ধরে নিতে পারেন যে স্ট্রিংয়ের আগে বাইটটি *(V-1)শূন্য?

— নটকি

যখন আপনি একটি নতুন ভেক্টর বরাদ্দ, তার শুরুতে সবসময় খালি সেগমেন্ট থেকে শুরু তার শেষ এটা IS একটি খালি চরিত্র

— Abr001am

1

রেটিনা, 181 135 129 বাইট

প্রতিটি লাইন পৃথক ফাইলে থাকা উচিত। <empty>একটি খালি ফাইল উপস্থাপন করে। আউটপুটটি আনারিতে রয়েছে।

^\..*
$&1;
^:.*
$&11;
^.
<empty>
(`^\..*
$&1
^:.*
$&11
^.(.*?1+;1+)
$1
^(\..*);(1+)
$1$2;
;1$
;
^(:.*?)(1+).*
$1$2$2;
)`^.(.*?1+;)
$1
;
<empty>

যখন ${0}1ব্যবহার করা হয়, ধনুর্বন্ধনী আলাদা $0থেকে 1অন্যথায় এটি হবে, $01, 1 ম ম্যাচিং গ্রুপ। আমি ব্যবহার করার চেষ্টা করেছি $001, তবে এটি রেজেক্সের .NET স্বাদে কাজ করবে না বলে মনে হচ্ছে।

সম্পাদনা: পাওয়া গেছে যে $&একই $0।

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

মন্তব্য করেছে:

^\..*           # Push if .
$&1;
^:.*            # Push if :
$&11;
^.              # Pop op
<empty>


(`^\..*         # Loop, Push #
$&1
^:.*
$&11
^.(.*?1+;1+)    # Pop op
$1


^(\..*);(1+)    # Add if . (move ;)
$1$2;
;1$          # If mul by 1, remove
;
^(:.*?)(1+).*   # Mul if : (double)
$1$2$2;
)`^.(.*?1+;)    # Pop op, End Loop (clean up)
$1
;               # Remove semicolon
<empty>

— mbomb007
সূত্র

গল্ফ-ওয়াইজ আমি যে প্রধান জিনিসটি দেখছি সেটি হ'ল ধরণী / প্রতিস্থাপনের জোড়া (:)(.*)-> $1$2যা আমি নিশ্চিত (:.*)- -> $1(যেহেতু আপনি দুটি গ্রুপকে একই ক্রমে রাখছেন এবং তাদের সাথে আর কিছু করবেন না )।

— DLosc

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

— DLosc

পছন্দ করুন হ্যাঁ, আমি আসলে এটি ডাউনলোড করি নি। আমি প্রতিটি স্বতন্ত্র প্রতিস্থাপনের জন্য একটি অনলাইন রেইগেক্স প্রতিস্থাপন পরীক্ষক ব্যবহার করেছি।

— mbomb007

0

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

x=input()
l=[0,0]
for _ in x:
 t=len(l)-2<2
 l=[[[0,0,l[-2]*l[-1]],l+[2]][t],[[0,0,sum(l)],l+[1]][t]][_=='.']
print(l[-1])

Ungolfed:

x = input()
l = []
for i in x:
    if i == '.':
        if len(l) < 2: 
            l+=[1]        #True, True = 1,1
        else:
            l=[sum(l)]    #True, True = 1,0
    else:
        if len(l)<2:
            l+=[2]        #False, True = 0,1
        else:
            l=[l[0]*l[1]] #False, False = 0,0
print (l[0])

পাইথনে আপনি এই জাতীয় তালিকার সূচীটি উল্লেখ করেছেন:

list[index]

আপনি যে মধ্যে একটি বুলিয়ান মান লাগাতে পারেন Trueহয় 1এবং Falseহয় 0।

# t is True if the length is less than 2, else false.

l=[ 

  # |------- Runs if char is : -------|
  # |------- l<2 -------| |- l>=2 -|

    [ [ 0,0, l[-2]*l[-1] ], l+[2] ] [t],

                                      # |---- Runs if char is . ----| 
                                      # |--- l<2 ---|  |- l>=2 -|

                                        [ [0,0, sum(l)], l+[1] ] [t] ]
                                                                      [_=='.']

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

— টিম
সূত্র

0

পার্ল, 77 বাইট

@o=(0,'+','*');sub d{$_=shift;y/.:/12/;eval'('x s!\B(.)(.)!"$o[$2]$1)"!ge.$_}

সম্প্রসারিত:

@o=(0, '+', '*');
sub d{
    $_=shift;
    y/.:/12/;
    eval '(' x s!\B(.)(.)!"$o[$2]$1)"!ge.$_
}

@oঅ্যারে অপারেটরে ডিজিটের মানচিত্র তৈরী করে। তারপরে আমরা সংখ্যার অঙ্কগুলি যথাযথ অপারেটরের সাথে প্রতিস্থাপিত করে ইনফিক্সে পুনরায় অর্ডার করি। রেজিপেক্স দিয়ে শুরু হয় \Bতাই আমরা প্রথম অক্ষরের সাথে মেলে না। ফলাফলটি s///gআমাদের জানায় যে শুরুতে আমাদের কতগুলি মুক্ত প্যারেন দরকার। তারপরে, যখন আমরা পূর্ণ ইনফিক্স এক্সপ্রেশনটি একত্রিত করি, আমরা এটি মূল্যায়ন করতে পারি। ( evalআপনি যদি এর পরিবর্তে অভিব্যক্তিটি দেখতে চান তবে সরান )।

ফলাফল যাচাই করতে আমি পরীক্ষার জোতা ব্যবহার করেছি:

while(<>) {
    my ($a, $b) = m/(.*) (.*)/;
    print d($a), " $b\n";
}

ইনপুটটি হ'ল সংক্ষিপ্ত ভাব এবং তাদের মানগুলির তালিকা (প্রশ্নে সরবরাহ করা হয়) এবং আউটপুট {প্রকৃত, প্রত্যাশিত of এর জুড়ি}

— টবির গতি
সূত্র

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

সিজেএম, 27 24 23 22 বাইট

> <> (ফিশ) , 33 বাইট

হাস্কেল, 73 65 বাইট

সি, 104 বাইট

পাইথ, 25 24 বাইট

ব্যাখ্যা

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

পাইথ, 27 বাইট

রেটিনা , 105 75 73 বাইট

ব্যাখ্যা:

মরিচা, 170 টি অক্ষর

হাস্কেল, 88 81 79 বাইট

এপিএল (50)

রুবি - 96 অক্ষর

টিআই-বেসিক, 78 73 70 69 66 বাইট

যান, 129 115 112 বাইট

(কিছুটা) অবরুদ্ধ:

পাইথন 3, 74

কোড: সি (৮০ বাইট)

ইনপুট

আউটপুট

ক্রিয়া

সিমুলেশন:

রেটিনা, 181 135 129 বাইট

মন্তব্য করেছে:

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

পার্ল, 77 বাইট