introduction

Au pays de [Insérez un nom sympa ici], les gens n'achètent pas de choses avec de l'argent, car tout le monde est allergique au papier. Ils se payent des mots! Mais comment est-ce? Eh bien, ils donnent à chaque lettre des valeurs numériques:

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

(Avec quelques autres règles spéciales qui seront décrites plus loin)

Dans ce défi, votre tâche consistera à calculer la valeur des phrases.

Défi

Vous prendrez une entrée qui sera une phrase. Vous pouvez supposer que l'entrée n'a pas de nouvelles lignes ni d'espaces de fin. Le défi sera de calculer la valeur de la phrase, en utilisant ces règles:

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

• Une lettre majuscule vaut 1,5 fois sa lettre minuscule correspondante

H=h*1.5

Donc, le mot

cab

Ça vaudrait le coup c+a+b = 3+1+2 = 6

Mais le mot Cabavec un c majuscule vaudrait(c*1.5)+a+b = 4.5+1+2 = 7.5 donc Si votre entrée de programme était "Cab" votre programme sortirait 7,5

• Tous les caractères non alphabétiques valent 1.

C'est le golf de code, donc la réponse la plus courte en octets l'emporte. Bonne chance!

Python 3, 71 65 61 octets

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

Par une coïncidence extraordinaire, (ord(s)-64)*1.5est égal à ord(s)*1.5-96, nous n'avons donc qu'à écrire -96une fois. Le reste est assez simple.

Edit: rasé certains octets à l'aide de manigances d'exponentiation.

Python 2, 120 102 octets

Éditer:

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

Première soumission, pas trop golfique mais il faut commencer quelque part.

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 octets

sm|*hxGrdZ|}dG1.5 1z

Démonstration en direct et cas de test.

Explication

 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

Beaucoup d'utilisations créatives des valeurs booléennes en tant qu'entiers ici.

Version 23 octets:

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

Démonstration en direct et cas de test.

Julia, 63 octets

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

Cela résume simplement un tableau construit via une compréhension qui boucle sur les caractères de la chaîne d'entrée et effectue une arithmétique sur leurs points de code.

Non 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

Merci à Glen O d'avoir corrigé l'approche.

Bloqué , 85 43 octets

Ouais ouais, je sais, Python est plus court ..: P J'utilise la même logique que Tryth maintenant, pour la plupart.

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

Explication:

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 octets

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 octets

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

Comment cela fonctionne (wow, je n'en ai jamais fait!):

   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 octets

Pas encore vraiment joué au golf, mais un début:

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

Voici une version plus lisible:

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

Comment ça fonctionne:

.Q`a`A génère deux listes de lettres minuscules et majuscules

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

!:1+til 26mappe chaque lettre de chaque liste de 1 à 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

Multipliez la première liste par 1, la dernière par 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

Transformez-vous en un seul dictionnaire en utilisant ,/

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

Mappez les caractères de la chaîne d'entrée aux scores pertinents

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

Remplissez toutes les valeurs nulles avec 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

Somme

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

JavaScript, 121 octets

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

appeler le fichier js avec le nœud (node ​​index.js "Cab")

MATLAB, 68 octets

Cela profite du fait que les caractères sont automatiquement transtypés en entiers et que les valeurs booléennes peuvent être additionnées sous forme d'entiers.

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 octets

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

Testé sur v5.20.2.

Javascript (ES6), 85 82 80 67 octets

J'adore les défis rapides et faciles comme celui-ci. :)

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

Cela fonctionne en interprétant chaque caractère comme un nombre en base 36, en le multipliant par 1 ou 1,5 s'il est supérieur à 9 ( a-zou A-Z), et en donnant 1 à la place sinon. Comme toujours, les suggestions sont les bienvenues!

Python 3: 86 85 octets

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 octets

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

Appeler avec (LinqPad):

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

PHP, 102 octets

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;

Exemple d'utilisation:

$ 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

Rien de spécial dans l'algorithme. Chaque caractère de l'argument du premier programme ( $argv[1]) est vérifié A, Zpuis aet zet compté en conséquence.

PowerShell, 108 octets

Décemment compétitif, je suis un peu surpris. Pas trop minable pour ne pas avoir d'opérateur ternaire compact.

Code:

$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

Expliqué:

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

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

L' !!avant isloweret isuppersont nécessaires, car les valeurs booléennes renvoyées par ces fonctions ne sont pas garanties d'être, 0et la 1vraie valeur était 1024en effet sur mon système!

Candy , 26 22 octets

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

Merci à @Tryth pour l'astuce de factorisation!

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

L'invocation est avec le drapeau -I, comme dans candy -I "Cab" -e $prg

Le code dans sa forme longue est:

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 octets

Code:

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

Expliqué:

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

Exemple:

p(`Cab`).
7.5

PHP, 75 octets

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

Exécuter en tant que pipe avec -nrou l' essayer en ligne .