Напишіть програму, яка містить рядок непарної довжини, що містить лише символи .та :. За допомогою спочатку порожнього стека генеруйте число з цього рядка наступним чином:

Для кожного символу c у рядку (йде зліва направо) ...

• Якщо c є, .а стек має менше 2 елементів, натисніть 1 на стеку.
• Якщо c є, .а стек має 2 або більше елементів, висуньте два верхніх значення зі стека та натисніть їх суму на стек.
• Якщо c є, :а стек має менше 2 елементів, натисніть 2 на стек.
• Якщо c є, :а стек містить 2 або більше елементів, висуньте два верхніх значення зі стека та висуньте їх добуток на стек.

Отримане число - це значення у верхній частині стека. Ваша програма повинна надрукувати цей номер у stdout (з необов'язковим останнім рядком).

(Невеликий аналіз показує, що залишається лише одне число, якщо рядок не має рівну довжину, тому ми ігноруємо їх. Насправді, стек ніколи не має більше двох елементів.)

Наприклад, число для ::...:.:.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

Виграє найкоротша програма в байтах. Tiebreaker - це раніше повідомлення.

• Ви можете припустити, що введення завжди дійсне, тобто рядок, що містить тільки .і :довжина якої непарна.
• Замість того, щоб писати програму, ви можете написати функцію, яка займає дійсний рядок і друкує або повертає згенероване число.

CJam, 27 24 23 22 байт

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

Досить прямо вперед. Я використовую стек CJam як стек, згаданий у питанні;)

Алгоритм

Спочатку давайте розглянемо код ASCII для .та :.

'.i ':ied

[46 58]

Оскільки в CJam індекс обертається, давайте подивимось, чи можемо ми використовувати ці значення безпосередньо для отримання потрібної операції.

'.i4% ':i4%ed

[2 2]

Тому я не можу просто використовувати коди ASCII в операційній рядці 4 довжини. Давайте спробуємо деякі інші значення

'.i 10% ':i 10%ed

[6 8]

який на 4-х довжинах струни зводиться до

[2 0]

Я можу використовувати цю операцію mod 10, але це коштуватиме 2 байти. Давайте спробуємо щось інше

'.i5% ':i5%ed

[1 3]

Приємно !, тепер ми просто віднімаємо 1 для умови розміру стека, щоб отримати індекси 0, 1, 2 and 3та використовувати 5масив довжини ( "1+2* ") як випадок вимикача. Останній простір - це лише наповнювач, щоб зробити його довжиною 5. Це лише 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

> <> (Риба) , 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
• if 1( ':') помножити два верхні елементи, створюючи стек [0 product]
• завжди додайте два топ-елементи, створюючи стек [0 sum]або[0+product=product]
• 40.стрибок (петля) назад в положення (4,0), наша точка 4,i:1+?\~n;

Haskell, 73 65 байт

Просте рішення, використовуючи той факт, що стек ніколи не має більше ніж 2 елементи.

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

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

Ну, це занадто довго.

Pyth, 25 24 байти

eu?]?.xGHsGtG+GhHmqd\:zY

Отримав ідею, вивчаючи рішення @ isaacg. Але я використовую стек.

Інтернет-демонстрація або тестовий набір

Пояснення

Перше, що я роблю, це перетворити рядок введення в 0 і 1. A "."перетворюється в a 0, a ":"в a 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

JavaScript (ES6), 65

Ми використовуємо лише 2 комірки нашого стека.

Почніть вводити значення в s [0].
Потім у кожній непарній позиції (рахуючи від 0) у рядок введення введіть значення s [1].
У кожній парній позиції виконайте вичислення (додавання чи множення) та збережіть результат у s [0].

Тож забудьте про стек і використовуйте лише 2 змінні, a і b.

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

Піт, 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.

Демонстрація.

Сітківка , 105 75 73 байт

Моя перша програма Retina! (Спасибі Мартіну Бюттнеру за збереження 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;(тобто натискає 1).

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

Збігається, якщо на стеку є 0 або 1 елемент, за яким слідує двокрапка. Якщо це так, він замінює товсту кишку aa;(тобто штовхає 2).

;(a+;)\.
$1

Збігається, якщо на стеку є два елементи, за якими слідує крапка. Видаляє період і крапку з комою між елементами, тим самим додаючи їх.

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

Збігається, якщо на стеку є два пункти, у верхній частині яких - 2, за якими слідує двокрапка. Вилучає двокрапку і 2 і повторює інше число двічі, множуючи тим самим на 2.

)`;a;:
;

Регекс збігається, якщо на стеку є два пункти, у верхній частині яких розміщено 1, а слідує двокрапка. Видаляється двокрапка та 1, залишаючи інше число незмінним (тобто помножене на 1).

)`вказує кінець циклу. Якщо в рядку були внесені якісь зміни, контроль повертається до вершини програми і запускає заміни знову. Якщо рядок перестав змінюватися, ми замінили всі періоди та колонки, і все, що залишилося, - це очищення ...

;
<empty>

Видаляє крапку з комою.

a
1

Перетворює всі зразки на 1. Знову ж таки, якщо в одинарних номерах дозволено використовувати будь-який символ, цей крок зайвий.

Іржа, 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 / else, змусивши їх повернути значення, яке негайно відкидається, а це означає, що вам потрібно лише одна крапка з комою замість двох.

Наприклад,

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

може бути змінено на

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

що рятує персонажа, стригаючи крапку з комою.

Хаскелл, 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

Здається, що хтось побив мене до позначки в рішенні Haskell, і не тільки це, їх рішення коротше мого. Це погано, але я не бачу причин не публікувати те, що я придумав.

APL (50)

Я тут дуже сильний, бо APL не є мовою на основі стека. Я, нарешті, зловживав скороченням, щоб скоротити програму.

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

Внутрішня функція приймає «команду» зліва та стек праворуч і застосовує її, повертаючи стек. Зовнішня функція зменшує її над рядком, починаючи з порожнього стека.

Пояснення:

• (⌽⍵),⊂⍬: початковий список для зменшення. ⊂⍬являє собою порожній список, який представляє стек, (⌽⍵)є зворотним вводом. (Скорочення застосовується справа наліво над списком, тому рядок буде оброблятися справа наліво. Попереднє введення введення змушує застосувати символи в правильному порядку.)

• {... }: внутрішня функція. Він бере стек праворуч, символ зліва і повертає змінений стек.

  • F←'.:'⍳⍺: індекс символу в рядку .:, це буде 1 або 2 залежно від значення.
  • 2>⍴⍵:F,⍵: Якщо 2 більше, ніж поточний розмір стека, просто додайте поточне значення до стеку.
  • ⋄: інакше,
    • 2↓⍵: вилучіть два верхні елементи зі стека
    • (... )/2↑⍵: зменшити задану функцію над ними та додати її до стеку.
    • ⍎F⌷'+×': функція або +(додавання), або ×(множення), обрана методом F.

• ⊃: нарешті, поверніть найвищий елемент у стеку

Рубін - 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

Безголівки:

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 байт

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 хороший для однокласників, тому що дужки в дужках необов’язкові; навпаки, це погана мова, де потрібно зберігати кілька значень, оскільки для зберігання змінної потрібно два-чотири байти місця. Тому мета - написати якомога більше у кожному рядку. TI-BASIC також жахливий (для токенізованої мови) при будь-якому маніпулюванні струнами; навіть читання підрядка є тривалим.

Прийоми включають:

• int(e^([boolean]замість 1+(boolean; зберігає один байт
• Часткова сума списку замість розрізання списку (що потребує зберігання у списку): зберігає 3 байти

Іди, 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

Пітон 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.

ну це настільки проста операція, складна оп (навмисно)

це просто ...

вираз у дужках переведений на постфікс * / + операцію

Код: 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;}

• цю функцію слід викликати з рядка хвоста так: f (V + 10), де V = ".: ..:.: .. ::"

вхід

довжина = 2n + 1 вектор V типу char '.' або ':'

Вихідні дані

ціле число k

Функція

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

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

Моделювання:

спробуйте тут

Сітківка, 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>

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

Безголівки:

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 ви посилаєтесь на індекс такого списку:

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] ]
                                                                      [_=='.']

Спробуйте його онлайн тут

Perl, 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";
}

Введення - це перелік крапкових виразів та їх значень (надається у запитанні), а вихід - пари {фактичні, очікувані}.