Introducción

En la tierra de [Inserte un nombre genial aquí], las personas no compran cosas con dinero, porque todos tienen una alergia severa al papel. ¡Se pagan con palabras! Pero como es eso? Bueno, le dan valores a cada letra:

a=1,b=2,c=3,etc. 

(Con algunas otras reglas especiales que se describirán más adelante)

En este desafío, su tarea será calcular el valor de las oraciones.

Desafío

Tomarás una entrada que será una oración. Puede suponer que la entrada no tiene líneas nuevas ni espacios finales. El desafío será calcular el valor de la oración, usando estas reglas:

a=1,b=2,c=3,etc.  

• Una letra mayúscula vale 1,5 veces su letra minúscula correspondiente

H=h*1.5

Entonces, la palabra

cab

Valdría la pena c+a+b = 3+1+2 = 6

Pero la palabra Cabcon mayúscula valdría la pena. (c*1.5)+a+b = 4.5+1+2 = 7.5 Por lo tanto, si la entrada de su programa fuera "Cab", su programa generaría 7.5

• Todos los caracteres no alfabéticos valen 1.

Este es el código de golf, por lo que la respuesta más corta en bytes gana. ¡Buena suerte!

Python 3, 71 65 61 bytes

lambda z:sum((ord(s)*1.5**(s<'_')-96)**s.isalpha()for s in z)

Por una coincidencia extraordinaria, (ord(s)-64)*1.5es igual a ord(s)*1.5-96, por lo que solo tenemos que escribir -96una vez. El resto es bastante sencillo.

Editar: recorté algunos bytes usando travesuras de exponenciación.

Python 2, 120 102 bytes

Editar:

e=raw_input()
print sum([ord(l)-96for l in e if not l.isupper()]+[1.5*ord(l)-96for l in e if l.isupper()])

Primera presentación, no tan golfosa, pero uno tiene que comenzar en alguna parte.

def s2(p):
 c=0
 for l in p:
  if l.isupper():
   c+=(ord(l.lower())-96)*1.5
  else:
   c+=ord(l)-96
 return c
print s(raw_input())

Pyth, 23 20 bytes

sm|*hxGrdZ|}dG1.5 1z

Demostración en vivo y casos de prueba.

Explicación

 m                 z    For each input character
    hxGrdZ              Get the value of it's lowercase form, or 0 for non-alphabetic characters
   *      |}dG1.5       Multiply it by 1 if it's lowercase, 1.5 if uppercase
  |               1     If it's still zero, it's a non-alphabetic character, so use 1 as its value
s                       Sum of all the values

Algunos usos creativos de valores booleanos como enteros aquí.

Versión de 23 bytes:

sm+*hxGJrdZ|}dG1.5!}JGz

Demostración en vivo y casos de prueba.

Julia, 63 bytes

s->sum(c->isalpha(c)?(64<c<91?1.5:1)*(c-(64<c<91?'@':'`')):1,s)

Esto simplemente suma una matriz construida a través de una comprensión que recorre los caracteres en la cadena de entrada y realiza la aritmética en sus puntos de código.

Sin golf:

function char_score(c::Char)
    (64 < c < 91 ? 1.5 : 1) * (c - (64 < c < 91 ? '@' : '`')) : 1
end

function sentence_value(s::String)
    sum(char_score, s)
end

Gracias a Glen O por arreglar el enfoque.

Atascado , 85 43 Bytes

Sí, sí, lo sé, Python es más corto ...: P Estoy usando la misma lógica que Tryth ahora, en su mayor parte.

s_"str.isalpha"fgl;l-|0Gc"_91<1.5;^*96-":++

Explicación:

s_                                            # Take input & duplicate
  "str.isalpha"fg                             # Filter for only alpha chars, save
                 l;l-|                        # Determine number of symbols in start string
                      0Gc                     # Get saved string, convert to char array
                         "_91<1.5;^*96-":     # Logic to find score for each letter
                                         ++   # Sum the list of nums, add to # of symbols

Python 2, 101 bytes

v=0
for x in raw_input():v+=(ord(x.lower())-96)*(1.5 if ord(x)<96 else 1)if x.isalpha()else 1
print v

CJam, 30 bytes

q:i91,64fm1.5f*32,5f-+1fe>f=:+

Cómo funciona esto (¡guau, nunca he hecho uno de estos!):

   91,64fm1.5f*32,5f-+1fe>      Construct an array so that a[i] == score for chr(i)
q:i                             Read STDIN and convert to ASCII codes
                          f=    Index each from the array
                            :+  Sum the result

F #, 168 bytes

Realmente aún no jugamos al golf, pero un comienzo:

fun(w:string)->w|>Seq.map(fun c->if Char.IsLetter c then (if Char.IsUpper(c) then (float)(Math.Abs(64-(int)c))*1.5 else (float)(Math.Abs(96-(int)c))) else 1.0)|>Seq.sum

Aquí una versión más legible:

let calc (w : string) =
    w
    |> Seq.map (fun c -> if Char.IsLetter c then (if Char.IsUpper(c) then (float)(Math.Abs(64 - (int)c)) * 1.5 else (float)(Math.Abs (96 - (int)c))) else 1.0)
    |> Seq.sum

K, 30

+/1^(,/1 1.5*(.Q`a`A)!\:1+!26)

.

k)+/1^(,/1 1.5*(.Q`a`A)!\:1+!26)"Programming Puzzles & Code Golf"
349f

Cómo funciona:

.Q`a`A genera dos listas de letras minúsculas y mayúsculas

k).Q`a`A
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

!:1+til 26asigna cada letra en cada lista del 1 al 26

k)(.Q`a`A)!\:1+!26
"abcdefghijklmnopqrstuvwxyz"!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Multiplica la primera lista por 1, la última por 1.5

k)1 1.5*(.Q`a`A)!\:1+!26
"abcdefghijklmnopqrstuvwxyz"!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26f
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"!1.5 3 4.5 6 7.5 9 10.5 12 13.5 15 16.5 18 19.5 21 22.5 24 25.5 27 28.5 30 31.5 33 34.5 36 37.5 39

Pase a un solo diccionario usando ,/

k)(,/1 1.5*(.Q`a`A)!\:1+!26)
a| 1
b| 2
c| 3
d| 4
..

Asigna los caracteres de la cadena de entrada a las puntuaciones relevantes

k)(,/1 1.5*(.Q`a`A)!\:1+!26)"Programming Puzzles & Code Golf"
24 18 15 7 18 1 13 13 9 14 7 0n 24 21 26 26 12 5 19 0n 0n 0n 4.5 15 4 5 0n 10.5 15 12 6

Rellene cualquier valor nulo con 1

k)1^(,/1 1.5*(.Q`a`A)!\:1+!26)"Programming Puzzles & Code Golf"
24 18 15 7 18 1 13 13 9 14 7 1 24 21 26 26 12 5 19 1 1 1 4.5 15 4 5 1 10.5 15 12 6

Suma

k)+/1^(,/1 1.5*(.Q`a`A)!\:1+!26)"Programming Puzzles & Code Golf"
349f

JavaScript, 121 bytes

l=process.argv[2].split(""),r=0;for(k in l)c=l[k],o=c.toLowerCase(),r+=(o.charCodeAt(0)-96)*(o===c?1:1.5);console.log(r);

llamar al archivo js con nodo (nodo index.js "Cab")

MATLAB, 68 bytes

Esto aprovecha el hecho de que los caracteres se convierten automáticamente en enteros y que los valores booleanos se pueden sumar como enteros.

sum([t(t>96&t<132)-96,(t(t>64&t<91)-64)*1.5,t<65|(t>90&t<97)|t>122])

Perl 5, 77 bytes

@_=split//,$ARGV[0];$i+=(ord)*(/[a-z]/||/[A-Z]/*1.5||96/ord)-96for@_;print$i

Probado en v5.20.2.

Javascript (ES6), 85 82 80 67 bytes

Me encantan los desafíos rápidos y fáciles como este. :)

t=>[...t].map(c=>u+=(v=parseInt(c,36)-9)>0?v*(c>'Z'||1.5):1,u=0)&&u

Esto funciona interpretando cada carácter como un número base 36, multiplicándolo por 1 o 1.5 si es mayor que 9 ( a-zo A-Z), y dando 1 en su lugar si no. Como siempre, las sugerencias son bienvenidas!

Python 3: 86 85 bytes

t=0
for c in input():k=ord(c)-64;t+=k*1.5if 0<k<27else k-32if 32<k<59else 1
print(t)

C # 81 bytes

decimal a(string i){return i.Sum(c=>c>64&&c<91?(c-64)*1.5m:c>96&&c<123?c-96:1m);}

Llamar con (LinqPad):

a("Hello World").Dump();

PHP, 102 bytes

foreach(str_split($argv[1])as$c){$v=ord($c)-64;$s+=A<=$c&&$c<=Z?1.5*$v:(a<=$c&&$c<=z?$v-32:1);}echo$s;

Ejemplo de uso:

$ php -d error_reporting=0 value.php cab
6
$ php -d error_reporting=0 value.php Cab
7.5
$ php -d error_reporting=0 value.php 'Programming Puzzles & Code Golf'
349

Nada especial en el algoritmo. Cada carácter del argumento del primer programa ( $argv[1]) se compara Ay Zentonces ay zy contó en consecuencia.

PowerShell, 108 bytes

Decente competitivo, estoy un poco sorprendido. No está mal para no tener un operador ternario compacto.

Código:

$a=[char[]]$args[0];$a|%{$b=$_-64;If($b-in(1..26)){$c+=$b*1.5}ElseIf($b-in(33..58)){$c+=$b-32}Else{$c++}};$c

Explicado:

$a=[char[]]$args[0]                # Take command-line input, cast as char array
$a|%{                              # For each letter in the array
  $b=$_-64                         # Set $b as the int value of the letter (implicit casting), minus offset
  If($b-in(1..26)){$c+=$b*1.5}     # If it's a capital, multiply by 1.5.
                         # Note that $c implicitly starts at 0 the first time through
  ElseIf($b-in(33..58)){$c+=$b-32} # Not a capital
  Else{$c++}                       # Not a letter
  }
$c                                 # Print out the sum

C, 85 bytes

float f(char*s){return(*s-96)*!!islower(*s)+1.5*(*s-64)*!!isupper(*s)+(*++s?f(s):0);}

El !!antes islowery isupperson necesarios, porque no se garantiza que los valores booleanos devueltos por estas funciones sean 0y 1, ¡el verdadero valor estaba 1024en mi sistema!

Candy , 26 22 bytes

(~ "a" <{A # 64-2 / ​​3 * | A # 96-} h) Z

¡Gracias a @ Tryth por el truco de factorización!

(~"a"<{A2/3*|A}#96-h)Z

La invocación es con la bandera -I, como en candy -I "Cab" -e $prg

El código en su forma larga es:

while     # loop while able to consume characters from stack
  peekA   # A gets stack to
  "a"
  less    # is pop() < "a"
  if
    pushA   # capitalized
    digit2
    div
    digit3
    mult
  else
    pushA   # lower case
  endif
  number
  digit9
  digit6
  sub
  popAddZ   # add pop() to counter register Z
endwhile
pushZ       # push Z onto stack as answer

Prólogo (SWI), 101 bytes

Código:

X*Y:-X>64,X<91,Y is X*1.5-96;X>96,X<123,Y is X-96.
_*1.
p(L):-maplist(*,L,A),sumlist(A,B),write(B).

Explicado:

X*Y:-X>64,X<91,       % When X is upper case
     Y is X*1.5-96    %      Y is 1.5 times charvalue starting at 1
     ;X>96,X<123,     % OR when X is lower case
     Y is X-96.       %      Y is charvalue starting at 1
_*1.                  % ELSE Y is 1
p(L):-maplist(*,L,A), % Get list of charvalues for all chars in string
      sumlist(A,B),   % Take sum of list
      write(B).       % Print

Ejemplo:

p(`Cab`).
7.5

PHP, 75 bytes

while(~$c=$argn[$i++])$r+=ctype_alpha($c)?ord($c)%32*(1+($c<a)/2):1;echo$r;

Ejecutar como tubería -nro probarlo en línea .