Sadece karakterleri içeren bir tek uzunluk dizede götüren bir program yazın .ve :. Başlangıçta boş bir yığının yardımıyla, bu dizgiden aşağıdaki gibi bir sayı oluşturun:

Karakter dizisindeki her c karakteri için (soldan sağa doğru) ...

• C ise .ve yığında 2 öğeden daha az varsa , yığında 1 tuşuna basın.
• Eğer c olan .ve yığın 2 ya da daha fazla eleman vardır, yığın kapalı, iki üst değerleri pop ve yığına bunların toplamı itin.
• C ise :ve yığında 2 öğeden daha az varsa , yığında 2 tuşuna basın.
• Eğer c olan :ve yığın 2 ya da daha fazla eleman vardır, yığın kapalı, iki üst değerleri pop ve yığın üzerine kendi ürün itin.

Sonuçta ortaya çıkan sayı yığının en üstündeki değerdir. Programınız bu numarayı stdout'a yazdırmalıdır (isteğe bağlı izleyen bir yeni satır ile).

(Küçük bir analiz, dizenin uzunluğu daha uzun olmadığı sürece, sadece bir sayı kaldığını gösteriyor, bu yüzden bunları görmezden geliyoruz.

Örneğin ::...:.:., 9 sayısı :

  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

Akıl sağlığı kontrolü olarak, işte tüm uzunluk 1, 3 ve 5 dizelerinin sayıları:

. 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

Bayt cinsinden en kısa program kazanır. Tiebreaker daha önce yayınlandı.

• Girişin her zaman geçerli olduğunu, yani yalnızca içeren .ve :uzunluğu tuhaf bir dize olduğunu varsayabilirsiniz .
• Bir program yazmak yerine, geçerli bir dize alan ve oluşturulan sayıyı basan veya döndüren bir işlev yazabilirsiniz.

CJam, 27 24 23 22 bayt

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

Oldukça yalındır. CJam'ın yığınını soruda belirtilen yığın olarak kullanıyorum;)

Algoritma

İlk için ASCII kodu bakmak sağlar .ve :.

'.i ':ied

[46 58]

CJam'da indeks etrafından dolandığından, istenen değerleri elde etmek için bu değerleri doğrudan kullanıp kullanamayacağımızı görelim.

'.i4% ':i4%ed

[2 2]

Bu yüzden ASCII kodlarını 4 uzunluklu bir işlem dizisinde kullanamıyorum. Diğer bazı değerleri deneyelim

'.i 10% ':i 10%ed

[6 8]

4 uzunluğundaki bir ipte

[2 0]

Bu mod 10 işlemini kullanabilirim ama bu 2 bayt olacak. Başka bir şey deneyelim

'.i5% ':i5%ed

[1 3]

Güzel !, şimdi dizinleri almak 0, 1, 2 and 3ve bir anahtarlık olarak bir 5uzunluk dizisi ( "1+2* ") kullanmak için yığın büyüklüğü koşulu için 1'i çıkardık . Son boşluk, uzunluğu 5 yapmak için sadece bir dolgu maddesidir. Bu, modlama işlemine kıyasla sadece 1 ekstra bayttır.

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

Burada çevrimiçi deneyin

Cosechy sayesinde 1 bayt kurtarıldı

> <> (Balık) , 33 bayt

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

Küçük hileler / optimizasyonlar ile oldukça basit.

Açıklama:

• Bilgi: i= girişin -1sonuna gelindiğinde sonraki giriş karakterinin kod noktası ; a= 10; b= 11; )=>
• iilk girdi karakterinin kod noktası,
• b%1- top_of_stack mod 11 - 1maskeler 48 ('.') , 56 (':')için1 , 2
• i:1+?\~n; Giriş sonuna ulaşıldığında, son sonucu yazdırın ve sonlandırın
• aksi takdirde:
• b%1- maske girişi 1 , 2
• 0@0iki sayının altına bas
• i5a*)Bir sonraki girişi okuyun ve 0 , 1karşılaştırarak maskeleyin .50
• if 1( ':') yığını oluşturan iki elemanı toplar [0 ürün]
• her zaman en iki eleman oluşturma yığın ekleme ya [0 sum]veya[0+product=product]
• 40.(döngü) konumuna geri dönmek (4,0), amacımız 4,i:1+?\~n;

Haskell, 73 65 bayt

Yığının hiçbir zaman 2'den fazla eleman içermemesi olgusunu kullanan basit bir çözüm.

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

C, 104 bayt

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

Bu çok uzun.

Pyth, 25 24 bayt

eu?]?.xGHsGtG+GhHmqd\:zY

@ İsaacg'ın çözümünü inceleyerek bir fikrim var. Ama ben bir yığın kullanıyorum.

Çevrimiçi Gösteri veya Test Paketi

açıklama

Yaptığım ilk şey, giriş dizesini 0 ve 1 s'ye dönüştürmek. Bir "."bir dönüştürülmüş olur 0, bir ":"bir içine 1.

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

Sonra bu sayıların listesini azaltırım:

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

JavaScript (ES6), 65

Yığımızın sadece 2 hücresini kullanıyoruz.

S [0] içine bir değer koymaya başlayın.
Ardından, giriş dizesindeki her tek pozisyona (0'dan sayma), s [1] içine bir değer koyun.
Her eşit konumda, bir calc uygulayın (ekleyin veya çarpın) ve sonucu s [0] cinsinden kaydedin.

Yani yığını unut ve sadece 2 değişken kullan, a ve b.

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

Hızlı bir test

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

Çıktı

"." 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

Pyth, 27 bayt

Jmhqd\:zu?*GhHteH+GhHctJ2hJ

Bir yığın? Kim bir deste ihtiyacı var.

                       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.

Gösteri.

Retina , 105 75 73 bayt

İlk Retina programım! (Martin Büttner'e 2 bayt kaydettiği için teşekkürler, dilin ilk icat edilmesinden bahsetmiyor.)

Her satır ayrı bir dosyaya gitmelidir; veya hepsini bir dosyaya koyabilir ve -sbayrağını kullanabilirsiniz . <empty>Notasyonu boş bir dosya / hattını temsil eder.

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

Mbomb007'nin cevabından ilham aldım , fakat biraz farklı bir yaklaşım benim. En büyük fark, yığını dotty dizesinin önüne (yığının üstü sağa bakacak şekilde) oluşturmam. Bu, sembolleri yerinde bulunan sayılara dönüştürmeyi kolaylaştırır. Ayrıca , bunun gibi sekanslarda belirsizliği engellemek için sadece sonunda değiştirerek ayerine kullanıyorum . Gibi bir cevap unary sayı olarak kabul edilebilir ise, son iki satır / dosya 4 bayt tasarruf için elimine edilebilir.1$1aaaaaaa

Açıklama:

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

Yığında ( (a+;)?) 0 veya 1 öğe varsa, ardından bir nokta ( \.); öyleyse, periyodun yerine geçer a;(yani, 1 iter).

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

Yığında 0 veya 1 öğe varsa ve ardından iki nokta üst üste bindiğinde eşleşir. Eğer öyleyse, kolonu ile değiştirir aa;(yani 2'ye basar).

;(a+;)\.
$1

Yığında iki öğe varsa ve ardından bir nokta varsa eşleşir. Öğeler arasındaki süreyi ve noktalı virgül siler, böylece bunları ekler.

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

Yığında, üstünde 2 olan ve ardından iki nokta üst üste iki öğe varsa eşleşir. Kolonu ve 2'yi siler ve diğer sayıyı iki kez tekrar eder, böylece 2 ile çarpılır.

)`;a;:
;

Düzenli düzenleme, yığında iki tanesi varsa üst kısmı 1 olan ve ardından iki nokta üst üste bindiğinde eşleşir. Kolonu ve 1'i siler, diğer sayıyı değiştirmeden bırakır (yani 1 ile çarpılır).

)`bir döngünün sonunu gösterir. Dizide herhangi bir değişiklik yapıldıysa, kontrol programın en üstüne geri döner ve yerine geçenleri tekrar çalıştırır. İpin değiştirilmesi durduysa, tüm periyotları ve kolonları değiştirdik ve geriye kalan tek şey temizleme ...

;
<empty>

Artık noktalı virgül siler.

a
1

Tüm a'ları 1'e dönüştürür. Yine, eğer tek sayıların herhangi bir sembolü kullanmasına izin verilirse, bu adım gerekli değildir.

Pas, 170 karakter

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}

Rust'un golf oynamakta kesinlikle korkunç olduğuna dair daha fazla kanıt. Tam kodlanmamış kod:

#[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}

İşte bunda kullandığım ilginç bir numara. Bir karakteri bir if / else ifadesinde hemen atılan bir değeri döndürerek tıraş edebilirsiniz, yani iki yerine yalnızca bir noktalı virgül gerekir.

Örneğin,

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

içine değiştirilebilir

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

bir noktalı virgül tıraş ederek bir karakter kaydeder.

Haskell, 88 81 79 Bayt

(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

Görünüşe göre birisi beni Haskell çözümü üzerine attı, sadece çözümü değil, çözümleri benimkinden daha kısa. Bu kötü ama geldiğim şeyi göndermemek için bir neden görmüyorum.

APL (50)

Burada büyük bir dezavantajım var çünkü APL yığın tabanlı bir dil değil. Sonunda programı kısaltmak için suistimali yaptım.

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

İç işlev solda bir 'komut' alır ve sağda bir yığın alır ve yığını geri döndürür. Dış işlev, boş bir yığından başlayarak dizgiyi küçültür.

Açıklama:

• (⌽⍵),⊂⍬: azaltılacak ilk liste. ⊂⍬yığını temsil eden kutulu bir boş liste (⌽⍵)girişin tam tersidir. (Küçültme listeye sağdan sola uygulanır, bu nedenle dize sağdan sola işlenir. Girişi önceden ters çevirmek, karakterleri doğru sıraya göre uygular.)

• {... }: iç işlev. Yığını sağa, sola doğru bir karakter alır ve değiştirilen yığını döndürür.

  • F←'.:'⍳⍺: Dizedeki karakterin indeksi .:, bu değere bağlı olarak 1 veya 2 olacaktır.
  • 2>⍴⍵:F,⍵: 2, geçerli yığın boyutundan büyükse, geçerli değeri yığına eklemeniz yeterlidir.
  • ⋄: aksi takdirde,
    • 2↓⍵: en üstteki iki öğeyi yığından kaldır
    • (... )/2↑⍵: belirli bir işlevi üzerlerinde azaltın ve yığına ekleyin.
    • ⍎F⌷'+×': işlev, +(toplama) veya ×(çarpma), tarafından seçilir F.

• ⊃: Sonunda, yığındaki en üstteki öğeyi döndür

Ruby - 96 karakter

Buradaki sorta ilginç parçası eval.

Bunun dışında, ilk karakterden sonra, yığının her zaman 2, matematik, 2, matematiğe gideceği varsayımını yapıyorum. karakterin matematik veya sayı olup olmadığını Konumsal.

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`

TI-BASIC, 78 73 70 69 66 bayt

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 tek gömleklerde iyidir, çünkü parantezleri kapatmak isteğe bağlıdır; tersine, bir değişkene kaydetme iki ila dört bayt alan gerektirdiğinden, birden çok değerin kaydedilmesinin gerekli olduğu zayıf bir dildir. Dolayısıyla amaç, her satıra olabildiğince çok yazmaktır. TI-BASIC ayrıca herhangi bir dize manipülasyonunda korkunç bir dildir (tokenize edilmiş bir dil için); bir alt dize okumak bile uzundur.

Püf noktaları şunlardır:

• int(e^([boolean]yerine 1+(boolean; bir bayt kaydeder
• Liste dilimleme yerine bir listenin kısmi toplamı (listeye kaydetmeyi gerektirir): 3 bayt kaydeder

Gitmek, 129 115 112 bayt

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

(biraz) ungolfed:

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

Burada çevrimiçi deneyin: http://play.golang.org/p/B3GZonaG-y

Python 3, 74

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

İlk olarak giriş listesini, ilk değeri başlangıç ​​değeri olarak alarak 1'ler ve 2'ler dizisine dönüştürür x. Ardından, bir anda iki elementi sçıkarır, ilk sayıyı alır ve ikincisinin 1 mi yoksa 2 mi olduğuna bağlı olarak mevcut sayı ile ekleyerek veya çarparak.

iyi bu çok kolay operasyon, op tarafından kasıtlı (kasıtlı)

sadece ...

Parantez içi ifade, postfixed * / + işlemine çevrildi

Kod: C (80 bayt)

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

• bu fonksiyon dizge kuyruğundan şöyle çağrılmalıdır: f (V + 10) V = ".: ..:.: .. ::"

giriş

uzunluk = 2n + 1 vektör char 'türü' veya ':'

Çıktı

bir tamsayı k

fonksiyon

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

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

Simülasyon:

burada dene

Retina, 181 135 129 bayt

Her satır ayrı bir dosyada olmalıdır. <empty>boş bir dosyayı temsil eder. Çıkış Unary'de.

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

Ne zaman ${0}1kullanılır, parantez ayrı $0dan 1aksi takdirde olurdu $01, 1 eşleştirme grubu. Kullanmayı denedim $001, ancak bu regex'in .NET lezzetinde çalışmıyor gibi görünüyor.

Düzenleme: $&Aynı olduğu bulundu $0.

Sahte kodda bu, aşağıda görüldüğü gibi, esasen bir do-while döngüsü olacaktır. İlk sayıya bastım, sonra döngü: ikinci sayıyı it, işlemi kaldır (komutu), matematiği kaldır, işlemi kaldır. Dönmeye devam et. Bir işlem başlatıldığında, tüm talimatlar tamamlandıktan sonra bunun da boşa çıkacağını unutmayın.

Yorumlananlar:

^\..*           # 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>

Python 3, 122 bayt

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])

Python'da şöyle bir listenin dizinine başvurursunuz:

list[index]

Buna bir boole değeri koyabilirsiniz, Trueis 1ve Falseis 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] ]
                                                                      [_=='.']

Burada çevrimiçi deneyin

Perl, 77 bayt

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

genişletilmiş:

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

@oDizi operatörlerine basamak alır. Sonra, rakamları çiftleri uygun operatörle değiştiririz, yeniden yerleştirmek için yeniden düzenleriz. Regexp ile başlar, \Bböylece ilk karakterle eşleşmeyiz. Sonuçta s///g, başlangıçta kaç tane açık parele ihtiyacımız olduğunu söyler. Sonra, tam akış ifadesini topladığımızda, onu değerlendirebiliriz. ( evalBunun yerine ifadeyi görmek istiyorsanız kaldırın ).

İşte sonuçları doğrulamak için kullandığım test kablo demeti:

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

Girdi, nokta ifadelerinin listesi ve değerleri (soruda sağlanmıştır) ve çıktı {gerçek, beklenen} çiftleridir.