Tâche

Construisez une calculatrice, qui prend n'importe quelle chaîne, à partir d'un fichier, stdin ou autre, et additionne toutes les valeurs des caractères.

Exemple

Input
Hello World!

Output
1085

Règles

La calculatrice doit accepter uniquement le codage ASCII.

Le code le plus court gagne.

Remarques

En ce qui concerne le commentaire de m.buettner, je dois dire que je n'ai pas pensé à la partie multi-octets.
Je laisse donc cela en bonus.
La calculatrice doit être exécutée telle qu'elle est écrite, donc pas besoin de la modifier avant la compilation ou l'interprétation.

Prime

Grâce à Synthetica , voici encore un bonus,

Le programme qui a la sortie la plus faible lorsque vous utilisez son code lorsque son entrée gagne obtient une étoile.

Je ne veux pas le modifier complètement.

Si vous l'écrivez en plus pour afficher la valeur (à droite) en UTF-8, vous obtenez une étoile.

Le code qui s'exécute le plus rapidement sur mon ordinateur portable (Lenovo Yoga 13 Intel Core i5 3317U 1,7 GHz, 8 Go de RAM, 128 Go SSD, Intel HD 4000, Windows 8) obtient une étoile.

Les codes Web s'exécuteront d'abord sous IE11 avec chakra puis dans FireFox 29.0.1 avec SpiderMonkey

Le code Linux s'exécutera sur un Raspberry Pi avec Raspbian.

La corde de test est la suivante:

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!(

Amusez-vous à coder :)

Bonusscoring

J'ai l'intention de faire le pointage ce samedi afin que le 07.06.14, toutes les réponses après cette date n'obtiennent pas de points bonus;)

Vous pouvez télécharger le code que je vais utiliser pour les tests ici, n'hésitez pas à le fork et à l'améliorer :)

Petite mise à jour à cause du bonus, mon ordinateur portable est partiellement cassé donc je le ferai probablement le week-end prochain, j'en suis vraiment désolé :(

GolfScript, 4 caractères

{+}*

Utilise simplement l'opérateur de pliage ( *) pour additionner tous les caractères.

Si cela doit fonctionner avec la chaîne vide, 9 caractères:

{{+}*}0if

Merci à @PeterTaylor d'avoir fourni une version alternative à 6 caractères qui fonctionne avec une chaîne vide:

0\{+}/

APL (8)

+/⎕UCS⍞

Explication:

• +/ somme de
• ⎕UCS valeurs unicode de
• ⍞ saisie de caractères

Haskell 36

main=interact$show.sum.map fromEnum

Outils Shell + GNU, 29 octets

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

Prend l'entrée de stdin:

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

Score propre: 2385

c, 52 octets

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

Compiler avec (quelques avertissements produits):

gcc addchars.c -o addchars

Prend l'entrée de stdin:

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

Score propre: 4354

Javascript ( ES6 ) 51

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

gs2 , 1 octet

d

d( 0x64/ sum), bien sûr, résume tous les octets en entrée standard.

Python 3 - 28 octets

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

Exemple d'exécution:

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

Obtient l'entrée de stdin, maps la ordfonction pour obtenir la valeur ASCII de chaque caractère, sums it et prints.

Assemblage 8086 (16 bits) - 47 41 octets

Le contenu du test.comfichier est:

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

Le travail réel est effectué dans les 11 premiers octets; J'ai besoin du reste pour imprimer le résultat en notation décimale.

Code source (donne en entrée à l' debug.comassembleur DOS ):

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

Quelques notes sur le code:

• Ne gère qu'une seule ligne (jusqu'au caractère de fin de ligne 13); se bloque si aucune fin de ligne
• Seuls les caractères 7 bits sont pris en charge (sinon les résultats sont incorrects)
• Sorties 0 pour entrée vide
• Impossible de gérer une sortie supérieure à 64 Ko
• L'instruction à l'adresse 0x10d se remplace (pure coïncidence)
• Doit utiliser des émulateurs DOS comme DosBox pour assembler et exécuter ce programme

CJam, 3 octets (somme 260)

q1b

Vous pouvez l' essayer en ligne .
Merci jimmy23013 d'avoir aidé à couper 2 personnages :)

Explication:

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

Befunge98, 6 octets, somme: 445

2j@.~+

Tout interprète devrait être bien. J'utilise CCBI .

Utilisez comme suit:

printf 'Hello World!' | ccbi calc.fg

Fonctionne pour les caractères multi-octets et les chaînes vides.

Explication

• 2j- sautez par-dessus les deux instructions suivantes ( @et .- voir ci-dessous)
• ~ - mettre le prochain caractère sur la pile
• +- ajoutez la valeur de code du nouveau caractère à la somme actuelle. Le pointeur d'instructions revient au début et le cycle se répète
• quand il ~rencontre un EOF il inverse la direction du pointeur et les deux instructions "cachées" sont exécutées:
• . - imprimer la somme
• @ - sortie

Rubis, 13 12 octets

p~9+gets.sum

sumest une fonction intégrée qui additionne les caractères d'une chaîne. Soustrait 10 pour tenir compte de la nouvelle ligne à la fin de getsla valeur de retour.

(Modifié 4 ans plus tard pour changer x-10en ~9+x... la valeur de ~9is -10, mais il nous permet de supprimer l'espace entre pet son argument, en économisant un octet.)

PowerShell - 27

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

Exemple

> SumChars.ps1 'Hello World!'

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

Julia - 11 7 caractères, somme résultante = 943 536

Puisque la question permet à l'entrée de provenir de la source que vous voulez, je choisis une variable existante. Supposons que Acontient la chaîne que nous souhaitons évaluer.

sum(A)1

En fin de compte, vous pouvez additionner directement la chaîne, et elle évaluera ... cependant, en raison de la façon dont la sommation des caractères est gérée, s'il y a un nombre impair de caractères dans la chaîne, elle produira un caractère, plutôt qu'un entier quelconque. En tant que tel, nous le forçons à convertir en int en multipliant par 1.

Ancienne version:

sum(A.data)

Sortira dans une notation hexadécimale (si la somme est inférieure à 256, ce sera 0x??, sinon ce sera 8 octets 0x????????). S'il est utilisé dans le code où le résultat est utilisé, il fonctionnera comme n'importe quel autre numéro (c'est comme ça que Julia affiche les entiers non signés).

Pour voir la valeur du résultat en décimal, mettez ce qui précède dans int(), comme dans int(sum(A.data)).

Pour toute personne qui ne connaît pas Julia, vous attribuez Aexactement la même manière que vous effectuez les autres affectations aux variables. Alors, A="Hello World!"ou A="sum(n.data)". Dans le cas où vous devez saisir des caractères "ou ', il existe plusieurs options, dont la plus simple (car elle évite d'avoir besoin de connaître les nuances des littéraux de chaîne Julia) est A=readline(), suivie simplement en tapant la chaîne dans STDIN (won ' t gérer les nouvelles lignes, cependant). La séquence d'échappement pour newline est, comme d'habitude, \nmais je ne pense pas que vous puissiez l'utiliser avec readline ().

K5, 2 octets (fonction), 5 octets (programme)

Une fonction

+/

Programme

+/0:`

Je ne sais pas si K5 a été créé avant ou après la publication de ce défi. Peu importe ... C'EST IMPRESSIONNANT !!

En K5, si vous effectuez des opérations arithmétiques sur des chaînes, il convertit les caractères en leurs codes ASCII. Donc, cela utilise simplement l'opérateur sum +/(en fait, c'est plus + plus).

Matlab / Octave 4 octets (bonus: 405)

Ce code est une fonction anonyme, qui fait le travail, il prendra une chaîne et renverra le nombre requis.

@sum

Go (59 caractères)

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

Tout dans Go est utf8 par défaut. Le codetext en `délimètres parcourus lui-même donne une sortie de: 5399.

Jolf, 2 octets (non concurrent)

Essayez-le ici!

ui
u  sum of
 i  the input string

Umm ... Je ne sais pas quoi dire d'autre.

Gol> <> , 4 octets (non concurrents)

Remarque: cette langue est plus récente que le défi.

iEh+

Javascript ES6, 41 octets

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

Merci à @ETHproductions pour 2 octets enregistrés!

Python, 24 octets

C'est plus court que n'importe quelle solution Python jusqu'à présent: une fonction anonyme sans nom, qui prend la chaîne en argument et retourne la somme.

lambda x:sum(x.encode())

Essayez-le en ligne!

Tout d'abord, le x.encode()transforme en bytesobjet. Alors,sum ajoute les valeurs de code de caractère. Comme il s'agit d'une fonction lambda, la valeur est renvoyée implicitement.

De plus, on pourrait avoir lambda x:sum(map(ord,x))pour le même nombre d'octets.

SML, 42 36

Il suffit d'ajouter une autre langue.

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

Convertit String en tableau char, calcule le nombre ascii de chaque valeur et calcule la somme de tous les nombres ascii.

C 32

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

D (fonction: 60)

Certainement pas là-dedans pour le gagner.

En supposant qu'il n'a pas besoin d'être un programme complet

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

Appelé comme ça

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

Production:

Hello World! = 1085

D (programme: 133)

Ne compte pas les sauts de ligne.

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

Avec plus d'espace et des noms de variable plus longs pour plus de lisibilité

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

Pour prendre en charge les sauts de ligne dans l'entrée, je pourrais utiliser byLine(KeepTerminator.yes)- la bonne façon, pour 20 caractères - ou ajouter un '\n'à ma ligne - qui rompt l'entrée sur une seule ligne et peut donner la mauvaise somme sur Windows à cause de CRLF, pour 18 caractères.

JavaScript (ES6) 54 58

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

54 octets grâce à 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;

Non golfé

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

Boucle en Sajoutant la ordvaleur du caractère au résultat. où x == résultat

Modifications:

4 caractères enregistrés en passant à int64 et en modifiant l'ajout à la somme.

k (8 caractères)

+/6h$0:0

Traduction Q

sum `int$read0 0

Valeur bonus:

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

J (7)

Si proche, mais si loin ... Eh bien, je suppose que 7 est assez décent, car cette réponse accepte également les chaînes vides. (Je fonde mon utilisation d'une variable comme entrée sur la phrase from a file, stdin or whatever)

+/a.i.b

Explication:

a.

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

a. contient tous les caractères ASCII.

   'people' i. 'pow'
0 2 6

x i. yest similaire à celui de python [x.index(i) for i in y].

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

À cet effet, a. i. yconvertit yen un tableau de ses valeurs ASCII

   +/1 2 3 4 5 6
21

+/est comme sum: +/1 2 3 4 5 6signifie1+2+3+4+5+6

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

Le tout en action

Pour le bonus:

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

Pas mal, je suppose.

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

Bon sang.

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

Merci @algorithmshark

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

Merci @marinus

R, 35 caractères (somme de 3086) 26 octets (somme de 2305)

sum(utf8ToInt(readline()))

readline()est un caractère plus long que scan(,"")mais scandivise l'entrée par défaut sur les espaces.

Usage:

> 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 octets (non concurrent)

Cette réponse n'est pas en concurrence car Japt a été créé après la publication de ce défi.

U¬mc x

Assez simple. Essayez-le en ligne!

Comment ça fonctionne

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 (non-competing)

us

Try it online!

u generates an array of all charcode values in the input string, and s finds their sum.

When run on itself, it returns 232.

This is similar to Conor's Jolf answer, except that I use a byte to convert the string into an array of character codes (which is implicit in Jolf), whereas he uses a byte to retrieve the input (which is implicit in PlatyPar).