이 과제는 1부터 주어진 숫자를 포함하여 정수 내의 모든 자릿수의 합계를 계산하는 프로그램이나 스크립트를 작성하는 것입니다.

입력, 하나의 양의 정수. 해당 숫자와 모든 작은 숫자의 자릿수 합계를 출력합니다.

예 :

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

분명히하기 위해 정수가 아닌 숫자 의 합계를 계산합니다 . 한 자리 입력의 경우에도 동일합니다. 그러나 10보다 큰 입력은 다른 응답을 갖습니다. 이것은 것입니다 잘못된 응답 :

Input: 12
Output: 78

차이점을 보여주는 또 다른 예 :

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

더 큰 테스트 사례 (CORRECT RESPONSE) :

Input: 1000000
Output: 27000001

규칙 및 지침 :

• 제출 된 코드는 기능이 아니라 완전한 프로그램 또는 스크립트 여야합니다. 코드에 포함, 수입 등이 필요한 경우 게시 된 코드에 포함해야합니다.
• 숫자는 하드 코딩되지 않은 사용자가 입력해야합니다. 입력은 명령 행 인수, 파일, stdin 또는 언어가 사용자 입력을 취할 수있는 다른 수단으로 수신 될 수 있습니다.
• 코드는 적어도 입력을 올바르게 처리 할 수 ​​있어야합니다 (2^64)-1.
• 코드는 합계 만 출력해야합니다.
• 제출 된 프로그램 및 스크립트는 사용하기 쉽고 컴퓨터 리소스를 낭비하지 않아야합니다 (예 : 모든 문자를 담을 수있는 큰 배열을 선언해서는 안 됨). 이에 대한 엄격한 보너스 나 페널티는 없지만 훌륭한 프로그래머가 되십시오.

채점 :

기본 점수 매기기 메커니즘은 코드 길이입니다. 점수가 낮을수록 좋습니다. 다음 보너스 및 위약금도 적용됩니다 :

• 코드가 모든 양수를 처리 할 수있는 경우 -25 보너스 :1234567891234567891234564789087414984894900000000
• 예를 들어 코드에서 간단한 표현식을 처리 할 수있는 경우 -50 보너스55*96-12 . 이 보너스를 받으려면 코드에서 + - / *(더하기, 빼기, 나누기, 곱하기) 연산자를 처리하고 연산 순서를 시행해야합니다. 나눗셈은 정규 정수 나누기입니다.
  • 주어진 예제 ( 55*96-12)는로 평가됩니다 5268. 코드는 입력 중 하나에 대해 동일하게 반환해야합니다 81393. 정답은 입니다.
• -10 보너스 코드에서 -50 보너스 를 받을 수 있고 ^(지수) 연산자를 처리 할 수 있는 경우 보너스 .
• -100 보너스 코드의 -50 보너스 자격을 경우 와 사용하지 않는 eval또는 핸들 식 비슷합니다.
• 코드가 웹 리소스에 의존하는 경우 +300 페널티

펄 6 : 108-(25 + 50 + 100) + 0 = -67 포인트

골프 솔루션 ( xfix의 훌륭한 솔루션을 기반으로 한 최종 라인 ) :

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

골프 용 솔루션 :

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

평가 단계는 각각의 기호에 걸쳐 반복하는 방식으로 작동합니다 *, /, +, -, 두 정수 사이의 거짓말, 그리고 기능을 사용하여 기호가 나타내는 것을 대체 찾을 때.

더 자세하게 설명 +하자면, 각 기호 (예 :)와 표시해야 할 접두사 함수 (예 : &[+]을 &infix:<+>실행할 때 Perl 6에서 사용 하는 속기 및 동일한 함수 1 + 2)와 전역 대체 ( s:g[…] = …펄 5와 같은 )를 수행합니다. s/…/…/ge)는 기호 ( (\d+) $sym (\d+))로 구분 된 두 정수와 일치 하고 해당 정수 ( infix($0, $1))로 불리는 해당 infix 함수의 출력으로 대체합니다 .

마지막으로,이 평가 된 표현은에 들어가고 say [+] (1..$expression)».comb, xfix는 그의 솔루션에서 매우 잘 설명합니다 .

파티에 늦어서 미안해 ☺

편집 : 지수에 대한 지원이 제거되었습니다. 어쨌든 정확히 10 자였으며 올바르게 연관성을 나타내지 않았습니다.

매스 매 티카 30- (10 + 50) = -30

ybeltukov 덕분에 4 문자가 줄었습니다.

Range@n1에서 사이의 숫자를 반환합니다 n.

Integerdigits@n 각 숫자를 숫자로 나눕니다.

Total[n,2]숫자를 합산합니다. 2는 서로 다른 레벨, 즉 목록의 목록에 걸쳐 합산을 허용하는 것입니다.

IntegerDigits@Range@#~Total~2&

테스팅

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

51

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

27000001

표현

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

https://codegolf.stackexchange.com/a/11423/13877 식 평가를 수행하기 위해 @Fors의 답변을 여기에서 매우 부끄럽게 훔칩니다.

샘플 사용법 :

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

참고 : 식 구현은 연산자 우선 순위를 가정하지 않으며 값을받을 때 값을 소비합니다. 예, 1+2*3 = 9오히려 일반적인 것보다 7.

sed, 411 283-25 = 258

지금 당장 더 골프를 치고 싶지 않아요. :-) 원격으로 큰 정수로도 사용하지 않는 것이 좋지만 기술적 으로는 임의로 큰 정수를 처리 할 수 ​​있습니다. 단항).

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

샘플 사용

(읽기 쉽도록 입력 줄이 들여 쓰기되었습니다.)

  5
15
  12
51
  33
183

파이썬, 55- (50 + 25 + 10) = -30

비효율적이지만 더 짧고 식을 처리 할 수 ​​있습니다.

편집 : 트릭을 주셔서 감사합니다 Wolframh 와 legoStormtroopr : D

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

파이썬, 149- (25 + 50 + 10) = 64

내 첫 번째 버전

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

입력:

1234567891234567891234564789087414984894900000000

산출:

265889343871444899381999757086453238874482500000214

파이썬-108 문자-85 보너스, 23 스트로크, 매우 큰 입력 처리

이러한 솔루션의 대부분은 입력보다 적은 모든 정수를 루핑하고 모든 숫자 합계를 합산하는 것처럼 보입니다. 이것은 효과가 있지만 우아하지 않다고 생각하며 1234567891234567891234564789087414984894900000000평생 입력을 처리 할 수 ​​없다고 생각하기 때문에 25 포인트 보너스를받을 수 있는지 여부에 의문을 제기합니다 . 실제로 n숫자를 입력 할 O(10^n)때 이러한 솔루션은 시간 이 걸립니다. 대신이 문제에 수학을 던지기로했습니다.

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

모든 x자릿수 세트는 세트와 동형입니다 {0,1,2,3,4,5,6,7,8,9}^x. A는 고정을 위해 (n,sig)거기에 x다른 값 sig, 10^x-1요점 sig행 번째 인덱스 세트는 n모든 숫자의 합 0-9이 모두에 의해 처리된다 (45)이다 f.

g 우리 모두에게 친숙 할 것입니다

magic입력 번호의 모든 자릿수를 취하여 최소에서 최대로 반복합니다. 예제 입력으로이를 추적하는 것이 가장 쉽습니다 (예 :) 1,234,567.

범위를 처리하기 위해 1,234,567-1,234,560, 우리는 모든 숫자를 추가해야 1하는 7, 그리고에 추가 7시간보다 큰 모든 숫자를 다루는 다른 숫자의 합을, 1,234,560. 이제 나머지를 처리해야합니다.

범위를 처리하기 위해 ( )를 1,234,560-1,234,500더하고 상한을로 떨어 뜨립니다 . 드롭의 나머지 부분을 만들 때 모든 한 자리 숫자가 6 번 표시됩니다 ( ). 우리는 모든 숫자 를 정확히 각 시간 ( ) 까지 볼 수 있습니다 . 이 숫자의 다른 모든 숫자는 정확히 60 번 ( ) 표시됩니다. 우리는 이제보다 큰 모든 숫자를 다루었습니다 . 모든 의미에 동일한 논리가 귀납적으로 적용됩니다.6val1,234,559val*f(sig)0510(10**sig)*g(val-1)(val*10**sig)*sum(digits[sig+1:])1,234,500

WolframH 덕분에 이것을 골프화하면이 솔루션을

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

그리고 모든 정수의 자릿수 합계의 합 1234567891234567891234564789087414984894900000000은265889343871444927857379407666265810009829069029376

골프 버전에서 던질 수 있었던 가장 큰 숫자는 10 ^ 300입니다.이 시점에서 수레가 넘치기 시작하고 숫자 불안정으로 인해 문제가 발생하기 시작합니다. 빠른 제곱 및 곱셈 지수 함수를 사용하면이 문제가 사라집니다.

그리고 LaTeX 지원은 정말 유용 할 것입니다 ...

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

입력은 숫자를 처리 1E100하고 자동으로 평가합니다. 식을 처리 할 수 ​​있습니다.

그것은 엄청나게 큰 배열이지만 컴퓨터 리소스를 낭비하지 않습니다 (이것은 계산기 에서 실행 됩니다 ).

스칼라 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 = 99

다음은 기술적으로 "임의"양의 정수에 대해 25 보너스를 받을 수있는 대체 버전 이지만 알고리즘이 입력에서 선형 시간이므로 비현실적으로 느립니다. 어쨌든, 쓰는 것은 재미있었습니다. ASCII 문자로 읽은 숫자를 수동으로 뺍니다. 이 버전은 150 자입니다. (이제 끔찍하고 논쟁을 불러 일으키는 루프 코드로!)

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

씨, 229224- (50 + 100) = 74

표현 처리 변형. 일반적인 규칙에 따라 연산자 우선 순위를 구현합니다 / * - +. 97 개의 토큰 = 48 개의 용어로 제한됩니다.

#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

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

입력이 "12"라고 가정하십시오.

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

스택은 [0,1,2,3,...,12]입니다.

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

스택은 "01234...9101112"입니다.

' '* # join a space between all characters

스택은 "0 1 2 ... 1 0 1 1 1 2"입니다.

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

스택은 [0,1,2,...,9,1,0,1,1,1,2]입니다.

{+}* # fold addition across the new array

원하는대로 스택은 51입니다.

여기에 입력은 지수를 포함 할 수있는 유효한 GolfScript 표현식 일 수 있습니다. 예를 들면 다음과 같습니다.

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

이후 2(5 + 5) - 8 = 12. 나는 이것이 보너스를받을 자격이 있다고 생각하지만 아마도 GolfScript의 역 폴란드 표기법이 아닌 정상적인 형태 일 경우에만 예상되었을 것입니다.

루비, 37-50 = -13

하늘을 가로 질러 두 배의 평가! 다른 Ruby 솔루션과 마찬가지로 이론적으로는 임의로 많은 수의 작업을 수행 할 수 있어야하지만 실행 시간은 ... 심할 것입니다.

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

구버전 (49-50 점수)

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

10 개의 문자 보너스가 실제로는 지수에 대한 문자가 캐럿이어야한다고 가정하면, 내가 추가 할 수있는 가장 짧은 방법은 다음과 같습니다.

.gsub ?^,'**'

보너스보다 많은 캐릭터가 필요합니다.

Perl 6 (28-75 + 0 = -47 바이트)

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

모든 양수를 처리 할 수 ​​있습니다 (그러나 현재 Perl 6 구현은 느리지 만 Perl 6은 기본적으로 큰 정수를 지원하기 때문에 큰 숫자는 시간이 오래 걸립니다). 그것은 사용하는 eval간단한 계산기를 구현하기 위해, (쉰 개 문자 다섯 명 문자 처벌 가치가있다). 현재 구현이 느리기 때문에 속도가 느리지 만 이론적으로는 (Perl 6 구현이 개선 될 때) 충분히 빠릅니다. 또한, 놀랍게도, 나는 Mathematica와 함께 이겼습니다 (현재).

» 이 코드에서는 실제로 필요하지 않지만 성능상의 이유로 여기에 넣습니다 (그렇지 않으면 프로그램이 전체 문자열을 할당합니다. 여기에있는 이유는 Perl 6에 무한 문자열이 없지만 무한 목록이 있기 때문입니다.

어쨌든이 코드의 작동 방식을 물어볼 수 있습니다. 글쎄, 나는 그것을 부분적으로 전달할 것입니다.

• get.eval

  이것은 한 줄 ( get함수)을 얻고 그것을 평가합니다 ( eval방법).

• 1..get.eval

  그 후, Perl 6은 1평가 된 값 까지 범위 객체를 준비 합니다. 이것은 범위이므로 어떤 것도 할당되지 않습니다.

• ».comb

  .comb메소드는 문자열을 문자로 분할합니다 ( 인수와 함께 호출되지 않은 경우 ). 예를 'cat'.comb들어을 반환합니다 'c', 'a', 't'. »목록 요소를 매핑하므로 .comb목록 자체뿐만 아니라 모든 항목에서 실행됩니다 (예 : (4, 9)».sqrtgives 2, 3). Perl 6에는 무한리스트 (예 : Haskell 등)가 있기 때문에 필요 이상으로 할당되지 않습니다.

  »문자는 실제로 필요 .comb하지는 않지만 목록에서 직접 사용할 수 있지만 암시 적 문자열 강제가 필요합니다 (Perl 6에는 무한 문자열이 없으므로 메모리가 낭비됩니다). 예를 들어 1, 2, 3문자열로 변환 한 후 list는을 반환합니다 1 2 3. Perl 6의 경우 공백은 0을 의미하는 완벽하게 훌륭한 숫자이므로 이러한 변환에서도 코드가 작동합니다. 그러나 컴퓨팅 리소스를 남용 할 수 있습니다.

• [+]

  이것은 감소 연산자입니다. 기본적으로 사이 []에 연산자를 사용할 수 있습니다 (이 경우) +. 연산자를 감소 후의리스트 정도로 감소되고 [+] 1, 2, 3있다 1 + 2 + 3인 6. Perl 6은 숫자와 문자열에 별도의 연산자를 사용하므로 연결로 간주되지 않습니다.

• say

  마지막으로 say결과를 출력합니다. 결국, 당신은 최종 결과를보고 싶어합니까?

펄 31-보너스 없음

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

샘플 출력 :

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

펄 5 와 -p, 50-28 바이트 : -22

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

온라인으로 사용해보십시오!

J, 22

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

설명

평가는 오른쪽에서 왼쪽으로 진행됩니다.

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)

이를 실행하면 사용자에게 입력을 요청합니다.

이전 버전 (표현식을 처리 할 수 ​​없음) : 46 자 :

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

배치-(181-50)-131

약간의 재미.

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

좀 더 읽기 쉽게 만들겠습니다.

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

이전 방법은 파일에 쓰고 읽는 것과 반대로 for 루프를 사용하여 powershell 명령의 출력을 얻습니다.

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

입력을 변수로 설정하십시오 v.-를 사용 /a하여 산술 표현식을 승인하십시오.
불행하게도 확장 지연을 가능하게해야했습니다.
for 루프를 사용하여 1부터 입력 된 값까지 계산 v합니다.
9보다 큰 숫자를 처리하려면 powershell을 사용하여 문자열의 길이를 얻은 다음 다른 for 루프를 사용하여 해당 문자열을 분할하고 합 - s.
당신은 수 의 이름을 변경 powershell.exe하는 p.exeC에서 : \ WINDOWS \ SYSTEM32는 \의 WindowsPowerShell \ V1.0 \ 그럼 그냥 그것을 호출 p "&{'%%a'.length-1}9 바이트를 저장. 그러나 그것은 실제로 그 정신에 있지 않습니다.

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

점심을 먹으면서 두 번째를 떠났습니다.

속도가 느리기 때문에 이보다 너무 큰 숫자로는 실제로 테스트 할 수 없습니다 . 그러나 상당히 많은 수의 경우 작동합니다. 2147483647다음과 같은 오류가 발생하기 전에 가장 큰 수 (최대 32 비트 정수)입니다.

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

물론 이것은 도전에서 나를 실격시킵니다.

Dyalog APL , 9 – 160 * = -151

+/⍎¨∊⍕¨⍳⎕

온라인으로 사용해보십시오!

⎕ 평가를 받다
 예 : "7+5"제공12

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

⍕¨ 각 숫자를 문자열로 형식화
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ 입대하다
 "123456789101112"

⍎¨ 각 문자를 실행합니다 (한 자릿수 숫자 목록을 나타냅니다).
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ 합집합  51

* 득점

식을 입력으로 받아들이 기 때문에 -50 보너스. 표현식은 유효한 APL이어야하며 OP에 따라 허용됩니다. .

-10 보너스는 ^(* PLP에서) .

식 입력은 명시 적으로 사용하지 않고 eval(즉 ⍎, APL에서) 처리되므로 -100 보너스 .

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

예쁜

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

• 모든 양수를 처리 할 수 ​​있습니다
• +-/ * 연산으로 표현식을 처리 할 수 ​​있습니다
• ^ (전원) 연산자를 처리 할 수 ​​있습니다.
• eval 또는 이와 유사한 방식없이 표현식을 처리 할 수 ​​있습니다 ¹

expression의 결과가 정수가 아닌 경우 먼저 잘립니다. 표현식 결과가 음수이면 결과가 정의되지 않습니다.

다음과 같이 사용하십시오.

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

1 : Bash에서 Python을 호출하는 것을 제외하고는 그렇지 않다고 생각합니다. 실제로 있다고 생각되면 조정 점수는 -7입니다.

자바, 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);
    }
}

식을 처리합니다. 원하는 표현을 목표로 지정하십시오. 길이가 길어질 때까지 처리합니다. 모든 공백을 한 줄로 정리하고 인쇄 할 명령문을 정리하지 않으면 254 자로 계산됩니다 (긴 단어 기반 Java 프로그래밍을 고려할 때).

추신 : 이것은 논리뿐만 아니라 완전한 프로그램입니다. 논리뿐만 아니라 프로그램에 주어진 단어 수.

자바 (JDK8), 272

내 첫 도전은, 제안은 환영합니다 =)

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

들여 쓰기 :

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은이 도전보다 몇 개월 어려서 녹색 확인 표시를받을 수 없습니다. 또한, 이것은 처음부터 Perl을 꺾지 않습니다. ;) 나는 접근법을 아주 좋아했기 때문에 어쨌든 게시하고 싶었다.

l~),s:~:+

여기에서 테스트하십시오.

아이디어는 0에서 N 사이의 범위를 작성하는 것입니다.이 범위는 문자열로 변환되어 정수를 연속적으로 연결합니다. N = 12 인 경우

"0123456789101112"

그런 다음 각 문자는 :~(정수 배열을 포함하여) 정수로 변환 된 다음으로 요약됩니다 :+. CJam은 임의로 큰 정수를 처리 할 수 ​​있습니다.

파이썬 3 +의 애 스터 ,1017 1007 바이트-(25 + 50 + 100) = 점수 : 842 834

제거 ts하고 변경 하여 10 바이트 절약p

편집 : 엄청나게 긴 정수를 테스트 할 수 없습니다 (1234567891234567891234564789087414984894900000000) [내 컴퓨터가 멈춤] 그러나 내 지식으로는 Python 3은 임의로 긴 정수를 지원합니다.

이 구현 사용AST를 남용합니다. 나는 AST를 "평가 또는 유사한"학대하는 것을 고려하지 않을 것입니다.

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

ungolfed를 쓰기에는 너무 게 으르므로 클래스에 대한 설명을 드리겠습니다.

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.

마지막 행은 입력에서 적절한 순서로 이러한 클래스를 실행하여 작업 순서를 유지하고 원치 않는 동작을 방지합니다.

사용법 예 ($ 또는>는 사용자 입력을 의미) 및 실제 프로그램은 한 번만 입력을받습니다.

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

예쁜

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

루비-> 83-50 = 33

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

"테스트"버전 :

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 

테스트 결과

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

그것은 또 다른 시도입니다.

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

예쁜

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

루비 69-50 = 19 (또는 -4)

이것은 확실히 함께 골프를 칠 수 있지만 여기에 첫 번째 다섯 번째 시도입니다

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

또한 모든 숫자에서 작동하지만 O (n)보다 느리게 실행되므로 매우 느리므로 -25를 추가하지 않습니다. 속도 저하가 양호하면 -4가됩니다 .

루비 133-50-25 = 58

이것은 O (n)보다 적은 시간에 실행되고 실제 수학을 사용하는 더 빠른 버전이므로 큰 정수에 대한 결과를 빠르게 제공 할 수 있으므로 -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]

하스켈, 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 점)

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

산출:

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