Tarefa

Construa uma calculadora, que use qualquer string, de um arquivo, stdin ou qualquer outra coisa, e adicione todos os valores dos caracteres.

Exemplo

Input
Hello World!

Output
1085

Regras

A calculadora precisa aceitar apenas codificação ASCII.

O código mais curto vence.

Notas

Em relação ao comentário de m.buettner, devo dizer que não pensei na parte multibyte.
Então deixo isso como uma coisa bônus também.
A calculadora deve ser executada como escrita, portanto, não é necessário modificá-la antes de compilar ou interpretar.

Bônus

Graças à Synthetica , aqui está mais um bônus,

O programa que tem a menor saída quando você usa seu código à medida que a entrada ganha recebe uma estrela.

Não quero modificá-lo completamente.

Se você escrever mais para gerar o valor (à direita) em UTF-8, receberá uma estrela.

O código que executa mais rapidamente no meu laptop (Lenovo Yoga 13 Intel Core i5 3317U 1.7Ghz, 8GB RAM, 128GB SSD, Intel HD 4000, Windows 8) ganha uma estrela.

Os códigos da Web serão executados primeiro no IE11 com chakra e depois no FireFox 29.0.1 com SpiderMonkey

O código Linux será executado em um Raspberry Pi com Raspbian.

A cadeia de teste é esta:

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

Divirta-se codificação :)

Bonusscoring

Pretendo fazer a pontuação neste sábado para que, em 06.06.14, todas as respostas após essa data não recebam pontos de bônus;)

Você pode baixar o código que eu vou usar para testar aqui, fique à vontade para bifurcar e melhorá-lo :)

Pouca atualização por causa do bônus, meu laptop está parcialmente quebrado, então provavelmente o farei no próximo fim de semana. Sinto muito por isso :(

GolfScript, 4 caracteres

{+}*

Simplesmente usa o operador fold ( *) para adicionar todos os caracteres.

Se precisar trabalhar com a sequência vazia, 9 caracteres:

{{+}*}0if

Agradecemos ao @PeterTaylor por fornecer uma versão alternativa de 6 caracteres que funciona com uma string vazia:

0\{+}/

APL (8)

+/⎕UCS⍞

Explicação:

• +/ soma de
• ⎕UCS valores unicode de
• ⍞ entrada de caracteres

Haskell 36

main=interact$show.sum.map fromEnum

Ferramentas Shell + GNU, 29 bytes

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

Toma entrada de stdin:

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

Pontuação própria: 2385

c, 52 bytes

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

Compile com (alguns avisos produzidos):

gcc addchars.c -o addchars

Toma entrada de stdin:

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

Pontuação própria: 4354

Javascript ( ES6 ) 51

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

gs2 , 1 byte

d

d( 0x64/ sum), é claro, resume todos os bytes na entrada padrão.

Python 3-28 bytes

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

Exemplo de execução:

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

Obtém a entrada de stdin, mapé a ordfunção para obter o valor ASCII de cada caractere, sums e prints.

Conjunto 8086 (16 bits) - 47 41 bytes

O conteúdo do test.comarquivo é:

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

O trabalho real é realizado nos primeiros 11 bytes; Preciso do resto para imprimir o resultado em notação decimal.

Código fonte (dê como entrada para o debug.comassembler do 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

Algumas notas sobre o código:

• Manipula apenas uma linha (até o caractere de final de linha 13); trava se nenhum final de linha
• Apenas caracteres de 7 bits são suportados (os resultados estão incorretos)
• Saídas 0 para entrada vazia
• Não é possível lidar com uma saída superior a 64K
• A instrução no endereço 0x10d se substitui (pura coincidência)
• Tem que usar emuladores do DOS como o DosBox para montar e executar este programa

CJam, 3 bytes (soma 260)

q1b

Você pode experimentá-lo online .
Obrigado jimmy23013 por ajudar a cortar 2 caracteres :)

Explicação:

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

Befunge98, 6 bytes, soma: 445

2j@.~+

Qualquer intérprete deve estar bem. Eu uso o CCBI .

Use da seguinte maneira:

printf 'Hello World!' | ccbi calc.fg

Funciona para caracteres multibyte e cadeias vazias.

Explicação

• 2j- pule as próximas duas instruções ( @e .- veja abaixo)
• ~ - coloque o próximo caractere na pilha
• +- adicione o valor do código do novo caractere à soma atual. O ponteiro de instruções passa para o início e o ciclo se repete
• quando ~encontra um EOF, ele inverte a direção do ponteiro e as duas instruções "ocultas" são executadas:
• . - imprima a soma
• @ - Saída

Ruby, 13 12 bytes

p~9+gets.sum

sumé uma função interna que soma os caracteres de uma sequência. Subtrai 10 para contabilizar a nova linha no final do getsvalor de retorno.

(Editado 4 anos depois para mudar x-10para ~9+x... o valor de ~9é -10, mas permite remover o espaço entre pe seu argumento, salvando um byte.)

PowerShell - 27

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

Exemplo

> SumChars.ps1 'Hello World!'

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

Julia - 11 7 caracteres, soma resultante = 943 536

Como a pergunta permite que a entrada venha de qualquer fonte que você queira, escolho uma variável existente. Suponha que Acontenha a string que queremos avaliar.

sum(A)1

Como se vê, você pode somar a string diretamente e ela avaliará ... no entanto, devido à maneira como a soma de caracteres é manipulada, se houver um número ímpar de caracteres na string, ela produzirá um caractere, em vez de um número inteiro de qualquer tipo. Dessa forma, forçamos a conversão para int multiplicando por 1.

Versão antiga:

sum(A.data)

Produzirá uma notação hexadecimal (se a soma for menor que 256, será 0x??, caso contrário, serão 8 bytes como 0x????????). Se usado no código em que o resultado é usado, ele funcionará como qualquer outro número (é exatamente como Julia exibe entradas não assinadas).

Para ver o valor do resultado em decimal, coloque o acima em int(), como em int(sum(A.data)).

Para quem não conhece Julia, você atribui Aexatamente da mesma maneira que faz outras atribuições a variáveis. Então A="Hello World!"ou A="sum(n.data)". No caso em que você precisa inserir caracteres "ou ', existem várias opções, das quais a mais fácil (porque evita a necessidade de conhecimento das nuances dos literais de sequência de Julia) A=readline(), seguida pela simples digitação da sequência em STDIN (ganhou ' lidar com novas linhas, no entanto). A sequência de escape da nova linha é, como sempre, \nmas não acredito que você possa usá-la com readline ().

K5, 2 bytes (função), 5 bytes (programa)

Função

+/

Programa

+/0:`

Não tenho certeza se o K5 foi criado antes ou depois do lançamento deste desafio. Independentemente disso ... ISTO É INCRÍVEL !!

No K5, se você executar operações aritméticas em cadeias, ele converterá os caracteres em seus códigos ASCII. Portanto, isso apenas usa o operador sum +/(na verdade, é mais + over).

Matlab / Octave 4 bytes (bônus: 405)

Esse código é uma função anônima, que executa o trabalho, pega uma string e retorna o número necessário.

@sum

Go (59 caracteres)

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

Tudo no Go é utf8 por padrão. O codetexto em `delimetros executado por si só fornece uma saída de: 5399.

Jolf, 2 bytes (não competitivo)

Experimente aqui!

ui
u  sum of
 i  the input string

Umm ... não sei mais o que dizer.

Gol> <> , 4 bytes (não concorrente)

Nota: esse idioma é mais novo que o desafio.

iEh+

Javascript ES6, 41 bytes

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

Graças a @ETHproductions por 2 bytes salvos!

Python, 24 bytes

Isso é mais curto do que qualquer solução Python até agora: uma função anônima sem nome, que pega a string como argumento e retorna a soma.

lambda x:sum(x.encode())

Experimente online!

Primeiro, x.encode()transforma-o em um bytesobjeto. Então,sum adiciona os valores do código de char. Como essa é uma função lambda, o valor é implicitamente retornado.

Além disso, um poderia ter lambda x:sum(map(ord,x))para a mesma contagem de bytes.

SML, 42. 36.

Apenas adicionando outro idioma.

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

Converte String em matriz de caracteres, calcula o número ASCII de cada valor e calcula a soma de todos os números ASCII.

C 32

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

D (função: 60)

Definitivamente não para ganhar.

Supondo que ele não precise ser um programa completo

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

Chamado assim

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

Resultado:

Hello World! = 1085

D (programa: 133)

Não conta quebras de linha.

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

Com mais espaço em branco e nomes de variáveis ​​mais longos para facilitar a leitura

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

Para dar suporte a quebras de linha na entrada, eu poderia usar byLine(KeepTerminator.yes)- da maneira correta, para 20 caracteres - ou anexar um '\n'à minha linha - que quebra a entrada de linha única e pode dar a soma errada no Windows por causa do CRLF, para 18 caracteres.

JavaScript (ES6) 54 58

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

54 bytes graças a nderscore :

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

Delfos ( 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;

Faz um loop Sadicionando o ordvalor do caractere ao resultado. onde x == resultado

Editar% s:

Salvo 4 caracteres, alternando para int64 e alterando a adição à soma.

k (8 caracteres)

+/6h$0:0

Tradução Q

sum `int$read0 0

Valor do bônus:

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

J (7)

Tão perto, ainda tão longe ... Oh, bem, acho que 7 é decente o suficiente, pois essa resposta também aceita cadeias vazias. (Estou baseando meu uso de uma variável como entrada na frase from a file, stdin or whatever)

+/a.i.b

Explicação:

a.

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

a. contém todos os caracteres ASCII.

   'people' i. 'pow'
0 2 6

x i. y é semelhante ao python [x.index(i) for i in y] .

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

Portanto, a. i. yconverte yem uma matriz de seus valores ASCII

   +/1 2 3 4 5 6
21

+/é como sum: +/1 2 3 4 5 6significa1+2+3+4+5+6

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

A coisa toda em ação

Para o bônus:

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

Nada mal, eu acho.

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

Bem, droga.

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

Obrigado @algorithmshark

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

Obrigado @marinus

R, 35 caracteres (soma de 3086) 26 bytes (soma de 2305)

sum(utf8ToInt(readline()))

readline()é um caractere mais longo que, scan(,"")mas scandivide a entrada em espaços por padrão.

Uso:

> 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 (não concorrente)

Esta resposta não é concorrente porque o Japt foi criado após o lançamento deste desafio.

U¬mc x

Bem simples. Experimente online!

Como funciona

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 (não concorrente)

us

Experimente online !

ugera uma matriz de todos os valores de códigos na string de entrada e sencontra sua soma.

Quando executado sozinho, ele retorna 232.

Isso é semelhante à resposta Jolf de Conor , exceto que eu uso um byte para converter a string em uma matriz de códigos de caracteres (que está implícita no Jolf), enquanto ele usa um byte para recuperar a entrada (que está implícita no PlatyPar).