introduzione

Nella terra di [Inserisci qui un bel nome], la gente non compra cose con i soldi, perché tutti hanno una grave allergia alla carta. Si pagano a parole! Ma come va? Bene, danno ad ogni lettera i valori numerici:

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

(Con alcune altre regole speciali che verranno descritte in seguito)

In questa sfida, il tuo compito sarà calcolare il valore delle frasi.

Sfida

Riceverai un input che sarà una frase. Si può presumere che l'input non abbia newline o spazi finali. La sfida sarà calcolare il valore della frase, usando queste regole:

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

• Una lettera maiuscola vale 1,5 volte la corrispondente lettera minuscola

H=h*1.5

Quindi, la parola

cab

Ne varrebbe la pena c+a+b = 3+1+2 = 6

Ma la parola Cabcon la maiuscola c varrebbe. (c*1.5)+a+b = 4.5+1+2 = 7.5 Quindi, se il tuo input di programma fosse "Cab", il tuo programma avrebbe prodotto 7.5

• Tutti i caratteri non alfabetici valgono 1.

Questo è il golf del codice, quindi vince la risposta più breve in byte. In bocca al lupo!

Python 3, 71 65 61 byte

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

Per una straordinaria coincidenza, (ord(s)-64)*1.5è uguale a ord(s)*1.5-96, quindi dobbiamo scrivere solo -96una volta. Il resto è piuttosto semplice.

Modifica: rasato alcuni byte usando shenanigans esponenziali.

Python 2, 120 102 byte

Modificare:

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()])

Prima presentazione, non così da golf ma bisogna cominciare da qualche 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 byte

sm|*hxGrdZ|}dG1.5 1z

Demo live e casi di test.

Spiegazione

 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

Parecchi usi creativi di valori booleani come numeri interi qui.

Versione a 23 byte:

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

Demo live e casi di test.

Julia, 63 byte

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

Questo semplicemente somma un array costruito attraverso una comprensione che scorre sopra i caratteri nella stringa di input ed esegue l'aritmetica sui loro punti di codice.

Ungolfed:

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

Grazie a Glen O per aver risolto l'approccio.

Bloccato , 85 43 byte

Sì sì, lo so, Python è più corto ..: P Sto usando la stessa logica di Tryth ora, per la maggior parte.

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

Spiegazione:

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 byte

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 byte

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

Come funziona (wow, non ne ho mai realizzato uno!):

   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 byte

Non ho ancora giocato a golf, ma un inizio:

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

Ecco una versione più leggibile:

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

Come funziona:

.Q`a`A genera due elenchi di lettere minuscole e maiuscole

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

!:1+til 26mappa ogni lettera in ogni elenco da 1 a 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

Moltiplica il primo elenco per 1, l'ultimo per 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

Usa il raze in un unico dizionario ,/

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

Mappare i caratteri nella stringa di input sui punteggi pertinenti

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

Inserisci i valori null 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

Somma

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

JavaScript, 121 byte

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

chiama il file js con il nodo (nodo index.js "Cab")

MATLAB, 68 byte

Ciò sfrutta il fatto che i caratteri vengono automaticamente convertiti in numeri interi e che i valori booleani possono essere sommati come numeri interi.

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 byte

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

Testato su v5.20.2.

Javascript (ES6), 85 82 80 67 byte

Adoro le sfide facili e veloci come questa. :)

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

Funziona interpretando ciascun carattere come un numero base-36, moltiplicandolo per 1 o 1,5 se è maggiore di 9 (a-z o A-Z), e dando 1 invece in caso contrario. Come sempre, suggerimenti benvenuti!

Python 3: 86 85 byte

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 byte

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

Chiama con (LinqPad):

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

PHP, 102 byte

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;

Esempio di utilizzo:

$ 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

Niente di speciale nell'algoritmo. Ogni carattere dell'argomento del primo programma ( $argv[1]) viene verificato Ae Zquindi ae ze conteggiato di conseguenza.

PowerShell, 108 byte

Abbastanza competitivo, sono un po 'sorpreso. Non troppo malandato per non avere un operatore Ternario compatto.

Codice:

$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

Ha spiegato:

$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 byte

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

I !!prima islowere isuppersono necessari, perché i valori booleani restituiti da queste funzioni non sono garantiti 0e 1, il vero valore era 1024davvero sul mio sistema!

Candy , 26 22 byte

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

Grazie a @ Tryth per il trucco di fattorizzazione!

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

L'invito è con la bandiera -I, come in candy -I "Cab" -e $prg

Il codice nella sua forma lunga è:

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

Prolog (SWI), 101 byte

Codice:

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

Ha spiegato:

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

Esempio:

p(`Cab`).
7.5

PHP, 75 byte

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

Esegui come pipe -nro provalo online .