Il tuo compito è determinare se una determinata stringa è della lunghezza corretta e può essere rappresentata con tessere Scrabble e, in tal caso, produrre la somma del punteggio di ogni lettera.

Se non sai come giocare a Scrabble: hai 100 tessere con varie lettere dalla A alla Z stampate, oltre a due caratteri jolly che possono rappresentare qualsiasi lettera. Ogni lettera ha un certo numero di punti e ogni tessera (ma non necessariamente una parola) può essere usata una sola volta. Quando viene riprodotta una parola, viene sommato il valore in punti di ciascuna tessera utilizzata, che diventa il punteggio. Poiché è disponibile un numero limitato di lettere, una parola può contenere una determinata lettera tutte le volte che la lettera ha tessere + caratteri jolly non utilizzati. La scacchiera Scrabble è di 15 × 15 celle, quindi la parola deve contenere da 2 a 15 caratteri.

Per un elenco della quantità e del punteggio di ciascuna lettera nella versione inglese, vedere di seguito o http://boardgames.about.com/od/scrabble/a/tile_distribute.htm ( archivio ).

Lettera Qtà Punti Lettera Qtà Punti
------------------- -------------------
A 9 1 O 8 1
B 2 3 P 2 3
C 2 3 Q 1 10
D 4 2 R 6 1
E 12 1 S 4 1
F 2 4 T 6 1
G 3 2 U 4 1
H 2 4 V 2 4
I 9 1 W 2 4
J 1 8 X 1 8
K 1 5 Y 2 4
L 4 1 Z 1 10
M 2 3 [selvaggio] 2 0
N 6 1

Ulteriori regole

• Il programma deve prendere una singola stringa di input da STDIN o simili.
• L'input conterrà sempre solo lettere maiuscole.
• Se la stringa contiene più copie di una lettera di quante siano i caratteri jolly o le tessere non utilizzati per quella lettera OPPURE la lunghezza della stringa non è compresa tra 2 e 15 inclusi, il programma dovrebbe generare Invalid.
• Altrimenti, il punteggio dovrebbe essere sommato usando i dati della tabella sopra e l'output.
• Non utilizzare i caratteri jolly se non necessario.
• Non preoccuparti di bonus come i punteggi di doppia parola o se la stringa è una parola reale.
• Il programma deve produrre il risultato tramite STDOUT o simili.
• Non sono consentite scappatoie vietate per impostazione predefinita .
• L'uso di una fonte esterna come un sito Web, nonché qualsiasi libreria, API, funzione o simili che calcola i punteggi di Scrabble o le quantità appropriate non sono consentiti.
• Questo è code-golf , quindi vince meno byte.

Procedura dettagliata

Input: CODEGOLF
C -> 3, O -> 1, D -> 2, E -> 1, G -> 2, O -> 1, L -> 1, F -> 4
3 + 1 + 2 + 1 + 2 + 1 + 1 + 4 = 15
Output: 15

Casi test

Input Output
------------------------
SCRABBLE 14
JAZZ 19
CAMBIO STACKEX 32
XYWFHQYVZVJKHFW 81
PIZZAZZ non valido
KIXOKEJAJAX Non valido
MISUNDERSTANDING Non valido

Perl 5 228 205 186 184 178 177 153 150 149 142 137 135

Esegui con perl -E.

golfed:

$_=<>;@a=@b=map-ord,'            0 0@0 H        ``'=~/./g;say s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

Questa soluzione utilizza alcuni caratteri non stampabili, quindi di seguito viene fornito un dump esadecimale:

00000000: 245f 3d3c 3e3b 4061 3d40 623d 6d61 702d  $_=<>;@a=@b=map-
00000010: 6f72 642c 2703 0904 0909 2030 2030 030e  ord,'..... 0 0..
00000020: 4030 0e20 0704 4809 1809 601d 0e0e 6027  @0. ..H...`...`'
00000030: 3d7e 2f2e 2f67 3b73 6179 2073 212e 2128  =~/./g;say s!.!(
00000040: 2461 5b24 713d 3634 2d6f 7264 2426 5d2b  $a[$q=64-ord$&]+
00000050: 3d38 293c 383f 242d 2b3d 312d 3239 2f24  =8)<8?$-+=1-29/$
00000060: 625b 2471 5d3a 2b2b 246a 2167 657e 7e5b  b[$q]:++$j!ge~~[
00000070: 322e 2e31 355d 2626 246a 3c33 3f24 2d3a  2..15]&&$j<3?$-:
00000080: 496e 7661 6c69 64                        Invalid

In alternativa, usando Ctrl + Tasto:

$_=<>;@a=@b=map-ord,'^C^I^D^I^I 0 0^C^N@0^N ^G^DH^I^X^I`^]^N^N`'=~/./g;print s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

Ungolfed + ha commentato:

# Read in input
$_=<>;
# @a and @b: represents approximately 8x the number of tiles (when rounded up). The 
#   non-multiple-of-8 values distinguish tiles that are given equally, but are worth
#  different values
@b=@a=map-ord,"...."~=/./g;
# above is equivalent to
# @a=@b=(-03,-09,-04,-09,-09,-32,-48,-32,-48,-03,-14,-64,-48,-14,-32,-07,-04,-72,-09,-24,-09,-96,-29,-14,-14,-96);
say
    # for each character
    s!.!
        # $q: A->-1, B->-2, etc.
        # decrement number of $q tiles, add points if needed, otherwise
        #    increment j, which counts number of wilds used
        # truncate(1-29/b[q]): decimal values were chosen specifically
        #    for this to return the point value. b[q] is the number of tiles
        #    of the qth letter after a originally given.
        #  $- contains the score, is initially zero (if in a one line program, 
        #   as the golfed version is), and is always an integer
        ($a[$q=64-ord$&]+=8)<8 ? $- += 1 - 29/$b[$q] : ++$j
    # s returns length, check if between 2 and 15
    !ge ~~ [2..15]
    # make sure less than 3 negative tiles (aka wilds) 
    && $j < 3 ?
        # print score
        $-
    # or invalid
    : Invalid

C, Rev 2, 151 145 138

Ispirato dal codice di 159 byte nel commento di @ bebe, ho estratto altri 8 14 21 caratteri:

4 byte salvati riorganizzando il contatore della lunghezza i. Viene inizializzato su 1 (supponendo che il programma non prenda argomenti) quindi moltiplicato per 4 ogni volta che viene letta una lettera. Trabocca a zero quando la lunghezza della parola è maggiore di 15, quindi per verificare se la lunghezza della parola è sbagliata, controlliamo semplicemente se i<5(lo metto in i<9modo da dare comunque invalido per le parole di una lettera se l'utente si inizializza accidentalmente ia 2 mettendo un singolo argomento sulla riga di comando.)

4 byte salvati modificando il test delle condizioni del loop in un semplice &31. Ciò richiede che la parola sia terminata con uno spazio (ASCII 32) o un carattere null (ASCII 0.) Normalmente l'input da tastiera è terminato da una nuova riga (ASCII 10), quindi il programma è un po 'scomodo da usare, perché devi digitare il spazio quindi premere anche Invio per far leggere al buffer il computer. Per le stringhe con fine riga, potrei abbinare ma non battere il modo in cui lo fa.

6 13 byte salvati modificando la codifica in - (numero di riquadri di ogni lettera) - (punteggio per quella lettera-1) * 13 . Ciò richiede ora un intervallo da -4 per L, S, U a -118 per Q, Z. La ragione per usare numeri negativi è evitare l'intervallo ASCII non stampabile da 0 a 31. Invece l'intervallo utilizzato è il complemento a due dei numeri negativi da 256-4 = 252 a 256-118 = 138. Questi sono caratteri ASCII estesi stampabili. Esistono problemi con la copia e incolla di questi in Unicode (il modo in cui si semplifica in ASCII dipende dalla tabella codici installata che può portare a risultati imprevedibili), quindi ho inserito i codici ASCII corretti nel commento del programma.

Il vantaggio di questa codifica è l'eliminazione della variabile rpoiché il numero di riquadri viene sempre ridotto di 1 (poiché è memorizzato come un numero negativo, lo facciamo t[x]++. Inoltre, l'operatore postfix significa che possiamo eseguire questo incremento contemporaneamente a aggiungendo il punteggio a s.

//char t[]={32,247,228,228,239,244,215,240,215,247,164,203,252,228,250,248,228,138,250,252,250,252,215,215,164,215,138,0};
b,s;
main(i,x){
  for(char t[]=" ÷ääïô×ð×÷¤ËüäúøäŠúüúü×פ׊";x=getchar()&31;i*=4)
    t[x]%13?
      s-=t[x]++/13-1:
      b++;
  printf(i<9|b>2?"Invalid":"%d",s);
} 

C, 184 Rev 1 173 (o 172 con opzione compilatore)

Sto usando GCC e con l'opzione del compilatore -std=c99mi permetterà di passare char t[]="...."all'inizializzazione del forciclo per un salvataggio di un punto e virgola aggiuntivo. Per leggibilità, ho mostrato il programma senza questa modifica e con spazi bianchi lasciati.

#define T t[x[1][i]-65]
i,b,s;
main(int r,char**x){
  char t[]="Z>>QxS=SZW6(><P>m<(<(SSWSm";
  for(;x[1][i];i++)
    T/10?
      s+=r=T%10+1,T-=r*10:
      b++;
  printf(i<2|i>15|b>2?"Invalid":"%d",s);
}

Il trucco è nel datatable. Per ogni lettera un codice ASCII del modulo (punteggio totale delle tessere per quella lettera) * 10 + (punteggio di una tessera-1) è memorizzato nella tabella t[]. In fase di esecuzione, questi punteggi totali vengono ridotti quando le tessere vengono esaurite.

Il punteggio totale di tutte le tessere per ogni lettera varia da 12 per E fino a 4 per L, S, U. Questa forma di codifica consente di utilizzare solo caratteri ASCII stampabili (ASCII 120, xper E fino a ASCII 40, (per L, S, U.) L'uso del numero di riquadri richiederebbe un intervallo compreso tra 120 e 10, motivo per cui I evitato.

Grazie ad una #definemacro, un singolo simbolo Tviene utilizzato nel programma principale per recuperare l'indice lettera idal primo argomento a riga di comando, ASCII sottrarre A= 65 da esso per dare un indice, e cercarlo nella tabella T: t[x[1][i]-65].

Il forloop viene utilizzato più come un whileloop: il loop termina quando nella stringa di input viene rilevato un byte zero (terminatore di stringa).

Se le tessere di quella lettera non sono esaurite ( T/10è diverso da zero) sviene incrementato dal punteggio delle tessere T%10+1per mantenere un punteggio totale. Allo stesso tempo, il punteggio delle tessere viene memorizzato r, in modo che il valore nella tabella rappresentata da Tpossa essere diminuito da r*10per indicare che una tessera è stata utilizzata. Se le tessere sono esaurite, il carattere jolly / contatore vuoto bviene incrementato.

L' printfaffermazione è abbastanza autoesplicativa. se la lunghezza della parola è fuori dai limiti o il conteggio del bianco è troppo alto, stampa Invalidaltrimenti stampa il punteggio s.

JavaScript (ES6) - 241 230 199 182

f=s=>{for(i=t=_=0,E=12,A=I=9,B=C=M=P=28,D=17,F=H=V=W=Y=41,G=16,J=X=92,K=53,L=S=U=4,N=R=T=6,O=8,Q=Z=118;c=s[i++];)this[c]%13<1?_++:t+=1+this[c]--/13|0;alert(i<3|i>16|_>2?"Invalid":t)}

Modifica : modificato il modo in cui ho codificato le quantità / i punteggi per ridurre le dimensioni e rimuovere le variabili non ascii

Modifica 2 : ha cambiato la codifica quantità / punteggio in numeri interi anziché in stringhe

Modifica 3 - passato a %13(grazie @ edc65), invertito la codifica, modificato direttamente i valori e alcuni altri miglioramenti minori

Testato nella console di Firefox.

Python 3, 217 201

b=2;i=s=0;w=input()
while i<26:n=w.count(chr(i+65));q=int('9224c232911426821646422121'[i],16);b-=max(0,n-q);s+=min(n,q)*int('1332142418513113a11114484a'[i],16);i+=1
print(["Invalid",s][-b<1<len(w)<16])

Ungolfed:

b=2    # number of blanks available
i=s=0  # letter index 0..25, running score tally
w=input()

# Loop through each letter of the alphabet
while i<26:
    # Get number of occurrences in the word
    n=w.count(chr(i+65))
    # Get quantity of the letter from hex encoded string
    q=int('9224c232911426821646422121'[i],16)
    # Remove blanks for each occurrence over that letter's quantity
    b-=max(0,n-q)
    # Score the non-blank tiles, getting scores from hex-encoded string
    s+=min(n,q)*int('1332142418513113a11114484a'[i],16)
    # Increment
    i+=1

# If b > -1 and 1 < len(w) < 16, print the score; otherwise, print "Invalid"
print(["Invalid",s][-b<1<len(w)<16])

Modifica: Grazie a @BeetDemGuise per un suggerimento che alla fine mi ha portato a molto più di una riduzione di 1 carattere! Codice originale di seguito:

q=[77-ord(x)for x in'DKKIAKJKDLLIKGEKLGIGIKKLKL'];b=2;s=0;w=input()
for c in set(w):n=w.count(c);o=ord(c)-65;b-=max(0,n-q[o]);s+=min(n,q[o])*(1+int('02210313074020029000033739'[o]))
print(["Invalid",s][-b<1<len(w)<16])

BEFUNGE 93 - 210 byte.

Ma non controlla il limite di 15 lettere.

v1332142418513113:11114484: >01g:"0"-!#v_1-01p1+\v
 9224<232911426821646422121v  "Invalid"<      vp0<
<vp00p10"20"p200p900
>>~:55+-!#v_"@"-::1g:"0"-! #^_1-\1p0g+"0"-02g+>02p
_v#:-1<    #p90+g90-"0"g1:<
     @.g20<        @,,,,,,,<

C, 197

Presuppone che la stringa sia fornita come argomento della riga di comando, ad es ./scrabble STACKEXCHANGE

s;n;m=31;main(int c,char**v){char d[]="BIBBDLBCBIAADBFHBAFDFDBBABA@ACCBADBDAHEACAACJAAAADDHDJ";for(;c=*v[1]++&m;d[c]--,s+=d[c+27]&m)n+=1+m*(!(d[c]&m||d[c=0]&m));printf(n>1&&n<16?"%d":"Invalid",s);}

JavaScript - 232 201

t=[9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1];w=r=0;for(i=y=z.length;i--;){x=z.charCodeAt(i)-65;if(!t[x])w++;else{t[x]--;r+=-~"02210313074020029000033739"[x]}}alert(w>2|y<2|y>15?"Invalid":r)

zmemorizza la parola. Output come avviso.

Modifica: migliorato come da raccomandazioni di seguito.

Haskell - 538

Salvalo come scrabble.hs e poi compilarlo usando

ghc --make scrabble && ./scrabble

Quindi inserisci la parola come input e premi invio

l=['A'..'Z']
sc=zip l [1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10]
vfs a y =snd $ filter (\x -> fst x == y) a !! 0
q = zip l [9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1]
i s =filter (\x -> (fst x) >=0) [(length [x | x <- s, x == a] - vfs q a,a) | a <- l]
main = do
 s <- getLine
 if length s <= 15 && length s > 2 && sum (map fst (i s)) <= 2 then
  putStrLn $ show (sum [vfs sc x| x <- s] - sum [(vfs sc (snd x)) * (fst x) | x <- (filter (\x -> fst x > 0) (i s))])
 else do
  putStrLn "Invalid"

Python 2.7 - 263

Non potevo avvicinarmi in alcun modo alla risposta di DLosc , ma questo tratta ogni lettera come una "borsa" da cui tiri, fino a quando non è vuota, quindi tiri gli spazi vuoti, e quando è vuota si sbaglia.

S=input().lower()
X={chr(97+i):[int(y)+1]*(77-ord(x))for i,(x,y)in enumerate(zip('DKKIAKJKDLLIKGEKLGIGIKKLKL','02210313074020029000033739'))}
B=[0,0]
try:
 if len(S)>15:1/0
 print sum(map(lambda x:X[x].pop()if len(X[x])>0 else B.pop(),S))
except:
 print "invalid"

Haskell, 290 283

Per quanto ne so, per ora:

import Data.List
t="CdC8d::Od;D;d41N:dd:6dNdN;;4;6"
s w@(_:_:_)=let d=concat(zipWith(replicate.(`div`11).f 33)t("AEIO"++['A'..]))\\w;y=drop 15w in if length(d++w++y++y++y)>100 then s""else show$187-(sum$map((`mod`11).f 0.(t!!).f 61)d)
s _="Invalid"
f n=(-n+).fromEnum
main=interact s

Questo codice rispetta le regole in modo molto rigoroso, quindi assicurati di non passare caratteri extra (come la fine della riga). Usa così:echo -n "JAZZ" | runghc scrabble.hs .

Spiegazione

Il modello , 65 è il numero ASCII di , a causa del duplicato all'inizio del pool. Il resto è solo scaldavivande.(_:_:_) assicura che vengano considerate solo le stringhe di almeno due caratteri, tutto il resto risulta"Invalid" (modello di fallback _). La tabella dei riquadri è codificata come 11*nTiles+valueconvertita in ASCII con un offset che consente alla ricerca modulo 11 di funzionare, dove le lettere AEIOsono duplicate perché ricorrono più di 6 volte ciascuna. Il pool di tessere viene quindi creato utilizzandoreplicate , da cui i caratteri nella parola vengono rimossi quando si verificano (differenza elenco,\\). Il pool contiene 98 tessere, quindi se la lunghezza totale della parola e la parte rimanente del pool è maggiore di 100, abbiamo usato troppi caratteri jolly. Inoltre, la parola meno le prime 15 lettere viene aggiunta tre volte al calcolo della lunghezza, quindi qualsiasi parola più lunga di 15 lettere sembra automaticamente utilizzare tre caratteri jolly e quindi non è valida. Il punteggio viene eseguito sul pool rimanente, che inizialmente aveva 187 punti, da cui sottraggiamo semplicemente. Si noti che f 61anzichéf 65'A'"AEIO"

Python3 - 197

s,i,c,r=input(),0x1a24182424416141611a2381612341151891243224c142232391,[],[]; p=len(s)
for w in s:e=8*ord(w)-520;c+=[s.count(w)<=i>>e+4&15];r+=[i>>e&15]
print(['Invalid',sum(r)][all([p>2,p<15]+c)])

Mettiamo i bignum da usare: D (Al momento non gestisce i caratteri jolly, ho saltato la lettura di quella regola, dannazione)

Rubino - 195

b=2
i=s=0
w=$*[0]
(?A..?Z).map{|l|n=w.count(l);q='9224c232911426821646422121'[i].to_i(16);b-=[0,n-q].max;s+=[n,q].min*'1332142418513113a11114484a'[i].to_i(16);i+=1}
p(-b<1&&w.size<16?s:'Invalid')

Sto supponendo che l'output di "Invalid"va bene, altrimenti non avrei bisogno di fare $><<(-b<1&&w.size<16?s:'Invalid')che aumenterebbe fino a 198

Clojure - 325

Non faccio il clojure da un po ', quindi sono sicuro che ci sono diversi modi per migliorare la mia soluzione.

(let[w(first *command-line-args*)o(map #(count(filter #{%}(seq w)))(map char(range 65 91)))i(apply +(filter neg?(map #(- % %2)'(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1) o)))](println(if(or(> -2 i)(not(<= 2(count w)15)))"Invalid"(apply +(map #(* % %2)o'(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10))))))

Qualche cosa non golf

(let [word    (first *command-line-args*)
      letters (map char(range 65 91))
      occ     (map #(count (filter #{%} (seq word))) letters)
      invalid (apply + (filter neg? (map #(- % %2)
                '(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1)
                occ)))
      score   (apply + (map #(* % %2) occ '(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10)))]
    (println
      (if (or (> -2 invalid)
              (not (<= 2 (count word) 15)))
        "Invalid"
        score)))

ES6: 184 (non rigoroso)

wsi presume che contenga già la parola. rè la stringa di output.

i=0,o=[..."291232342c124322491181541236181231a61416141242418241a"].map(c=>parseInt(c,16)),r=!w[16]&&w[2]&&[...w].every(c=>o[c=c.charCodeAt()*2-129]-->0?i+=o[c+1]:o[0]--)?i+"":"Invalid"

Ecco spiegato e un po 'meno golfato:

// The sum.
i = 0,

// The data for the letters. It's encoded similar to the Ruby version, with
// the first being the wildcard holder. The rest hold in hex form the
// following: first = quantity left, second = value.
// The .map(c => parseInt(c, 16) simply parses all the hex characters.
o = [..."291232342c124322491181541236181231a61416141242418241a"]
  .map(c => parseInt(c, 16)),

// The result, `r`.
r = !w[16] || // If there is a 16th character in the word or no 2nd character,
    w[2] &&   // then the next section isn't evaluated. It immediately equates
              // to true, thus returning "Invalid".
   [...w] // Convert the string into an array of characters (ES6 equivalent to
          // `.split('')`
    .every(c => // This loop terminates when the callback returns a falsy
                // value.
      // Gets the ASCII value, subtracts 65, doubles it (the lookup table is
      // in pairs within one array), and decrements the counter at that entry.
      // The lookup table also doubles as a data holder.
      o[c = c.charCodeAt() * 2 - 129]--
        > 0 ?  // Test if there is something to take away. This must return
               // false at 0 and -1 so wildcards can be taken.
        i += o[c+1] : // If there was something to take away, then add the
                      // letter value to the sum.
        o[0]--) // Otherwise, take a wildcard. If this is already at 0, then
                // it returns falsy.
      ? "Invalid" : i + "" // This is where the text is returned.

Dardo - 201

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:2}){if((m=a[0].length)>1&&m<16)for(i in a[s=0].codeUnits)x>>(m=i*8-520)&15>0?r+=(x-=1<<m)>>m+4&15:++s;print(s<2?r:"Invalid");}

Ciò richiede bignum, quindi non verrà compilato in JavaScript.
Con più spazi bianchi:

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:3}){
  if((m=a[0].length)>1&&m<16)
    for(i in a[s=0].codeUnits)
      x>>(m=i*8-520)&15>0
      ? r+=(x-=1<<m)>>m+4&15
      : ++s;
  print(s<3?r:"Invalid");
}

PHP, 180 170 168 byte

for($q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);$o=31&ord($argv[1][$i++]);)$s+=$q[$o]++>L?$q[0]++>L?$f=1:0:X02210313074020029000033739[$o]+1;echo$f|$i<3|$i>16?Invalid:$s;

Sìì! battendo JS!

abbattersi

for(
    $q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);  // init quantities: L=1,A=12
    $o=31&ord($argv[1][$i++]);                  // loop through characters: map to [1..26]
)
    $s+=                                          // increase score by ...
        $q[$o]++>L?                                 // old quantity below 1?
        $q[0]++>L?$f=1                              // no more wildcards? set error flag
        :0                                          // wildcard: 0 points
        :X02210313074020029000033739[$o]+1;         // else: letter score
echo$f|$i<3|$i>16?Invalid:$s;                   // output

Sono così felice che non ci sia un punteggio di lettere superiore a 10.