Cho một số nguyên n > 9, cho mỗi lần chèn có thể giữa các chữ số trong số nguyên đó, chèn một phép cộng +và đánh giá. Sau đó, lấy số gốc modulo những kết quả đó. Xuất tổng cộng của các hoạt động này.

Một ví dụ với n = 47852:

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

Đầu vào

Một số nguyên dương duy nhất trong bất kỳ định dạng thuận tiện , n > 9.

Đầu ra

Đầu ra số nguyên duy nhất theo kỹ thuật xây dựng ở trên.

Quy tắc

• Bạn không cần phải lo lắng về đầu vào lớn hơn loại mặc định của ngôn ngữ của bạn.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

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

05AB1E , 12 10 byte

v¹¹N¹‚£O%O

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

JavaScript, 43 47 byte

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

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

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

Lấy đầu vào dưới dạng chuỗi.

Chỉnh sửa:

+4 byte : Các số 0 đứng đầu trong JavaScript chuyển đổi số thành số bát phân):

Brachylog , 20 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này thực hiện các công thức được đưa ra. Điều duy nhất chúng ta phải cẩn thận là khi a 0ở giữa đầu vào: trong trường hợp đó Brachylog trở nên khá kỳ quặc, ví dụ, nó sẽ không chấp nhận rằng một danh sách các số nguyên bắt đầu bằng một số nguyên 0có thể được ghép thành một số nguyên ( mà sẽ yêu cầu bỏ qua hàng đầu 0- điều này chủ yếu được lập trình theo cách đó để tránh các vòng lặp vô hạn). Do đó, để khắc phục vấn đề đó, chúng tôi chuyển đổi đầu vào thành một chuỗi và sau đó chuyển đổi lại tất cả các đầu vào được tách thành số nguyên.

                       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 (Javascript), 42, 40 byte

CHỈNH SỬA:

• Loại bỏ s , -2 byte

Chơi gôn

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

Kiểm tra

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

Python 2, 45 byte

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

Sử dụng số học thay vì chuỗi để phân chia đầu nvào thành các phần n/cvà n%c, cđệ quy thông qua quyền hạn 10.

Thạch , 12 byte

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

Dùng thử trực tuyến!

Làm sao?

ŒṖṖ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

Perl 35 32 27 byte

Bao gồm +3 cho -p

Đã lưu 8 byte nhờ Dada

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

C 77 + 4 = 81 byte

chơi gôn

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

Bị đánh cắp

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

Python 2, 68 64 68 byte

^{-4 byte nhờ nhà nghiên cứu bản đồ}

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

^{* Đầu vào là một chuỗi}

C, 59 byte

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

tlà 10,100,1000,...và đại diện cho sự cắt giảm trong số lượng lớn. n/tlà phần bên phải và n%tphần bên trái. Nếu tlớn hơn số, nó đã hoàn thành.

Ungolfed và cách sử dụng:

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

Võng mạc , 38 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

1

Không chính xác hiệu quả ...

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

\B
,$';$_¶$`

Giữa mỗi cặp ký tự, chúng tôi chèn một dấu phẩy, mọi thứ ở phía trước của trận đấu, dấu chấm phẩy, toàn bộ đầu vào, một nguồn cấp dữ liệu và mọi thứ sau trận đấu. Đối với đầu vào 12345này cung cấp cho chúng tôi:

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

Tức là mọi sự phân tách có thể có của đầu vào cùng với một cặp đầu vào. Chúng tôi không cần dòng cuối cùng mặc dù vậy:

G-2`

Chúng tôi loại bỏ nó.

\d+|,
$*

Điều này thay thế mỗi số cũng như dấu phẩy bằng đại diện đơn nguyên của nó. Vì dấu phẩy không phải là số, nên nó được coi là số không và chỉ cần xóa. Điều này thêm hai phần trong mỗi phần tách.

(1+);\1*

Điều này sẽ tính toán modulo bằng cách loại bỏ tất cả các bản sao của số thứ nhất khỏi số thứ hai.

1

Đó là nó, chúng tôi chỉ đơn giản là đếm số lượng 1còn lại trong chuỗi và in kết quả.

Bình thường, 14 byte

s.e%QssMc`Q]k`

Một chương trình lấy đầu vào của một số nguyên và in kết quả.

Bộ kiểm tra

Làm thế nào nó hoạt động

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

Haskell, 62 byte

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

Xác định một hàm f. Xem nó vượt qua tất cả các trường hợp thử nghiệm.

Perl 6 , 33 byte

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

Mở rộng:

{                  # 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
}

Toán học, 75 byte

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

Điều này sử dụng khớp mẫu trên danh sách các chữ số để trích xuất tất cả các phân vùng của chúng thành hai phần. Mỗi phân vùng như vậy vào avà bsau đó được thay thế bằng

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

Điều đáng chú ý ở đây là khoản tiền của danh sách có độ dài bất bình đẳng vẫn unevaluated, vì vậy ví dụ nếu alà 1,2và blà 3,4,5sau đó chúng tôi đầu tiên thay thế này với {1,2} + {3,4,5} + {}. Thuật ngữ cuối cùng là để đảm bảo rằng nó vẫn chưa được đánh giá khi chúng ta chia đều một số chữ số chẵn. Bây giờ, Maphoạt động trong Mathicala đã được khái quát hóa đầy đủ rằng nó hoạt động với bất kỳ loại biểu thức nào, không chỉ các danh sách. Vì vậy, nếu chúng tôi ánh xạ FromDigitstổng này, nó sẽ biến mỗi danh sách đó trở lại thành một số. Tại thời điểm đó, biểu thức là tổng của các số nguyên, hiện được đánh giá. Điều này tiết kiệm một byte qua giải pháp thông thường hơn Tr[FromDigits/@{{a},{b}}], chuyển đổi hai danh sách trước và sau đó tổng hợp kết quả.

Thật ra , 16 15 byte

Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

Chỉnh sửa: -1 byte nhờ vào Teal pelican.

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

Ungolfing

         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.

Ruby, 64 byte

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

Lấy đầu vào là một chuỗi

Befunge, 101 96 byte

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

Hãy thử trực tuyến!

Giải trình

&              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 byte

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

⎕IOphải 1. Giải thích (Tôi không giỏi giải thích, bất kỳ ý nghĩa nào cho việc này đều rất đáng hoan nghênh):

{+/⍵|⍨{(⍎⍵↑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 byte

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

Chương trình đầy đủ với các trường hợp không được giải thích, giải thích và các trường hợp thử nghiệm:

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

Tùy viên , 48 byte

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

Hãy thử trực tuyến!

Giải trình

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

Clojure, 91 81 byte

Chỉnh sửa: cái này ngắn hơn vì nó khai báo một hàm ẩn danh (fn[v](->> ...))và không sử dụng ->>macro mặc dù nó dễ đọc và gọi theo cách đó hơn.

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

Nguyên:

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

Tạo một chuỗi 1, 10, 100, ... và lấy 10 mục đầu tiên (giả sử các giá trị đầu vào nhỏ hơn 10 ^ 11), ánh xạ tới modul như được chỉ định trong thông số kỹ thuật và tính tổng. Tên hàm dài làm cho giải pháp này khá dài nhưng ít nhất là ngay cả phiên bản chơi gôn cũng khá dễ theo dõi.

Đầu tiên tôi đã thử tung hứng các chuỗi xung quanh nhưng nó đòi hỏi hàng tấn nồi hơi.

Vợt 134 byte

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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

5842
1
6
2097
8331
505598476

R , 50 byte

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

Hãy thử trực tuyến!

SNOBOL4 (CSNOBOL4) , 92 byte

	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

Hãy thử trực tuyến!

Ruby 45 byte

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

Đây là một giải pháp thực sự gọn gàng. Đó là kỹ thuật chính xác, nhưng nó là siêu không hiệu quả. Sẽ hiệu quả hơn nhiều khi viết q.to_s.size.times {...}. Chúng tôi sử dụng q.times vì ​​nó lưu các ký tự và số lần thêm vào thông qua biểu thức chỉ ước tính bằng không.

PHP , 60 byte

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

Hãy thử trực tuyến!

Java 8, 127 66 byte

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

-61 byte bằng cách tạo một cổng của câu trả lời C # @adrianmp .

Hãy thử nó ở đây.

Pari / GP , 42 byte

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

Hãy thử trực tuyến!

Japt , 11 10 byte

¬x@%OvUi+Y

Thử nó

Giải trình

               :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