Anotador de Scrabble

42

Reto:

Tome una cadena de letras mayúsculas o minúsculas como entrada (opcional) y calcule la puntuación que esa cadena obtendría en un juego de Scrabble en inglés.

Reglas:

El puntaje de cada letra es el siguiente (use esto incluso si hay otras versiones del juego):

1 point: E, A, I, O, N, R, T, L, S, U
2 points: D, G
3 points: B, C, M, P
4 points: F, H, V, W, Y
5 points: K
8 points: J, X
10 points: Q, Z

La puntuación de una cadena es simplemente la suma de las puntuaciones de cada una de las letras utilizadas. Puede suponer que tiene muchos mosaicos disponibles, por lo que las palabras largas y las palabras con muchas de las mismas letras son entradas válidas.

Casos de prueba:

ABC       ->    7
PPCG      ->   11
STEWIE    ->    9
UGPYKXQ   ->   33
FIZZBUZZ  ->   49
ABCDEFGHIJKLMNOPQRSTUVWXYZ  -> 87

¡La respuesta más corta en cada idioma gana! Los formatos de entrada y salida son flexibles, por lo que puede tomar la entrada como una matriz de caracteres (mayúsculas o minúsculas) si lo desea.

Stewie Griffin
fuente
66
Espero ver una solución MATLAB / Octave. Todos mis intentos fueron terriblemente largos ... = /
Stewie Griffin
44
Espero ver una solución Beatnik. Porque, ya sabes, esa sería la herramienta adecuada para el trabajo.
Giuseppe
@StewieGriffin ¿Cuenta 85 bytes como horriblemente largo?
Luis Mendo
3
¿Mathematica no tiene una función incorporada?
sergiol
1
@manassehkatz definitivamente deberías intentarlo. Le recomiendo que publique el desafío en el Sandbox para obtener comentarios y ayuda antes de publicarlo en el sitio principal. Los desafíos complejos son notoriamente difíciles de resolver sin ningún comentario.
Stewie Griffin

Respuestas:

16

sed 4.2.2 , 81

s/[QZ]/JD/g
s/[JX]/KB/g
s/K/FE/g
s/[FHVWY]/BE/g
s/[BCMP]/DE/g
s/[DG]/EE/g
s/./1/g

La salida es en unario .

Reduce cada letra a una combinación de letras de menor puntaje hasta que todas las letras sean de 1 puntaje. Luego reemplaza aquellos con 1s para dar un recuento unario.

Pruébalo en línea!

Trauma digital
fuente
10

Haskell , 86 84 bytes

f s=length s+sum[n|x<-s,(n,y)<-zip(9:7:[1..])$words"QZ JX DG BCMP FHVWY K",x`elem`y]

Pruébalo en línea!

Explicación

La mayoría de las letras dan un puntaje de 1 y, por lo tanto, no necesitamos hacer un seguimiento de estas, en lugar de eso solo disminuimos cada puntaje (también guardamos 1 byte 10) y luego agregamos la longitud de la cadena al puntaje resultante.

¡Gracias @nimi por -2 bytes (reorganizando las palabras y usando en [1..]lugar de [4,3..])!

ბიმო
fuente
1
zip[1..]$words"DG BCMP FHVWY K . . JX . QZ"da otra alternativa con la misma duración
Angs
10

Octava , 50 bytes

@(t)'				'/3*sum(65:90==t')'

Pruébalo en línea!

Desafío aceptado. Explicación:

@(t)             % Define anonymous function taking a single argument t.
    ' ... '/3    % Row vector with letter scores. Corresponds to char([1 3 3 2 ...]*3). 
                 % The factor 3 was necessary to avoid a newline.

*                % Dot product (yes, * is dot product, .* is not. Go figure). Equivalent to sum of element-wise products.
     65:90       % Alphabet
          ==t'   % Broadcast equality with input string.
 sum(         )  % Sum this matrix. Gives the count of each letter in the alphabet
               ' % Transpose into column vector for dot product
Sanchises
fuente
¡Muy inteligente! ¡El uso de no imprimibles fue un buen toque! :)
Stewie Griffin
@StewieGriffin ¡Es solo un byte en comparación con, -47pero eso es un código de golf para ti!
Sanchises
1
Suspiro. Bien y verdaderamente fuera de golf. No me había dado cuenta de que podías usar ==así en Octave. No funciona en MATLAB. Bueno saber.
Tom Carpenter
2
@TomCarpenter No pretendo frotar sal en la herida, pero la forma "antigua" de hacerlo (con bsxfun) también es más corta a 61 bytes: ¡ Pruébelo en línea!
Sanchises
3
WAT 50 bytes que ni siquiera
Luis Mendo
9

Beatnik , 733 bytes

Como realmente tenía que hacerse, aquí está. Fue realmente desagradable depurar y proporcionó algunos desafíos.

La entrada debe ser solo letras mayúsculas. La salida es unaria (¿espero que esté bien?)

J K ZZZZZZK Z ZD ZB ZZZZZZZZZZZZZZZZZA K A Z ZD ZB ZZZZZZZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZZZKD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZKA K A Z ZD ZB ZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZK K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZKD K A Z ZD ZB ZZZZZZZK K A Z ZD ZB ZZZZKB K A Z ZD ZB ZZZZZZKF K A Z ZD ZB ZZZZZZB K A Z ZD ZB ZZZZZFB K A Z ZD ZB ZZZZZA K A Z ZD ZB ZZZAK K A Z ZD ZB ZZZ K A Z ZD ZB ZD K A Z ZD ZB ZKB K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K A ZKA ZZZZZZZZZZZZZZZZZZY

Pruébalo en línea!

El proceso general es:

  • obtener carácter de entrada
  • restar 65
  • verificar si el resultado es 0
    • si 0 salta la cantidad especificada de palabras.
    • de lo contrario, reste 1 y repita la verificación.
  • Los objetivos de salto son operaciones de impresión push seguidas de un bucle de regreso al comienzo del programa.

Termina con un error.

Una explicación más completa:

J K ZZZZZZK Z ZD               # Get input and subtract 65
ZB ZZZZZZZZZZZZZZZZZA K A Z ZD # Character A - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZKF K A Z ZD  # Character B - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZB K A Z ZD   # Character C - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZ K A Z ZD    # Character D - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZKD K A Z ZD   # Character E - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character F - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character G - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZ K A Z ZD       # Character H - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZB K A Z ZD      # Character I - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKA K A Z ZD        # Character J - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKF K A Z ZD        # Character K - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZK K A Z ZD        # Character L - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character M - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character N - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZKD K A Z ZD         # Character O - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZK K A Z ZD           # Character P - if 0 jump to print, otherwise subtract 1
ZB ZZZZKB K A Z ZD             # Character Q - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZKF K A Z ZD           # Character R - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZB K A Z ZD            # Character S - if 0 jump to print, otherwise subtract 1
ZB ZZZZZFB K A Z ZD            # Character T - if 0 jump to print, otherwise subtract 1
ZB ZZZZZA K A Z ZD             # Character U - if 0 jump to print, otherwise subtract 1
ZB ZZZAK K A Z ZD              # Character V - if 0 jump to print, otherwise subtract 1
ZB ZZZ K A Z ZD                # Character W - if 0 jump to print, otherwise subtract 1
ZB ZD K A Z ZD                 # Character X - if 0 jump to print, otherwise subtract 1
ZB ZKB                         # Character Y - if 0 jump to print, otherwise subtract 1
K ZZZZKF KF                    # Jump Point for print 1111111111
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111111
K ZZZZKF KF                    #
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111
K ZZZZKF KF                    # Jump Point for print 1111
K ZZZZKF KF                    # Jump Point for print 111
K ZZZZKF KF                    # Jump Point for print 11
K ZZZZKF KF                    # Jump Point for print 1
K A ZKA ZZZZZZZZZZZZZZZZZZAAAA # Jump back to start
MickyT
fuente
1
Golfizado
jimmy23013
@ jimmy23013 muy agradable, deberías publicar eso.
MickyT
8

Brain-Flak , 210, 204, 198, 184 , 170 bytes

({<([{}]<>(({}{}))(([][][][][])<((([]())<([][])>))((((()))))>)[](((()()())<((()))>)((())()()()()))((())()()())((()())()())[]((((())())()))(())){({}<{}>())}>{}{}<{{}}><>})

Pruébalo en línea!

¡Gracias a @JoKing por guardar 14 bytes!

Versión legible:

({              # For each character

                # Push array of letter scores
                # Also adjust character to 1-indexing
        <([{}]<>
        (({}{}))    # Push 2 0s
        (([][][][][])   # 10
        <((([]())   # 4
        <([][])>    # 8
        ))      # 4,4
        ((((()))))> # 1,1,1,1
        )       # 10
        []      # Add 12 to difference
        (((()()())  # 3
        <((()))>    # 1,1
        )       # 3
        ((())()()()())) # 1, 5
        ((())()()())    # 1, 4
        ((()())()())    # 2, 4
        []      # Add 22 to difference
        ((((())())()))  # 1,2,3
        (())        # 1
        )   # Push 65-char

        {({}<{}>())} # Index character into score array
        >
        {}{}         # Add score to running total
        <{{}}><>     # Clear the stack

})               # Implicit print of total score
DJMcMayhem
fuente
170 bytes
Jo King
2
Para una definición dada de 'legible' :)
Matt Lacey
Hice una edición para tratar de aclarar la explicación, siéntase libre de retroceder si encuentra un problema.
Kamil Drakari
7

Pyth, 40 bytes

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1

Pruébalo aquí

Explicación

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1
 m                              Q  For each character in the (implicit) input...
    x.e  b                     1   ... find the first index in...
          c." zØÍ jÙ¹>;%OG5§"\     ['dg','bcmp','fhvwy','k','','','jx','','qz']
       }d                          ... containing the character...
  +2                               ... 2-indexed.
s                                  Take the sum.
Mnemotécnico
fuente
7

JavaScript (Node.js) , 71 66 63 62 bytes

  • @Arnauld impresionante como siempre reduciendo 7 bytes
  • gracias a l4m2 por reducir 1 byte
s=>Buffer(s).map(x=>s="02210313074020029000033739"[x-65]-~s)|s

Pruébalo en línea!

DanielIndie
fuente
6

Java 8, 75 71 70 bytes

s->s.chars().map(c->"\n\n".charAt(c-65)).sum()

-1 byte cambiando "02210313074020029000033739".charAt(c-65)-47a no imprimibles (y dos \n) para que -47se pueda eliminar. Inspirado por la respuesta Octave de @Sanchises .

Pruébalo en línea.

s->          // Method with String parameter and integer return-type
  s.chars()  //  Loop over the characters as IntStream
   .map(c->"\n\n".charAt(c-65))
             //   Convert the character to its value
   .sum()    //   And sum it all together
Kevin Cruijssen
fuente
5

Octava / MATLAB, 85 bytes

@(x)sum([1:4 7 9]*any(reshape(char(strsplit('DG BCMP FHVWY K JX QZ')),6,1,5)==x,3)+1)

Pruébalo en línea!

Luis Mendo
fuente
Mejor que mis intentos :-) aún más de lo que hubiera pensado antes de probarlo ... ¡Tenías un enfoque muy diferente!
Stewie Griffin
5

Jalea , 19 bytes

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S

Un enlace monádico que acepta una lista de caracteres en mayúscula que devuelve un entero

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S - Link: list of characters
O                   - ordinals ('A'->65, B->66...)
                 ¤  - nilad followed by link(s) as a nilad:
  “ÆẠḃbṂƬɠF#ṁ²’     -   literal 14011114485013321424185131
                ⁵   -   literal 10
               ḃ    -   bijective-base = [1,3,10,1,1,1,1,4,4,8,4,10,1,3,3,2,1,4,2,4,1,8,5,1,3,1]
 ị                  - index into (1-based & modular) (vectorises)
                    -  i.e. mapping from: O P  Q R S T U V W X Y  Z A B C D E F G H I J K L M N)
                  S - sum
Jonathan Allan
fuente
5

R , 90 63 bytes

function(W,u=utf8ToInt)sum(u('

')[u(W)-64])

Pruébalo en línea!

Toma la entrada como una cadena en mayúscula. R maneja cadenas no imprimibles y multilíneas sin problemas, así que eso es bueno. ¡Ahora somos casi el doble del paquete externo!

Y porque CRAN tiene tantas cosas al azar:

R + ScrabbleScore 31 bytes

ScrabbleScore::sws(scan(,""),F)

Pruébalo en línea!

Lamentablemente, swsverifica la validez por defecto.

Giuseppe
fuente
Tuve una jugada con la lista de puntajes y
recorté
@MickyT agradable! ¡Jugué con los no imprimibles y los reutilicé en utf8ToIntlugar de hacerlo matchy pude conseguir algunos más!
Giuseppe
4

Emojicode , 358 bytes

🐖🔥➡️🔡🍇🍮s 0🔂l🍡🐕🍇🍮s➕s🍺🐽🍯🔤a🔤1🔤e🔤1🔤i🔤1🔤l🔤1🔤n🔤1🔤o🔤1🔤r🔤1🔤s🔤1🔤t🔤1🔤u🔤1🔤d🔤2🔤g🔤2🔤b🔤3🔤c🔤3🔤m🔤3🔤p🔤3🔤f🔤4🔤h🔤4🔤v🔤4🔤w🔤4🔤y🔤4🔤k🔤5🔤j🔤8🔤x🔤8🔤q🔤10🔤z🔤10🍆🔡l🍉🍎🔡s 10🍉

Pruébalo en línea!

Explicación:

Cambié los nombres de las variables de letras simples a palabras más significativas, y expandí algunas partes de mi código para que sea más legible para las personas que no están familiarizadas con el idioma. Puede probar el programa ampliado aquí .

🐋🔡🍇      👴 define a class that takes a string
 🐖🔥➡️🔡🍇    👴 define a method that returns a string
  🍦values🍯    👴 create int dictionary
   🔤a🔤1 🔤e🔤1 🔤i🔤1 🔤l🔤1 🔤n🔤1 🔤o🔤1 🔤r🔤1 🔤s🔤1 🔤t🔤1 🔤u🔤1 🔤d🔤2 🔤g🔤2
   🔤b🔤3 🔤c🔤3 🔤m🔤3 🔤p🔤3 🔤f🔤4 🔤h🔤4 🔤v🔤4 🔤w🔤4 🔤y🔤4 🔤k🔤5 🔤j🔤8 🔤x🔤8
   🔤q🔤10 🔤z🔤10
  🍆        👴 ^ dictionary contains letters(keys) and their numerical values

  🍮score 0                         👴 declare 'score' variable and set to 0
   🍦iterator🍡🐕                     👴 transform input string to iterator
    🔂letter iterator🍇                👴 iterate over each byte in input string
     🍮score➕score 🍺🐽values 🔡letter   👴 add value of each letter to score
   🍉
  🍎🔡score 10    👴 return the score as a string
 🍉
🍉

🏁🍇          👴 begin the program here
 😀🔥🔤abc🔤    👴 call scoring method and print the score
 😀🔥🔤ppcg🔤    👴 repeat with other test cases
 😀🔥🔤stewie🔤
 😀🔥🔤fizzbuzz🔤
 😀🔥🔤abcdefghijklmnopqrstuvwxyz🔤
🍉
X1M4L
fuente
77
ay ... mis ojos ... ¿hay alguna opción en golf.se para ocultar algunos idiomas específicos? ^^
Olivier Dulac
1
@OlivierDulac Probablemente haya una forma de evitar que el navegador represente emoji especialmente. Cada uno tiene caracteres Unicode en blanco y negro estándar asociados con ellos.
mbomb007
3

Octava , 73 bytes

@(x)sum('09977433333222211'(([~,y]=ismember(x,'QZJXKFHVWYBCMPDG'))+1)-47)

Pruébalo en línea!

Se utiliza ismemberpara asignar cada carácter en la secuencia de entrada xen su índice en la cadena de búsqueda 'QZJXKFHVWYBCMPDG'. Cualquier elemento no encontrado se asignará a un índice de 0 (esto incluirá los caracteres de 1 punto).

A continuación, agregamos 1 al índice para que los 0 se conviertan en referencias válidas de 1 índice y busquemos en la cadena '09977433333222211'. Este es un elemento más largo que la primera cadena de búsqueda. Los dígitos representan el valor en puntos de cada elemento en la cadena original, menos 1, con el elemento extra como un '0' en el beginning.

Finalmente, la cadena resultante se convierte en enteros restando 47( '0'-1), produciendo el valor de punto para cada letra, y todos los valores de punto se suman.

Tom Carpenter
fuente
1
¡Muy inteligente! :)
Stewie Griffin
3

C ++, 95 bytes

char*m="02210313074020029000033739";
int f(char*p){int n=0;while(*p)n+=m[*p++-65]-47;return n;}

Pruébelo en línea (no es un enlace TIO lo siento)

Explicación:

  • Declara m, una matriz de los valores de cada letra en orden, menos 1. El menos 1 se debe a Q y Z: no podría tener un número de dos dígitos allí
  • Itera a través de la cadena phasta llegar al carácter nulo, y agrega la puntuación del número ( *pnos da la letra, y -65así podemos indexar correctamente la matriz). Dado que mes a, char*se convierte en a, charpor lo tanto, menos, 48así que devuélvelo a 0, pero suma 1ya que mse declara como un puntaje menos para cada personaje.

No soy un aficionado ávido aquí, así que espero haberlo hecho correctamente. Creo que devolverlos ncuenta como imprimir el valor, y que declarar una función está bien.

Tas
fuente
¡Muy agradable! El único byte que puede guardar es la nueva línea: ¡ Pruébelo en línea!
movatica
2

Japt , 36 bytes

£2+`dg
bcmp
fhvwy
k


jx

qzbøX
x

Toma la entrada como una cadena en minúscula, devuelve un número.
Breve explicación:

£2+`dg
¬       // Split the input into chars,
 £      // then map over each char, returning
  2+`dg // 2 plus

qzbøX
    bøX // the char's index in
qz    // the hardcoded string split by newlines.
x       // And finally sum the whole thing.

Pruébalo en línea!

Liendre
fuente
2

Rubí , 60 bytes.

->s{s.sum{|c|"BDDCBECEBIFBDBBDKBBBBEEIEK"[c.ord-65].ord-65}}

Pruébalo en línea!

Una lambda, que acepta la entrada como una matriz de caracteres (mayúsculas) y devuelve un entero.

benj2240
fuente
2

Gforth , 109 bytes

: V s" 1332142418513113:11114484:" ; : C 0 NAME 0 DO DUP C@ 65 - V DROP + C@ 48 - ROT + SWAP 1+ LOOP DROP . ;

La entrada debe ser mayúscula:
C PPCG 11 OK

Legible

\ String used as table with values for each letter in the alphabet
\ : follows 9 in the ASCII-table
: V
   s" 1332142418513113:11114484:"
;

: C
   0                   \ Initialize sum        ( sum               )
   NAME                \ Get the string        ( sum  c-addr count )
   0 DO                \ Start of loop         ( sum  c-addr       )
      DUP C@           \ Get letter            ( sum  c-addr char  )
      65 -             \ Calculate table index ( sum  c-addr index )
      V DROP + C@      \ Get table entry       ( sum  c-addr entry )
      48 -             \ Calculate entry value ( sum  c-addr value )
      ROT + SWAP       \ Update sum            ( sum' c-addr       )
      1+               \ Next character        ( sum' c-addr'      )
   LOOP
   DROP .              \ Drop c-addr and print result
;

Pruébalo en línea!

Kitana
fuente
2

Perl 6 , 52 bytes

{TR/A..Z/02210313074020029000033739/.comb.sum+.ords}

Pruébalo en línea!

Asigna cada carácter a un dígito y los suma. Y agrega 1 para cada carácter porque no hay un dígito 10 sin incurrir en bytes unicode.

Phil H
fuente
2

Retina 0.8.2 , 41 bytes

T`BCDGJKMPQXZF\HVWY`221174229793
.
$*..
.

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: Al igual que la respuesta de Haskell, las letras no triviales se traducen a 1 menos que su puntaje, y 1 se agrega más tarde cuando los caracteres se convierten en unarios. Poner el FHVWYúltimo les permite a todos mapear a una puntuación de 3 + 1.

Neil
fuente
2

C (gcc), 78 72 bytes

i;f(char*s){for(i=0;*s;)i+="\n\n"[*s++-65];s=i;}

En realidad hay 26 caracteres en esa cadena. Vea el código representado correctamente y ejecútelo aquí .

Gracias a gastropner por jugar al golf 6 bytes.

Versión sin golf:

i; // declare a variable to store the score; it is implicitly of type int
f(char* s) { // function taking a string as argument and implicitly returning an int
    for(i = 0; // initialize the score to 0
        *s; ) // iterate over the string until we hit terminating NUL byte
        i += "\n\n"[*s++ - 65]; // this is a 26-char string containing the ASCII equivalent of each numeric scrabble value; 65 is ASCII code for 'A', mapping the alphabet onto the string
    s = i; // implicitly return the score
}
OOBalance
fuente
2

Excel, 91 bytes

{=LEN(A1)+SUM(0+("0"&MID("02210313074020029000033739",CODE(MID(A1,ROW(A:A),1)&"z")-64,1)))}

Explicación:

  • La entrada está en la celda A1
  • La fórmula debe ingresarse como una fórmula de matriz con Ctrl+ Shift+ Enter, que agrega los corchetes { }a ambos extremos.
  • MID(A1,ROW(A:A),1) extrae cada carácter por turno (y también muchos valores vacíos, ya que devolverá tantos valores como filas en la hoja)
  • CODE(MID(~)&"z")extrae el valor ASCII para cada carácter. El &"z"anexa una zal final del MID()resultado porque CODE()no le gusta entradas vacías. Sin zembargo, el valor ASCII para es más alto que cada letra mayúscula, por lo que se ignora efectivamente más adelante.
  • MID("02210313074020029000033739",CODE(~)-64,1) extrae una letra de la cadena de puntuación en función de su valor ASCII ajustado por 64 para que las letras corran 1-26 en lugar de 65-90.
  • "0"&MID(~)antepone un cero al MID()resultado porque Excel no le permitirá hacer cálculos matemáticos con cadenas vacías, de las cuales habrá varias.
  • 0+("0"&MID(~)) convierte todas esas cadenas en números.
  • SUM(0+("0"&MID(~))) suma todas esas cadenas que ahora son números.
  • LEN(A1)+SUM(~)agrega la longitud de la entrada a la suma porque todos los valores en la cadena de puntuación ( 02210313074020029000033739) se ajustaron en uno para que todos tengan un dígito de longitud.

Hay una solución muy similar en Google Sheets, pero viene en 97 bytes porque ArrayFromula()es más larga que {}(pero al menos puede manejar 0 + "" = 0).

=Len(A1)+ArrayFormula(Sum(0+Mid("02210313074020029000033739",Code(Mid(A1,Row(A:A),1)&"z")-64,1)))
Tostadas de ingeniero
fuente
1
Bien hecho. Tengo una solución de Excel con 26 SUBSTITUTE(), llegando a un considerable 527 bytes.
Wernisch
2

Wolfram Language (Mathematica) , 74 bytes

¡Por supuesto, Wolfram | Alpha admite la puntuación Scrabble! Esta es una función anónima.

Plus@@(First[WolframAlpha["Scrabble "<>##,"NumberData"]]&/@Characters[#])&

Esto no funciona en TIO.

Para ejecutar, vaya aquí , desplácese hacia abajo y haga clic en "Crear un cuaderno nuevo» ". El código para usar en la computadora portátil está en este programa TIO para que pueda copiarlo. Pegue cada llamada de función en su propio bloque de código. Si ejecuta demasiados en un solo bloque, la ejecución no se completará.

Tenga en cuenta que WolframAlphaenvía una solicitud a través de Internet. Aunque hay otras respuestas sobre PPCG que lo usan, pensé que debería saberlo.

Este programa utiliza la siguiente función más corta, pero la invoca en cada carácter individual de la entrada (¡envía una llamada por separado a Wolfram | Alpha cada vez!)


Esto solo funciona para entradas de hasta 15 de longitud, el ancho de una placa Scrabble. (49 bytes)

First[WolframAlpha["Scrabble "<>#,"NumberData"]]&

Igual que el anterior, pero mostrará el resultado en un cuadro, junto con si la entrada es una palabra Scrabble válida. (45 bytes)

First[WolframAlpha["Scrabble "<>#,"Result"]]&
mbomb007
fuente
2

K (oK) , 60 38 bytes

Solución:

+/1+.:'"02210313074020029000033739"65!

Pruébalo en línea!

Explicación:

Indice los puntajes, resuma el resultado.

+/1+.:'"02210313074020029000033739"65! / the solution
                                   65! / input modulo 65 to get position in A-Z
       "02210313074020029000033739"    / index into the scores (1 point lower)
    .:'                                / value (.:) each (') to convert to ints
  1+                                   / increase by 1
+/                                     / sum up
callejero
fuente