Questa sfida è quella di scrivere un programma o uno script che conteggi la somma di tutte le cifre all'interno degli interi da 1 a compreso un determinato numero.

Input, un numero intero positivo. Output, la somma delle cifre in quel numero e tutti i numeri più piccoli.

Esempi:

Input: 5 
Integer Sequence: 1, 2, 3, 4, 5
Sum of Digits: 1 + 2 + 3 +4 + 5 = 15

Input: 12
Integer Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 
Sum of Digits: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 0 + 1 + 1 + 1 + 2 = 51

Per essere chiari, questo significa contare una somma delle cifre , non i numeri interi. Per gli input a una cifra, questo sarà lo stesso. Tuttavia, input superiori a 10 avranno risposte diverse. Questa sarebbe una risposta errata :

Input: 12
Output: 78

Un altro esempio, per mostrare la differenza:

Input: 10

Integer Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Sum of Integers (INCORRECT RESPONSE): 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

Digit Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0
Sum of Digits (CORRECT RESPONSE): 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 0 = 46

Un caso di prova più ampio (RISPOSTA CORRETTA):

Input: 1000000
Output: 27000001

Regole e linee guida:

• Il codice inviato deve essere un programma o uno script completo, non solo una funzione. Se il codice richiede inclusioni, importazioni, ecc., Devono essere inclusi nel codice registrato.
• Il numero deve essere inserito dall'utente - non codificato. L'input può essere ricevuto come argomento della riga di comando, file, stdin o qualsiasi altro mezzo con cui la tua lingua può accettare l'input dell'utente.
• Il codice deve essere in grado di gestire correttamente gli input almeno fino a (2^64)-1.
• Il codice dovrebbe generare solo la somma.
• I programmi e gli script inviati devono essere facili da usare e non sprecare risorse informatiche (ad esempio: non devono dichiarare matrici follemente grandi per contenere ogni personaggio). Non ci sono bonus o penalità rigide per questo, ma per favore sii un buon programmatore.

punteggio:

Il meccanismo di punteggio primario è in base alla lunghezza del codice. I punteggi più bassi sono migliori. Si applicano anche i seguenti bonus e penalità:

• -25 Bonus se il tuo codice è in grado di gestire tutti i numeri positivi, ad esempio:1234567891234567891234564789087414984894900000000
• -50 Bonus se il tuo codice può gestire espressioni semplici, per esempio 55*96-12. Per beneficiare di questo bonus, il codice dovrebbe gestire gli + - / *operatori (addizione, sottrazione, divisione, moltiplicazione) e far rispettare l'ordine delle operazioni. La divisione è una divisione intera regolare.
  • L'esempio fornito ( 55*96-12) valuta 5268. Il tuo codice dovrebbe restituire lo stesso per uno di questi input - la risposta è corretta 81393.
• -10 Bonus se il tuo codice si qualifica per il bonus -50 e può gestire l' ^operatore (esponente).
• -100 Bonus se il tuo codice si qualifica per il bonus -50 e non usa evalo simili per gestire le espressioni.
• +300 Penalità se il codice si basa su risorse Web.

Perl 6: 108 - (25 + 50 + 100) + 0 = -67 punti

Soluzione golfata (linea finale basata sull'ottima soluzione di xfix ):

$!=get;for '*',&[*],'/',&[/],'+',&[+],'-',&[-] ->$s,&f{$!~~s:g[(\d+)$s(\d+){}]=f |@()}
say [+] (1..$!)».comb

Soluzione senza golf:

my $expression = get;
for '*', &[*],
    '/', &[/],
    '+', &[+],
    '-', &[-]
-> $sym, &infix {
    $expression ~~ s:g[(\d+) $sym (\d+) {}] = infix($0, $1)
}
say [+] (1..$expression)».comb

La fase di valutazione funziona l'iterazione su ogni simbolo *, /, +, -, trovando quando che si trova tra due interi, e sostituendo che utilizza la funzione di quel simbolo rappresenta.

Più in dettaglio: prende ogni simbolo (ad es. +) E la funzione infix che dovrebbe rappresentare (ad es. &[+]Quale è la scorciatoia per &infix:<+>e la stessa funzione che Perl 6 chiama quando si esegue 1 + 2) e fa una sostituzione globale ( s:g[…] = …, che è come Perl 5 s/…/…/ge), che corrisponde a due numeri interi separati dal simbolo ( (\d+) $sym (\d+)) e lo sostituisce con l'output della funzione di infissione corrispondente chiamata con tali numeri interi ( infix($0, $1)).

Infine, questa espressione valutata viene inserita in say [+] (1..$expression)».comb, che xfix spiega molto bene nella sua soluzione .

Mi dispiace di essere così in ritardo alla festa ☺

EDIT: rimosso il supporto per gli esponenti; aveva comunque esattamente 10 caratteri e non associava correttamente.

Mathematica 30- (10 + 50) = -30

Accorciato di 4 caratteri grazie a ybeltukov.

Range@nrestituisce i numeri da 1 a n.

Integerdigits@n scompone ciascuno di quei numeri nelle sue cifre.

Total[n,2]somma le cifre. Il 2 è quello di consentire la somma attraverso diversi livelli, cioè elenchi di elenchi.

IntegerDigits@Range@#~Total~2&

analisi

IntegerDigits@Range@#~Total~2&[12]

51

IntegerDigits@Range@#~Total~2 &[1000000]

27000001

espressioni

IntegerDigits@Range@#~Total~2 &[55*96 - 12]

55*96 - 12

81393
5268

IntegerDigits@Range@#~Total~2 &[5268]

81393

IntegerDigits@Range@#~Total~2 &[55*96^2 - 12]
55*96^2 - 12

12396621
506868

IntegerDigits@Range@#~Total~2 &[506868]

12396621

C: 150 138 - (100 + 50) = -12

a,b,c;main(d){for(scanf("%d ",&a);~scanf("%c%d ",&d,&b);a=d^43?d%5?d%2?a/b:a*b:a-b:a+b);for(;a;)for(b=a--;b;b/=10)c+=b%10;printf("%d",c);}

Rubare molto vergognosamente la risposta di @Fors da qui per fare la valutazione dell'espressione: https://codegolf.stackexchange.com/a/11423/13877

Esempio di utilizzo:

./a.exe <<< "5 + 7"
51

Nota: l'implementazione dell'espressione non presuppone alcuna precedenza per l'operatore e consuma i valori quando li riceve; ex, 1+2*3 = 9piuttosto che il tipico 7.

sed, 411 283 - 25 = 258

Non posso preoccuparmi di giocare a golf in questo momento. :-) Non raccomandato per l'uso con numeri interi anche remoti, ma tecnicamente potrebbe gestire numeri arbitrariamente grandi (probabilmente esaurirai la RAM abbastanza rapidamente, poiché io (più o meno devo codificare) il numero in unario).

s/$/x0123456789/
:l
/9$/H
:b
s/(.)(y*x\1)/y\2/
/(.)y*x\1/b b
s/(.)([xy].*)(.)\1/\3\2\3\1/
:c
s/y(.*(.))/\2\1/
/y/b c
/0$/b f
/^0*x.*9$/!b l
x
s/x[^\n]*\n//g
:d
s/(.)(.*x.*(.)\1)/z\3\2/
/[^z0]x/b d
s/0|x.*|\n//g
H;x
s/./0/g
s/$/x9876543210/
x
:e
x
b l
:f
x
s/.//
/./b e
x
s/^0+|x.*//g

Esempio di utilizzo

(Inserire le righe rientrate per facilitare la lettura.)

  5
15
  12
51
  33
183

pitone, 55- (50 + 25 + 10) = -30

Inefficiente ma più breve e anche in grado di gestire le espressioni.

EDIT: Grazie Wolframh e legoStormtroopr per i trucchi: D

s,t=0,input()
while t:s+=sum(map(int,`t`));t-=1
print s

pitone, 149- (25 + 50 + 10) = 64

La mia prima versione

def d(n):
 if n/10==0:return n*(n+1)/2
 c,t=0,n
 while t/10:c,t=c+1,t/10
 p=10**c;m=n%p
 return d(m)+t*(m+1)+p*t*(t-1)/2+p*c*t*45/10
print d(input())

ingresso:

1234567891234567891234564789087414984894900000000

produzione:

265889343871444899381999757086453238874482500000214

Python - 108 caratteri meno 85 bonus, 23 colpi, gestisce input molto molto molto grandi

La maggior parte di queste soluzioni sembra essere in loop su tutti gli ints meno dell'input e sommare tutte le loro cifre. Funziona, ma mi sembra inelegante, e mi chiederei se sono davvero idonei per il bonus di 25 punti, dal momento che non penso che sarebbero in grado di gestire l'input 1234567891234567891234564789087414984894900000000durante la nostra vita. In effetti, su un input di ncifre, queste soluzioni richiedono O(10^n)tempo. Ho scelto invece di gettare un po 'di matematica a questo problema.

#Returns the sum of all digits in all x-digit numbers
def f(x):
    return x*(10**(x-1))*45

#Returns the sum of all numbers up to x
def g(x):
    return x*(x+1)/2

#Solves the problem quickly
def magic(x):
    digits = [int(y) for y in list(str(x))]
    digits.reverse()
    total = 0

    for (sig, val) in enumerate(digits):
        total += (10**sig)*g(val-1) + val*f(sig) + val + (val*10**sig)*sum(digits[sig+1:])
    return int(total)

Il set di tutti x numeri delle cifre è isomorfo all'insieme {0,1,2,3,4,5,6,7,8,9}^x. Per un valore fisso (n,sig)ci sono xvalori diversi per sig, 10^x-1punti con l' sigindice th impostato su ne la somma di tutte le cifre 0-9è 45. Tutto questo è gestito daf .

g è qualcosa che probabilmente conosciamo tutti

magicprende tutte le cifre nel numero di input e scorre da esse al meno significativo. È più facile rintracciarlo con un input di esempio, diciamo 1,234,567.

Per gestire l'intervallo 1,234,567-1,234,560, dobbiamo sommare tutte le cifre da 1a 7, e aggiungere 7volte la somma delle altre cifre, per gestire tutti i numeri maggiori di1,234,560 . Ora dobbiamo occuparci del resto.

Per gestire l'intervallo 1,234,560-1,234,500, aggiungiamo il simbolo 6( val) e rilasciamo il limite superiore a 1,234,559. Nel fare il resto del drop, vedremo ogni numero a una cifra 6 volte (val*f(sig) ). Vedremo tutti i numeri da 0a volte 5esattamente 10ciascuno ( (10**sig)*g(val-1)). Vedremo tutte le altre cifre in questo numero esattamente 60 volte ( (val*10**sig)*sum(digits[sig+1:])). Ora abbiamo trattato tutti i numeri strettamente maggiori di1,234,500 . La stessa logica si applica induttivamente a tutti i significati.

Giocare a golf, grazie a WolframH, riduce questa soluzione a

d=map(int,str(input()))
print sum(v*(10**s*((v-1)/2+sum(d[:~s]))-~s*9*10**s/2)for s,v in enumerate(d[::-1]))

E la somma delle cifre somma di tutti i numeri interi fino a 1234567891234567891234564789087414984894900000000è265889343871444927857379407666265810009829069029376

Il numero più grande che sono riuscito a lanciare alla versione golfata è 10 ^ 300, a quel punto i galleggianti iniziano a traboccare e l'instabilità numerica inizia a causare problemi. Con una rapida funzione esponenziale quadrata e moltiplicata, questo problema svanirebbe.

E il supporto LaTeX sarebbe davvero utile ...

TI-BASIC, 137 - (50 + 10 + 100) = -23

Input A:Disp cumSum(randIntNoRep(1,A))→L₁:"?:For(A,1,dim(L₁:Ans+sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",L₁(A),1:End:Disp sub(Ans,2,length(Ans)-1

Input gestisce numeri fino a 1E100e valuta automaticamente. In grado di gestire espressioni.

Sebbene sia un array follemente grande, non sto sprecando risorse del computer (questo viene eseguito da una calcolatrice ).

Scala 66

println((1 to readLine().toInt).flatMap(x=>(x+"").map(_-'0')).sum)

C, 77 74

n,v,i;main(){scanf("%d",&n);for(;i||(i=n--);i/=10)v+=i%10;printf("%d",v);}

C, 150 124-25 = 99

Ecco una versione alternativa che dovrebbe tecnicamente essere ammissibile per il bonus 25 per "qualsiasi" intero positivo, ma è impraticabilmente lento poiché l'algoritmo ha un tempo lineare nel suo input. Indipendentemente da ciò, è stato divertente scrivere. Sottrae manualmente un numero letto come caratteri ASCII. Questa versione è di 150 caratteri. (Ora con un codice orribile, turbolento e pieno di discussione!)

n,v;main(int n,char**a){char*p;do{for(p=a[1];*p>47;p++)v+=*p-48;for(;*--p==48;)*p=57;
p[0]--;}while(p>=a[1]);printf("%d",v);}

C, 229 224 - (50 + 100) = 74

Variazione di gestione delle espressioni. Attrezzi precedenza degli operatori secondo regole caratteristici / * - +. Limitato a 97 token = 48 termini.

#define F(X,Y)for(q=n+1;q+1!=p;)*q-X?q+=2:(q[-1]Y##=q[1],memmove(q,q+2,(p-q)*4))
n[99],*p,*q,v,i;main(){for(p=n;~scanf("%d%c",p,p+1);)p+=2;F('/',/);F('*',*);
F('-',-);F('+',+);for(;i||(i=n[0]--);i/=10)v+=i%10;printf("%d",v);}

GolfScript 18-50 = -32

~),{`+}*' '*~]{+}*

Spiegazione: Supponiamo che l'ingresso sia "12":

~), # turn input into integer, increment, and then turn into an array of all numbers less than or equal to input.  

Stack è [0,1,2,3,...,12].

{`+}* # fold string concatenation across the array

Stack è "01234...9101112".

' '* # join a space between all characters

Stack è "0 1 2 ... 1 0 1 1 1 2".

~] # evaluate the stack into an array.  No `[` is necessary since the stack is otherwise empty.

Stack è [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

Lo stack è 51, come desiderato.

L'input qui può essere qualsiasi espressione GolfScript valida, che può includere esponenti. Per esempio:

echo "5 5 + 2 * 8 -" | ruby golfscript.rb h.gs
-> 51

Da allora 2(5 + 5) - 8 = 12. Penso che questo dovrebbe qualificarsi per il bonus, ma forse ci si aspettava che fosse solo in forma normale, non la notazione polacca inversa di GolfScript.

Rubino, 37-50 = -13

Doppio eval, attraverso il cielo! Come con le altre soluzioni di Ruby, penso che questo dovrebbe teoricamente essere in grado di funzionare con numeri arbitrariamente grandi, ma i tempi di esecuzione sarebbero ... terribili.

p eval [*1..eval(gets)].join.chars*?+

Versione precedente (punteggio 49-50)

p"#{[*1..eval(gets)]}".chars.map(&:to_i).inject:+

Supponendo che il bonus di 10 personaggi richieda effettivamente che il personaggio per l'espiazione sia un punto di inserimento, il modo più breve che potrei pensare di aggiungere è:

.gsub ?^,'**'

Che costa più personaggi di quanto il bonus darebbe.

Perl 6 (28-75 + 0 = -47 byte)

say [+] (1..get.eval)».comb

Può gestire tutti i numeri positivi (tuttavia, quelli grandi impiegheranno molto tempo, perché attualmente le implementazioni di Perl 6 sono lente, ma Perl 6 supporta nativamente i grandi numeri interi). Utilizza eval, al fine di implementare una semplice calcolatrice (vale la pena di cinque caratteri per cinquanta caratteri). È lento solo perché le attuali implementazioni sono lente, ma in teoria dovrebbe essere abbastanza veloce (quando le implementazioni di Perl 6 migliorano, cioè). Inoltre, sorprendentemente, vinco con Mathematica (per ora).

» in questo codice non è effettivamente necessario, ma l'ho messo qui per motivi di prestazioni (altrimenti, il programma allocerebbe l'intera stringa. Il motivo per cui è qui è che Perl 6 non ha stringhe infinite, ma ha liste infinite.

Ad ogni modo, potresti chiedere come funziona anche questo codice. Bene, lo farò passare parte per parte.

• get.eval

  Questo ottiene una riga ( getfunzione) e la valuta ( evalmetodo).

• 1..get.eval

  Successivamente, Perl 6 prepara un oggetto range, dal 1valore valutato. Questa è una gamma, quindi non viene assegnato nulla di enorme.

• ».comb

  .comb Il metodo divide la stringa in caratteri ( meno che non venga chiamato con un argomento ). Ad esempio, 'cat'.combrestituisce 'c', 'a', 't'. »mappa gli elementi dell'elenco, quindi .combviene eseguito su ogni elemento, non solo sull'elenco stesso (ad esempio, (4, 9)».sqrtfornisce 2, 3). Anche questo non alloca più del necessario, perché Perl 6 ha elenchi infiniti (come Haskell, per esempio).

  »il personaggio in realtà non è necessario, poiché .combpuò essere utilizzato direttamente nell'elenco, ma ciò implica una coercizione implicita di stringhe (e Perl 6 non ha stringhe infinite, quindi questo sprecherebbe memoria). Ad esempio, 1, 2, 3restituisce l'elenco dopo la conversione nella stringa 1 2 3. Per Perl 6, uno spazio è un numero perfettamente fine che significa 0, quindi il codice funzionerebbe, anche con tale conversione. Tuttavia, abuserebbe delle risorse informatiche.

• [+]

  Questo è un operatore ridotto. Fondamentalmente, tra [], puoi mettere un operatore da usare, in questo caso +. L'elenco dopo l'operatore di riduzione è ridotto, quindi[+] 1, 2, 3 è 1 + 2 + 3, che è 6. Perl 6 utilizza operatori separati per numeri e stringhe, quindi non sarà considerato come concatenazione.

• say

  Infine, saygenera il risultato. Dopo tutto, vuoi vedere il risultato finale, vero?

Perl 31 - Nessun bonus

map{s/./$%+=$&/ge}0..<>;print$%

Uscita campione:

perl -e 'map{s/./$%+=$&/ge}0..<>;print$%'
1000000
27000001

Perl 5 con -p, 50 - 28 byte: -22

map$\+=$_,/./g for 1..eval}{

Provalo online!

J, 22

([:+/[:"."0[:":>:@:i.)

Spiegazione

La valutazione procede da destra a sinistra.

i. n -> 0 1 2...n-1

>: n -> n+1

": numbers -> 'numbers'

"."0 -> (on each scalar item) apply ". -> '123' -> 1 2 3

+/ -> sum

R, 64 - (50 + 10) = 4

sum(utf8ToInt(paste(0:eval(parse(t=scan(,""))),collapse=""))-48)

Quando viene eseguito, all'utente viene chiesto di immettere.

Versione precedente (impossibile gestire le espressioni): 46 caratteri:

sum(utf8ToInt(paste(0:scan(),collapse=""))-48)

Lotto - (181-50) - 131

Solo per divertirci.

@set/av=%1
@setLocal enableDelayedExpansion&for /L %%a in (1,1,%v%)do @set a=%%a&powershell "&{'%%a'.length-1}">f&set/pb=<f&for /L %%c in (0,1,!b!)do @set/as+=!a:~%%c,1!
@echo !s!

Lo renderò un po 'più leggibile:

@set /a v=%1
setLocal enableDelayedExpansion
for /L %%a in (1,1,%v%) do (
    @set a=%%a
    powershell "&{'%%a'.length-1}">f
    set /p b=<f
    for /L %%c in (0,1,!b!) do @set /a s+=!a:~%%c,1!
)
@echo !s!

Il vecchio metodo utilizza loop per ottenere l'output del comando powershell, invece di scrivere e leggere da un file:

@set /a v=%1
@setLocal enableDelayedExpansion&for /L %%a in (1,1,%v%)do @set a=%%a&for /F usebackq %%b in (`powershell "&{'%%a'.length-1}"`)do @for /L %%c in (0,1,%%b)do @set /a s+=!a:~%%c,1!
@echo !s!

Imposta l'input su una variabile - v- usando /aper accettare espressioni aritmetiche.
Purtroppo era necessario abilitare l'espansione ritardata.
Utilizzare un ciclo for per contare da 1 al valore immesso - v.
Per gestire numeri maggiori di 9, ho dovuto usare PowerShell per ottenere la lunghezza della stringa, quindi usare un altro per il ciclo per dividere quella stringa e aggiungerla al somma - s.
Si potrebbe cambiare il nome di powershell.exea p.exein C: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ poi lo chiamano con un solo p "&{'%%a'.length-1}, risparmiando 9 byte. Ma questo non è proprio nello spirito.

H:\>sumof.bat 12
51
H:\>sumOf.bat (55*96-12)
81393

Ho lasciato la seconda corsa mentre facevo la pausa pranzo.

Non riesco davvero a provarlo con numeri troppo grandi di questo a causa di quanto è lento. Tuttavia dovrebbe funzionare per numeri abbastanza grandi. 2147483647è il numero più grande che ci vorrà (massimo 32 bit interi) prima di dare il seguente errore -

H:\>sumOf.bat 2147483648
Invalid number.  Numbers are limited to 32-bits of precision.

Questo ovviamente mi esclude dalla sfida.

Dyalog APL , 9-160 * = -151

+/⍎¨∊⍕¨⍳⎕

Provalo online!

⎕ottenere ingresso valutata
 per esempio "7+5"dà12

⍳indici 1 ... n
 [1,2,3,4,5,6,7,8,9,10,12]

⍕¨ formattare ogni numero in stringa
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ arruolarsi (appiattire)
 "123456789101112"

⍎¨ esegue ogni carattere (restituisce un elenco di numeri di numeri a cifra singola)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ somma  51

* Punteggio

-50 bonus in quanto accetta anche espressioni come input. L'espressione deve essere APL valida, accettabile secondo OP .

-10 bonus perché perché gestisce anche il ^( *in APL).

-100 di bonus perché l'input dell'espressione viene gestito senza l'uso esplicito di eval(cioè ⍎in APL).

C # (161)

using C=System.Console;using System.Linq;class X{static void Main(){C.WriteLine(Enumerable.Range(1,int.Parse(C.ReadLine())).SelectMany(i=>i+"").Sum(c=>c-48));}}

Bella

using C = System.Console;
using System.Linq;

class X
{
    static void Main()
    {
        C.WriteLine(
            Enumerable.Range(1, int.Parse(C.ReadLine()))
                .SelectMany(i => i + "")
                .Sum(c => c - 48)
            );
    }
}

Python3 + Bash (78-185 = -107)

python3 -c"print(sum(sum(map(int,str(x+1)))for x in range(int(${1//^/**}))))"

• può gestire tutti i numeri positivi
• può gestire le espressioni con l'operazione + - / *
• può gestire l'operatore ^ (potenza).
• può gestire espressioni, senza valutazione o simili¹

Se il risultato dell'espressione non è intero, verrà prima troncato. Se il risultato dell'espressione è negativo, il risultato non è definito.

Usalo come:

bash golf.sh "12 + (42 / 3 + 3^4)"

1: a meno che non contiate invocare Python da Bash in quanto tale, ma non penso che sia il caso. Se pensi che sia effettivamente, il punteggio corretto è -7.

Java, 254

class T
{
    public static void main(String[] a)
    {
        long target = 10, count = 0;
        String[] digits = new String[50];
        for (long i = 1; i <= target; i++)
        {
            digits = String.valueOf(i).split("(?!^)");
            for (int j = 0; j < digits.length; j++)
                if (digits.length > j)
                    count += Integer.parseInt(digits[j]);
        }
        System.out.println(count);
    }
}

Gestisce le espressioni. Dai qualsiasi espressione desideri nel bersaglio. Gestisce fino a quando la lunghezza lunga può gestire. Se ripulisci togliendo tutti gli spazi in una riga e nessuna istruzione da stampare, conta fino a 254 caratteri (considerando la programmazione Java basata su parole lunghe e lunghe).

PS: questo è un programma completo, non solo logico. Le parole contano per il programma, non solo per la logica.

Java (JDK8), 272

My first challenge I'm in, suggestions are welcome =)

import java.util.*;import java.util.stream.*;class C{public static void main(String[]a){System.out.print(Arrays.asList(IntStream.range(1,new Integer(a[0])).mapToObj(s->s+"").collect(Collectors.joining()).split("")).stream().map(Integer::valueOf).reduce(0,Integer::sum));}}

Indented:

import java.util.*;
import java.util.stream.*;

class C {

   public static void main(String[] a) {
     System.out.print(Arrays.asList(IntStream.range(1,new Integer(a[0]))
            .mapToObj(s->s+"")
            .collect(Collectors.joining())
            .split(""))
            .stream()
            .map(Integer::valueOf)
            .reduce(0,Integer::sum));
  }
}

CJam, 9 - 25 = -16

CJam is a few months younger than this challenge, so this is not eligible for the green checkmark. Furthermore, this isn't beating Perl in the first place. ;) I quite liked the approach though, so I wanted to post it anyway.

l~),s:~:+

Test it here.

The idea is to create a range from 0 to N. This range is then converted to a string, which just concatenates the integers back to back. For N = 12, we'd get

"0123456789101112"

Then each character is converted to a integer with :~ (yielding an array of integers), and then summed up with :+. CJam can deal with arbitrarily big integers.

Python 3 + astor, 1017 1007 bytes - (25 + 50 + 100) = Score: 842 834

saved 10 bytes by removing ts and changing p

edit: I am unable to test the ridiculously long integer (1234567891234567891234564789087414984894900000000) [hangs my computer] but from my knowledge, Python 3 supports arbritrarily long integers.

This implementation uses abuses AST. I wouldn't consider abusing AST as "eval or similar".

from ast import*
from astor import*
nt,bo,m,d,a,s,n,p,ty=NodeTransformer,BinOp,Mult,Div,Add,Sub,Num,map,type
class M(nt):
    def visit_BinOp(t,z):
        if ty(z.left)==bo and ty(z.right)==bo:return bo(t.visit_BinOp(z.left),z.op,t.visit_BinOp(z.right))
        if ty(z.left)==bo:return bo(t.visit_BinOp(z.left),z.op,z.right)
        if ty(z.right)==bo:return bo(z.left,z.op,t.visit_BinOp(z.right))
        if ty(z.op)==m:return n(z.left.n*z.right.n)
        if ty(z.op)==d:return n(z.left.n/z.right.n);return z
class A(nt):
    def visit_BinOp(t,z):
        if ty(z.left)==bo and ty(z.right)==bo:return bo(t.visit_BinOp(z.left),z.op,t.visit_BinOp(z.right))
        if ty(z.left)==bo:return bo(t.visit_BinOp(z.left),z.op,z.right)
        if ty(z.right)==bo:return bo(z.left,z.op,t.visit_BinOp(z.right))
        if ty(z.op)==a:return n(z.left.n+z.right.n)
        if ty(z.op)==s:return n(z.left.n-z.right.n);return z
class S(nt):
    def visit_Num(t,z):return n(sum(p(int,list("".join(p(str,range(1,z.n+1)))))))
print(to_source(S().visit(A().visit(M().visit(parse(input()))))))

Too lazy to write ungolfed, so I'll give you an explanation of the classes:

M(NodeTransformer|nt) - converts multiplication and division into their results.
A(NodeTransformer|nt) - converts addition and subtraction into their results.
S(NodeTransformer|nt) - converts numbers into their sum of digits via the Pythonic (naïve) way.

The last line just executes these classes in the appropriate order on the input, to preserve order of operations, and prevent unwanted behavior.

Example usage ($ or > means user input) and by the way, the actual program takes input only once:

$ python3 summer.py
> 5
15
> 10
46
> 12
51
> 1000000
27000001
> 55*96-12
81393

C# (108)

int c(int n){return string.Join("",Enumerable.Range(1,n).Select(i=>i+"")).ToArray().Select(c=>c-'0').Sum();}

Pretty

int c(int n)
{
    return string.Join("", Enumerable.Range(1, n).Select(i => i + "")).ToArray().Select(c => c - '0').Sum();
}

Ruby -> 83-50 = 33

p (1..eval(gets.chomp)).each.inject{|c,e|c+e.to_s.chars.map{|x|x.to_i}.inject(:+)}                     

"To test" version:

module Math
  class CountSum
    def sum(number)
      (1..number).each.inject do |c, e|
        c + e.to_s.chars.map{ |x| x.to_i }.inject(:+)                                                  
      end
    end
  end
end 

Tests results

$ rspec sum_spec.rb  --format doc --color

Math::CountSum
  #sum
    single digit number
      when 5, should return 15
    double digit number
      when 12, should return 51
    arbitrary number
      when 1000000 should return 27000001

Finished in 5.34 seconds
3 examples, 0 failures

C# (80)

Its my another attempt.

double c(int n){double s=0;while(n>0)foreach(var c in n--+"")s+=c-48;return s;}

Pretty

double c(int n)
{
    double s = 0;
     while (n > 0)
        foreach(var c in n--+"") 
            s += c - 48;
    return s;
}

Ruby 69-50 = 19 (or -4)

This can definitely be golfed together but here is the first fifth try

p (1..eval(gets)).inject{|i,s|i+=s.to_s.chars.map(&:to_i).inject :+}

It also works for all numbers but is very slow for them as it runs slower than O(n), so I wouldn't add the -25. If slowness is fine, then it would be -4 though

Ruby 133-50-25 = 58

This is the faster version, that runs in less-than O(n) time (and uses actual math!), so it can provide results for large integers fast, thereby I added the -25:

n=eval(gets);p (d=->n,l{k=10**l;c,r=n.to_s[0].to_i,n%k;n<10?n*(n+1)/2:c*45*l*k/10+k*(c*(c-1)/2)+(r+1)*c+d[r,l-1]})[n,n.to_s.length-1]

Haskell, 74-25=49

main=getLine>>=print.sum.map(\c->read[c]).concatMap show.(\x->[0..x]).read

ECMAScript 6, 86 - 50 = 36

for(s="",i=eval(prompt());i;s+=i--)alert(s.replace(/\d/g,c=>Array(-~c).join()).length)

R (72 points)

f=function(n) sum(as.integer(strsplit(paste0(1:n,collapse=""),"")[[1]]))

Output:

> f(5)
[1] 15
> f(12)
[1] 51
> f(1000000)
[1] 27000001