Votre tâche consiste à résumer et à générer le score d'un joueur dans une partie de bowling à 10 quilles après 21 lancers maximum .

Les rouleaux sont représentés comme une séquence d'entiers dans votre méthode de saisie préférée . Chaque entier correspond au nombre de broches qui ont été renversées dans ce rouleau.

Notation

Après chaque tour, le nombre de quilles renversées dans ce tour est compté dans le score final. Si un joueur renverse les dix quilles dans le premier jet d'un tour, c'est une grève et le tour est terminé. Sinon, la manche dure encore un jet. Si le deuxième rouleau d'un tour abat toutes les broches restantes, c'est une pièce de rechange .

Pour chaque coup, il y a un bonus égal à la somme des quilles renversées dans les deux rouleaux suivants. Pour chaque pièce de rechange, il y a un bonus égal au nombre de quilles renversées au prochain lancer.

Au 10e et dernier tour, le joueur peut obtenir des rouleaux supplémentaires: En cas de grève, le joueur obtient deux rouleaux supplémentaires pour compenser son bonus de grève. En cas de réserve, le joueur obtient un jet de plus.

Exemples

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

Règles

• Vous pouvez supposer que l'entrée est valide.
• Selon le commentaire de Mego, j'ai assoupli les exigences relatives aux méthodes d'entrée / sortie pour répondre à notre norme actuelle .
• Les réponses dans des langues plus récentes que le défi sont autorisées
• Le code le plus court gagne!

GolfScript, 50 41 caractères

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

Une autre tentative dans GolfScript ( exécutez-le en ligne ).

Une explication du code suit. La solution utilise la nature de pile du problème (consommer des rouleaux les uns après les autres) mais par conséquent, l'entrée doit être inversée.

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

La version précédente:

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

Python, 116 110 105 105 103 100 99 caractères

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)

Dépenser 30 caractères en entrée est gênant. Suggestions bienvenues.

Un grand merci à Howard pour les améliorations.

R, 101 octets

Je ne sais pas pourquoi ce défi a été heurté, mais j'aime ça, donc je vais quand même répondre tard.

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)

Essayez-le en ligne!

Non golfé:

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

Fonction récursive. Prend xen entrée, qui détient les scores. Initialise les snoyaux et ccalcule le nombre de tours lancés.

L'instruction if vérifie si 10 tours sont lancés ou si xest vide. Si tel est le cas, le score est retourné. Sinon, la fonction s'appellera comme suit:

Il supprime les lancers x, en vérifiant s'il s'agit d'une frappe ou non. Si c'est le cas, la première entrée est supprimée, sinon les deux premières. (S=x[1]!=10)vérifie les grèves. Nous supprimons l' -index ( ) 0:S, où Sest 1 s'il s'agit d'une grève, et 0 sinon. Et puis on ajoute un: -(0:(x[1]!=10)+1). Nous passons le raccourci xà l'appel suivant.

Quant au score, on le retrouve en prenant x[1:2]s'il s'agit d'un tour régulier, et x[1:3]s'il s'agit d'une frappe ou d'un jeu de rechange. Nous vérifions si elle sum(x[1:2])est supérieure ou égale à 10. S'il s'agit d'une grève, c'est évidemment le cas. S'il s'agit d'une pièce de rechange, cela fonctionne également. Donc, si c'est VRAI, nous ajoutons x[3]à la somme. Ceci est ensuite ajouté à 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

EDIT : Une réécriture lourde, plagiant sans vergogne la grande approche basée sur la pile de Howard. Je suis convaincu que plus peut être supprimé pour accéder au dernier élément d'un tableau sans le détruire ...

Rubis, 252 octets

Accepte les entrées dans un tableau, ajoutez d'abord tous les éléments, puis recherchez le bonus de rechange et de frappe

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 octets

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

prend l'entrée des arguments de la ligne de commande; courir avec-nr ou testez-le en ligne .

panne

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 octets

Nécessite des -apdrapeaux

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

Essayez-le en ligne!

Gelée ,  36  35 octets

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

Un lien monadique acceptant une liste d'entiers et renvoyant un entier.

Essayez-le en ligne!

Comment?

Calcule le score de chaque série de trois bols qui se chevauchent comme s'il s'agissait d'une séquence commençant au début d'une image et ajoute éventuellement un identifiant de frappe ( -1), aplatit cette liste résultante, la fractionne aux identifiants de frappe, puis supprime chaque deuxième résultat de chaque morceau (en supprimant les scores de ces courses qui n'ont pas vraiment commencé avec le début d'une image).

Pour répondre à l'image finale, un zéro est d'abord ajouté à l'entrée (pour permettre le découpage en 3 pour permettre à une image de commencer sur ce qui était l'avant-dernier bol) et les scores résultants sont tronqués aux dix premiers (pour supprimer le maintenant possible faux 11e cadre) avant de les résumer.

+\µ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?

Premier essai:

#!/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

Malheureusement, il y a certains cas où cela échoue. Je reviendrai le refaire plus tard.