Diese Herausforderung besteht darin, ein Programm oder ein Skript zu schreiben, das die Summe aller Ziffern innerhalb der ganzen Zahlen von 1 bis einschließlich einer bestimmten Zahl zählt.

Eingabe, eine positive ganze Zahl. Ausgabe, die Summe der Ziffern dieser Zahl und aller kleineren Zahlen.

Beispiele:

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

Um klar zu sein, ist dies eine Summe der Ziffern zu zählen - nicht die ganzen Zahlen. Dies gilt auch für einstellige Eingaben. Eingaben, die größer als 10 sind, reagieren jedoch unterschiedlich. Dies wäre eine falsche Antwort:

Input: 12
Output: 78

Ein weiteres Beispiel, um den Unterschied zu zeigen:

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

Ein größerer Testfall (RICHTIGE ANTWORT):

Input: 1000000
Output: 27000001

Regeln & Richtlinien:

• Der übermittelte Code muss ein vollständiges Programm oder Skript sein - nicht nur eine Funktion. Wenn für den Code Einschlüsse, Importe usw. erforderlich sind, müssen diese im Buchungscode enthalten sein.
• Die Nummer muss vom Benutzer eingegeben werden - nicht fest codiert. Eingaben können als Befehlszeilenargument, Datei, Standardeingabe oder auf andere Weise empfangen werden, mit der Ihre Sprache Benutzereingaben verarbeiten kann.
• Der Code muss in der Lage sein, mindestens bis zu Eingaben ordnungsgemäß zu verarbeiten (2^64)-1.
• Der Code sollte nur die Summe ausgeben.
• Eingereichte Programme und Skripte sollten benutzerfreundlich sein und keine Computerressourcen verschwenden (z. B .: Sie sollten keine wahnsinnig großen Arrays deklarieren, in denen jedes Zeichen Platz findet). Es gibt keinen strengen Bonus oder eine Strafe dafür, aber bitte seid gute Programmierer.

Wertung:

Der primäre Bewertungsmechanismus ist die Codelänge. Niedrigere Werte sind besser. Die folgenden Boni und Strafen gelten ebenfalls:

• -25 Bonus, wenn Ihr Code alle positiven Zahlen verarbeiten kann, zum Beispiel:1234567891234567891234564789087414984894900000000
• -50 Bonus, wenn Ihr Code beispielsweise einfache Ausdrücke verarbeiten kann 55*96-12. Um sich für diesen Bonus zu qualifizieren, sollte der Code + - / *Operatoren (Addition, Subtraktion, Division, Multiplikation) handhaben und die Reihenfolge der Operationen durchsetzen. Division ist eine reguläre Ganzzahldivision.
  • Das angegebene Beispiel ( 55*96-12) ergibt 5268. Ihr Code sollte für jede dieser Eingaben den gleichen Wert zurückgeben - die richtige Antwort lautet 81393.
• -10 Bonus, wenn sich Ihr Code für den -50 Bonus qualifiziert und mit dem ^(Exponenten-) Operator umgehen kann .
• -100 Bonus, wenn sich Ihr Code für den -50 Bonus qualifiziert und keine evaloder ähnliche Ausdrücke verwendet.
• +300 Strafe, wenn Ihr Code auf Webressourcen angewiesen ist.

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

Golfed-Lösung (Final Line basiert auf der großartigen Lösung von xfix ):

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

Lösung ohne Golf:

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

Der Evaluierungsschritt funktioniert durch Iterieren über jedes Symbol *, /, +, -, zu finden , wenn das liegt zwischen zwei ganzen Zahlen, und Ersetzen , dass die Funktion des Symbol darstellt.

Genauer gesagt: Es nimmt jedes Symbol (z. B. +) und die Infix-Funktion, die es darstellen soll (z. B. &[+]die Abkürzung für &infix:<+>und dieselbe Funktion, die Perl 6 beim Ausführen aufruft 1 + 2), und führt eine globale Ersetzung durch ( s:g[…] = …ähnlich wie Perl 5) s/…/…/ge), der zwei durch das Symbol ( (\d+) $sym (\d+)) getrennte Ganzzahlen entspricht und durch die Ausgabe der entsprechenden Infix-Funktion ersetzt, die mit diesen Ganzzahlen ( infix($0, $1)) aufgerufen wird .

Schließlich wird dieser ausgewertete Ausdruck eingespeistsay [+] (1..$expression)».comb , was xfix in seiner Lösung sehr gut erklärt .

Tut mir leid, dass ich so spät zur Party komme

BEARBEITEN: Unterstützung für Exponenten entfernt; es waren sowieso genau 10 Zeichen und die Assoziativität war nicht korrekt.

Mathematica 30- (10 + 50) = -30

Verkürzt um 4 Zeichen dank ybeltukov.

Range@nLiefert die Zahlen von 1 bis n.

Integerdigits@n teilt jede dieser Zahlen in Ziffern auf.

Total[n,2]summiert die Ziffern. Die 2 soll das Summieren über verschiedene Ebenen hinweg ermöglichen, dh Listen von Listen.

IntegerDigits@Range@#~Total~2&

Testen

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

51

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

27000001

Ausdrücke

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

Sehr beschämend, @Fors Antwort von hier zu stehlen, um die Ausdrucksbewertung durchzuführen: https://codegolf.stackexchange.com/a/11423/13877

Beispielnutzung:

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

Anmerkung: Die Ausdrucksimplementierung nimmt keine Operatorpriorität an und verbraucht die Werte so, wie sie empfangen werden. ex, 1+2*3 = 9eher als das typische 7.

sed, 411 283 - 25 = 258

Ich kann mich momentan nicht mehr darum kümmern, Golf zu spielen. :-) Nicht empfohlen für die Verwendung mit auch nur entfernt großen Ganzzahlen, aber technisch gesehen könnte es mit beliebig großen Ganzzahlen umgehen (wahrscheinlich geht Ihnen der Arbeitsspeicher jedoch ziemlich schnell aus, da ich die Zahl (mehr oder weniger) einkodieren muss unary).

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

Beispielgebrauch

(Eingabezeilen zum leichteren Lesen eingerückt.)

  5
15
  12
51
  33
183

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

Ineffizient und doch kürzer und auch in der Lage, Ausdrücke zu verarbeiten.

EDIT: Danke Wolframh und legoStormtroopr für die Tricks: D

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

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

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

Eingang:

1234567891234567891234564789087414984894900000000

Ausgabe:

265889343871444899381999757086453238874482500000214

Python - 108 Zeichen minus 85 Boni, 23 Striche, verarbeitet sehr sehr sehr große Eingaben

Die meisten dieser Lösungen scheinen alle Ints weniger als die Eingabe zu durchlaufen und alle ihre Ziffernsummen zu addieren. Das funktioniert, aber ich halte es für unelegant und würde die Frage stellen, ob sie wirklich für den 25-Punkte-Bonus in Frage kommen, da ich nicht glaube, dass sie in der Lage wären, die Eingaben 1234567891234567891234564789087414984894900000000in unserem Leben zu verarbeiten. Tatsächlich nbrauchen diese Lösungen bei der Eingabe von Ziffern O(10^n)Zeit. Ich habe mich stattdessen entschlossen, ein bisschen Mathe auf dieses Problem zu werfen.

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

Die Menge aller xZiffern ist isomorph zur Menge {0,1,2,3,4,5,6,7,8,9}^x. Für eine feste (n,sig)gibt es xunterschiedliche Werte für sig, 10^x-1Punkte mit dem sigth Indexmenge zu n, und die Summe aller Ziffern 0-9ist 45. Dies alles durch gehandhabt wird f.

g ist etwas, mit dem wir wahrscheinlich alle vertraut sind

magicNimmt alle Ziffern der eingegebenen Nummer und durchläuft sie von der niedrigsten bis zur höchsten. Dies lässt sich am einfachsten mit einer Beispieleingabe verfolgen 1,234,567.

Um mit dem Bereich umzugehen 1,234,567-1,234,560, müssen wir alle Ziffern von 1bis 7addieren 7und die Summe der anderen Ziffern addieren , um mit allen Zahlen umzugehen, die größer als sind 1,234,560. Wir müssen uns jetzt um den Rest kümmern.

Um mit dem Bereich umzugehen 1,234,560-1,234,500, fügen wir das 6( val) hinzu und senken die Obergrenze auf 1,234,559. Wenn wir den Rest des Abwurfs machen, sehen wir jede einstellige Zahl sechsmal ( val*f(sig)). Wir werden alle Zahlen von 0bis 5genau zu 10jeder Zeit sehen ( (10**sig)*g(val-1)). Wir werden alle anderen Ziffern in dieser Nummer genau 60 Mal sehen ( (val*10**sig)*sum(digits[sig+1:])). Wir haben uns jetzt mit allen Zahlen auseinandergesetzt, die strikt größer sind als 1,234,500. Die gleiche Logik gilt induktiv für alle Bedeutungen.

Golfen dies, dank WolframH, reduziert diese Lösung auf

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

Und die Summe der Ziffernsummen aller ganzen Zahlen bis zu 1234567891234567891234564789087414984894900000000ist265889343871444927857379407666265810009829069029376

Die größte Zahl, die ich bei der Golf-Version geschafft habe, ist 10 ^ 300, an diesem Punkt fangen die Schwimmer an zu überlaufen und die numerische Instabilität fängt an, Probleme zu verursachen. Mit einer schnellen Funktion zur Potenzierung von Quadraten und Multiplikationen würde dieses Problem verschwinden.

Und LaTeX-Unterstützung wäre wirklich nützlich ...

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

Die Eingabe verarbeitet Zahlen bis zu 1E100und wertet sie automatisch aus. Kann mit Ausdrücken umgehen.

Obwohl es ein wahnsinnig großes Array ist, verschwende ich keine Computerressourcen (dies wird von einem Taschenrechner ausgeführt ).

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

Hier ist eine alternative Version, die technisch für den Bonus von 25 für "jede" positive Ganzzahl in Frage kommen sollte , aber sie ist unpraktisch langsam, da der Algorithmus in seiner Eingabe eine lineare Zeit aufweist. Trotzdem hat es Spaß gemacht zu schreiben. Subtrahiert manuell eine als ASCII-Zeichen eingelesene Zahl. Diese Version ist 150 Zeichen. (Jetzt mit schrecklichem, argumentierendem, schleifenförmigem Code!)

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

Variation im Umgang mit Ausdrücken. Implementiert Operatorpräzedenz nach typischen Regeln: / * - +. Beschränkt auf 97 Token = 48 Bedingungen.

#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

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

Erläuterung: Angenommen, die Eingabe ist "12":

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

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

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

Stack ist "01234...9101112".

' '* # join a space between all characters

Stack ist "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 ist [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

Der Stapel ist wie gewünscht 51.

Die Eingabe kann ein beliebiger gültiger GolfScript-Ausdruck sein, der Exponenten enthalten kann. Beispielsweise:

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

Seit 2(5 + 5) - 8 = 12. Ich denke, dies sollte sich für den Bonus qualifizieren, aber vielleicht sollte es nur in normaler Form sein, nicht in der umgekehrten polnischen Notation von GolfScript.

Rubin, 37 - 50 = -13

Doppelte Bewertung, den ganzen Weg über den Himmel! Wie bei den anderen Ruby-Lösungen sollte dies theoretisch mit beliebig großen Zahlen funktionieren können, aber die Ausführungszeit wäre ... fatal.

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

Ältere Version (49 - 50 Punkte)

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

Angenommen, der Bonus von 10 Zeichen setzt tatsächlich voraus, dass das Zeichen für die Potenzierung ein Caret ist. Der kürzeste Weg, den ich einschätzen könnte, ist:

.gsub ?^,'**'

Was mehr Charaktere kostet als der Bonus geben würde.

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

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

Es kann mit allen positiven Zahlen umgehen (große Zahlen werden jedoch eine lange Zeit in Anspruch nehmen, da derzeit Perl 6-Implementierungen langsam sind, Perl 6 jedoch große ganze Zahlen nativ unterstützt). Es verwendet eval, um einen einfachen Taschenrechner zu implementieren (fünf Zeichen Strafe für fünfzig Zeichen ist es wert). Es ist langsam, nur weil die aktuellen Implementierungen langsam sind, aber theoretisch sollte es schnell genug sein (wenn Perl 6-Implementierungen verbessert werden). Überraschenderweise gewinne ich auch mit der Mathematica (vorerst).

» In diesem Code wird er eigentlich nicht benötigt, aber ich habe ihn aus Performancegründen hier abgelegt (andernfalls würde das Programm den gesamten String zuweisen. Der Grund dafür ist, dass Perl 6 keine unendlichen Strings hat, aber unendliche Listen.

Wie auch immer, Sie können sich fragen, wie dieser Code überhaupt funktioniert. Nun, ich werde es Teil für Teil weitergeben.

• get.eval

  Dies erhält eine Zeile ( getFunktion) und wertet diese aus ( evalMethode).

• 1..get.eval

  Danach bereitet Perl 6 ein Bereichsobjekt von 1bis zum ausgewerteten Wert vor. Dies ist eine Reichweite, daher wird nichts Großes zugewiesen.

• ».comb

  .combMethode teilt Zeichenfolge in Zeichen auf ( sofern nicht mit einem Argument aufgerufen ). Zum Beispiel 'cat'.combkehrt zurück 'c', 'a', 't'. »ordnet die Listenelemente zu, wird also .combfür jedes Element ausgeführt - nicht nur für die Liste selbst (z. B. (4, 9)».sqrtgibt 2, 3). Dies belegt auch nicht mehr als nötig, da Perl 6 unendlich viele Listen hat (wie zum Beispiel Haskell).

  »Zeichen werden eigentlich nicht benötigt, da .combes direkt in der Liste verwendet werden kann, dies beinhaltet jedoch impliziten String-Zwang (und Perl 6 hat keine unendlichen Strings, so dass dies Speicher verschwenden würde). Beispiel: 1, 2, 3Liste nach Konvertierung in die Zeichenfolge gibt zurück 1 2 3. Für Perl 6 ist ein Leerzeichen eine sehr feine Zahl, die 0 bedeutet, sodass der Code auch bei einer solchen Konvertierung funktionieren würde. Es würde jedoch Computerressourcen missbrauchen.

• [+]

  Dies ist ein Reduktionsoperator. Grundsätzlich können []Sie in diesem Fall zwischen einen Operator eingeben +. Die Liste nach reduzieren Bediener verringert wird , so [+] 1, 2, 3ist 1 + 2 + 3, was ist 6. Perl 6 verwendet separate Operatoren für Zahlen und Zeichenfolgen, sodass dies nicht als Verkettung betrachtet wird.

• say

  Zum Schluss wird saydas Ergebnis ausgegeben. Immerhin wollen Sie das Endergebnis sehen, nicht wahr?

Perl 31 - Keine Boni

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

Beispielausgabe:

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

Perl 5 mit -p50 - 28 Bytes: -22

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

Probieren Sie es online!

J, 22

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

Erläuterung

Die Auswertung erfolgt von rechts nach links.

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)

Wenn dies ausgeführt wird, wird der Benutzer zur Eingabe aufgefordert.

Alte Version (kann keine Ausdrücke verarbeiten): 46 Zeichen:

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

Charge - (181 - 50) - 131

Nur zum Spaß.

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

Ich werde es ein bisschen lesbarer machen:

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

Die alte Methode verwendet die for-Schleife, um die Ausgabe des Powershell-Befehls abzurufen, im Gegensatz zum Schreiben in und Lesen aus einer Datei:

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

Setzen Sie die Eingabe auf eine Variable - v- /a, um arithmetische Ausdrücke zu akzeptieren.
Leider war eine verzögerte Erweiterung notwendig.
Verwenden Sie eine for-Schleife, um von 1 bis zum eingegebenen Wert zu zählen - v.
Um mit Zahlen größer als 9 umgehen zu können, musste ich Powershell verwenden, um die Länge der Zeichenfolge zu ermitteln, und dann eine andere for-Schleife verwenden, um die Zeichenfolge aufzuteilen und zur Summe hinzuzufügen - s.
Sie können den Namen von powershell.exein p.exeC: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ ändern und ihn dann mit nur p "&{'%%a'.length-1}9 Byte speichern. Aber das stimmt nicht wirklich.

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

Habe das zweite Rennen hinter mir gelassen, während ich meine Mittagspause eingelegt habe.

Ich kann es nicht wirklich mit Zahlen testen, die zu viel größer sind, weil es zu langsam ist. Es sollte jedoch für ziemlich große Zahlen funktionieren. 2147483647ist die größte Zahl, die benötigt wird (maximal 32-Bit-Ganzzahl), bevor der folgende Fehler ausgegeben wird:

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

Dies disqualifiziert mich natürlich von der Herausforderung.

Dyalog APL , 9-160 * = -151

+/⍎¨∊⍕¨⍳⎕

Probieren Sie es online!

⎕ausgewerteten Input bekommen
 zB "7+5"gibt12

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

⍕¨ Formatieren Sie jede Zahl in eine Zeichenfolge
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ eintreten (abflachen)
 "123456789101112"

⍎¨ führe jedes Zeichen aus (ergibt eine Liste von einstelligen Zahlen)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ Summe  51

* Wertung

-50 Bonus, da er sogar Ausdrücke als Eingabe akzeptiert. Der Ausdruck muss eine gültige APL sein, die nach OP zulässig ist .

-10 Bonus weil es auch die ^( *in APL) behandelt.

-100 Bonus, da Ausdruckseingaben ohne explizite Verwendung von eval(dh ⍎in APL) verarbeitet werden.

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

Ziemlich

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

• Kann alle positiven Zahlen verarbeiten
• Kann Ausdrücke mit + - / * verarbeiten
• Kann mit ^ (Power) Operator umgehen.
• kann mit Ausdrücken umgehen, ohne eval oder ähnliches¹

Wenn das Ergebnis des Ausdrucks keine Ganzzahl ist, wird es zuerst abgeschnitten. Wenn das Ergebnis des Ausdrucks negativ ist, ist das Ergebnis undefiniert.

Verwenden Sie es wie folgt:

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

1: es sei denn, Sie möchten Python von Bash als solches aufrufen, aber ich denke nicht, dass dies der Fall ist. Wenn Sie glauben, dass dies tatsächlich der Fall ist, beträgt die angepasste Punktzahl -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);
    }
}

Behandelt Ausdrücke. Geben Sie dem Ziel den gewünschten Ausdruck. Griffe, bis die Länge lang ist. Wenn Sie bereinigen, indem Sie alle Leerzeichen in einer Zeile und keine Anweisung zum Drucken entfernen, werden 254 Zeichen verwendet (unter Berücksichtigung der Java-Programmierung mit langen, langen Wörtern).

PS: Dies ist ein vollständiges Programm, nicht nur Logik. Die angegebenen Wörter zählen für das Programm, nicht nur für die Logik.

Java (JDK8), 272

Meine erste Herausforderung, bei der ich bin, Vorschläge sind willkommen =)

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

Eingerückt:

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 ist einige Monate jünger als diese Herausforderung, daher ist dies nicht für das grüne Häkchen zulässig. Außerdem schlägt dies Perl nicht in erster Linie. ;) Der Ansatz hat mir aber sehr gut gefallen, deshalb wollte ich ihn trotzdem posten.

l~),s:~:+

Teste es hier.

Die Idee ist, einen Bereich von 0 bis N zu erstellen. Dieser Bereich wird dann in eine Zeichenfolge konvertiert, die nur die ganzen Zahlen hintereinander verkettet. Für N = 12 würden wir bekommen

"0123456789101112"

Dann wird jedes Zeichen mit in eine Ganzzahl umgewandelt :~(was ein Array von Ganzzahlen ergibt) und dann mit aufsummiert :+. CJam kann mit beliebig großen ganzen Zahlen umgehen.

Python 3 + Astor ,1017 1007 Bytes - (25 + 50 + 100) = Ergebnis: 842 834

10 Bytes durch Entfernen tsund Ändern gespartp

Bearbeiten: Ich kann die lächerlich lange Ganzzahl (1234567891234567891234564789087414984894900000000) [hängt meinen Computer] nicht testen, aber meines Wissens unterstützt Python 3 beliebig lange Ganzzahlen.

Diese Implementierung Verwendetmissbraucht AST. Ich würde AST nicht als "eval or similar" missbrauchen.

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

Zu faul, um ungolfed zu schreiben, deshalb erkläre ich dir die Klassen:

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.

In der letzten Zeile werden diese Klassen nur in der entsprechenden Reihenfolge für die Eingabe ausgeführt, um die Reihenfolge der Vorgänge beizubehalten und unerwünschtes Verhalten zu verhindern.

Beispielverwendung ($ oder> bedeutet Benutzereingabe) und das eigentliche Programm nimmt übrigens nur eine Eingabe vor:

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

Ziemlich

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

Rubin -> 83-50 = 33

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

"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 

Testergebnisse

$ 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 ist mein weiterer Versuch.

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

Ziemlich

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

Ruby 69-50 = 19 (oder -4)

Dies kann auf jeden Fall zusammen gespielt werden, aber hier ist der erste fünfte Versuch

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

Es funktioniert auch für alle Zahlen, ist jedoch sehr langsam, da es langsamer als O (n) läuft, sodass ich die -25 nicht addieren würde. Wenn Langsamkeit in Ordnung ist, dann wäre es -4 obwohl

Rubin 133-50-25 = 58

Dies ist die schnellere Version, die in weniger als O (n) Zeit ausgeführt wird (und die tatsächliche Mathematik verwendet!), Sodass sie schnell Ergebnisse für große ganze Zahlen liefern kann. Dabei habe ich die -25 hinzugefügt:

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

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

Ausgabe:

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