Dato un numero intero n > 9, per ogni possibile inserimento tra le cifre in quel numero intero, inserire un'aggiunta+ e valutare. Quindi, prendi il numero originale modulo quei risultati. Stampa la somma totale di queste operazioni.

Un esempio con n = 47852:

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

Ingresso

Un singolo numero intero positivo in qualsiasi formato conveniente ,n > 9 .

Produzione

L'output intero singolo seguendo la tecnica di costruzione sopra.

Regole

• Non devi preoccuparti di input più grandi del tipo predefinito della tua lingua.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

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

05AB1E , 12 10 byte

v¹¹N¹‚£O%O

Utilizza la codifica CP-1252 . Provalo online!

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>

Accetta l'input come stringa.

Modificare:

+4 byte : zero iniziali in JavaScript converte il numero in ottale):

Brachylog , 20 byte

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

Provalo online!

Spiegazione

Questo implementa la formula data. L'unica cosa di cui dobbiamo fare attenzione è quando a 0è nel mezzo dell'input: in quel caso Brachylog diventa piuttosto eccentrico, ad esempio non accetterà che un elenco di numeri interi che iniziano con a 0possa essere concatenato in un numero intero ( che richiederebbe di ignorare il comando 0- questo è principalmente programmato in questo modo per evitare loop infiniti). Pertanto, per aggirare quel problema, convertiamo l'input in una stringa e poi riconvertiamo tutti gli input suddivisi in numeri interi.

                       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

Modifiche:

• Sbarazzato di s , -2 byte

golfed

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 byte

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

Utilizza l'aritmetica anziché le stringhe per dividere l'input nin parti n/ce n%c, che cricorre attraverso poteri di 10.

Gelatina , 12 byte

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

TryItOnline!

Come?

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

Include +3 per -p

Risparmiato 8 byte grazie a Dada

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

C 77 + 4 = 81 byte

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 byte

^{-4 byte grazie all'atlologo}

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

^{* L'input è una stringa}

C, 59 byte

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,...e rappresenta il taglio nel grande numero. n/tè la parte destra e n%tla parte sinistra. Se tè maggiore del numero, è finito.

Ungolfed e utilizzo:

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

Retina , 38 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

1

Non esattamente efficiente ...

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

\B
,$';$_¶$`

Tra ogni coppia di caratteri, inseriamo una virgola, tutto davanti alla partita, un punto e virgola, l'intero input, un avanzamento riga e tutto dopo la partita. Per input 12345questo ci dà:

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

Vale a dire ogni possibile suddivisione dell'ingresso insieme a una coppia dell'ingresso. Tuttavia non abbiamo bisogno dell'ultima riga:

G-2`

Lo scartiamo.

\d+|,
$*

Questo sostituisce ogni numero e la virgola con la sua rappresentazione unaria. Poiché la virgola non è un numero, viene trattata come zero e rimossa semplicemente. Ciò aggiunge le due parti in ciascuna divisione.

(1+);\1*

Questo calcola il modulo rimuovendo tutte le copie del primo numero dal secondo numero.

1

Ecco, contiamo semplicemente quanti 1s rimangono nella stringa e lo stampiamo come risultato.

Pyth, 14 byte

s.e%QssMc`Q]k`

Un programma che accetta l'input di un numero intero e stampa il risultato.

Suite di test

Come funziona

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]

Definisce una funzione f. Guardalo passare tutti i casi di test.

Perl 6 , 33 byte

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

Allargato:

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

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

Questo utilizza la corrispondenza dei modelli nell'elenco delle cifre per estrarre tutte le loro partizioni in due parti. Ciascuna di tali partizioni in ae bviene quindi sostituita con

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

La cosa notevole è che somme di liste di lunghezza diversa rimangono non valutata, in modo ad esempio se aè 1,2ed bè3,4,5 quindi in primo luogo abbiamo sostituiamo questo con {1,2} + {3,4,5} + {}. L'ultimo termine è lì per garantire che rimanga ancora sottovalutato quando dividiamo uniformemente un numero pari di cifre. Ora l' Mapoperazione in Mathematica è sufficientemente generalizzata da funzionare con qualsiasi tipo di espressione, non solo con le liste. Quindi, se mappiamo FromDigitssu questa somma, trasformerà ciascuna di quelle liste in un numero. A quel punto, l'espressione è una somma di numeri interi, che ora viene valutata. Ciò consente di risparmiare un byte rispetto alla soluzione più convenzionale Tr[FromDigits/@{{a},{b}}]che converte prima le due liste e quindi riassume il risultato.

In realtà , 16 15 byte

Suggerimenti di golf benvenuti! Provalo online!

Modifica: -1 byte grazie al pellicano 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.

Rubino, 64 byte

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

Prende l'input come stringa

Befunge, 101 96 byte

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

Provalo online!

Spiegazione

&              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←⍕⍵}

⎕IOdeve essere 1. Spiegazione (non sono bravo a spiegare, eventuali miglioramenti a questo sono molto ben accetti):

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

Programma completo con metodo non risolto, spiegato e casi di test:

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 byte

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

Provalo online!

Spiegazione

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

Modifica: è più breve in quanto dichiara una funzione anonima (fn[v](->> ...))e non utilizza ->>macro anche se era più facile da leggere e chiamare in quel modo.

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

Originale:

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

Genera una sequenza di 1, 10, 100, ... e accetta i primi 10 elementi (supponendo che i valori di input siano inferiori a 10 ^ 11), esegue il mapping ai moduli come specificato nelle specifiche e calcola la somma. I nomi di funzioni lunghe rendono questa soluzione piuttosto lunga ma almeno anche la versione golfata dovrebbe essere abbastanza facile da seguire.

Per prima cosa ho provato a destreggiarsi tra le corde, ma richiedeva tonnellate di scaldabagno.

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

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

test:

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

Produzione:

5842
1
6
2097
8331
505598476

R , 50 byte

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

Provalo online!

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

Provalo online!

Ruby 45 byte

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

Questa è una soluzione davvero accurata. È tecnicamente corretto, ma è super inefficiente. Sarebbe molto più efficiente scrivere q.to_s.size.times {...}. Usiamo q.times perché salva i caratteri e il numero extra di volte che passa attraverso il proc l'espressione si limita a zero.

PHP , 60 byte

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

Provalo online!

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 creando una porta della risposta C # di @adrianmp .

Provalo qui.

Pari / GP , 42 byte

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

Provalo online!

Japt , 11 10 byte

¬x@%OvUi+Y

Provalo

Spiegazione

               :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