Ваша задача состоит в том, чтобы подвести итоги и оценку выходного одного игрока в игре 10-контактный боулинг после до 21 рулонов .

Броски представлены в виде последовательности целых чисел в вашем предпочтительном методе ввода . Каждое целое число соответствует количеству пинов, которые были сбиты в этом броске.

счет

После каждого раунда количество выбитых в этом раунде булавок засчитывается в итоговый счет. Если игрок сбивает все десять булавок в первом броске раунда, это удар , и раунд окончен. В противном случае раунд длится еще один бросок. Если второй бросок раунда сбивает все оставшиеся булавки, это запасной .

Для каждого удара есть бонус, равный сумме булавок, сбитых в двух следующих бросках. Для каждого запасного есть бонус, равный количеству булавок, сбитых в следующем броске.

В 10-м и последнем раунде игрок может получить дополнительные броски: в случае удара игрок получает еще два броска, чтобы получить бонус за удар. В случае запаса игрок получает еще один бросок.

Примеры

Input: 4 3 8 2 7 1 10 7 3 0 10 2 2 10 10 5 4
Output: 131

Input: 10 10 9 1 7 3 2 7 10 1 9 10 7 1 10 10 10
Output: 183

правила

• Вы можете предположить, что ввод действителен.
• Согласно комментарию Мего, я ослабил требования к методам ввода / вывода, чтобы соответствовать нашему текущему стандарту .
• Разрешены ответы на языках, которые новее, чем задание
• Самый короткий код выигрывает!

GolfScript, 50 41 символов

~0]-1%~0{\.9>{+1$3$}{@+.9>3$*}if++}10*p];

Еще одна попытка в GolfScript ( запустите его онлайн ).

Объяснение кода приведено ниже. Решение использует стековый характер проблемы (потребляет броски один за другим), но поэтому ввод должен быть обратным.

~0          # Take the input and evaluate to single numbers on the stack. Add zero.
]-1%~       # Reverse the stack (make array, reverse array, dump array)

0           # Start with a sum of zero
{           # Perform this block 10 times (once for each round)
  \         #   Take the next roll
  .9>{      #   If it is a strike
    +       #     Add the value of the roll to the sum
    1$3$    #     and duplicate top two members of the stack (i.e. next two rolls).
  }{        #   ... else ...
    @+      #     Take the next roll and add with first roll in round.
    .9>     #     Does this sum show a spare?
    3$*     #     Get next roll (potential bonus) and multiply with yes/no.
            #     Since we pushed an additional 0 in the beginning 
            #     there is a spare roll even for the last round.
  }if       #   endif
  ++        #   Add top three stack entries together
            #   (i.e. sum+2 bonus rolls for strike, sum+rolls+bonus else)
}10*        # Loop ten times

p];         # Sum is top of stack. Print sum and discard any leftover rolls.

Предыдущая версия:

~].1>.1>]zip{((.10<{@(0=@+@1>1$9><}*@}10*;]{+}.@**

Python, 116 110 105 103 100 99 символов

z=map(int,raw_input().split())
s=0
exec('s+=sum(z[:2+(z[0]+z[1]>9)]);z=z[2-(z[0]>9):];'*10)

Тратить 30 символов на ввод утомительно. Предложения приветствуются.

Большое спасибо Говарду за улучшения.

R 101 байт

Я не уверен, почему этот вызов был повышен, но мне это нравится, так что я все равно поздно отвечу.

f=function(x,s=0,c=10)`if`(c&length(x),f(x[-(0:(x[1]!=10)+1)],sum(x[1:(2+(sum(x[1:2])>9))])+s,c-1),s)

Попробуйте онлайн!

Ungolfed:

f <- function(throws, score = 0, count = 10){
  if(count != 0 & length(throws) != 0){
    IsStrike <- throws[1] == 10
    IsStrikeOrSpare <- sum(throws[1:2]) >= 10
    f(throws[-c(1, 2 * !IsStrike)],
      score + sum(throws[c(1:(2 + IsStrikeOrSpare))]),
      count - 1)
  } else {
    return(score)
  }
}

Рекурсивная функция. Принимает в xкачестве входных данных, который содержит оценки. Инициализирует sядра и cподсчитывает количество брошенных раундов.

Оператор if проверяет, были ли выброшены 10 раундов или xпусто. Если это так, результат возвращается. В противном случае функция будет вызывать себя следующим образом:

Он удаляет броски x, проверяя, является ли это ударом или нет. Если это так, первая запись удаляется, а первые две. (S=x[1]!=10)чеки на удары. Мы удаляем ( -) index 0:S, где S1, если это удар, и 0, если нет. А потом добавьте: -(0:(x[1]!=10)+1). Мы передаем сокращенный xк следующему звонку.

Что касается счета, это можно узнать, x[1:2]если это обычный ход, а x[1:3]также удар или запасной. Мы проверяем, sum(x[1:2])больше или равен 10. Если это удар, очевидно, это так. Если это запасной, то это тоже работает. Так что, если это ИСТИНА, мы добавляем x[3]к сумме. Это тогда добавлено к s.

CoffeeScript ( 234 215 170)

z=(a)->b=(Number i for i in a.split(' ').reverse());t=0;(r=b.pop();l=b.length;if(9<r)then(t+=r;t+=b[l-1]+b[l-2];)else(f=r+b.pop();t+=f;(t+=b[l-2])if 9<f))for i in[0..9];t

РЕДАКТИРОВАТЬ : здоровенная переписать, бесстыдно плагиат великий подход на основе стека Говарда. Я уверен, что можно получить больше за доступ к последнему элементу массива, не разрушая его ...

Рубин, 252 байта

Принимает входные данные в массив, сначала добавляет все элементы, затем ищет запасной и ударный бонус.

s,p,t,r=0,0,1,1
o=ARGV
o.each_with_index do |m,n|
y=m.to_i
s+=y
if r<10
p+=y
if p==10&&t==1
r,p=(r+1),0
s+=o[n+1].to_i+o[n+2].to_i
elsif p<10&&t==1
t=2
elsif p<10&&t==2
t,p,r=1,0,(r+1)
elsif p==10&&t==2
t,p,r=1,0,(r+1)
s+=o[n+1].to_i
end end end
puts s

PHP, 82 байта

for($a=$argv;$r++<10;$i+=$p<10)$s+=(9<$q=$a[++$i+1]+$p=$a[$i])*$a[$i+2]+$q;echo$s;

принимает входные данные из аргументов командной строки; запустить -nrили проверить это онлайн .

сломать

for($a=$argv;       # import arguments
    $r++<10;        # loop through rounds
    $i+=$p<10)          # 6. if no strike, increment throw count again
    $s+=(9<
        $q=$a[++$i+1]+  # 1. increment throw count  2. $q=second throw plus
        $p=$a[$i]       # 3. $p=first throw
        )*$a[$i+2]      # 4. if $q>9 (strike or spare), add third throw to sum
    +$q;                # 5. add first and second throw to sum
echo$s;             # print sum

Perl 5 , 65 + 2 = 67 байт

Требуются -apфлаги

$\+=(($"=shift@F)<10?$"+=shift@F:10+$F[1])+$F[0]*(9<$")for 0..9}{

Попробуйте онлайн!

Желе ,  36  35 байт

+\µi©⁵+Ị$ḂḤị;®×Ị¤¡-
;0Ç3ƤFṣ-m€2Fḣ⁵S

Монадическая ссылка, принимающая список целых чисел и возвращающая целое число.

Попробуйте онлайн!

Как?

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

Чтобы обслужить последний кадр, к входу сначала добавляется ноль (чтобы позволить трехстороннюю нарезку, чтобы позволить кадру начинать с того, что было предпоследней чашей), и результирующие оценки усекаются до первой десятки (чтобы убрать теперь возможен фиктивный 11-й кадр) до их подведения итогов.

+\µi©⁵+Ị$ḂḤị;®×Ị¤¡- - Link 1, threeBowlEvaluate: list, bowlScores
                    -               e.g. [0,4,6]   [9,1,10]   [0,4,4]  [10,7,9]
 \                  - cumulative reduce with:
+                   -   addition         [0,4,10]  [9,10,20]  [0,4,8]  [10,17,26]
  µ                 - monadic chain separation, call that "left"
     ⁵              - literal ten        10        10         10       10
   i                - first index in left 3         2 (spare)  0        1 (strike)
    ©               - (copy to register for later reuse)
        $           - last two links as a monad (f(x)):
       Ị            -   abs(x) <= 1       0         0          1        1
      +             -   add x             3         2          1        2
         Ḃ          - modulo by 2         1         0          1        0
          Ḥ         - double              2         0          2        0
           ị        - index into left (both 1-indexed and modular)
                    -            ...      4        20          4       26
                  - - literal -1         -1        -1         -1       -1
                 ¡  - repeat:
            ;       - ...action: concatenate
                ¤   - ...number of times: nilad followed by link(s) as a nilad:
             ®      -   z from register   3         2          0        1
               Ị    -   abs(z) <= 1       0         0          1        1
              ×     -   multiply          0         0          0        1 (strike)
                    - ...yielding:        4         20         4        [26,-1]

;0Ç3ƤFṣ-m€2Fḣ⁵S - Main link: list bowlValues
                -                    e.g. [4,3,8,2,7,1,10,7,3,0,10,2,2,10,10,5,4]
 0              - literal zero            0
;               - concatenate             [4,3,8,2,7,1,10,7,3,0,10,2,2,10,10,5,4,0]
   3Ƥ           - for infixes of length 3:
  Ç             -   last link (1) as a monad
                -                         [7,11,17,9,8,11,[20,-1],10,3,12,[14,-1],4,12,[25,-1],[19,-1],9]
     F          - flatten                 [7,11,17,9,8,11,20,-1,10,3,12,14,-1,4,12,25,-1,19,-1,9]
       -        - literal -1              -1
      ṣ         - split at                [[7,11,17,9,8,11,20],[10,3,12,14],[4,12,25],[19],[9]]
          2     - literal two             2
        m€      - modulo slice for €ach   [[7,17,8,20],[10,12],[4,25],[19],[9]]
           F    - flatten                 [7,17,8,20,10,12,4,25,19,9]
             ⁵  - literal ten             10
            ḣ   - head to index           [7,17,8,20,10,12,4,25,19,9] (no effect this time)
              S - sum                     131

Perl, 140?

Первая попытка:

#!/usr/bin/perl
# usage: ./bowling.pl [list of scores]

@A=@ARGV;{last if(9<$n++);$a=shift@A;$S+=$a;($S+=$A[0]+$A[1])&redo if($a==10);$b=shift@A;$S+=$b;($S+=$A[0])&redo if(10==$a+$b);redo}print$S

К сожалению, есть определенные случаи, когда это терпит неудачу. Я приду и переделаю это позже.