Einführung

Im Land von [Coolen Namen hier einfügen] kaufen die Leute nichts mit Geld, weil jeder eine schwere Allergie gegen Papier hat. Sie bezahlen sich mit Worten! Aber wie ist das Nun, sie geben jedem Buchstaben Zahlenwerte:

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

(Mit einigen anderen Sonderregeln, die später beschrieben werden)

In dieser Herausforderung besteht Ihre Aufgabe darin, den Wert von Sätzen zu berechnen.

Herausforderung

Sie werden eine Eingabe machen, die ein Satz ist. Sie können davon ausgehen, dass die Eingabe keine Zeilenumbrüche oder Leerzeichen enthält. Die Herausforderung besteht darin, den Wert des Satzes nach folgenden Regeln zu berechnen:

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

• Ein Großbuchstabe hat den 1,5-fachen Wert des entsprechenden Kleinbuchstabens

H=h*1.5

Also das Wort

cab

Wäre es wert c+a+b = 3+1+2 = 6

Aber das Wort Cabmit einem Großbuchstaben c wäre wert. (c*1.5)+a+b = 4.5+1+2 = 7.5 Wenn Ihre Programmeingabe "Cab" wäre, würde Ihr Programm 7.5 ausgeben

• Alle nicht alphabetischen Zeichen sind 1 wert.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes. Viel Glück!

Python 3, 71 65 61 Bytes

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

Durch einen außergewöhnlichen Zufall (ord(s)-64)*1.5ist es gleich ord(s)*1.5-96, also müssen wir nur -96einmal schreiben . Der Rest ist ziemlich direkt.

Bearbeiten: Einige Bytes mit Exponentiation-Spielereien abgeschabt.

Python 2, 120 102 Bytes

Bearbeiten:

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

Erste Vorlage, nicht so golfen, aber man muss irgendwo anfangen.

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

Live-Demo und Testfälle.

Erläuterung

 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

Nicht wenige kreative Verwendungen von Booleschen Werten als Ganzzahlen hier.

23-Byte-Version:

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

Live-Demo und Testfälle.

Julia, 63 Bytes

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

Dies summiert einfach ein Array, das über ein Verständnis aufgebaut ist, das die Zeichen in der Eingabezeichenfolge durchläuft und an ihren Codepunkten eine Arithmetik durchführt.

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

Vielen Dank an Glen O für die Korrektur des Ansatzes.

Feststecken , 85 43 Bytes

Yeah yeah, ich weiß, Python ist kürzer.: P Ich verwende zum größten Teil die gleiche Logik wie Tryth.

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

Erläuterung:

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=:+

So funktioniert das (wow, ich habe noch nie eines davon gemacht!):

   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

Noch nicht richtig golfen, aber ein Anfang:

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

Hier eine lesbarere Version:

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

Wie es funktioniert:

.Q`a`A generiert zwei Listen mit Klein- und Großbuchstaben

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

!:1+til 26ordnet jeden Buchstaben in jeder Liste von 1 bis 26 zu

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

Multiplizieren Sie die erste Liste mit 1, die letzte mit 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

Mit in ein einzelnes Wörterbuch zerlegen ,/

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

Ordnen Sie die Zeichen in der Eingabezeichenfolge den entsprechenden Ergebnissen zu

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

Füllen Sie alle Nullwerte mit 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

Summe

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

js-Datei mit node aufrufen (node ​​index.js "Cab")

MATLAB, 68 Bytes

Dies nutzt die Tatsache aus, dass Zeichen automatisch in Ganzzahlen umgewandelt werden und dass Boolesche Werte als Ganzzahlen summiert werden können.

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

Getestet am v5.20.2.

Javascript (ES6), 85 82 80 67 Bytes

Ich mag solche schnellen und einfachen Herausforderungen. :)

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

Dies funktioniert, indem jedes Zeichen als Basis-36-Zahl interpretiert wird, mit 1 oder 1,5 multipliziert wird, wenn es größer als 9 ( a-zoder A-Z) ist, und stattdessen 1 gegeben wird, wenn dies nicht der Fall ist. Wie immer sind Vorschläge willkommen!

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

Mit (LinqPad) anrufen:

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;

Anwendungsbeispiel:

$ 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

Nichts Besonderes im Algorithmus. Jedes Zeichen aus dem Argument ( $argv[1]) des ersten Programms wird gegen Aund Zdann aund geprüft zund entsprechend gezählt.

PowerShell, 108 Bytes

Anständig wettbewerbsfähig, ich bin ein bisschen überrascht. Nicht allzu schäbig, wenn man keinen kompakten ternären Operator hat.

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

Erklärt:

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

Die !!vor islowerund isuppersind notwendig, da die von diesen Funktionen zurückgegebenen Booleschen Werte nicht garantiert sind 0und der 1wahre Wert 1024tatsächlich auf meinem System war!

Süßigkeit , 26 22 Bytes

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

Vielen Dank an @Tryth für den Faktorisierungstrick!

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

Der Aufruf erfolgt mit dem Flag -I wie in candy -I "Cab" -e $prg

Der Code in seiner langen Form ist:

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 Bytes

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

Erklärt:

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

Beispiel:

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;

Laufen Sie als Pipe mit -nroder versuchen Sie es online .