Aufgabe

Erstellen Sie einen Taschenrechner, der eine beliebige Zeichenfolge aus einer Datei, stdin oder was auch immer nimmt und alle Werte der Zeichen addiert.

Beispiel

Input
Hello World!

Output
1085

Regeln

Der Rechner muss nur ASCII-Codierung akzeptieren.

Der kürzeste Code gewinnt.

Anmerkungen

Zu dem Kommentar von m.buettner muss ich sagen, ich habe nicht an den Multibyte-Teil gedacht.
Also lasse ich es auch als Bonus.
Der Taschenrechner sollte so ausgeführt werden, wie er geschrieben wurde, sodass vor dem Kompilieren oder Interpretieren keine Änderungen erforderlich sind.

Bonus

Dank Synthetica gibt es hier noch einen Bonus,

Das Programm , das die niedrigste Ausgang hat , wenn Sie seinen Code als seine Eingabe verwenden gewinnt bekommt einen Stern.

Ich möchte es nicht komplett modifizieren.

Wenn Sie es zusätzlich schreiben, um den (rechten) Wert in UTF-8 auszugeben, erhalten Sie einen Stern.

Der Code, der auf meinem Laptop am schnellsten ausgeführt wird (Lenovo Yoga 13 Intel Core i5 3317U 1,7 GHz, 8 GB RAM, 128 GB SSD, Intel HD 4000, Windows 8), erhält einen Stern.

Webcodes werden zuerst unter IE11 mit Chakra und dann in FireFox 29.0.1 mit SpiderMonkey ausgeführt

Linux-Code läuft auf einem Raspberry Pi mit Raspbian.

Der Teststring lautet wie folgt:

q/%8hnp>T%y?'wNb\},9krW &D9']K$n;l.3O+tE*$*._B^s!@k\&Cl:EO1zo8sVxEvBxCock_I+2o6 yeX*0Xq:tS^f)!!7=!tk9K<6#/E`ks(D'$z$\6Ac+MT&[s[]_Y(`<g%"w%cW'`c&q)D$0#C$QGf>?A$iawvc,}`9!('`c&q)D$0#C$QGf>?A$iawvc,}`9!(

Viel Spaß beim Programmieren :)

Bonusscoring

Ich plane, die Wertung an diesem Samstag zu machen, damit am 07.06.14 alle Antworten nach diesem Datum keine Bonuspunkte mehr bekommen;)

Sie können den Code, den ich zum Testen verwenden werde, hier herunterladen. Fühlen Sie sich frei, ihn zu teilen und zu verbessern :)

Kleines Update wegen des Bonus, mein Laptop ist teilweise kaputt, also werde ich es wahrscheinlich nächstes Wochenende machen, das tut mir wirklich leid :(

GolfScript, 4 Zeichen

{+}*

Verwenden Sie einfach den Fold-Operator ( *), um alle Zeichen zu addieren.

Wenn es mit der leeren Zeichenfolge funktionieren muss, 9 Zeichen:

{{+}*}0if

Vielen Dank an @PeterTaylor für die Bereitstellung einer alternativen 6-Zeichen-Version, die mit einer leeren Zeichenfolge funktioniert:

0\{+}/

APL (8)

+/⎕UCS⍞

Erläuterung:

• +/ die Summe von
• ⎕UCS Unicode-Werte von
• ⍞ Zeicheneingabe

Haskell 36

main=interact$show.sum.map fromEnum

Shell + GNU-Tools, 29 Byte

echo `od -An -tuC`|tr \  +|bc

Übernimmt die Eingabe von stdin:

$ printf "%s" 'Hello World!' | ./addchars.sh 
1085
$ 

Eigene Punktzahl: 2385

c, 52 Bytes

c;main(p){while(~(p=getchar()))c+=p;printf("%d",c);}

Kompilieren Sie mit (einige Warnungen erzeugt):

gcc addchars.c -o addchars

Übernimmt die Eingabe von stdin:

$ printf "%s" 'Hello World!' | ./addchars 
1085 $ 

Eigene Punktzahl: 4354

Javascript ( ES6 ) 51

alert([...prompt(x=0)].map(y=>x+=y.charCodeAt())|x)

gs2 , 1 byte

d

d( 0x64/ sum) fasst natürlich alle Bytes in der Standardeingabe zusammen.

Python 3 - 28 Bytes

print(sum(map(ord,input())))

Beispiellauf:

$ ./sum_string.py <<< 'Hello World!'
1085

Ruft die Eingabe von stdin ab, maps die ordFunktion, um den ASCII-Wert jedes Zeichens abzurufen, sums it und prints.

8086 Assembly (16 Bit) - 47 41 Byte

Der Inhalt der test.comDatei ist:

98 01 c3 b4 01 cd 21 3c 0d 75 f5 89 c7 c6 05 24
89 d8 b1 0a 4f 31 d2 f7 f1 80 ca 30 88 15 09 c0
75 f2 89 fa b4 09 cd 21 c3

Die eigentliche Arbeit wird in den ersten 11 Bytes erledigt; Ich brauche den Rest, um das Ergebnis in Dezimalschreibweise auszudrucken.

Quellcode (als Eingabe für den DOS- debug.comAssembler):

a
; input the string; count the sum
    cbw
    add bx, ax
    mov ah, 1
    int 21
    cmp al, d
    jne 100
; Prepare for output: stuff an end-of-line marker
    mov di, ax
    mov [di], byte 24
    mov ax, bx
    mov cl, a
; 114
; Divide by 10; write digits to buffer
    dec di
    xor dx, dx
    div cx
    or  dl, 30
    mov [di], dl
    or  ax, ax
    jne 114
; Print the string
    mov dx, di
    mov ah, 9
    int 21
    ret

rcx 29
n test.com
w
q

Einige Anmerkungen zum Code:

• Behandelt nur eine Zeile (bis zum Zeilenendezeichen 13); hängt, wenn kein Zeilenende vorhanden ist
• Es werden nur 7-Bit-Zeichen unterstützt (sonst sind die Ergebnisse falsch)
• Gibt 0 für leere Eingabe aus
• Kann keine Ausgabe verarbeiten, die größer als 64 KB ist
• Anweisung an Adresse 0x10d überschreibt sich selbst (reiner Zufall)
• Sie müssen DOS-Emulatoren wie DosBox verwenden , um dieses Programm zusammenzustellen und auszuführen

CJam, 3 Bytes (Summe 260)

q1b

Sie können es online ausprobieren .
Danke jimmy23013, dass du dabei hilfst, 2 Charaktere abzuhacken :)

Erläuterung:

q     read the input into a string  
1b    convert from base 1, treating each character as its numeric value

Befunge98, 6 Bytes, Summe: 445

2j@.~+

Jeder Dolmetscher sollte in Ordnung sein. Ich benutze CCBI .

Verwenden Sie wie folgt:

printf 'Hello World!' | ccbi calc.fg

Funktioniert für Multibyte-Zeichen und leere Zeichenfolgen.

Erläuterung

• 2j- die nächsten beiden Anweisungen überspringen ( @und .- siehe unten)
• ~ - den nächsten char auf den stapel legen
• +- Addiere den Code-Wert des neuen Zeichens zur aktuellen Summe. Der Befehlszeiger springt an den Anfang und der Zyklus wiederholt sich
• Wenn er ~auf ein EOF trifft, kehrt er die Richtung des Zeigers um und die beiden "versteckten" Anweisungen werden ausgeführt:
• . - die Summe ausdrucken
• @ - Ausfahrt

Ruby, 13 bis 12 Bytes

p~9+gets.sum

sumist eine integrierte Funktion, die die Zeichen einer Zeichenfolge summiert. Subtrahiert 10, um den Zeilenumbruch am Ende des getsRückgabewerts zu berücksichtigen .

(Edited 4 Jahre später zu ändern , x-10um ~9+x... den Wert ~9heißt -10, aber es lässt uns den Raum zwischen entfernen pund seinem Argument, ein Byte zu speichern.)

PowerShell - 27

[char[]]$args[0]|measure -s

Beispiel

> SumChars.ps1 'Hello World!'

Count    : 12
Average  : 
Sum      : 1085
Maximum  : 
Minimum  : 
Property : 

Julia - 11 7 Zeichen, resultierende Summe = 943 536

Da die Frage zulässt, dass die Eingabe von einer beliebigen Quelle stammt, wähle ich eine vorhandene Variable. Angenommen, diese Aenthält den String, den wir auswerten möchten.

sum(A)1

Wie sich herausstellt, können Sie die Zeichenfolge direkt summieren, und sie wird ausgewertet. Aufgrund der Art und Weise, wie Zeichen summiert werden, wird jedoch ein Zeichen ausgegeben, wenn die Zeichenfolge eine ungerade Anzahl von Zeichen enthält. eher als eine ganze Zahl jeglicher Art. Als solches erzwingen wir die Umwandlung auf int, indem wir mit 1 multiplizieren.

Alte Version:

sum(A.data)

Wird in hexadezimaler Schreibweise ausgegeben (wenn die Summe kleiner als 256 ist, ist dies der Fall 0x??, andernfalls sind es 8 Byte 0x????????). Wenn es in Code verwendet wird, in dem das Ergebnis verwendet wird, funktioniert es wie jede andere Zahl (Julia zeigt nur nicht signierte Ints an).

Um den Wert des Ergebnisses als Dezimalzahl anzuzeigen, schließen Sie das Obige in int()wie in ein int(sum(A.data)).

Für alle, die Julia nicht kennen, weisen Sie sie Agenau so zu, wie Sie andere Zuweisungen für Variablen vornehmen. Also, A="Hello World!"oder A="sum(n.data)". In dem Fall, dass Sie in setzen müssen "oder 'Zeichen gibt es mehrere Optionen, die einfachste davon (weil es Bedürfnis nach Kenntnis der Nuancen von Julia Stringliterale vermeidet) ist A=readline(), gefolgt von der einfach in der Zeichenfolge in STDIN eingeben (won‘ nicht mit Zeilenumbrüchen umgehen). Die Escape-Sequenz für newline ist wie üblich, \naber ich glaube nicht, dass Sie das mit readline () verwenden können.

K5, 2 Bytes (Funktion), 5 Bytes (Programm)

Funktion

+/

Programm

+/0:`

Ich bin mir nicht sicher, ob K5 vor oder nach dem Posten dieser Herausforderung erstellt wurde. Egal ... DAS IST FANTASTISCH !!

Wenn Sie in K5 arithmetische Operationen für Zeichenfolgen ausführen, werden die Zeichen in ihre ASCII-Codes konvertiert. Hier wird nur der Summenoperator verwendet +/(eigentlich ist das Plus + vorbei).

Matlab / Octave 4 Bytes (Bonus: 405)

Dieser Code ist eine anonyme Funktion, die den Job erledigt, eine Zeichenfolge akzeptiert und die erforderliche Nummer zurückgibt.

@sum

Go (59 Zeichen)

func d(s string)(t int){for _,x:=range s{t+=int(x)};return}

Alles in Go ist standardmäßig utf8. Codetext in Delimetern, der durch sich selbst läuft, ergibt eine Ausgabe von: 5399.

Jolf, 2 Bytes (nicht konkurrierend)

Probieren Sie es hier aus!

ui
u  sum of
 i  the input string

Ähm ... Ich weiß nicht, was ich sonst sagen soll.

Gol> <> , 4 Bytes (nicht konkurrierend)

Hinweis: Diese Sprache ist neuer als die Herausforderung.

iEh+

Javascript ES6, 41 Bytes

_=>[..._].map(y=>x+=y.charCodeAt(),x=0)|x

Danke an @ETHproductions für 2 Bytes gespart!

Python, 24 Bytes

Dies ist kürzer als jede andere Python-Lösung: Eine unbenannte anonyme Funktion, die die Zeichenfolge als Argument verwendet und die Summe zurückgibt.

lambda x:sum(x.encode())

Probieren Sie es online!

Zuerst x.encode()wandelt es in ein bytesObjekt. Dann sumfügt die Zeichen-Code - Werte. Da dies eine Lambda-Funktion ist, wird der Wert implizit zurückgegeben.

Zusätzlich könnte man lambda x:sum(map(ord,x))für die gleiche Byteanzahl haben.

SML, 42 36

Füge einfach eine weitere Sprache hinzu.

fun$x=foldl op+0(map ord(explode x))

Konvertiert String in char-Array, berechnet die ASCII-Nummer jedes Werts und berechnet die Summe aller ASCII-Nummern.

C 32

f(char*s){return*s?*s+f(s+1):0;}

D (Funktion: 60)

Auf jeden Fall nicht drin, um es zu gewinnen.

Vorausgesetzt, es muss kein vollständiges Programm sein

int c(string i){int s;foreach(e;i){s+=cast(int)e;}return s;}

Genannt wie so

void main ()
{
    import std.stdio;
    auto hw = "Hello World!";
    writefln("%s = %d", hw, c(hw));
}

Ausgabe:

Hello World! = 1085

D (Programm: 133)

Zählt keine Zeilenumbrüche.

void main(){import std.algorithm,std.stdio;stdin.byLine.map!((a){int s;foreach(e;a){s+=cast(int)e;}return s;}).reduce!"a+b".writeln;}

Mit mehr Leerzeichen und längeren Variablennamen zur besseren Lesbarkeit

void main () {
    import std.algorithm, std.stdio;

    stdin.byLine
        .map!((line) {
                int sum;
                foreach (ch; line) {
                    sum += cast(int)ch;
                }
                return sum;
            })
        .reduce!"a+b"
        .writeln;
}

Um Zeilenumbrüche in der Eingabe zu unterstützen, könnte ich entweder byLine(KeepTerminator.yes)die richtige Methode für 20 Zeichen verwenden oder ein '\n'an meine Zeile anhängen , wodurch die Eingabe in einer Zeile unterbrochen wird und unter Windows aufgrund von CRLF möglicherweise die falsche Summe für 18 Zeichen angegeben wird.

JavaScript (ES6) 54 58

alert([].reduce.call(prompt(),(v,c)=>v+c.charCodeAt(0),0))

54 Bytes dank nderscore :

alert([...prompt()].reduce((v,c)=>v+c.charCodeAt(),0))

Delphi ( 87 83)

function x(s:string):int64;var c:char;begin x:=0;for c in s do x:=result+ord(c)end;

Ungolfed

function x(s:string):int64;
var
  c:char;
begin
  x:=0;
  for c in s do
    x:=result+ord(c)
end;

Schleifen durch S Addition orddes Zeichenwerts zum Ergebnis. Wobei x == Ergebnis

Bearbeitungen:

4 Zeichen durch Umschalten auf int64 und Ändern der Addition zur Summe gespeichert.

k (8 Zeichen)

+/6h$0:0

Q Übersetzung

sum `int$read0 0

Bonuswert:

k)+/6h$0:0
+/6h$0:0
438i

J (7)

So nah und doch so fern ... Naja, ich denke 7 ist anständig genug, da diese Antwort auch leere Zeichenketten akzeptiert. (Ich verwende eine Variable als Eingabe für die Phrase. from a file, stdin or whatever)

+/a.i.b

Erläuterung:

a.

┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~��������������������������������������������������������������������������������������������������������������������������������

a. enthält alle ASCII-Zeichen.

   'people' i. 'pow'
0 2 6

x i. yist ähnlich wie Python [x.index(i) for i in y].

   a. i. 'Hello World!'
72 101 108 108 111 32 87 111 114 108 100 33

Hierfür, a. i. ywandelt yin ein Array von Werten seiner ASCII

   +/1 2 3 4 5 6
21

+/ist wie sum: +/1 2 3 4 5 6bedeutet1+2+3+4+5+6

   +/ a. i. 'Hello World!'
1085

Das Ganze in Aktion

Für den Bonus:

   b=:'+/a.i.b'
   +/a.i.b
482

Nicht schlecht, denke ich.

   b=:'0\{+}/'
   +/a.i.b
478

Na verdammt.

   A=:'+/a.i.A'
   +/a.i.A
449

Vielen Dank, @algorithmshark

    A=:'+/3 u:A'
    +/3 u:A
413

Vielen Dank @marinus

R, 35 Zeichen (Summe von 3086) 26 Bytes (Summe von 2305)

sum(utf8ToInt(readline()))

readline()ist ein Zeichen länger als scan(,""), scanteilt die Eingabe jedoch standardmäßig in Leerzeichen auf.

Verwendung:

> sum(utf8ToInt(readline()))
Hello World!
[1] 1085
> sum(utf8ToInt(readline()))
sum(utf8ToInt(readline()))
[1] 2305
> sum(utf8ToInt(readline()))
q/%8hnp>T%y?'wNb\},9krW &D9']K$n;l.3O+tE*$*._B^s!@k\&Cl:EO1zo8sVxEvBxCock_I+2o6 yeX*0Xq:tS^f)!!7=!tk9K<6#/E`ks(D'$z$\6Ac+MT&[s[]_Y(`<g%"w%cW'`c&q)D$0#C$QGf>?A$iawvc,}`9!('`c&q)D$0#C$QGf>?A$iawvc,}`9!(
[1] 14835

Japt , 6 Bytes (nicht konkurrierend)

Diese Antwort ist nicht konkurrierend, da Japt erstellt wurde, nachdem diese Herausforderung veröffentlicht wurde.

U¬mc x

Ziemlich einfach. Probieren Sie es online!

Wie es funktioniert

U¬mc x  // Implicit: U = input string
U¬      // Split U into chars.
  mc    // Map each item to its char code.
     x  // Sum.
        // Implicit: output last expression

PlatyPar , 2 Bytes (nicht konkurrierend)

us

Probieren Sie es online !

ugeneriert ein Array aller Zeichencodewerte in der Eingabezeichenfolge und ermittelt sderen Summe.

Wenn es auf sich selbst läuft, kehrt es zurück 232.

Dies ähnelt Conors Jolf-Antwort , außer dass ich ein Byte verwende, um die Zeichenfolge in ein Array von Zeichencodes zu konvertieren (was in Jolf impliziert ist), während er ein Byte verwendet, um die Eingabe abzurufen (was in PlatyPar impliziert ist).