Suma de sumas modulares

34

Dado un entero n > 9, para cada posible inserción entre dígitos en ese entero, inserte una suma +y evalúe. Luego, tome el número original módulo esos resultados. Salida de la suma total de estas operaciones.

Un ejemplo con n = 47852:

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

Entrada

Un número entero positivo solo en cualquier formato conveniente , n > 9.

Salida

La salida de entero único siguiendo la técnica de construcción anterior.

Reglas

  • No necesita preocuparse por una entrada mayor que el tipo predeterminado de su idioma.
  • Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
  • Las lagunas estándar están prohibidas.
  • Este es el por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

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

Respuestas:

10

05AB1E , 12 10 bytes

v¹¹N¹‚£O%O

Utiliza la codificación CP-1252 . Pruébalo en línea!

Adnan
fuente
3
agradable, no se volvió a cargar y se publicó D.s¨s.p¨R+¹s%Osin ver esto; P
Urna de pulpo mágico el
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>

Toma la entrada como cadena.


Editar:

+4 bytes : los ceros a la izquierda en JavaScript convierten el número a octal):

Washington Guedes
fuente
2
Ese fragmento es bastante bueno, al ver que se actualiza en tiempo real de esa manera.
AdmBorkBork
¿Se puede guardar un byte haciendo (+'$&$''+$`)?
Neil
@Neil. En la primera iteración $`está vacía, y arrojará un error al intentar evaluar (13+)(como ejemplo).
Washington Guedes
7

Brachylog , 20 bytes

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

Pruébalo en línea!

Explicación

Esto implementa la fórmula dada. De lo único que debemos tener cuidado es cuando a 0está en el medio de la entrada: en ese caso, Brachylog se vuelve bastante peculiar, por ejemplo, no aceptará que una lista de enteros que comienzan con a 0se pueda concatenar en un entero ( lo que requeriría ignorar el inicio 0, esto se programa principalmente de esa manera para evitar bucles infinitos). Por lo tanto, para evitar ese problema, convertimos la entrada en una cadena y luego convertimos todas las entradas divididas en enteros.

                       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               
Fatalizar
fuente
6

ES6 (Javascript), 42, 40 bytes

EDICIONES:

  • Se deshizo de s , -2 bytes

Golfed

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

Prueba

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

zepelín
fuente
Si se limita a m<2**31entonces, puede comenzar con el x=1ahorro de un byte.
Neil
6

Python 2, 45 bytes

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

Utiliza aritmética en lugar de cadenas para dividir la entrada nen partes n/cy n%c, que crecurre a través de potencias de 10.

xnor
fuente
6

Jalea , 12 bytes

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

TryItOnline!

¿Cómo?

ŒṖṖ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
Jonathan Allan
fuente
5

Perl 35 32 27 Bytes

Incluye +3 para -p

Guardado 8 bytes gracias a Dada

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

C 77 + 4 = 81 bytes

golf

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

Sin golf

#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));
}
Mukul Kumar
fuente
Debe iniciar de r=0tal manera que si se llama nuevamente a la función, el resultado sea correcto. Está en algún lugar de Meta, si usa variables globales, entonces tiene que lidiar con los efectos secundarios de llamar a una función más de una vez.
Karl Napf
@KarlNapf que bueno?
Mukul Kumar
C no permite valores de función predeterminados, su código no se compila. Puede declarar rglobal pero dentro de la función como una declaración que puede decir r=0;, vea mi respuesta, por ejemplo.
Karl Napf
1
@KarlNapf tu ans es v2 de mi ans ... mucho mejor gracias
Mukul Kumar
5

Python 2, 68 64 68 bytes

-4 bytes gracias al atlasólogo

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

* La entrada es una cadena

Barra
fuente
Ahorre 4:lambda n:sum(int(n)%eval(n[:i]+'+'+n[i:])for i in range(len(n)))
atlasólogo
1
Falla para las entradas que contienen un cero con un 8o 9después y da respuestas incorrectas para otros (como el último caso de prueba). Los números que comienzan con un cero son octales. repl.it/EmMm
mbomb007
@ mbomb007 arreglado
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;}

tes 10,100,1000,...y representa el corte en el gran número. n/tes la parte derecha y n%tla parte izquierda. Si tes mayor que el número, está terminado.

Sin golf y uso:

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));
}
Karl Napf
fuente
Ohhh mi ... por favor agrega una explicación.
Mukul Kumar
@MukulKumar ¿está bien así?
Karl Napf
si eso es lindo
Mukul Kumar
3

Retina , 38 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

1

No exactamente eficiente ...

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Explicación

\B
,$';$_¶$`

Entre cada par de caracteres, insertamos una coma, todo delante del partido, un punto y coma, toda la entrada, un salto de línea y todo después del partido. Para la entrada 12345esto nos da:

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

Es decir, cada posible división de la entrada junto con un par de la entrada. Sin embargo, no necesitamos esa última línea:

G-2`

Lo descartamos.

\d+|,
$*

Esto reemplaza cada número, así como la coma, con su representación unaria. Como la coma no es un número, se trata como cero y simplemente se elimina. Esto agrega las dos partes en cada división.

(1+);\1*

Esto calcula el módulo eliminando todas las copias del primer número del segundo número.

1

Eso es todo, simplemente contamos cuántos 1s quedan en la cadena e imprimimos eso como resultado.

Martin Ender
fuente
3

Pyth, 14 bytes

s.e%QssMc`Q]k`

Un programa que toma la entrada de un número entero e imprime el resultado.

Banco de pruebas

Cómo funciona

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
TheBikingViking
fuente
3

Perl 6 , 33 bytes

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

Expandido:

{                  # 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
}
Brad Gilbert b2gills
fuente
3

Mathematica, 75 bytes

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

Esto utiliza la coincidencia de patrones en la lista de dígitos para extraer todas sus particiones en dos partes. Cada una de estas particiones ay bluego se reemplaza con

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

Lo notable aquí es que las sumas de listas de longitud desigual permanecen sin evaluar, por lo que, por ejemplo, si aes 1,2y bes 3,4,5, primero reemplazamos esto con {1,2} + {3,4,5} + {}. El último término está ahí para garantizar que aún no se haya evaluado cuando dividimos equitativamente un número par de dígitos. Ahora la Mapoperación en Mathematica está suficientemente generalizada para que funcione con cualquier tipo de expresión, no solo con listas. Entonces, si asignamos FromDigitsesta suma, convertirá cada una de esas listas en un número. En ese punto, la expresión es una suma de enteros, que ahora se evalúa. Esto ahorra un byte sobre la solución más convencional Tr[FromDigits/@{{a},{b}}]que convierte las dos listas primero y luego resume el resultado.

Martin Ender
fuente
3

En realidad , 16 15 bytes

Sugerencias de golf bienvenidas! Pruébalo en línea!

Editar: -1 byte gracias a 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.
Sherlock9
fuente
Si mueve ╜% dentro de la sección de funciones, no necesita usar ♀ y le ahorrará 1 byte: D (; ╗ $ lr ╤╜d+╜%MΣ)
Teal pelican
@ Tealpelican Gracias por el consejo: D Avísame si tienes alguna otra sugerencia de golf
Sherlock9
2

Ruby, 64 bytes

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

Toma la entrada como una cadena

Lee W
fuente
Desafortunadamente, Ruby interpreta los literales enteros que comienzan con 0octal, lo que significa que esto falla en el último caso de prueba. Aquí hay una solución de 78 bytes que aborda eso.
benj2240
2

Befunge, 101 96 bytes

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

Pruébalo en línea!

Explicación

&              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.
James Holderness
fuente
2

APL, 29 bytes

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

⎕IOdebe ser 1. Explicación (no soy bueno para explicar, cualquier mejora a esto es muy bienvenida):

{+/⍵|⍨{(⍎⍵↑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
Zacharý
fuente
Ahí está hecho.
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;};

Programa completo con método explicado y sin fundamentos y casos de prueba:

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
    }
}
adrianmp
fuente
2

Adjunto , 48 bytes

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

Pruébalo en línea!

Explicación

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
Conor O'Brien
fuente
1

Clojure, 91 81 bytes

Editar: esto es más corto ya que declara una función anónima (fn[v](->> ...))y no usa ->>macro, aunque fue más fácil de leer y llamar de esa manera.

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

Genera una secuencia de 1, 10, 100, ... y toma los primeros 10 elementos (suponiendo que los valores de entrada son menores que 10 ^ 11), se asigna a los módulos como se especifica en las especificaciones y calcula la suma. Los nombres largos de funciones hacen que esta solución sea bastante larga, pero al menos incluso la versión de golf debería ser bastante fácil de seguir.

Primero intenté hacer malabarismos con las cuerdas pero requería toneladas de repeticiones.

NikoNyrh
fuente
1

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

Sin golf:

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

Pruebas:

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

Salida:

5842
1
6
2097
8331
505598476
rnso
fuente
Tantos
padres
No es tan difícil como parece.
rnso 12/12/2016
0

Ruby 45 Bytes

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

Esta es una solución realmente ordenada. Es técnicamente correcto, pero es super ineficiente. Sería mucho más eficiente escribir q.to_s.size.times {...}. Usamos q.times porque guarda caracteres, y la cantidad adicional de veces que pasa por el proceso la expresión solo se evalúa a cero.

Philip Weiss
fuente
¡Lo siento! Esta es una solución de 45 bytes escrita en rubí. He editado la publicación para reflejar eso.
Philip Weiss
Subcampeón de 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

Intentalo


Explicación

               :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
Lanudo
fuente
1
Esto se marcó como de baja calidad: P
Christopher