integer가 주어지면 해당 정수의 n > 9숫자 사이에 가능한 각 삽입에 대해 더하기를 삽입 +하고 평가하십시오. 그런 다음 결과를 원래 숫자로 모듈로 가져갑니다. 이러한 작업의 합계를 출력하십시오.

예를 들면 다음과 n = 47852같습니다.

47852 % (4785+2) = 4769
47852 % (478+52) =  152
47852 % (47+852) =  205
47852 % (4+7852) =  716
                  -----
                   5842

입력

하나의 양의 정수 편리한 형식으로 , n > 9.

산출

위의 구성 기술에 따른 단일 정수 출력.

규칙

• 언어의 기본 유형보다 큰 입력에 대해 걱정할 필요가 없습니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

예

47852 -> 5842
13 -> 1
111 -> 6
12345 -> 2097
54321 -> 8331
3729105472 -> 505598476

05AB1E , 12 10 바이트

v¹¹N¹‚£O%O

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

자바 스크립트, 43 47 바이트

f=
n=>eval(n.replace(/./g,'+'+n+"%($`+ +'$&$'')"))

I.oninput=_=>O.value=f(I.value)

<input id=I>
<input id=O disabled>

입력을 문자열로받습니다.

편집하다:

+4 바이트 : JavaScript에서 선행 0은 숫자를 8 진수로 변환합니다.

Brachylog , 20 바이트

:{$@~c#C:@$a+:?r%}f+

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

설명

이것은 주어진 공식을 구현합니다. A는 때 우리가 조심해야 할 유일한 것은은 0입력의 중간에 : 그것이로 시작하는 정수의 목록이 것을 허용하지 않습니다 예를 들어 Brachylog는 꽤 황당 얻을 경우에 0(정수로 연결될 수있다 선행을 무시해야합니다 0. 무한 루프를 피하기 위해 주로 프로그래밍됩니다). 따라서이 문제를 피하기 위해 입력을 문자열로 변환 한 다음 분할 된 모든 입력을 정수로 다시 변환합니다.

                       Example Input: 47852

:{               }f    Find all outputs of that predicate: [716,205,152,4769]
  $@                     Integer to String: "47852"
    ~c#C                 #C is a list of two strings which when concatenated yield the Input
                           e.g. ["47","852"]. Leave choice points for all possibilities.
        :@$a             Apply String to integer: [47,852]
            +            Sum: 899
             :?r%        Input modulo that result: 205
                   +   Sum all elements of that list               

ES6 (자바 스크립트) 4240 바이트

EDITS :

• 당함 제거 의 , -2 바이트

골프

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10)

테스트

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10);

[47852,13,111,12345,54321,3729105472].map(x=>console.log(M(x)));

파이썬 2, 45 바이트

f=lambda n,c=10:n/c and n%(n/c+n%c)+f(n,c*10)

용도는 문자열을 입력하기보다는 분할 산술 n부분으로 n/c하고 n%c, c(10)의 힘으로 재귀한다.

젤리 , 12 바이트

ŒṖṖLÐṂḌS€⁸%S

TryItOnline!

어떻게?

ŒṖṖLÐṂḌS€⁸%S - Main link: n
ŒṖ           - partitions (implicitly treats the integer n as a list of digits)
  Ṗ          - pop - remove the last partition (the one with length one)
    ÐṂ       - keep those with minimal...
   L         - length (now we have all partitions of length 2)
      Ḍ      - undecimal (convert each entry back to an integer)
       S€    - sum each (add the pairs up)
         ⁸   - left argument, n
          %  - mod (vectorises)
           S - sum

펄 35 32 27 바이트

에 +3 포함 -p

Dada 덕분에 8 바이트 절약

$\+=$_%($`+$')while//g}{

C 77 + 4 = 81 바이트

골프

i,N,t,r,m;f(n){for(r=0,m=n;n;t=n%10,n/=10,N+=t*pow(10,i++),r+=m%(n+N));return r;}  

언 골프

#include<stdio.h>
#include<math.h>

i,N,t,r,m;

f(n)
{
    m=n;
    r=0;
    while(n)
    {
        t=n%10;
        n/=10;
        N+=t*pow(10,i++);
        r+=m%(n+N);
    }
    return r;
}

main()
{
    printf("%d",f(47852));
}

파이썬 2, 68 64 68 바이트

^{Atlasologist 덕분에 -4 바이트}

lambda x:sum(int(x)%(int(x[:i])+int(x[i:]))for i in range(1,len(x)))

^{* 입력은 문자열입니다}

C, 59 바이트

t,s;f(n){s=0;t=10;while(t<n)s+=n%(n/t+n%t),t*=10;return s;}

t이다 10,100,1000,...와 큰 수의 컷을 나타냅니다. n/t오른쪽 부분과 n%t왼쪽 부분입니다. 경우 t수보다 더 큰, 그것은 완료됩니다.

언 골프 및 사용법 :

t,s;
f(n){
 s=0;
 t=10;
 while(t<n)
  s += n % (n/t + n%t),
  t *= 10;
 return s;
}

main(){
 printf("%d\n",f(47852));
}

레티 나 , 38 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

\B
,$';$_¶$`
G-2`
\d+|,
$*
(1+);\1*

1

정확히 효율적이지 않습니다 ...

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

설명

\B
,$';$_¶$`

모든 문자 쌍 사이에 쉼표, 일치하는 항목 앞에있는 모든 항목, 세미콜론, 전체 입력, 줄 바꿈 및 일치하는 항목 뒤에있는 모든 항목을 삽입합니다. 입력을 위해 12345다음을 제공합니다.

1,2345;12345
12,345;12345
123,45;12345
1234,5;12345
12345

즉, 입력 쌍과 함께 가능한 모든 입력 분할. 그러나 마지막 줄은 필요하지 않습니다.

G-2`

우리는 버립니다.

\d+|,
$*

이렇게하면 각 숫자와 쉼표가 단항으로 바뀝니다. 쉼표는 숫자가 아니기 때문에 0으로 취급되며 간단히 제거됩니다. 각 분할에 두 부분이 추가됩니다.

(1+);\1*

이것은 두 번째 숫자에서 첫 번째 숫자의 모든 사본을 제거하여 모듈로를 계산합니다.

1

그것은 1문자열에 남은 수를 세고 그 결과로 인쇄합니다.

Pyth, 14 바이트

s.e%QssMc`Q]k`

정수를 입력 받아 결과를 출력하는 프로그램입니다.

테스트 스위트

작동 원리

s.e%QssMc`Q]k`   Program. Input: Q
s.e%QssMc`Q]k`Q  Implicit input fill
 .e          `Q  Map over str(Q) with k as 0-indexed index:
        c`Q]k     Split str(Q) into two parts at index k
      sM          Convert both elements to integers
     s            Sum
   %Q             Q % that
s                Sum
                 Implicitly print

하스켈, 62 바이트

f x|m<-mod x=sum[m$div x(10^k)+m(10^k)|(k,_)<-zip[0..]$show x]

함수를 정의합니다 f. 모든 테스트 사례를 통과했는지 확인하십시오.

펄 6 , 33 바이트

{sum $_ X%m:ex/^(.+)(.+)$/».sum}

넓히는:

{                  # bare block lambda with implicit parameter ｢$_｣

  sum

    $_             # the input

    X%             # cross modulus

    m :exhaustive /  # all possible ways to segment the input
      ^
      (.+)
      (.+)
      $
    /».sum         # sum the pairs
}

Mathematica, 75 바이트

Tr@ReplaceList[IntegerDigits@#,{a__,b__}:>Mod[#,FromDigits/@({a}+{b}+{})]]&

자릿수 목록에서 패턴 일치를 사용하여 모든 파티션을 두 부분으로 추출합니다. 에 이러한 각각의 파티션 a과는 b다음으로 대체됩니다

Mod[#,FromDigits/@({a}+{b}+{})]

여기서 주목할만한 점은 경우 예를 들어, 그래서 길이가 같지 않은리스트의 합이, 평가되지 않은 남아 있다는 것입니다 a이다 1,2하고 b있다 3,4,5우리가 처음으로이 교체 {1,2} + {3,4,5} + {}. 마지막 용어는 짝수의 숫자를 균등하게 나눌 때 여전히 평가되지 않은 상태로 유지되도록하기위한 것입니다. 이제 MapMathematica 의 작업은 목록뿐만 아니라 모든 종류의 표현으로 작동하도록 충분히 일반화되었습니다. 따라서이 FromDigits합계를 매핑 하면 각 목록이 다시 숫자로 바뀝니다. 이 시점에서 표현식은 정수의 합계이며 이제 평가됩니다. 이렇게하면 Tr[FromDigits/@{{a},{b}}]두 목록을 먼저 변환 한 다음 결과를 요약 하는보다 일반적인 솔루션보다 바이트가 절약 됩니다.

실제로 는 16 15 바이트

골프 제안을 환영합니다! 온라인으로 사용해보십시오!

편집 : 청록 펠리칸 덕분에 -1 바이트.

;╗$lr`╤╜d+╜%`MΣ

언 골핑

         Implicit input n.
;╗       Save a copy of n to register 0.
$l       Yield the number of digits the number has, len_digits.
r        Yield the range from 0 to len_digits - 1, inclusive.
`...`M   Map the following function over that range, with variable x.
  ╤        Yield 10**x.
  ╜        Push a copy of n from register 0.
  d        Push divmod(n, 10**x).
  +        Add the div to the mod.
  ╜        Push a copy of n from register 0.
  %        Vectorized modulo n % x, where x is a member of parition_sums.
         This function will yield a list of modulos.
Σ        Sum the results together.
         Implicit return.

루비, 64 바이트

->s{s.size.times.reduce{|a,i|a+s.to_i%eval(s[0,i]+?++s[i..-1])}}

입력을 문자열로받습니다.

Befunge, 101 96 바이트

&10v
`#v_00p:::v>+%\00g1+:9
*v$v+55g00</|_\55+
\<$>>\1-:v ^<^!:-1 
+^+^*+55\_$%\00g55
.@>+++++++

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

설명

&              Read n from stdin.
100p           Initialise the current digit number to 1.

               -- The main loop starts here --

:::            Make several duplicates of n for later manipulation.

v+55g00<       Starting top right, and ending bottom right, this
>>\1-:v          routine calculates 10 to the power of the
^*+55\_$         current digit number.

%              The modulo of this number gives us the initial digits.
\              Swap another copy of n to the top of the stack.

_\55+*v        Starting bottom left and ending top left, this
^!:-1\<          is another calculation of 10 to the power of
00g55+^          the current digit number.

/              Dividing by this number gives us the remaining digits.
+              Add the two sets of digits together.
%              Calculate n modulo this sum.
\              Swap the result down the stack bringing n back to the top.

00g1+          Add 1 to the current digit number.
:9`#v_         Test if that is greater than 9.
00p            If not, save it and repeat the main loop.

               -- The main loop ends here --

$$             Clear the digit number and N from the stack.
++++++++       Sum all the values that were calculated.
.@             Output the result and exit.

APL, 29 바이트

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}

⎕IO이어야합니다 1. 설명 (나는 설명이 좋지 않습니다. 이것에 대한 모든 개선은 매우 환영합니다) :

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}
{                           } - Function (Monadic - 1 argument)
                           ⍵  - The argument to the function
                          ⍕   - As a string
                        R←    - Stored in R
                      1↓      - All except the first element
                    ⍳⍴        - 1 to the length
      {           }           - Another function
               ⍵↓R            - R without ⍵ (argument of inner function) leading digits
              ⍎               - As a number
             +                - Plus
       (    )                 - Grouping
         ⍵↑R                  - The first ⍵ digits of R
        ⍎                     - As a number
                   ¨          - Applied to each argument
   ⍵|⍨                        - That modulo ⍵ (outer function argument)
 +/                           - Sum

C #, 67 바이트

n=>{long d=n,s=0,p=1;while(d>9)s+=n%((d/=10)+n%(p*=10));return s;};

ungolfed, 설명 된 방법 및 테스트 사례가 포함 된 전체 프로그램 :

using System;

public class Program
{
    public static void Main()
    {
        Func<long,long> f=
        n=>
        {
            long d = n, // stores the initial number
                 r,         // remainder, stores the last digits
                 s = 0, // the sum which will be returned
                 p = 1; // used to extract the last digit(s) of the number through a modulo operation
            while ( d > 9 ) // while the number has more than 1 digit
            {
                d /= 10;    // divides the current number by 10 to remove its last digit
                p *= 10;    // multiplies this value by 10
                r = n % p;  // calculates the remainder, thus including the just removed digit
                s += n % (d + r);   // adds the curent modulo to the sum
            }
            return s;   // we return the sum
        };

        // test cases:
        Console.WriteLine(f(47852)); //5842
        Console.WriteLine(f(13));   // 1
        Console.WriteLine(f(111));  // 6
        Console.WriteLine(f(12345));    // 2097
        Console.WriteLine(f(54321));    // 8331
        Console.WriteLine(f(3729105472));   // 505598476
    }
}

첨부 , 48 바이트

Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits

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

설명

Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits
                                          Digits    convert input to digits
    {                                   }@          call lambda with digits as argument
                      SplitAt[_,1..#_-1]            split digits at each partition
              Map[N]=>                              Map N to two-deep elements
          Sum@                                      Takes the sum of each sub array
     N[_]%                                          convert digits to int and vector mod
Sum@                                                sum the resultant array

클로저, 91 81 바이트

편집 : 익명 함수를 선언하고 매크로를 (fn[v](->> ...))사용하지 않기 때문에 더 짧 ->>습니다. 매우 쉽게 읽을 수는 있지만 호출합니다.

(fn[v](apply +(map #(mod v(+(quot v %)(mod v %)))(take 10(iterate #(* 10 %)1)))))

기발한:

(defn s[v](->> 1(iterate #(* 10 %))(take 10)(map #(mod v(+(quot v %)(mod v %))))(apply +)))

1, 10, 100, ...의 시퀀스를 생성하고 처음 10 개 항목을 가져오고 (입력 값이 10 ^ 11보다 작다고 가정) 사양에 지정된대로 모듈로에 매핑하고 합계를 계산합니다. 함수 이름이 길면이 솔루션은 상당히 길어 지지만 적어도 골프 버전조차도 따라 가기가 쉬워야합니다.

먼저 끈을 저글링하려고 시도했지만 많은 수의 상용구가 필요했습니다.

라켓 134 바이트

(let((s(number->string n))(h string->number)(g substring))(for/sum((i(range 1(string-length s))))(modulo n(+(h(g s 0 i))(h(g s i))))))

언 골프 드 :

(define (f n)
  (let ((s (number->string n))
        (h string->number)
        (g substring))
    (for/sum ((i (range 1 (string-length s))))
      (modulo n (+ (h (g s 0 i)) (h (g s i)))))))

테스트 :

(f 47852)
(f 13)
(f 111)
(f 12345)
(f 54321)
(f 3729105472)

산출:

5842
1
6
2097
8331
505598476

R , 50 바이트

function(n)sum(n%%(n%%10^(x=1:nchar(n))+n%/%10^x))

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

SNOBOL4 (CSNOBOL4) , 92 바이트

	N =INPUT
S	N LEN(X) . L REM . R	:F(O)
	S =S + REMDR(N,L + R)
	X =X + 1	:(S)
O	OUTPUT =S
END

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

루비 45 바이트

->q{t=0;q.times{|x|p=10**x;t+=q%(q/p+q%p)};t}

이것은 정말 깔끔한 솔루션입니다. 기술적으로는 정확하지만 매우 비효율적입니다. q.to_s.size.times {...}를 작성하는 것이 훨씬 더 효율적입니다. 우리는 문자를 저장하기 때문에 q.times를 사용하고, proc을 거치는 여분의 횟수는식이 단지 0으로 평가됩니다.

PHP , 60 바이트

for($n=1;($n*=10)<$a=$argn;)$r+=$a%(($a/$n^0)+$a%$n);echo$r;

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

자바 8, 127 66 바이트

n->{long m=n,r=0,p=1;for(;m>9;r+=n%((m/=10)+n%(p*=10)));return r;}

@adrianmp 의 C # 응답 포트를 생성하여 -61 바이트 .

여기에서 시도하십시오.

Pari / GP , 42 바이트

n->sum(i=1,logint(n,10),n%(n\10^i+n%10^i))

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

Japt , 11 10 바이트

¬x@%OvUi+Y

시도 해봐

설명

               :Implicit input of string U
¬              :Split to an array of characters
  @            :Pass each character at index Y through a function
      Ui+Y     :  Insert a + in U at index Y
    Ov         :  Evaluate as Japt
   %           :  Modulo U by the above
 x             :Reduce by addition