Biorąc pod uwagę liczbę całkowitą n > 9, dla każdego możliwego wstawienia między cyframi w tej liczbie całkowitej wstaw wstawkę +i oceń. Następnie weź oryginalny numer modulo te wyniki. Podaj sumę tych operacji.

Przykład z n = 47852:

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

Wkład

Pojedyncza dodatnia w dowolnym, wygodnym formacie , n > 9.

Wydajność

Wyjście pojedynczej liczby całkowitej zgodnie z powyższą techniką konstrukcyjną.

Zasady

• Nie musisz się martwić, że dane wejściowe są większe niż domyślny typ Twojego języka.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Przykłady

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

05AB1E , 12 10 bajtów

v¹¹N¹‚£O%O

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

JavaScript, 43 47 bajtów

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

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

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

Pobiera dane wejściowe jako ciąg.

Edytować:

+4 bajty : wiodące zera w JavaScript konwertują liczbę na ósemkową):

Brachylog , 20 bajtów

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

Wypróbuj online!

Wyjaśnienie

To implementuje podaną formułę. Jedyną rzeczą, na którą musimy uważać, jest to, gdy a 0znajduje się w środku danych wejściowych: w tym przypadku Brachylog robi się dość dziwaczny, na przykład nie akceptuje, że lista liczb całkowitych rozpoczynających się od a 0może być konkatenowana w liczbę całkowitą ( co wymagałoby zignorowania wiodącego 0- jest to głównie zaprogramowane w ten sposób, aby uniknąć nieskończonych pętli). Dlatego w celu obejścia tego problemu przekształcamy dane wejściowe na ciąg znaków, a następnie przekształcamy z powrotem wszystkie podzielone dane wejściowe na liczby całkowite.

                       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 bajtów

EDYCJE:

• Pozbyłem się s , -2 bajtów

Grał w golfa

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

Test

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 bajtów

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

Wykorzystuje arytmetykę zamiast ciągów do dzielenia danych wejściowych nna części n/ci n%c, która cpowraca przez potęgi 10.

Galaretka , 12 bajtów

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

TryItOnline!

W jaki sposób?

ŒṖṖ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 bajtów

Obejmuje +3 za -p

Zaoszczędzono 8 bajtów dzięki Dadzie

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

C 77 + 4 = 81 bajtów

grał w golfa

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

Bez golfa

#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 bajtów

^{-4 bajty dzięki atlasologowi}

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

^{* Dane wejściowe to ciąg znaków}

C, 59 bajtów

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

tjest 10,100,1000,...i reprezentuje cięcie dużej liczby. n/tjest prawą częścią i n%tlewą częścią. Jeśli tjest większy niż liczba, jest zakończony.

Niegolfowane i użytkowanie:

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

Siatkówka , 38 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

1

Niezupełnie wydajny ...

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

\B
,$';$_¶$`

Pomiędzy każdą parą znaków wstawiamy przecinek, wszystko przed dopasowaniem, średnik, całe wejście, wysuw linii i wszystko po meczu. W przypadku danych wejściowych 12345daje to nam:

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

Tj. Każdy możliwy podział wejścia wraz z parą wejścia. Nie potrzebujemy tej ostatniej linii, więc:

G-2`

Odrzucamy to.

\d+|,
$*

Zastępuje to każdą liczbę, a także przecinek, jego jednoznaczną reprezentacją. Ponieważ przecinek nie jest liczbą, jest traktowany jako zero i po prostu usuwany. Dodaje to dwie części w każdym podziale.

(1+);\1*

To oblicza moduł, usuwając wszystkie kopie pierwszego numeru z drugiego numeru.

1

To wszystko, po prostu liczymy, ile 1s pozostało w ciągu i wypisujemy to jako wynik.

Pyth, 14 bajtów

s.e%QssMc`Q]k`

Program, który pobiera liczbę całkowitą i wypisuje wynik.

Zestaw testowy

Jak to działa

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 bajty

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

Definiuje funkcję f. Zobacz, jak przejdzie wszystkie testy.

Perl 6 , 33 bajtów

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

Rozszerzony:

{                  # 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 bajtów

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

Używa dopasowania wzorca na liście cyfr, aby wyodrębnić wszystkie ich partycje na dwie części. Każda taka partycja na ai bjest następnie zastępowana przez

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

Godne uwagi jest tutaj to, że sumy list o nierównej długości pozostają nieocenione, więc np. Jeśli ajest 1,2i bjest, 3,4,5to najpierw zastępujemy to {1,2} + {3,4,5} + {}. Ostatni termin ma na celu zapewnienie, że nadal będzie nieoceniony, gdy równomiernie podzielimy parzystą liczbę cyfr. Teraz Mapdziałanie w Mathematica jest wystarczająco uogólnione, że działa z każdym rodzajem wyrażenia, nie tylko listami. Więc jeśli odwzorujemy FromDigitstę sumę, zamieni każdą z tych list z powrotem w liczbę. W tym momencie wyrażenie jest sumą liczb całkowitych, które teraz są oceniane. Oszczędza to bajt w stosunku do bardziej konwencjonalnego rozwiązania, Tr[FromDigits/@{{a},{b}}]które najpierw przekształca dwie listy, a następnie podsumowuje wynik.

Faktycznie , 16 15 bajtów

Zapraszamy do gry w golfa! Wypróbuj online!

Edycja: -1 bajt dzięki pelikanowi Teal.

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

Rubinowy, 64 bajty

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

Pobiera dane wejściowe jako ciąg

Befunge, 101 96 bajtów

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

Wypróbuj online!

Wyjaśnienie

&              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 bajtów

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

⎕IOmusi być 1. Wyjaśnienie (nie jestem dobry w wyjaśnianiu, wszelkie ulepszenia tego są bardzo mile widziane):

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

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

Pełny program z nieoznakowanymi, objaśnionymi metodami i przypadkami testowymi:

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

Attache , 48 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

Edycja: jest krótsza, ponieważ deklaruje anonimową funkcję (fn[v](->> ...))i nie używa ->>makra, chociaż łatwiej było to odczytać i wywołać w ten sposób.

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

Oryginalny:

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

Generuje sekwencję 1, 10, 100, ... i bierze pierwsze 10 pozycji (zakładając, że wartości wejściowe są mniejsze niż 10 ^ 11), mapuje na moduły zgodnie ze specyfikacją i oblicza sumę. Długie nazwy funkcji sprawiają, że to rozwiązanie jest dość długie, ale przynajmniej wersja golfowa powinna być dość łatwa do naśladowania.

Najpierw próbowałem żonglować strunami, ale wymagało to mnóstwa płyt kotłowych.

Rakieta 134 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wydajność:

5842
1
6
2097
8331
505598476

R , 50 bajtów

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

Wypróbuj online!

SNOBOL4 (CSNOBOL4) , 92 bajty

	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

Wypróbuj online!

Ruby 45 bajtów

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

To naprawdę fajne rozwiązanie. Jest to technicznie poprawne, ale jest bardzo nieefektywne. O wiele bardziej wydajne byłoby pisanie q.to_s.size.times {...}. Używamy q.times, ponieważ zapisuje znaki, a dodatkowa liczba przejść przez proces powoduje, że wyrażenie po prostu ocenia na zero.

PHP , 60 bajtów

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

Wypróbuj online!

Java 8, 127 66 bajtów

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

-61 bajtów poprzez utworzenie portu odpowiedzi C # @adrianmp .

Wypróbuj tutaj.

Pari / GP , 42 bajty

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

Wypróbuj online!

Japt , 11 10 bajtów

¬x@%OvUi+Y

Spróbuj

Wyjaśnienie

               :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