Summe der Modulosummen


34

Fügen Sie n > 9für jede mögliche Einfügung zwischen Ziffern in dieser Ganzzahl eine Addition ein +und bewerten Sie sie mit einer Ganzzahl . Nehmen Sie dann die ursprüngliche Zahl, um diese Ergebnisse zu modulieren. Die Gesamtsumme dieser Operationen ausgeben.

Ein Beispiel mit n = 47852:

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

Eingang

Eine einzelne positive ganze Zahl in jedem geeigneten Format , n > 9.

Ausgabe

Die Ausgabe einer einzelnen Ganzzahl gemäß der obigen Konstruktionstechnik.

Regeln

  • Sie müssen sich keine Gedanken über Eingaben machen, die größer sind als der Standardtyp Ihrer Sprache.
  • Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
  • Standardlücken sind verboten.
  • Dies ist daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

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

Antworten:



9

JavaScript, 43 47 Bytes

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

I.oninput=_=>O.value=f(I.value)
<input id=I>
<input id=O disabled>

Übernimmt die Eingabe als String.


Bearbeiten:

+4 Bytes : Führende Nullen in JavaScript konvertieren die Zahl in Oktal):


2
Dieses Snippet ist ziemlich gut, da es in Echtzeit aktualisiert wird.
AdmBorkBork

Können Sie ein Byte speichern, indem Sie tun (+'$&$''+$`)?
Neil

@Neil. In der ersten Iteration $`ist leer und es wird ein Fehler ausgegeben, der versucht zu evaluieren (13+)(als Beispiel).
Washington Guedes

7

Brachylog , 20 Bytes

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

Probieren Sie es online!

Erläuterung

Dies implementiert die angegebene Formel. Das Einzige, worauf wir achten müssen, ist, wenn sich a 0in der Mitte der Eingabe befindet: In diesem Fall wird Brachylog ziemlich schrullig. Beispielsweise wird nicht akzeptiert, dass eine Liste von Ganzzahlen, die mit a beginnen 0, zu einer Ganzzahl verkettet werden kann ( die die führende ignorieren würde erfordern 0- das so programmiert ist , in erster Linie auf diese Weise Endlosschleifen zu vermeiden). Um dieses Problem zu umgehen, konvertieren wir die Eingabe in eine Zeichenfolge und konvertieren dann alle geteilten Eingaben in Ganzzahlen zurück.

                       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               

6

ES6 (Javascript), 4240 Bytes

EDITS:

  • Wurde s , -2 Bytes los

Golf gespielt

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

Prüfung

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


Wenn Sie sich darauf beschränken, können m<2**31Sie mit x=1dem Speichern eines Bytes beginnen.
Neil

6

Python 2, 45 Bytes

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

Verwendet Arithmetik anstelle von Zeichenfolgen, um die Eingabe nin Teile n/cund zu teilen n%c, die cdurch Potenzen von 10 rekursiv sind.


6

Gelee , 12 Bytes

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

TryItOnline!

Wie?

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

5

Perl 35 32 27 Bytes

Beinhaltet +3 für -p

8 Bytes dank Dada gespart

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

5

C 77 + 4 = 81 Bytes

Golf gespielt

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

Sie sollten so initialisieren r=0, dass bei einem erneuten Aufruf der Funktion das Ergebnis korrekt ist. Es ist irgendwo in Meta, wenn Sie globale Variablen verwenden, dann müssen Sie mit den Nebenwirkungen des mehrmaligen Aufrufs einer Funktion umgehen.
Karl Napf

@KarlNapf so gut?
Mukul Kumar

C lässt keine Standardfunktionswerte zu, Ihr Code wird nicht kompiliert. Sie können rglobal deklarieren, aber innerhalb der Funktion als Anweisung, die Sie sagen können r=0;, siehe meine Antwort zum Beispiel.
Karl Napf

1
@ KarlNapf Ihre ans ist v2 meiner ans ... viel besser danke
Mukul Kumar

5

Python 2, 68 64 68 Bytes

-4 Bytes dank Atlasologe

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

* Die Eingabe ist eine Zeichenfolge


Speichern Sie 4:lambda n:sum(int(n)%eval(n[:i]+'+'+n[i:])for i in range(len(n)))
Atlasologe

1
Scheitert bei Eingaben, die eine Null mit einem 8oder 9danach enthalten, und gibt falsche Antworten für andere (wie im letzten Testfall). Zahlen, die mit einer Null beginnen, sind oktal. repl.it/EmMm
mbomb007

@ mbomb007 behoben
Rod

4

C 59 Bytes

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

tist 10,100,1000,...und repräsentiert den Schnitt in der großen Zahl. n/tist der rechte Teil und n%tder linke Teil. Wenn tgrößer als die Zahl ist, ist es fertig.

Ungolfed und Nutzung:

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

Ohhh mein .... bitte eine Erklärung hinzufügen.
Mukul Kumar

@MukulKumar okay so?
Karl Napf

ja das ist schön
Mukul Kumar

3

Retina , 38 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

1

Nicht gerade effizient ...

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

\B
,$';$_¶$`

Zwischen jedem Zeichenpaar wird ein Komma eingefügt, alles vor dem Match, ein Semikolon, die gesamte Eingabe, ein Zeilenvorschub und alles nach dem Match. Für die Eingabe 12345gibt uns dies:

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

Dh jede mögliche Aufteilung der Eingabe zusammen mit einem Paar der Eingabe. Diese letzte Zeile brauchen wir aber nicht:

G-2`

Wir werfen es weg.

\d+|,
$*

Dies ersetzt jede Zahl sowie das Komma durch ihre unäre Darstellung. Da das Komma keine Zahl ist, wird es als Null behandelt und einfach entfernt. Dies addiert die beiden Teile in jeder Aufteilung.

(1+);\1*

Dies berechnet das Modulo, indem alle Kopien der ersten Nummer von der zweiten Nummer entfernt werden.

1

Das war's, wir zählen einfach, wie viele 1s in der Zeichenkette übrig sind und geben das als Ergebnis aus.


3

Pyth, 14 Bytes

s.e%QssMc`Q]k`

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und das Ergebnis ausgibt.

Testsuite

Wie es funktioniert

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


3

Perl 6 , 33 Bytes

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

Erweitert:

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

3

Mathematica, 75 Bytes

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

Hierbei wird der Mustervergleich in der Ziffernliste verwendet, um alle Partitionen in zwei Teile zu extrahieren. Jede solche Partition in aund bwird dann durch ersetzt

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

Das Bemerkenswerte dabei ist, dass Summen von Listen mit ungleicher Länge unbewertet bleiben. Wenn also z. B. aist 1,2und bist, 3,4,5ersetzen wir dies zuerst durch {1,2} + {3,4,5} + {}. Der letzte Term soll sicherstellen, dass er immer noch unbewertet bleibt, wenn wir eine gerade Anzahl von Ziffern gleichmäßig aufteilen. Jetzt ist die MapOperation in Mathematica so verallgemeinert, dass sie mit jeder Art von Ausdruck funktioniert, nicht nur mit Listen. Wenn wir also FromDigitsdiese Summe addieren, wird jede dieser Listen wieder zu einer Zahl. Zu diesem Zeitpunkt ist der Ausdruck eine Summe von ganzen Zahlen, die nun ausgewertet werden. Dies spart ein Byte gegenüber der herkömmlicheren Lösung Tr[FromDigits/@{{a},{b}}], bei der zuerst die beiden Listen konvertiert und dann das Ergebnis summiert werden.


3

Eigentlich , 16 15 Bytes

Golfvorschläge willkommen! Probieren Sie es online!

Bearbeiten: -1 Byte dank 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.

Wenn Sie ╜% innerhalb des Funktionsbereichs verschieben, brauchen Sie das ♀ nicht zu verwenden, und Sie sparen 1 Byte: D (; ╗ $ lr ╤╜d+╜%MΣ)
Teal

@Tealpelican Danke für den Tipp: D Lassen Sie mich wissen, wenn Sie weitere Golf-Vorschläge haben
Sherlock9

2

Ruby, 64 Bytes

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

Nimmt die Eingabe als String


Leider interpretiert Ruby ganzzahlige Literale, die mit 0oktal beginnen, was bedeutet, dass dies für den letzten Testfall fehlschlägt. Hier ist eine 78-Byte-Lösung, die das angeht.
benj2240

2

Befunge, 101 96 Bytes

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

Probieren Sie es online!

Erläuterung

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

2

APL, 29 Bytes

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

⎕IOmuss sein 1. Erklärung (Ich bin nicht gut darin zu erklären, irgendwelche Verbesserungen sind sehr willkommen):

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

Dort ist es geschafft.
Zacharý

2

C #, 67 Bytes

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

Volles Programm mit ungolfederten, erklärten Methoden und Testfällen:

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

2

Attache , 48 Bytes

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

Probieren Sie es online!

Erläuterung

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

1

Clojure, 91 81 Bytes

Bearbeiten: Dies ist kürzer, da es eine anonyme Funktion deklariert (fn[v](->> ...))und kein ->>Makro verwendet, obwohl es einfacher zu lesen und so aufzurufen war.

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

Original:

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

Erzeugt eine Sequenz von 1, 10, 100, ... und nimmt die ersten 10 Elemente (unter der Annahme, dass die Eingabewerte kleiner als 10 ^ 11 sind), ordnet sie Modulos zu, wie in den Spezifikationen angegeben, und berechnet die Summe. Lange Funktionsnamen machen diese Lösung ziemlich lang, aber zumindest sollte auch die Golfversion leicht zu befolgen sein.

Zuerst habe ich versucht, Saiten zu jonglieren, aber dafür war eine Menge Kochplatte erforderlich.


1

Schläger 134 Bytes

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

Testen:

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

Ausgabe:

5842
1
6
2097
8331
505598476

So viele enge Beziehungen ...: D
AdmBorkBork

Es ist nicht so schwierig, wie es scheint.
RNSO



0

Ruby 45 Bytes

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

Dies ist eine wirklich saubere Lösung. Es ist technisch korrekt, aber es ist super ineffizient. Es wäre viel effizienter, q.to_s.size.times {...} zu schreiben. Wir verwenden q.times, weil es Zeichen speichert und der Ausdruck für die zusätzliche Häufigkeit, mit der er den Prozess durchläuft, nur null ergibt.


Es tut uns leid! Dies ist eine 45-Byte-Lösung, die in Ruby geschrieben ist. Ich habe den Beitrag bearbeitet, um dies widerzuspiegeln.
Philip Weiss

Zweitplatzierter mit 46 Bytes: ->q{(0..q).reduce{|s,x|p=10**x;s+q%(q/p+q%p)}}
Philip Weiss,




0

Japt , 11 10 Bytes

¬x@%OvUi+Y

Versuch es


Erläuterung

               :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

1
Dies wurde als minderwertig eingestuft: P
Christopher
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.