25

एक ऐसा प्रोग्राम लिखिए जिसमें विषम लंबाई की स्ट्रिंग हो जिसमें केवल अक्षर हों .और :। प्रारंभ में खाली स्टैक की सहायता से , इस स्ट्रिंग से एक संख्या उत्पन्न करें:

स्ट्रिंग में प्रत्येक वर्ण c के लिए (बाएं से दाएं जा रहा है) ...

यदि c है .और स्टैक में 2 से कम तत्व हैं, तो स्टैक पर 1 पुश करें।
यदि सी है .और स्टैक में 2 या अधिक तत्व हैं, तो स्टैक से दो शीर्ष मानों को पॉप करें और स्टैक पर अपनी राशि को धक्का दें।
यदि c है :और स्टैक में 2 से कम तत्व हैं, तो स्टैक पर 2 पुश करें।
यदि c है :और स्टैक में 2 या अधिक तत्व हैं, तो स्टैक से दो शीर्ष मानों को पॉप करें और स्टैक पर उनके उत्पाद को धक्का दें।

परिणामी संख्या स्टैक के शीर्ष पर मान है। आपका प्रोग्राम इस नंबर को स्टडआउट (एक वैकल्पिक अनुगामी न्यूलाइन के साथ) प्रिंट करना चाहिए।

(थोड़ा विश्लेषण से पता चलता है कि केवल एक ही संख्या शेष है जब तक कि स्ट्रिंग की लंबाई भी नहीं है, यही वजह है कि हम उन लोगों को अनदेखा कर रहे हैं। वास्तव में, स्टैक में कभी भी 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

CJam, 27 24 23 22 बाइट्स

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

बहुत सीधा। मैं सीजेएम के स्टैक का उपयोग करता हूं क्योंकि प्रश्न में वर्णित स्टैक;)

कलन विधि

पहले के लिए .और ASCII कोड को देखने देता है :।

'.i ':ied

[४६ ५ []

चूंकि CJam में, इंडेक्स चारों ओर घूमता है, हम देखते हैं कि क्या हम वांछित ऑपरेशन को प्राप्त करने के लिए सीधे इन मानों का उपयोग कर सकते हैं।

'.i4% ':i4%ed

[२ २]

तो मैं बस एक 4 लंबाई ऑपरेशन स्ट्रिंग में ASCII कोड का उपयोग नहीं कर सकता। कुछ अन्य मूल्यों की कोशिश करें

'.i 10% ':i 10%ed

[६ 8]

जो 4 लंबाई की स्ट्रिंग पर उबलता है

[२ ०]

मैं इस मॉड 10 ऑपरेशन का उपयोग कर सकता हूं लेकिन इसकी लागत 2 बाइट होगी। कुछ और करने की कोशिश करें

'.i5% ':i5%ed

[१ ३]

अच्छा !, अब हम अनुक्रमणिका प्राप्त करने के लिए स्टैक आकार स्थिति के लिए 1 को घटाते हैं 0, 1, 2 and 3और एक स्विच केस के रूप में एक 5लंबाई सरणी ( "1+2* ") का उपयोग करते हैं । अंतिम स्थान लंबाई भरने के लिए सिर्फ एक भराव है। यह मोडिंग ऑपरेशन की तुलना में सिर्फ 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 बाइट ने cosechy के लिए धन्यवाद बचाया

— अनुकूलक
स्रोत

1

ऑपरेशन की स्ट्रिंग के लिए जगह क्या है?

— पीटर टेलर

@PeterTaylor ने पोस्ट में बताया।

— ऑप्टिमाइज़र

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 के समाधान का अध्ययन करके एक विचार प्राप्त किया। लेकिन मैं एक ढेर का उपयोग कर रहा हूं।

ऑनलाइन प्रदर्शन या टेस्ट सूट

व्याख्या

पहली बात यह है कि इनपुट स्ट्रिंग को 0s और 1s में बदलना है। A , a, a, "."में परिवर्तित हो जाता है ।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

जावास्क्रिप्ट (ईएस 6), 65

हम केवल अपने ढेर की 2 कोशिकाओं का उपयोग करते हैं।

मूल्य रखना शुरू करें [0]।
फिर, इनपुट स्ट्रिंग में प्रत्येक विषम स्थिति (0 से गिनती) पर, s [1] में मान डालें।
प्रत्येक भी स्थिति में, एक कैल्क (जोड़ें या गुणा करें) और s [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 जो काम नहीं करता है। for (i s में) अतिरिक्त गुण देता है इसके अलावा अनुक्रमित

— edc65

यह मेरे लिए फ़ायरफ़ॉक्स 37.0.2 में काम कर रहा है। एक साफ ब्राउज़र टैब में इसे चलाने का प्रयास करें। ऐसा लगता है कि स्टैकएक्सचेंज अतिरिक्त गुणों को स्ट्रिंग्स में जोड़ता है (stub.en.js में)

— 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 बाइट्स

मेरा पहला रेटिना कार्यक्रम! (2 बाइट्स बचाने के लिए मार्टिन ब्यूटनर को धन्यवाद, पहली बार में भाषा का आविष्कार करने का उल्लेख नहीं करना।)

प्रत्येक पंक्ति को एक अलग फ़ाइल में जाना चाहिए; या, आप उन सभी को एक फ़ाइल में रख सकते हैं और -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 या 1 आइटम हैं ( (a+;)?) एक अवधि के बाद ( \.); यदि ऐसा है, तो यह अवधि को बदल देता है a;(यानी एक धक्का देता है)।

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

मिलान होता है यदि स्टैक पर 0 या 1 आइटम हैं, जिसके बाद एक कोलन होता है। यदि हां, तो यह बृहदान्त्र को बदल देता है aa;(यानी एक 2 को धक्का देता है)।

;(a+;)\.
$1

मेल खाता है अगर एक अवधि के बाद स्टैक पर दो आइटम हैं। आइटम के बीच की अवधि और अर्धविराम को हटाता है, जिससे उन्हें जोड़ा जाता है।

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

मेल खाता है यदि स्टैक पर दो आइटम हैं, जिनमें से शीर्ष 2 है, इसके बाद एक कोलन है। बृहदान्त्र और 2 को हटाता है और दूसरी संख्या को दो बार दोहराता है, जिससे इसे 2 से गुणा किया जाता है।

)`;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)
};

जो एक अर्धविराम को काटकर एक चरित्र बचाता है।

— Doorknob
स्रोत

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

ऐसा लगता है कि किसी ने हास्केल समाधान के निशान पर मुझे हराया, इतना ही नहीं, उनका समाधान खदान से छोटा है। यह बुरा है लेकिन, मुझे लगता है कि मैं जो भी लेकर आया हूं उसे पोस्ट करने का कोई कारण नहीं है।

— आंख-morpork
स्रोत

2

एपीएल (50)

मैं यहां बहुत नुकसान में हूं, क्योंकि एपीएल स्टैक-आधारित भाषा नहीं है। मैं अंत में कार्यक्रम को छोटा करने के लिए दुरुपयोग को कम करने के लिए मिला, हालांकि।

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

आंतरिक फ़ंक्शन बाईं ओर एक 'कमांड' लेता है और दाईं ओर एक स्टैक होता है, और इसे लागू करता है, स्टैक वापस करता है। बाहरी फ़ंक्शन इसे स्ट्रिंग के ऊपर कम कर देता है, एक खाली स्टैक के साथ शुरू होता है।

स्पष्टीकरण:

(⌽⍵),⊂⍬: कम करने के लिए प्रारंभिक सूची। ⊂⍬एक बॉक्सिंग खाली सूची है, जो स्टैक का प्रतिनिधित्व करता है, (⌽⍵)इनपुट का उल्टा है। (रिडक्शन को सूची में दाएं-से-बाएं लागू किया जाता है, इसलिए स्ट्रिंग को दाएं-बाएं संसाधित किया जाएगा। पहले से इनपुट को उल्टा करने से यह सही क्रम में वर्णों को लागू करता है।)
{... }: आंतरिक कार्य। यह दाईं ओर स्टैक लेता है, बाईं ओर एक चरित्र, और संशोधित स्टैक लौटाता है।
- 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

टीआई-बेसिक एक-लाइनर्स में अच्छा है, क्योंकि कोष्ठक बंद करना वैकल्पिक है; इसके विपरीत, यह एक खराब भाषा है जहां कई मूल्यों को संग्रहीत करना आवश्यक है क्योंकि एक चर के लिए भंडारण करने पर दो से चार बाइट्स लगते हैं। इसलिए, लक्ष्य प्रत्येक पंक्ति में यथासंभव अधिक लिखना है। TI-BASIC भी किसी भी प्रकार के स्ट्रिंग हेरफेर पर (एक टोकन भाषा के लिए) भयानक है; यहां तक कि एक विकल्प पढ़ना लंबा है।

ट्रिक्स में शामिल हैं:

int(e^([boolean]के बजाय 1+(boolean; एक बाइट बचाता है
सूची स्लाइसिंग के बजाय किसी सूची का आंशिक योग (जिसे सूची में संग्रहीत करने की आवश्यकता होगी): 3 बाइट्स बचाता है

— lirtosiast
स्रोत

आपको Ans से इनपुट लेने के साथ ठीक होना चाहिए, जैसे ".:.":prgmDOTTY, 4 बाइट्स की बचत।

— एमआई राइट

@ सही मैं स्टैक पर नंबर स्टोर करने के लिए Ans का उपयोग करता हूं।

— lirtosiast

मेरा शुरू में मतलब था- लाइन 1 से छुटकारा पाएं, और दूसरी लाइन को बदल दें1+(":"=sub(Ans,1,1

— MI राइट

1

मुझे लूप में Str1 का उपयोग करने की आवश्यकता है, जहां Ans लिया जाता है, इसलिए मैं Ans में स्ट्रिंग रखने के साथ दूर नहीं जा सकता। इसे Ans1 से Str1 पर संग्रहीत करने से कोई स्थान नहीं बचेगा।

— 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 के आधार पर वर्तमान संख्या के साथ गुणा कर रहा है।

— XNOR
स्रोत

1

अच्छी तरह से यह इतना आसान ऑपरेशन है, ऑप द्वारा परिष्कृत (जानबूझकर)

यह सिर्फ ...

कोष्ठक अभिव्यक्ति का अनुवाद उपसर्ग * / + ऑपरेशन में किया गया

कोड: C (80 बाइट्स)

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) जहां वी = "।: ..:::: ::।"

इनपुट

लंबाई = 2 एन + 1 वेक्टर वी टाइप चार। ' या ':'

उत्पादन

एक पूर्णांक कश्मीर

समारोह

k = (V [1] op (V [3]) V [2]) op (V [5]) V [4] ...।

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

सिमुलेशन:

इसे यहाँ आज़माएँ

— Abr001am
स्रोत

आप यह कैसे मान सकते हैं कि स्ट्रिंग ( *(V-1)) से पहले बाइट शून्य है?

— नटकी

जब आप एक नया वेक्टर आवंटन, इसकी शुरुआत हमेशा की तरह, खाली खंड से शुरू होता है उसके अंत में यह है एक खाली चरित्र

— Abr001am

1

रेटिना, 181 135 129 बाइट्स

प्रत्येक पंक्ति एक अलग फ़ाइल में होनी चाहिए। <empty>एक खाली फ़ाइल का प्रतिनिधित्व करता है। उत्पादन Unary में है।

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

जब ${0}1उपयोग किया जाता है, तो ब्रेसिज़ से अलग $0होता है 1, अन्यथा यह $011 मिलान समूह होगा। मैंने प्रयोग करने की कोशिश की $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सरणी ऑपरेटरों को अंक मैप करता है। फिर हम उपयुक्त ऑपरेटर के साथ अंकों के युग्मों को प्रतिस्थापित करते हैं, जो कि infix के लिए पुन: क्रमबद्ध हैं। Regexp के साथ शुरू होता है \Bइसलिए हम बहुत पहले चरित्र से मेल नहीं खाते। परिणाम s///gहमें बताता है कि शुरुआत में हमें कितने खुले पार्न की आवश्यकता है। फिर, जब हमने पूर्ण infix अभिव्यक्ति इकट्ठी की है, तो हम इसका मूल्यांकन कर सकते हैं। (निकालें evalयदि आप इसके बजाय अभिव्यक्ति देखना चाहते हैं)।

परिणामों का सत्यापन करने के लिए मैंने परीक्षण का उपयोग किया है:

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

इनपुट बिंदी के भावों और उनके मूल्यों (प्रश्न में प्रदान की गई) की सूची है और आउटपुट {वास्तविक, अपेक्षित} के जोड़े हैं।

— टोबी स्पाईट
स्रोत

वोटिंग स्ट्रिंग्स का मूल्यांकन

CJam, 27 24 23 22 बाइट्स

> <> (मछली) , 33 बाइट्स

हास्केल, 73 65 बाइट्स

सी, 104 बाइट्स

पायथ, 25 24 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 65

पायथ, 27 बाइट्स

रेटिना , 105 75 73 बाइट्स

स्पष्टीकरण:

जंग, 170 वर्ण

हास्केल, 88 81 79 बाइट्स

एपीएल (50)

रूबी - 96 वर्ण

टीआई-बेसिक, 78 73 70 69 66 बाइट्स

चले जाओ, 129 115 112 बाइट्स

(कुछ हद तक)

पायथन 3, 74

कोड: C (80 बाइट्स)

इनपुट

उत्पादन

समारोह

सिमुलेशन:

रेटिना, 181 135 129 बाइट्स

टिप्पणी की:

पायथन 3, 122 बाइट्स

पर्ल, 77 बाइट्स