Escreva um programa que tenha uma sequência de comprimento ímpar contendo apenas os caracteres .e :. Com o auxílio de uma pilha inicialmente vazia , gere um número a partir desta sequência da seguinte maneira:

Para cada caractere c na string (da esquerda para a direita) ...

• Se c for .e a pilha tiver menos de 2 elementos, pressione 1 na pilha.
• Se c for .e a pilha tiver 2 ou mais elementos, retire os dois principais valores da pilha e empurre sua soma para a pilha.
• Se c for :e a pilha tiver menos de 2 elementos, pressione 2 na pilha.
• Se c for :e a pilha tiver 2 ou mais elementos, retire os dois principais valores da pilha e empurre o produto para a pilha.

O número resultante é o valor no topo da pilha. Seu programa deve imprimir esse número em stdout (com uma nova linha à direita opcional).

(Uma pequena análise mostra que resta apenas um número, a menos que a string tenha um comprimento uniforme, e é por isso que estamos ignorando-os. Na verdade, a pilha nunca possui mais de 2 elementos.)

Por exemplo, o número para ::...:.:.é 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

Como verificação de integridade, eis os números para todas as cadeias de comprimento 1, 3 e 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

O programa mais curto em bytes vence. O desempatador é um post anterior.

• Você pode assumir que a entrada é sempre válida, ou seja, uma string contendo apenas .e :cujo comprimento é ímpar.
• Em vez de escrever um programa, você pode escrever uma função que recebe uma sequência válida e imprime ou retorna o número gerado.

CJam, 27 24 23 22 bytes

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

Bem direto. Eu uso a pilha de CJam como a pilha mencionada na pergunta;)

Algoritmo

Primeiro vamos olhar o código ASCII para .e :.

'.i ':ied

[46 58]

Como no CJam, o índice envolve, vamos ver se podemos usar esses valores diretamente para obter a operação desejada.

'.i4% ':i4%ed

[2 2]

Portanto, não posso simplesmente usar os códigos ASCII em uma sequência de operações de 4 comprimentos. Vamos tentar alguns outros valores

'.i 10% ':i 10%ed

[6 8]

que em uma corda de 4 comprimentos se resume a

[2 0]

Eu posso usar esta operação mod 10, mas isso custará 2 bytes. Vamos tentar outra coisa

'.i5% ':i5%ed

[1 3]

Bom !, agora subtraímos 1 para a condição de tamanho da pilha para obter os índices 0, 1, 2 and 3e usar uma 5matriz de comprimento ( "1+2* ") como uma caixa de opção. O último espaço é apenas um preenchedor para o comprimento 5. Este é apenas 1 byte extra em comparação com a operação de modificação.

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

Experimente online aqui

1 byte salvo graças a cosechy

> <> (Peixe) , 33 bytes

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

Bastante simples, com pequenos truques / otimizações.

Explicação:

• Info: i= ponto de código do próximo caractere de entrada, -1se o final da entrada for atingido; a= 10; b= 11; )=>
• icodepoint do primeiro caractere de entrada,
• b%1- top_of_stack mod 11 - 1máscaras 48 ('.') , 56 (':')para1 , 2
• i:1+?\~n; se o fim da entrada alcançado imprimir o último resultado e terminar
• de outra forma:
• b%1- mascarar a entrada para 1 , 2
• 0@empurre 0sob o número dois
• i5a*)leia a próxima entrada e oculte-a para 0 , 1comparar com50
• if 1( ':') multiplique os dois principais elementos, criando a pilha [0 produto]
• sempre adicione os dois principais elementos, criando a pilha [0 sum]ou[0+product=product]
• 40.pule (loop) de volta à posição (4,0), nosso ponto 4,i:1+?\~n;

Haskell, 73 65 bytes

Uma solução simples, usando o fato de que a pilha nunca possui mais de 2 elementos.

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

C, 104 bytes

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

Bem, isso é muito longo.

Pitão, 25 24 bytes

eu?]?.xGHsGtG+GhHmqd\:zY

Tive uma idéia estudando a solução de @ isaacg. Mas estou usando uma pilha.

Demonstração on-line ou suíte de testes

Explicação

A primeira coisa que faço é converter a string de entrada em 0s e 1s. A "."é convertido em a 0, a ":"em a 1.

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

Então reduzo esta lista de números:

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

Nós usamos apenas 2 células da nossa pilha.

Comece colocando um valor em s [0].
Então, em cada posição ímpar (contando de 0) na string de entrada, coloque um valor em s [1].
Em cada posição par, execute um cálculo (adicione ou multiplique) e armazene o resultado em s [0].

Então esqueça a pilha e use apenas 2 variáveis, a e b.

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

Um teste rápido

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

Saída

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

Pitão, 27 bytes

Jmhqd\:zu?*GhHteH+GhHctJ2hJ

Uma pilha? Quem precisa de uma pilha.

                       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.

Demonstração.

Retina , 105 75 73 bytes

Meu primeiro programa de Retina! (Agradecemos a Martin Büttner por salvar 2 bytes, sem mencionar a invenção do idioma em primeiro lugar.)

Cada linha deve ir em um arquivo separado; ou, você pode colocá-los todos em um arquivo e usar o -ssinalizador. A <empty>notação representa um arquivo / linha vazio.

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

Inspirado pela resposta de mbomb007 , mas adoto uma abordagem um pouco diferente. Uma grande diferença é que eu construo a pilha na frente da string pontilhada (com o topo da pilha voltado para a direita). Isso facilita a conversão de símbolos para os números correspondentes no local. Eu também uso, em avez de 1, trocá-lo apenas no final, para evitar a análise de ambiguidade em sequências como $1a. Se uma resposta como aaaaaafor aceitável como um número unário, as duas últimas linhas / arquivos poderão ser eliminadas para economizar 4 bytes.

Explicação:

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

Corresponde se houver 0 ou 1 item na pilha ( (a+;)?) seguido por um ponto ( \.); Nesse caso, substitui o período por a;(ou seja, pressiona 1).

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

Corresponde se houver 0 ou 1 item na pilha seguido por dois pontos. Nesse caso, ele substitui o cólon por aa;(ou seja, pressiona 2).

;(a+;)\.
$1

Corresponde se houver dois itens na pilha seguidos por um ponto. Exclui o período e o ponto e vírgula entre os itens, adicionando-os.

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

Corresponde se houver dois itens na pilha, cujo topo é um 2, seguido por dois pontos. Exclui os dois pontos e o 2 e repete o outro número duas vezes, multiplicando-o por 2.

)`;a;:
;

A regex corresponde se houver dois itens na pilha, cuja parte superior é 1, seguida por dois pontos. Exclui os dois pontos e o 1, deixando o outro número inalterado (ou seja, multiplicado por 1).

)`indica o fim de um loop. Se alguma alteração foi feita na cadeia, o controle retornará para a parte superior do programa e executará as substituições novamente. Se a string parou de mudar, substituímos todos os pontos e dois pontos e tudo o que resta é a limpeza ...

;
<empty>

Exclui o ponto e vírgula restante.

a
1

Transforma todos os a em 1. Novamente, se números unários puderem usar qualquer símbolo, esta etapa será desnecessária.

Ferrugem, 170 caracteres

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}

Mais uma prova de que Rust é absolutamente terrível no golfe. Código completo não-destruído:

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

Aqui está um truque interessante que usei neste. Você pode raspar um caractere em uma instrução if / else fazendo com que ele retorne um valor que é imediatamente descartado, o que significa que você precisa apenas de um ponto e vírgula em vez de dois.

Por exemplo,

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

pode ser transformado em

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

que salva um personagem cortando um ponto e vírgula.

Haskell, 88 81 79 Bytes

(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

Parece que alguém me levou até o ponto em uma solução Haskell, não apenas isso, a solução deles é mais curta que a minha. Isso é ruim, mas não vejo razão para não postar o que eu criei.

APL (50)

Estou em grande desvantagem aqui, porque o APL não é uma linguagem baseada em pilha. Finalmente, acabei abusando da redução para encurtar o programa.

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

A função interna pega um 'comando' à esquerda e uma pilha à direita e a aplica, retornando a pilha. A função externa reduz a string, começando com uma pilha vazia.

Explicação:

• (⌽⍵),⊂⍬: a lista inicial para reduzir o excesso. ⊂⍬é uma lista vazia em caixa, que representa a pilha, (⌽⍵)é o inverso da entrada. (A redução é aplicada da direita para a esquerda na lista, para que a sequência seja processada da direita para a esquerda. A reversão da entrada antecipadamente faz com que os caracteres sejam aplicados na ordem correta.)

• {... }: a função interna. Ele pega a pilha à direita, um caractere à esquerda e retorna a pilha modificada.

  • F←'.:'⍳⍺: o índice do caractere na string .:, este será 1 ou 2, dependendo do valor.
  • 2>⍴⍵:F,⍵: Se 2 for maior que o tamanho atual da pilha, basta acrescentar o valor atual à pilha.
  • ⋄: de outra forma,
    • 2↓⍵: remova os dois principais itens da pilha
    • (... )/2↑⍵: reduza uma determinada função sobre eles e adicione-a à pilha.
    • ⍎F⌷'+×': a função é +(adição) ou ×(multiplicação), selecionada por F.

• ⊃: finalmente, retorne o item mais alto da pilha

Ruby - 96 caracteres

A parte interessante aqui é eval.

Além disso, estou assumindo que, após o primeiro caractere, a pilha sempre será 2, matemática, 2, matemática, .... Isso me permite usar menos código pegando dois caracteres ao mesmo tempo - nunca preciso descobrir descobrir se um caractere é matemática ou número. É posicional.

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 bytes

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

O TI-BASIC é bom em one-liners, porque os parênteses de fechamento são opcionais; por outro lado, é uma linguagem ruim em que o armazenamento de vários valores é necessário porque o armazenamento em uma variável ocupa de dois a quatro bytes de espaço. Portanto, o objetivo é escrever o máximo possível em cada linha. O TI-BASIC também é péssimo (para uma linguagem tokenizada) na manipulação de cadeias de qualquer tipo; até ler uma substring é demorado.

Os truques incluem:

• int(e^([boolean]em vez de 1+(boolean; salva um byte
• Soma parcial de uma lista em vez de fatiar (o que exigiria armazenamento em uma lista): economiza 3 bytes

Vai, 129 115 112 bytes

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

(um pouco) não destruído:

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

Experimente online aqui: 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)

Primeiro transforma a lista de entrada em uma sequência de 1 e 2, assumindo o primeiro valor como valor inicial x. Em seguida, retira dois elementos de cada vez da frente s, pegando o primeiro número e adicionando ou multiplicando o número atual com base no fato de o segundo ser 1 ou 2.

bem, essa é uma operação tão fácil, sofisticada pela operação (intencionalmente)

é apenas ...

expressão entre parênteses traduzida para a operação * / + pós-fixada

Código: C (80 bytes)

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

• esta função deve ser chamada a partir da cauda da string assim: f (V + 10) em que V = ".: ..:.: .. ::"

entrada

length = 2n + 1 vetor V do tipo char '.' ou ':'

Saída

um inteiro k

Função

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

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

Simulação:

tente aqui

Retina, 181 135 129 bytes

Cada linha deve estar em um arquivo separado. <empty>representa um arquivo vazio. A saída está em Unário.

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

Quando ${0}1é usado, as chaves separar $0do 1, caso contrário, seria $01, o grupo 1 correspondente. Eu tentei usar $001, mas isso parece não funcionar no sabor do .NET regex.

Editar: encontrado $&o mesmo que$0 .

No pseudo-código, este seria essencialmente um loop do-while, como visto abaixo. Eu pressiono o primeiro número e, em seguida, faço o loop: pressione o segundo número, remova a operação (instrução), faça contas, remova a operação Continue dando laços. Observe que, quando uma operação é acionada, isso também remove o espaço após todas as instruções serem concluídas.

Comentado:

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

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

Em python, você faz referência ao índice de uma lista como esta:

list[index]

Você pode colocar um valor booleano nisso, Trueé 1e 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] ]
                                                                      [_=='.']

Experimente online aqui

Perl, 77 bytes

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

expandido:

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

o @o matriz mapeia os dígitos para os operadores. Em seguida, substituímos pares de dígitos pelo operador apropriado, reordenado para infix. O regexp começa com, \Bpara não correspondermos ao primeiro caractere. O resultado de s///gnos diz quantas parênteses abertas precisamos no início. Então, quando montamos a expressão do infixo completo, podemos avaliá-la. (Remova evalse você gostaria de ver a expressão).

Aqui está o equipamento de teste que eu usei para verificar os resultados:

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

Entrada é a lista de expressões pontilhadas e seus valores (fornecidos na pergunta) e a saída é pares de {real, esperado}.