Wyzwanie polega na napisaniu programu lub skryptu, który zlicza sumę wszystkich cyfr w liczbach całkowitych od 1 do podanej liczby włącznie.

Wejście, jedna dodatnia liczba całkowita. Dane wyjściowe, suma cyfr w tej liczbie i wszystkie mniejsze liczby.

Przykłady:

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

Żeby było jasne, należy policzyć sumę cyfr - nie liczb całkowitych. W przypadku danych jednocyfrowych będzie to samo. Jednak dane wejściowe większe niż 10 będą miały różne odpowiedzi. To byłaby niepoprawna odpowiedź:

Input: 12
Output: 78

Kolejny przykład, aby pokazać różnicę:

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

Większy przypadek testowy (PRAWIDŁOWA REAKCJA):

Input: 1000000
Output: 27000001

Zasady i wytyczne:

• Przesłany kod musi być kompletnym programem lub skryptem, a nie tylko funkcją. Jeśli kod wymaga uwzględnienia, importu itp., Należy je uwzględnić w opublikowanym kodzie.
• Numer musi być wprowadzony przez użytkownika - nie zakodowany na stałe. Dane wejściowe mogą być odbierane jako argument wiersza polecenia, plik, standardowe wejście lub dowolny inny sposób, za pomocą którego Twój język może przyjmować dane wprowadzone przez użytkownika.
• Kod musi być w stanie poprawnie obsługiwać dane wejściowe przynajmniej do (2^64)-1.
• Kod powinien wypisywać tylko sumę.
• Przesłane programy i skrypty powinny być przyjazne dla użytkownika i nie marnować zasobów komputerowych (np .: nie powinny zadeklarować niesamowicie dużych tablic, w których zmieści się każda postać). Nie ma za to ścisłej premii ani kary, ale bądźcie dobrymi programistami.

Punktacja:

Podstawowym mechanizmem oceniania jest długość kodu. Niższe wyniki są lepsze. Obowiązują również następujące premie i kary:

• -25 Bonus, jeśli Twój kod obsługuje wszystkie liczby dodatnie, na przykład:1234567891234567891234564789087414984894900000000
• -50 Premia, jeśli Twój kod obsługuje na przykład proste wyrażenia 55*96-12. Aby kwalifikować się do tej premii, kod powinien obsługiwać + - / *(dodawanie, odejmowanie, dzielenie, mnożenie) operatorów i egzekwować kolejność operacji. Podział to zwykły podział na liczby całkowite.
  • Podany przykład ( 55*96-12) ma wartość 5268. Twój kod powinien zwrócić to samo dla każdego z tych danych wejściowych - poprawna odpowiedź to 81393.
• Bonus -10, jeśli twój kod kwalifikuje się do premii -50 i może obsłużyć ^operatora (wykładnik).
• Bonus -100, jeśli twój kod kwalifikuje się do premii -50 i nie używa evalani nie obsługuje podobnych wyrażeń.
• +300 Kara, jeśli twój kod opiera się na jakichkolwiek zasobach sieciowych.

Perl 6: 108 - (25 + 50 + 100) + 0 = -67 punktów

Rozwiązanie w golfa (ostatnia linia oparta na świetnym rozwiązaniu xfix ):

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

Rozwiązanie bez gry w golfa:

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

Etap oceny przez powtarzanie pracuje nad każdym symbolem *, /, +, -, znalezienie kiedy która leży pomiędzy dwiema liczbami całkowitymi, i podstawiając że korzystając z funkcji, która reprezentuje symbol.

Bardziej szczegółowo: pobiera każdy symbol (np. +) I funkcję infix, którą powinien reprezentować (np. &[+]Która jest skrótem &infix:<+>i ta sama funkcja, którą wywołuje Perl 6 podczas wykonywania 1 + 2) i dokonuje globalnego podstawienia ( s:g[…] = …podobnie jak Perl 5 s/…/…/ge), który dopasowuje dwie liczby całkowite oddzielone symbolem ( (\d+) $sym (\d+)) i zastępuje je wynikiem funkcji odpowiadającej infiksowi wywołanemu tymi liczbami całkowitymi ( infix($0, $1)).

Wreszcie, to ocenione wyrażenie jest wprowadzane say [+] (1..$expression)».comb, co xfix bardzo dobrze wyjaśnia w swoim rozwiązaniu .

Przepraszam za spóźnienie na imprezę ☺

EDYCJA: Usunięto obsługę wykładników; i tak miał dokładnie 10 znaków i nie działał prawidłowo.

Mathematica 30- (10 + 50) = -30

Skrócone o 4 znaki dzięki Ybeltukovowi.

Range@nzwraca liczby od 1 do n.

Integerdigits@n dzieli każdą z tych liczb na cyfry.

Total[n,2]sumuje cyfry. 2 ma umożliwić sumowanie na różnych poziomach, tj. Listach list.

IntegerDigits@Range@#~Total~2&

Testowanie

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

51

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

27000001

Wyrażenia

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

Bardzo haniebnie kradnie @Fors odpowiedź stąd, aby dokonać oceny wyrażenia: https://codegolf.stackexchange.com/a/11423/13877

Przykładowe użycie:

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

Uwaga: implementacja wyrażenia nie przyjmuje pierwszeństwa operatora i zużywa wartości w momencie ich otrzymania; np. 1+2*3 = 9zamiast typowego 7.

sed, 411 283–25 = 258

Nie mogę się teraz przejmować golfem. :-) Nie zaleca się używania nawet z zdalnie dużymi liczbami całkowitymi, ale technicznie może poradzić sobie z dowolnie dużymi liczbami całkowitymi (prawdopodobnie zabraknie pamięci RAM dość szybko, ponieważ (mniej lub bardziej muszę) kodować liczbę w 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

Przykładowe użycie

(Wcięte linie wejściowe dla łatwiejszego czytania.)

  5
15
  12
51
  33
183

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

Nieefektywny, ale krótszy, a także zdolny do obsługi wyrażeń.

EDYCJA: Dzięki Wolframh i legoStormtroopr za sztuczki: D

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

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

Moja pierwsza wersja

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

wkład:

1234567891234567891234564789087414984894900000000

wydajność:

265889343871444899381999757086453238874482500000214

Python - 108 znaków minus 85 bonusów, 23 uderzeń, obsługuje bardzo, bardzo duże nakłady

Większość z tych rozwiązań wydaje się zapętlać wszystkie liczby całkowite mniej niż dane wejściowe i sumować wszystkie swoje sumy cyfr. To działa, ale czuję, że to nieeleganckie, i zapytałbym, czy naprawdę kwalifikują się do premii za 25 punktów, ponieważ nie sądzę, aby byli w stanie poradzić sobie z wkładem 1234567891234567891234564789087414984894900000000w ciągu naszego życia. Rzeczywiście, po wprowadzeniu ncyfr rozwiązania te wymagają O(10^n)czasu. Zamiast tego postanowiłem rzucić trochę matematyki na ten problem.

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

Zbiór wszystkich xcyfr jest izomorficzny w tym zbiorze {0,1,2,3,4,5,6,7,8,9}^x. Na stałe (n,sig)są xróżne wartości sig, 10^x-1punkty z sig-tego zestawu do indeksu n, a suma wszystkich cyfr 0-9jest 45. To wszystko jest obsługiwane przez f.

g jest coś, co prawdopodobnie wszyscy znamy

magicpobiera wszystkie cyfry z liczby wejściowej i iteruje je od najmniej do najbardziej znaczącej. Powiedzmy, że najłatwiej jest to wyśledzić za pomocą przykładowego wejścia 1,234,567.

Aby poradzić sobie z zakresem 1,234,567-1,234,560, musimy dodać wszystkie cyfry od 1do 7i dodać 7sumę razy sumę pozostałych cyfr, aby poradzić sobie ze wszystkimi liczbami większymi niż 1,234,560. Teraz musimy zająć się resztą.

Aby poradzić sobie z zakresem 1,234,560-1,234,500, dodajemy 6( val) i upuszczamy górny limit do 1,234,559. Wykonując pozostałą część kropli, zobaczymy każdą cyfrę 6 razy ( val*f(sig)). Zobaczymy wszystkie liczby od dokładnie 0do każdego ( ). Zobaczymy wszystkie pozostałe cyfry w tej liczbie dokładnie 60 razy ( ). Mamy teraz do czynienia ze wszystkimi liczbami ściśle większymi niż . Ta sama logika będzie stosowana indukcyjnie we wszystkich znaczeniach.510(10**sig)*g(val-1)(val*10**sig)*sum(digits[sig+1:])1,234,500

Gra w golfa dzięki WolframH ogranicza to rozwiązanie do

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

I suma cyfr sum wszystkich liczb całkowitych do 1234567891234567891234564789087414984894900000000jest265889343871444927857379407666265810009829069029376

Największa liczba, jaką udało mi się rzucić w wersji golfowej, to 10 ^ 300, w którym to momencie liczby zmiennoprzecinkowe zaczynają się przepełniać, a niestabilność numeryczna zaczyna powodować problemy. Dzięki funkcji szybkiego potęgowania potęgi kwadratowej i mnożenia problem ten zniknąłby.

A wsparcie LaTeXa byłoby naprawdę przydatne ...

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 obsługuje liczby do 1E100i automatycznie ocenia. Obsługuje wyrażenia.

Chociaż jest to niesamowicie duża tablica, nie marnuję zasobów komputerowych (uruchamiane z kalkulatora ).

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 150–25 = 99

Oto alternatywna wersja, która technicznie powinna kwalifikować się do premii 25 za „dowolną” dodatnią liczbę całkowitą, ale jest niepraktycznie wolna, ponieważ algorytm ma czas liniowy na wejściu. Niezależnie od tego fajnie było pisać. Ręcznie odejmuje liczbę odczytaną jako znaki ASCII. Ta wersja ma 150 znaków. (Teraz z okropnym, porywającym argumentem, zapętlonym kodem!)

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

Zmiana obsługi wyrażeń. Operator wdraża pierwszeństwo według typowych zasad: / * - +. Ograniczony do 97 tokenów = 48 warunków.

#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

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

Objaśnienie: Załóżmy, że dane wejściowe to „12”:

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

Stos jest [0,1,2,3,...,12].

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

Stos jest "01234...9101112".

' '* # join a space between all characters

Stos jest "0 1 2 ... 1 0 1 1 1 2".

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

Stos jest [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

Stos wynosi 51, zgodnie z życzeniem.

Dane wejściowe mogą być dowolnym poprawnym wyrażeniem GolfScript, które może zawierać wykładniki wykładnicze. Na przykład:

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

Od 2(5 + 5) - 8 = 12. Myślę, że powinno to kwalifikować się do premii, ale być może oczekiwano, że będzie to tylko w normalnej formie, a nie odwrotna polska notacja GolfScript.

Rubin, 37-50 = -13

Podwójna ewolucja na całej przestrzeni nieba! Podobnie jak w przypadku innych rozwiązań Ruby, myślę, że teoretycznie powinno to być w stanie pracować z dowolnie dużymi liczbami, ale czas wykonania byłby ... tragiczny.

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

Starsza wersja (49-50 punktów)

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

Zakładając, że premia za 10 postaci faktycznie wymaga, aby postać potęgowała się jako karetka, najkrótszym sposobem, jaki mógłbym dodać, jest:

.gsub ?^,'**'

Który kosztuje więcej postaci niż dałby bonus.

Perl 6 (28 - 75 + 0 = -47 bajtów)

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

Może obsłużyć wszystkie liczby dodatnie (jednak duże zajmą dużo czasu, ponieważ obecnie implementacje Perla 6 są powolne, ale Perl 6 obsługuje natywnie duże liczby całkowite). Używa eval, aby zaimplementować prosty kalkulator (warto pięć kar za pięćdziesiąt znaków). Jest powolny tylko dlatego, że obecne implementacje są powolne, ale teoretycznie powinien być wystarczająco szybki (to znaczy, gdy poprawia się implementacja Perla 6). Co zaskakujące, wygrywam z Mathematica (na razie).

» w tym kodzie faktycznie nie jest potrzebny, ale umieszczam go tutaj ze względu na wydajność (w przeciwnym razie program przydzieli cały ciąg. Powodem jest to, że Perl 6 nie ma nieskończonych ciągów, ale ma nieskończone listy.

W każdym razie możesz zapytać, jak działa ten kod. Cóż, przekażę to część po części.

• get.eval

  Pobiera jedną linię ( getfunkcję) i ocenia ją ( evalmetoda).

• 1..get.eval

  Następnie Perl 6 przygotowuje obiekt zakresu, od 1do wartości oszacowanej. Jest to zakres, więc nic wielkiego nie jest przydzielane.

• ».comb

  .combMetoda dzieli ciąg na znaki ( chyba że wywoływany jest z argumentem ). Na przykład 'cat'.combzwraca 'c', 'a', 't'. »mapuje elementy listy, więc .combjest uruchamiany na każdym elemencie - nie tylko na samej liście (na przykład (4, 9)».sqrtdaje 2, 3). To także nie przydziela więcej niż potrzeba, ponieważ Perl 6 ma nieskończone listy (na przykład Haskell).

  »znak faktycznie nie jest potrzebny, ponieważ .combmożna go użyć bezpośrednio na liście, ale wiąże się to z niejawnym przymusem ciągów (a Perl 6 nie ma nieskończonych ciągów, więc marnuje to pamięć). Na przykład 1, 2, 3lista po konwersji na ciąg znaków zwraca 1 2 3. W przypadku Perla 6 spacja jest idealnie drobną liczbą, oznaczającą 0, więc kod działałby nawet przy takiej konwersji. Jednak nadużyłoby to zasobów komputerowych.

• [+]

  Jest to operator redukcji. Zasadniczo []w tym przypadku możesz użyć operatora +. Tablicy Po redukcji operator jest zmniejszona, co [+] 1, 2, 3jest 1 + 2 + 3, co jest 6. Perl 6 używa oddzielnych operatorów liczb i ciągów, więc nie będzie uważany za konkatenację.

• say

  Na koniec saywyświetla wynik. W końcu chcesz zobaczyć końcowy wynik, prawda?

Perl 31 - Brak bonusów

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

Przykładowe dane wyjściowe:

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

Perl 5 z -p, 50 - 28 bajtów: -22

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

Wypróbuj online!

J, 22

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

Wyjaśnienie

Ocena przebiega od prawej do lewej.

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)

Po uruchomieniu tego użytkownik jest proszony o wprowadzenie danych.

Stara wersja (nie obsługuje wyrażeń): 46 znaków:

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

Partia - (181–50) - 131

Dla odrobiny zabawy.

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

Sprawię, że będzie trochę bardziej czytelny:

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

Stara metoda używa pętli for do uzyskania danych wyjściowych polecenia powershell, w przeciwieństwie do zapisywania i odczytywania plików:

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

Ustaw dane wejściowe na zmienną - v- za pomocą, /aaby zaakceptować wyrażenia arytmetyczne.
Niestety konieczne było włączenie opóźnionego rozszerzenia.
Użyj pętli for, aby policzyć od 1 do wprowadzonej wartości - v.
Aby obsłużyć liczby większe niż 9, musiałem użyć programu PowerShell, aby uzyskać długość łańcucha, a następnie użyć innej pętli for, aby podzielić ten łańcuch i dodać go do sumy - s.
Państwo mogłoby zmienić nazwę powershell.exena p.exepodstawie katalogu C: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ następnie wywołać ją tylko p "&{'%%a'.length-1}, oszczędność 9 bajtów. Ale to nie jest w duchu tego.

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

Zostawiłem ten drugi z rzędu podczas przerwy na lunch.

Naprawdę nie mogę przetestować go z liczbami, które mają zbyt dużo większy niż ten ze względu na powolny jak to jest. Powinno to jednak działać w przypadku dość dużych liczb. 2147483647to największa liczba, jaką zajmie (maksymalnie 32-bitowa liczba całkowita) przed wystąpieniem następującego błędu -

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

To oczywiście dyskwalifikuje mnie z wyzwania.

Dyalog APL , 9–160 * = -151

+/⍎¨∊⍕¨⍳⎕

Wypróbuj online!

⎕uzyskać oceniany wkład,
 np. "7+5"daje12

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

⍕¨ sformatuj każdą liczbę w łańcuch
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ zaciągnąć się (spłaszczyć)
 "123456789101112"

⍎¨ wykonać każdy znak (zwraca listę liczb jednocyfrowych liczb)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ suma  51

* Punktacja

-50 premii, ponieważ akceptuje nawet wyrażenia jako dane wejściowe. Wyrażenie musi być poprawnym APL, co jest dopuszczalne zgodnie z OP .

-10 premii, ponieważ ponieważ obsługuje również ^( *w APL).

-100 premii, ponieważ wprowadzanie wyrażeń jest obsługiwane bez jawnego użycia eval(tj. ⍎W 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));}}

Ładny

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

• może obsłużyć wszystkie liczby dodatnie
• potrafi obsługiwać wyrażenia za pomocą operacji + - / *
• obsługuje operatora ^ (moc).
• radzi sobie z wyrażeniami, bez eval lub podobnych¹

Jeśli wynik wyrażenia nie jest liczbą całkowitą, najpierw zostanie obcięty. Jeśli wynik wyrażenia jest ujemny, wynik jest niezdefiniowany.

Używaj go jak:

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

1: chyba że policzysz wywoływanie Pythona z Bash jako takiego, ale nie sądzę, że tak jest. Jeśli uważasz, że tak jest, skorygowany wynik to -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);
    }
}

Obsługuje wyrażenia. Podaj dowolne wyrażenie w celu. Uchwyty do momentu, aż długość będzie w stanie wytrzymać. Jeśli posprzątasz usuwając wszystkie spacje w jednym wierszu i nie ma instrukcji do wydrukowania, liczy się ona do 254 znaków (biorąc pod uwagę programowanie Java oparte na długich słowach).

PS: To kompletny program, nie tylko logika. Liczba słów podanych dla programu, nie tylko logiki.

Java (JDK8), 272

Moje pierwsze wyzwanie, w którym jestem, sugestie są mile widziane =)

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

Zębaty:

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 jest kilka miesięcy młodszy od tego wyzwania, więc nie kwalifikuje się do zielonego znacznika wyboru. Co więcej, to nie bije Perla. ;) Podobało mi się to podejście, więc i tak chciałem je opublikować.

l~),s:~:+

Sprawdź to tutaj.

Chodzi o to, aby utworzyć zakres od 0 do N. Ten zakres jest następnie konwertowany na ciąg znaków, który po prostu łączy liczby całkowite z powrotem do tyłu. Za N = 12 dostalibyśmy

"0123456789101112"

Następnie każdy znak jest konwertowany na liczbę całkowitą za pomocą :~(uzyskując tablicę liczb całkowitych), a następnie sumowany za pomocą :+. CJam radzi sobie z dowolnie dużymi liczbami całkowitymi.

Python 3 + astor ,1017 1007 bajtów - (25 + 50 + 100) = wynik: 842 834

zapisano 10 bajtów, usuwając tsi zmieniającp

edycja: Nie jestem w stanie przetestować absurdalnie długiej liczby całkowitej (1234567891234567891234564789087414984894900000000) [zawiesza mój komputer], ale z mojej wiedzy, Python 3 obsługuje dowolnie długie liczby całkowite.

To wdrożenie wykorzystujenadużywa AST. Nie uważałbym nadużywania AST za „ewaluacyjny lub podobny”.

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

Zbyt leniwy, by pisać bez golfa, więc dam ci wyjaśnienie klas:

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.

Ostatni wiersz po prostu wykonuje te klasy w odpowiedniej kolejności na wejściu, aby zachować kolejność operacji i zapobiec niepożądanemu zachowaniu.

Przykładowe użycie ($ lub> oznacza dane wprowadzane przez użytkownika), a przy okazji, rzeczywisty program pobiera dane tylko raz:

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

Ładny

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(:+)}                     

Wersja „Aby przetestować”:

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 

Testuje wyniki

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

To moja kolejna próba.

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

Ładny

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

Ruby 69-50 = 19 (lub -4)

Z pewnością można razem grać w golfa, ale oto pierwsza piąta próba

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

Działa również dla wszystkich liczb, ale jest dla nich bardzo wolny, ponieważ działa wolniej niż O (n), więc nie dodałbym -25. Jeśli powolność jest w porządku, to byłoby -4 chociaż

Rubin 133–50–25 = 58

Jest to szybsza wersja, która działa w czasie krótszym niż O (n) (i wykorzystuje rzeczywistą matematykę!), Więc może zapewniać szybkie wyniki dla dużych liczb całkowitych, dlatego dodałem -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 punkty)

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

Wydajność:

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