Учитывая целое число 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 . Попробуйте онлайн!

JavaScript, 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 преобразуют число в восьмеричное):

Брахилог , 20 байт

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

Попробуйте онлайн!

объяснение

Это реализует приведенную формулу. Единственное, с чем нам следует быть осторожным, это когда a 0находится в середине ввода: в этом случае Brachylog становится довольно странным, например, он не примет, что список целых чисел, начинающихся с a, 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 (Javascript), 4240 байт

правок:

• Избавился от s , -2 байта

Golfed

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

Python 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

Perl 35 32 27 байт

Включает +3 для -p

Сохранено 8 байт благодаря Dada

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

C 77 + 4 = 81 байт

golfed

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

Ungolfed

#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 байт

^{-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больше, чем число, оно закончено.

Ungolfed и использование:

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+|,
$*

Это заменяет каждое число, а также запятую своим унарным представлением. Поскольку запятая не является числом, она рассматривается как ноль и просто удаляется. Это добавляет две части в каждом разделении.

(1+);\1*

Это вычисляет модуль, удаляя все копии первого числа от второго числа.

1

Вот и все, мы просто считаем, сколько 1s осталось в строке, и выводим это как результат.

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

Haskell, 62 байта

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

Определяет функцию f. Посмотрите, как пройти все тестовые случаи.

Perl 6 , 33 байта

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

Expanded:

{                  # 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} + {}. Последний член предназначен для того, чтобы гарантировать, что он все еще остается неоцененным, когда мы равномерно разделяем четное число цифр. Теперь Mapоперация в Mathematica достаточно обобщена, чтобы работать с любыми выражениями, а не только со списками. Поэтому, если мы сопоставим FromDigitsэту сумму, она превратит каждый из этих списков обратно в число. В этот момент выражение представляет собой сумму целых чисел, которая теперь оценивается. Это сохраняет байт по сравнению с более традиционным решением, Tr[FromDigits/@{{a},{b}}]которое сначала преобразует два списка, а затем суммирует результат.

На самом деле , 16 15 байт

Предложения по игре в гольф приветствуются! Попробуйте онлайн!

Изменить: -1 байт благодаря Тил Пеликан.

;╗$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.

Рубин, 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. Объяснение (я не очень хорошо объяснить, какие imporvements к этому будут очень приветствуется):

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

Clojure, 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))))))

Ungolfed:

(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, выражение просто обнуляется.

PHP , 60 байт

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

Попробуйте онлайн!

Java 8, 127 66 байт

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

-61 байт пути создания порта @adrianmp «s C # ответа .

Попробуй это здесь.

Пари / ГП , 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