Punteggio del bowling mondiale

Molte persone sono andate nel loro centro bowling locale per giocare a bowling e molte persone continuano a lottare per calcolare i loro punteggi. World Bowling ha introdotto un sistema di punteggio semplificato per attirare più persone allo sport. Questo sistema di punteggio viene utilizzato nei giochi internazionali.

Il sistema di punteggio funziona così (da Wikipedia ):

Il sistema di punteggio del bowling mondiale, descritto come "punteggio del frame corrente" [32], premia i pin come segue:

• strike: 30 (indipendentemente dai risultati dei tiri seguenti)
• riserva: 10 più pinfall sul primo rotolo del frame corrente
• aperto: pinfall totale per il frame corrente

Se non hai familiarità con il bowling a dieci pin, ecco un riepilogo.

Ci sono 10 perni alla fine di una pista da bowling dove l'obiettivo è quello di abbatterli tutti con una palla da bowling. Ottieni 2 tiri di una palla per tentare di abbatterli tutti, preferibilmente abbattendoli tutti con il primo lancio (noto come strike ). Se ricevi uno strike, quel frame è completato e non è necessario tirare la palla una seconda volta. Uno sciopero vale 30.

Se non abbatti tutti e dieci, ottieni un altro tiro. Se abbatti tutti i pin rimanenti, questo è noto come ricambio . Il punteggio vale 10 pin + il numero di pin eliminati al primo tiro. Ad esempio, se ho abbattuto 7 pin, quindi sono riuscito a abbattere i restanti 3, varrebbe la pena di 17.

Se dopo il tuo secondo tiro non riesci ad abbattere tutti e dieci, questo è noto come un frame aperto . Il punteggio vale il numero totale di pin eliminati per quel frame.

Ci sono 10 frame in un gioco . Se hai familiarità con il punteggio del bowling tradizionale, non ottieni un tiro extra nel decimo frame con il World Bowling Scoring. Nel punteggio del bowling tradizionale, sono necessari 12 colpi consecutivi per ottenere un punteggio perfetto di 300, mentre il punteggio del World Bowling richiede solo 10 colpi consecutivi.

Sfida

La tua sfida è quella di calcolare il punteggio dato valori da un foglio punteggio.

Su un foglio di punteggio, un errore è indicato da un trattino ( - ), uno strike con una X e uno di riserva con una barra ( / ). Se questi non si applicano, il conteggio delle cadute viene semplicemente indicato con un numero (1-9). Anche i falli e le divisioni vengono registrati sui fogli dei punteggi, ma non è necessario preoccuparsi di questi.

Ingresso

Ti verrà data una stringa composta da punteggi per ogni fotogramma e avrai un totale di dieci fotogrammi. Ogni fotogramma avrà fino a due valori, o anche solo 1 se si verifica un avvertimento. L'input può essere un parametro stringa per una funzione, letto da un file o da STDIN.

Ad esempio, se avessi abbattuto 1 perno sul mio primo lancio, quindi abbattuto 2, il fotogramma sarebbe simile a "12". Questo non significa 12 (dodici), ma significa 1 e 2, per un totale di 3.

Se avessi perso tutti i pin con entrambi i rulli (palle di grondaia), sarebbe simile a questo "-" (punteggio di 0).

Ogni fotogramma sarà separato da uno spazio.

Input di esempio

-- 9- -9 X -/ 8/ 71 15 44 X

Per scomporre questo esempio,

• Frame 1 (-) - mancano entrambi i tiri. segnato 0
• Frame 2 (9-): abbattuto 9 al primo tiro, mancato al secondo tiro. Punteggio 9
• Frame 3 (-9) - Ha perso tutto il primo, ha ottenuto 9 nel secondo. Punteggio 9
• Frame 4 (X) - Strike, abbattuto tutti e dieci. Punteggio 30
• Frame 5 (- /) - Ricambio, fallito tutto sul primo, abbattuto tutto con il 2 ° tiro. Punteggio 10 + 0 = 10
• Frame 6 (8 /) - Ricambio, 8 pin sul primo rotolo, abbattuto gli altri 2 con il 2 ° rotolo. Punteggio 10 + 8 = 18
• Frame 7 (71) - frame aperto, 7 pin sul primo rotolo, 1 pin sul secondo rotolo. Punteggio 7 + 1 = 8
• I frame 8,9,10 seguono gli stessi esempi di cui sopra.

Produzione

L'output sarà semplicemente un valore che ha la somma dei punteggi di tutti e 10 i frame. Utilizzando l'input di esempio, l'output sarà 128. L'output può essere una stringa o un tipo numerico. Può essere un valore restituito dalla funzione o scritto in STDOUT.

Regole

• Supponiamo che l'input sia sempre valido. Ad esempio, un frame non valido sarebbe "/ 8", "XX", "123", "0", ecc.
• Non devi preoccuparti di spaccature o falli.
• Il codice può essere un programma completo o una funzione che accetta una stringa e restituisce il punteggio.
• Il tuo codice non deve generare eccezioni.
• Questo è il codice golf, la risposta con il minor numero di byte vince.
• Le lingue che usano include o import devono includere le dichiarazioni di importazione come parte del loro codice e contare per il conteggio dei byte.

Casi test

"-- 9- -9 X -/ 8/ 71 15 44 X" -> 128
"-- -1 2- 12 22 5- 42 61 8- 72" -> 45
"X X X 1/ 2/ 3/ 4/ 5/ -- 9/" -> 174
"X X X X X X X X X X" -> 300
"-- -- -- -- -- -- -- -- -- --" -> 0

05AB1E , 12 11 byte

Codice

S'/T:'X30:O

Provalo online!

Spiegazione

S             # Split the string into a list of characters
 '/T:         # Replace '/' with 10
     'X30:    # Replace 'X' with 30
          O   # Sum up the array (ignoring non-number elements)

JavaScript, 43 byte

f=([c,...s])=>c?({'/':10,X:30}[c]|c)+f(s):0

f=([c,...s])=>c?({'/':10,X:30}[c]|c)+f(s):0

Score(<input style="width:200px" oninput="o.value=f(this.value)" />) = <output id=o></output>

Come funziona

Convertiamo ogni personaggio al suo punto:

• 'X' vale 30 punti
• '/' vale 10 punti
• '1' .. '9' vale 1 .. 9 punti
• altri personaggi valgono 0 punti

Quindi sommare tutti i punti.

Convertire

L' operatore OR bit a bit |converte il suo operando in Int32 prima di operare. Quando si converte in Int32, il valore prima converte in formato Numero (numero float a 64 bit), quindi trunk in Int32 (o convertito in 0 se non valido).

• ToInt32({'/':10,X:30}[c]) potrebbe essere letto come:
  • se c == '/': il risultato è 10;
  • se c == 'X': il risultato è 30;
  • altrimenti: il risultato è ToInt32(undefined)-> ToInt32(NaN)-> 0;
• ToInt32(c) potrebbe essere:
  • se c == '1' ... '9': il risultato è 1 .. 9;
  • se c == '': Number(c)è 0, il risultato è 0;
  • altrimenti: Number(c)è NaN, il risultato è 0;
• Bitwise o qui è uguale a "add", poiché uno dei suoi operandi sarà 0

Somma

• [c,...s] = slet c = s[0], e s = s.slice(1);
  • se s è una stringa vuota, c non è definita ;
  • altrimenti, c è la prima lettera di s
• undefined è falsy, la stringa non vuota (incluso lo spazio) è true

Stax , 13 byte

─*âⁿ┴8òt↨HÉ÷8

Esegui ed esegui il debug

Disimballato, ungolfed e commentato è così.

F               for each character in input, execute...
 9R$'/20*+'X+   build the string "123456789////////////////////X"
 I              get the index of the current character in string
 ^+             increment and add to running total
                (index is -1 when no match; space and dash are 0 score)

Esegui questo

Python 2 , 55 byte

lambda l:sum(map(('123456789/'+'X'*20).rfind,l))+len(l)

Provalo online!

Basato sull'approccio dell'indice di stringhe di molte soluzioni.

Java 8, 64 59 46 byte

s->s.map(c->c<46?0:c<48?10:c>87?30:c-48).sum()

-5 byte grazie a @Neil .
-13 byte grazie a @ OlivierGrégoire .

Spiegazione:

Provalo online.

s->               // Method with an IntStream parameter and integer return-type
  s.map(c->       //  Loop over the characters
          c<46?   //   If the character is a space or '-':
           0      //    Count it as 0
          :c<48?  //   Else-if it's a '/':
           10     //    Count it as 10
          :c>87?  //   Else-if it's an 'X':
           30     //    Count it as 30
          :       //   Else (it's a digit):
           c-48   //    Count it as the value of the digit
       ).sum()    //   And sum everything

F #, 106 103 byte

let s c=Seq.sumBy(fun x->if x=' '||x='-'then 0 elif x='X'then 30 elif x='/'then 10 else int(string x))c

Provalo online!

Penso che questo puzzle (senza il golf) sarebbe una grande domanda per una guida "Programmazione funzionale per principianti". E dovrei saperlo!

-3 da Kevin Cruijssen, per aver scoperto che lo spazio tra 'e "allora" può essere eliminato. Grazie!

La soluzione Stax di ricorsive sull'uso degli indici di stringa è molto buona. Se lo porti su F # puoi ottenerlo per 77 byte :

let s c=Seq.sumBy(fun x->"123456789/???????????????????X".IndexOf(char x)+1)c

Prova questo online!

Gelatina , 17 byte

ḟ⁾ -“X0/⁵”yV€o30S

Un collegamento monadico che accetta un elenco di caratteri e restituisce un numero intero

Provalo online!

Come?

ḟ⁾ -“X0/⁵”yV€o30S - Link: list of characters
 ⁾ -              - literal list of characters [' ','-']
ḟ                 - filter discard
    “X0/⁵”        - literal list of characters ['X','0','/','⁵']
          y       - translate (change 'X's to '0's and '/'s to '⁵'s)
           V€     - evaluate €ach character as Jelly code (the '⁵'s become 10s)
             o30  - logical OR with 30 (change all instances of 0 to 30)
                S - sum

Anche alle 17:

”/ẋ20ØD;;”XḊiЀ⁸S

Prova questo

Perl 6 , 30 byte

{TR'-/X '0㉈㉊'.univals.sum}

Provalo online!

Retina , 17 byte

X
///
/
55
\d
*
_

Provalo online!

Non sono abbastanza aggiornato sulle ultime modifiche alla Retina. Ne cercherò di più quando ne avrò la possibilità e vedrò se ci sono nuovi trucchi per giocare a golf. Il codice trasforma tutti gli strike in tre pezzi di ricambio, tutti i pezzi di ricambio in dieci punti, quindi tutti i punti con il numero corrispondente di caratteri di sottolineatura. Quindi conta il numero di caratteri di sottolineatura.

Perl 5 -pF , 30 27 byte

-3 byte grazie a Xcali

#!/usr/bin/perl -pF
$\+=m%/%+3*/X/.0+$_ for@F}{

Provalo online!

05AB1E , 14 byte

þ`I…/aXS¢ƶT*`O

Provalo online!

Spiegazione

þ`              # Push the digits of the input on the stack (removes everyting that isn't a digit)
  I…/aXS        # Push the input and the array "/","a","X" on the stack
        ¢       # Index of each element in the input ...
         ƶT*    # ... multiplied by its index (a could be anything that can't be found in the input), multiplied by 10.
            `O  # Sum the stack, implicit display

J , 33 byte

1#.31|('-123456789',20 1#'/X')i.]

Provalo online!

Spiegazione:

] l'ingresso

('-123456789',20 1#'/X')aggiunge 20 /e uno Xalla stringa-123456789

i. trova gli indici dell'input nella stringa sopra

31| modulo 31 - per sbarazzarsi degli spazi - non si trovano nella stringa, quindi i. restituisce 31 per loro

1#. trova la somma degli indici

Python 2 , 67 byte

-3 byte grazie a @KevinCruijssen

lambda I,p='-123456789/'+20*'X':sum(p.rfind(i)for i in I if i in p)

Provalo online!

Gelatina , 12 byte

⁾/X,“½œ‘y|0S

Provalo online!

Come funziona

⁾/X,“½œ‘y|0S  Main link. Argument: s (string)

⁾/X,“½œ‘      Literal; yield [['/', 'X'], [10, 30]].
        y     Transliterate; replace '/' with 10, 'X' with 30.
         |0   Bitwise OR with 0. Bitwise operators attempt to cast to int, mapping 
              '0', ..., '9' to 0, ..., 9. All other characters map to 0.
           S  Take the sum.

Python 3.6 , 54 byte

lambda s:sum(map(f'123456789/{6**24}X'.find,s),len(s))

Provalo online!

Kotlin , 50 byte

x->x.sumBy{"123456789/_${Math.E}_X".indexOf(it)+1}

Provalo online!

Spero che non sia contro le regole rispondere alla tua domanda, ma volevo unirmi al divertimento.

Math.Eproduce il valore 2.718281828459045. Lo sto usando per creare una stringa di riempimento per spingere X in posizione 30.

indexOfottiene la posizione (basata su 0) del carattere nella stringa "12345 ...". Se non viene trovato, restituisce -1. Aggiungiamo 1 per rendere questi 0 e questo rende anche la posizione in base a 0 il valore della stringa.

PHP, 119 109 byte

-10 byte grazie a @KevinCruijssen

<?foreach(explode(" ",$argv[1])as$f){[$a,$b]=str_split($f);$n+=$f==X?30:(int)$a+($b=='/'?10:(int)$b);}echo$n;

Provalo online!

Carbone , 23 byte

ＩΣＥχΣＥＳ⎇№-/Xλ×χ⌕-//XλＩλ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  Ｅχ                    Map over 10 frames
      Ｓ                 Input the frame
     Ｅ                  Map over the characters
            λ           Current character
        №-/X            Search the literal string `-/X`
                    λ   Current character
               ⌕-//X    Find position in literal string `-//X`
             ×χ         Multiply by predefined variable 10
                      λ Current character
                     Ｉ  Cast to integer
       ⎇                Ternary
    Σ                   Sum for each frame
 Σ                      Sum over frames
Ｉ                       Cast to string for implicit print

Rosso , 93 byte

func[b][s: 0
foreach c trim/all b[s: s - 1 + index? find{-123456789/...................X}c]s]

Provalo online!

C # (.NET Core) , 40 + 18 = 58 byte

using System.Linq;
s=>s.Sum(c=>c>87?30:c<46?0:c<48?10:c-48)

Provalo online!

C # (compilatore interattivo Visual C #) , 53 byte

Write(ReadLine().Sum(c=>c>87?30:c<46?0:c<48?10:c-48))

Provalo online!

SNOBOL4 (CSNOBOL4) , 169 151 147 byte

	F =INPUT ' '
R	F '-' =0	:S(R)
T	F 'X' ='_'	:S(T)
S	F LEN(1) . X ARB . Y ' ' REM . F	:F(O)
	X '_' =30
	Y '/' =10
	S =S + X + Y	:(S)
O	OUTPUT =S
END

Provalo online!

	F =INPUT ' '					;* read input and append a space
R	F '-' =0	:S(R)				;* replace - with 0
T	F 'X' ='_'	:S(T)				;* replace X with _
S	F LEN(1) . X ARB . Y ' ' REM . F	:F(O)	;* set first character to x, remainder up to ' ' to y, and remainder to F
	X '_' =20					;* replace _ in x with 20
	Y '/' =10					;* replace / in y with 10
	S =S + X + Y	:(S)				;* else X and Y are their values so we can sum them
O	OUTPUT =S					;* output the sum
END

Clojure , 70 byte

#(reduce(fn[s i](+ s(case i\- 0\/ 10\X 30\space 0(bigint(str i)))))0%)

Provalo online!

Quando si reduceesegue il ing su una stringa, ogni carattere viene effettivamente convertito in un carattere - chi avrebbe mai pensato. Ma questo significa, devo scrivere \spacee fa male più di quanto si possa immaginare. Inoltre, quando si crea un numero effettivo da un carattere, la combinazione dibigint e strsembra essere l'unica combinazione utilizzabile.

Bene, a parte tutte queste lotte: funzione anonima che restituisce il punteggio come naturale.

Rubino , 38 byte

->s{s.tr("/X -",":N00").sum-s.size*48}

Provalo online!