Este desafío es escribir un programa o script que cuente la suma de todos los dígitos dentro de los enteros desde 1 hasta e incluyendo un número dado.

Entrada, un entero positivo. Salida, la suma de dígitos en ese número y todos los números más pequeños.

Ejemplos:

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

Para ser claros, esto es contar una suma de los dígitos , no los enteros. Para entradas de un solo dígito, esto será lo mismo. Sin embargo, las entradas mayores de 10 tendrán respuestas diferentes. Esta sería una respuesta incorrecta :

Input: 12
Output: 78

Otro ejemplo, para mostrar la diferencia:

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 de prueba más grande (RESPUESTA CORRECTA):

Input: 1000000
Output: 27000001

Reglas y pautas:

• El código enviado debe ser un programa o script completo, no solo una función. Si el código requiere incluye, importaciones, etc., deben incluirse en el código publicado.
• El número debe ser ingresado por el usuario, no codificado. La entrada puede recibirse como un argumento de línea de comando, archivo, stdin o cualquier otro medio por el cual su idioma puede tomar la entrada del usuario.
• El código debe poder manejar correctamente las entradas al menos hasta (2^64)-1.
• El código solo debería generar la suma.
• Los programas y scripts enviados deben ser fáciles de usar y no desperdiciar recursos informáticos (por ejemplo, no deben declarar matrices increíblemente grandes para contener cada carácter). No hay una bonificación o penalización estricta por esto, pero sean buenos programadores.

Tanteo:

El mecanismo de puntuación principal es por longitud de código. Los puntajes más bajos son mejores. También se aplican las siguientes bonificaciones y sanciones:

• -25 Bonificación si su código puede manejar todos los números positivos, por ejemplo:1234567891234567891234564789087414984894900000000
• -50 Bonificación si su código puede manejar expresiones simples, por ejemplo 55*96-12. Para calificar para este bono, el código debe manejar + - / *(suma, resta, división, multiplicación) operadores y hacer cumplir el orden de las operaciones. La división es una división entera regular.
  • El ejemplo dado ( 55*96-12) se evalúa como 5268. Su código debe devolver lo mismo para cualquiera de esas entradas: la respuesta correcta es 81393.
• -10 Bonificación si su código califica para la bonificación -50 y puede manejar el ^operador (exponente).
• -100 de bonificación si su código califica para la bonificación de -50 y no utiliza evalo similar para manejar expresiones.
• +300 Penalización si su código se basa en cualquier recurso web.

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

Solución de golf (línea final basada en la gran solución de xfix ):

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

Solución sin golf:

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

La etapa de evaluación funciona mediante la iteración sobre cada símbolo de *, /, +, -, encontrando al que se encuentra entre dos números enteros, y sustituyendo que el uso de la función que representa el símbolo.

Más detalladamente: toma cada símbolo (por ejemplo +) y la función infija que se supone que representa (por ejemplo, &[+]cuál es la abreviatura &infix:<+>y la misma función que Perl 6 llama cuando ejecuta 1 + 2) y realiza una sustitución global ( s:g[…] = …que es como Perl 5 s/…/…/ge), que coincide con dos enteros separados por el símbolo ( (\d+) $sym (\d+)), y lo sustituye con la salida de la función infija correspondiente llamada con esos enteros ( infix($0, $1)).

Finalmente, esta expresión evaluada se alimenta say [+] (1..$expression)».comb, lo que xfix explica muy bien en su solución .

Perdón por llegar tan tarde a la fiesta ☺

EDITAR: Se eliminó el soporte para exponentes; De todos modos, tenía exactamente 10 caracteres y no asociaba correctamente.

Mathematica 30- (10 + 50) = -30

Acortado por 4 caracteres gracias a ybeltukov.

Range@ndevuelve los números del 1 al n.

Integerdigits@n divide cada uno de esos números en sus dígitos.

Total[n,2]suma los dígitos. El 2 es para permitir la suma en diferentes niveles, es decir, listas de listas.

IntegerDigits@Range@#~Total~2&

Pruebas

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

51

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

27000001

Expresiones

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

Robando vergonzosamente la respuesta de @Fors desde aquí para hacer la evaluación de la expresión: https://codegolf.stackexchange.com/a/11423/13877

Uso de la muestra:

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

Nota: la implementación de la expresión no asume ninguna precedencia del operador y consume valores a medida que los recibe; ex, en 1+2*3 = 9lugar de lo típico 7.

sed, 411283-25 = 258

No puedo molestarme más en jugar golf ahora mismo. :-) No se recomienda su uso incluso con números enteros remotamente grandes, pero técnicamente podría tratar con números enteros arbitrariamente grandes (sin embargo, es probable que se quede sin RAM bastante rápido, ya que (más o menos tengo que) codificar el número en 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

Uso de la muestra

(Líneas de entrada con sangría para facilitar la lectura).

  5
15
  12
51
  33
183

pitón, 55- (50 + 25 + 10) = -30

In-eficiente pero más corto y también capaz de manejar expresiones.

EDITAR: Gracias Wolframh y legoStormtroopr por los trucos: D

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

pitón, 149- (25 + 50 + 10) = 64

Mi primera version

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

entrada:

1234567891234567891234564789087414984894900000000

salida:

265889343871444899381999757086453238874482500000214

Python - 108 caracteres menos 85 bonos, 23 golpes, maneja entradas muy muy muy grandes

La mayoría de estas soluciones parecen estar girando sobre todas las entradas menos que la entrada y sumando todas sus sumas de dígitos. Esto funciona, pero creo que es poco elegante, y cuestionaría si son realmente elegibles para la bonificación de 25 puntos, ya que no creo que puedan manejar la entrada 1234567891234567891234564789087414984894900000000dentro de nuestras vidas. De hecho, en una entrada de ndígitos, estas soluciones toman O(10^n)tiempo. En su lugar, elegí arrojar algunas matemáticas a este 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)

El conjunto de todos los xnúmeros de dígitos es isomorfo al conjunto {0,1,2,3,4,5,6,7,8,9}^x. Para un fijo (n,sig)hay xdiferentes valores para sig, 10^x-1puntos con el sigíndice th establecido en n, y la suma de todos los dígitos 0-9es 45. Todo esto se maneja mediante f.

g es algo con lo que probablemente todos estamos familiarizados

magictoma todos los dígitos del número de entrada y los repite de menor a mayor importancia. Es más fácil rastrear esto con una entrada de ejemplo, por ejemplo 1,234,567.

Para tratar con el rango 1,234,567-1,234,560, debemos sumar todos los dígitos de 1a 7, y sumar 7veces la suma de los otros dígitos, para tratar con todos los números mayores que 1,234,560. Ahora tenemos que lidiar con el resto.

Para lidiar con el rango 1,234,560-1,234,500, agregamos el 6( val) y colocamos el límite superior en 1,234,559. Al hacer el resto de la caída, veremos cada número de un solo dígito 6 veces ( val*f(sig)). Veremos todos los números desde 0hasta 5exactamente 10cada uno ( (10**sig)*g(val-1)). Veremos todos los otros dígitos en este número exactamente 60 veces ( (val*10**sig)*sum(digits[sig+1:])). Ahora hemos tratado con todos los números estrictamente mayores que 1,234,500. La misma lógica se aplicará inductivamente en todos los significados.

Jugar al golf con gracias a WolframH reduce esta solución 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]))

Y la suma de las sumas de dígitos de todos los enteros hasta 1234567891234567891234564789087414984894900000000es265889343871444927857379407666265810009829069029376

El número más grande que he logrado lanzar en la versión de golf es 10 ^ 300, momento en el cual los flotadores comienzan a desbordarse y la inestabilidad numérica comienza a causar problemas. Con una función de exponenciación rápida de cuadrado y multiplicación, este problema desaparecería.

Y el soporte de LaTeX sería realmente útil ...

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

La entrada maneja números hasta 1E100y evalúa automáticamente. Puede manejar expresiones.

Aunque es una matriz increíblemente grande, no estoy desperdiciando recursos informáticos (esto se ejecuta desde una calculadora ).

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

Aquí hay una versión alternativa que técnicamente debería ser elegible para la bonificación de 25 para "cualquier" número entero positivo, pero es prácticamente lenta ya que el algoritmo es de tiempo lineal en su entrada. De todos modos, fue divertido escribir. Resta manualmente un número leído como caracteres ASCII. Esta versión tiene 150 caracteres. (¡Ahora con un código horrible, de discusión y de bucle!)

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

Variación de manejo de expresiones. Implementos de precedencia de los operadores de acuerdo a las reglas típicas: / * - +. Limitado a 97 tokens = 48 términos.

#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

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

Explicación: Supongamos que la entrada es "12":

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

Pila es [0,1,2,3,...,12].

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

Pila es "01234...9101112".

' '* # join a space between all characters

Pila es "0 1 2 ... 1 0 1 1 1 2".

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

Pila es [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

La pila es 51, según lo deseado.

La entrada aquí podría ser cualquier expresión válida de GolfScript, que puede incluir exponentes. Por ejemplo:

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

Desde 2(5 + 5) - 8 = 12. Creo que esto debería calificar para la bonificación, pero tal vez se esperaba que fuera solo si estaba en forma normal, no la notación polaca inversa de GolfScript.

Rubí, 37-50 = -13

¡Doble evaluación, todo el camino a través del cielo! Al igual que con las otras soluciones de Ruby, creo que en teoría esto debería ser capaz de funcionar con números arbitrariamente grandes, pero el tiempo de ejecución sería ... terrible.

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

Versión anterior (49-50 puntos)

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

Suponiendo que la bonificación de 10 caracteres realmente requiere que el carácter de exponenciación sea un símbolo de intercalación, la forma más corta que podría agregar es:

.gsub ?^,'**'

Lo que cuesta más personajes de los que daría la bonificación.

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

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

Puede manejar todos los números positivos (sin embargo, los grandes tardarán mucho tiempo, porque actualmente las implementaciones de Perl 6 son lentas, pero Perl 6 admite números enteros grandes de forma nativa). Utiliza eval, para implementar una calculadora simple (la pena de cinco caracteres por cincuenta caracteres vale la pena). Es lento solo porque las implementaciones actuales son lentas, pero en teoría, debería ser lo suficientemente rápido (cuando las implementaciones de Perl 6 mejoran, eso es). Además, sorprendentemente, gano con Mathematica (por ahora).

» en este código en realidad no es necesario, pero lo puse aquí por razones de rendimiento (de lo contrario, el programa asignaría una cadena completa. La razón por la que está aquí es que Perl 6 no tiene cadenas infinitas, pero sí tiene listas infinitas.

De todos modos, puede preguntar cómo funciona este código. Bueno, lo voy a pasar parte por parte.

• get.eval

  Esto obtiene una línea ( getfunción) y la evalúa ( evalmétodo).

• 1..get.eval

  Después de eso, Perl 6 prepara un objeto de rango, desde el 1valor evaluado. Este es un rango, por lo que no se asigna nada enorme.

• ».comb

  .combEl método divide la cadena en caracteres (a menos que se llame con un argumento ). Por ejemplo, 'cat'.combvuelve 'c', 'a', 't'. »asigna los elementos de la lista, por lo que .combse ejecuta en cada elemento, no solo en la lista misma (por ejemplo, (4, 9)».sqrtda 2, 3). Esto tampoco asigna más de lo necesario, porque Perl 6 tiene listas infinitas (como Haskell, por ejemplo).

  »el carácter en realidad no es necesario, ya que .combse puede usar directamente en la lista, pero esto implica una coerción de cadena implícita (y Perl 6 no tiene cadenas infinitas, por lo que desperdiciaría memoria). Por ejemplo, la 1, 2, 3lista después de la conversión a la cadena devuelve 1 2 3. Para Perl 6, un espacio es un número perfectamente fino que significa 0, por lo que el código funcionaría, incluso con dicha conversión. Sin embargo, abusaría de los recursos informáticos.

• [+]

  Este es un operador reducido. Básicamente, entre [], puede utilizar un operador, en este caso +. La lista después del operador reduce se reduce, así [+] 1, 2, 3es 1 + 2 + 3, cuál es 6. Perl 6 usa operadores separados para números y cadenas, por lo que no se considerará concatenación.

• say

  Finalmente, saygenera el resultado. Después de todo, quieres ver el resultado final, ¿no?

Perl 31 - Sin bonificaciones

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

Salida de muestra:

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

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

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

Pruébalo en línea!

J, 22

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

Explicación

La evaluación procede de derecha a izquierda.

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)

Cuando esto se ejecuta, se le pide al usuario que ingrese.

Versión anterior (no puede manejar expresiones): 46 caracteres:

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

Lote - (181-50) - 131

Solo por un poco de diversión.

@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 haré un poco más legible:

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

El método anterior usa el bucle para obtener la salida del comando powershell, en lugar de escribir y leer desde un archivo:

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

Establezca la entrada en una variable - v- usando /apara aceptar expresiones aritméticas.
Desafortunadamente, fue necesario habilitar la expansión demorada.
Use un bucle for para contar desde 1 hasta el valor ingresado - v.
Para manejar números mayores que 9, tuve que usar powershell para obtener la longitud de la cadena y luego usar otro bucle for para dividir esa cadena y agregarla a la suma - s.
Usted podría cambiar el nombre de powershell.exea p.exeen C: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ luego llamar con sólo p "&{'%%a'.length-1}, el ahorro de 9 bytes. Pero eso no está realmente en el espíritu de eso.

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

Dejé el segundo corriendo mientras tomaba mi almuerzo.

Realmente no puedo probarlo con números que son demasiado grandes debido a lo lento que es. Sin embargo, debería funcionar para números bastante grandes. 2147483647es el número más grande que tomará (máximo de 32 bits enteros) antes de dar el siguiente error:

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

Por supuesto, esto me descalifica del desafío.

Dyalog APL , 9-160 * = -151

+/⍎¨∊⍕¨⍳⎕

Pruébalo en línea!

⎕obtener una entrada evaluada,
 por ejemplo, "7+5"da12

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

⍕¨ formatee cada número en cadena
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ alistarse (aplanar)
 "123456789101112"

⍎¨ Ejecuta cada carácter (produce una lista de números de un solo dígito, números)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ suma  51

* Puntuación

-50 de bonificación ya que incluso acepta expresiones como entrada. La expresión debe ser APL válida, que es aceptable según OP .

-10 bonus porque porque también maneja el ^( *en APL).

-100 bonus porque la entrada de expresión se maneja sin el uso explícito de eval(es decir, ⍎en 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));}}

Bonita

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//^/**}))))"

• puede manejar todos los números positivos
• puede manejar expresiones con operación + - / *
• puede manejar ^ (poder) operador.
• puede manejar expresiones, sin eval o similar¹

Si el resultado de la expresión no es entero, primero se truncará. Si el resultado de la expresión es negativo, el resultado no está definido.

Úselo como:

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

1: a menos que cuentes invocar Python desde Bash como tal, pero no creo que sea así. Si crees que realmente lo es, entonces la puntuación ajustada es -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);
    }
}

Maneja expresiones. Dale cualquier expresión que desees en el objetivo. Maneja hasta que la longitud larga pueda manejar. Si limpia quitando todos los espacios en una línea, y no hay ninguna declaración para imprimir, cuenta hasta 254 caracteres (considerando la programación Java basada en palabras largas y largas).

PD: Este es un programa completo, no solo lógico. Las palabras cuentan para el programa, no solo la lógica.

Java (JDK8), 272

Mi primer desafío en el que estoy, las sugerencias son bienvenidas =)

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

Sangrado:

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 es unos meses más joven que este desafío, por lo que no es elegible para la marca de verificación verde. Además, esto no está ganando a Perl en primer lugar. ;) Me gustó bastante el enfoque, así que quería publicarlo de todos modos.

l~),s:~:+

Pruébalo aquí.

La idea es crear un rango de 0 a N. Este rango se convierte en una cadena, que simplemente concatena los enteros de forma consecutiva. Para N = 12, obtendríamos

"0123456789101112"

Luego, cada carácter se convierte en un entero con :~(lo que produce una matriz de enteros), y luego se resume con :+. CJam puede lidiar con enteros arbitrariamente grandes.

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

ahorró 10 bytes al eliminar tsy cambiarp

editar: no puedo probar el número entero ridículamente largo (1234567891234567891234564789087414984894900000000) [cuelga mi computadora] pero, que yo sepa, Python 3 admite números enteramente largos.

Esta implementacion usosabusa de AST. No consideraría abusar de AST como "eval o 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()))))))

Demasiado perezoso para escribir sin golf, así que te daré una explicación de las clases:

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.

La última línea solo ejecuta estas clases en el orden apropiado en la entrada, para preservar el orden de las operaciones y evitar comportamientos no deseados.

Ejemplo de uso ($ o> significa entrada del usuario) y, por cierto, el programa real solo ingresa una vez:

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

Bonita

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

Rubí -> 83-50 = 33

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

Versión "a prueba":

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 

Resultados de las pruebas

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

Es mi otro intento.

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

Bonita

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

Rubí 69-50 = 19 (o -4)

Esto definitivamente se puede jugar juntos, pero aquí está el primer quinto intento

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

También funciona para todos los números, pero es muy lento para ellos, ya que funciona más lento que O (n), por lo que no agregaría el -25. Si la lentitud está bien, entonces sería -4 aunque

Rubí 133-50-25 = 58

Esta es la versión más rápida, que se ejecuta en menos de O (n) tiempo (¡y usa las matemáticas reales!), Por lo que puede proporcionar resultados para enteros grandes rápidamente, por lo que agregué el -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 puntos)

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

Salida:

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