Racha de divisibilidad

31

Podemos definir la racha kde divisibilidad de un número nal encontrar el número entero no negativo más pequeño de ktal manera que n+kno sea divisible entre k+1.

Reto

En el idioma que elija, escriba un programa o función que genere o devuelva la Racha de divisibilidad de su entrada.

Ejemplos:

n=13:
13 is divisible by 1 
14 is divisible by 2 
15 is divisible by 3 
16 is divisible by 4 
17 is not divisible by 5

La racha de divisibilidad de 13es4

n=120:
120 is divisible by 1 
121 is not divisible by 2

La racha de divisibilidad de 120es1

Casos de prueba:

n      DS
2      1
3      2
4      1
5      2
6      1
7      3
8      1
9      2
10     1
2521   10

Más casos de prueba se pueden encontrar aquí .

Notas

Reglas

  • Puede suponer que la entrada es mayor que 1.

Tanteo

code-golf : gana la presentación con la puntuación más baja.

code-golf  number  division 
— Oliver
fuente
Sugiero cambiar el "entero positivo más pequeño" a "el entero no negativo más pequeño". No cambia el desafío en absoluto, pero con la descripción actual, implica que no necesitamos verificar la divisibilidad entre 1 (que técnicamente no deberíamos necesitar). O eso, o podría eliminar la divisibilidad por 1 controles de la descripción.
— TehPers
El entero positivo más pequeño es 1, y k + 1es 2, donde kes el entero positivo más pequeño. Perdón por la trampa.
— TehPers
¿No es lo mismo que encontrar el más pequeño kque no se divide n-1?
— Paŭlo Ebermann
@ PaŭloEbermann Tome n=7donde k=3: n-1es divisible por k.
— Oliver
Ah, me perdí el +1.
— Paŭlo Ebermann

Respuestas:

17

Java 8, 44 42 41 39 bytes

Tachado 44 sigue siendo regular 44; (

n->{int r=0;for(;~-n%--r<1;);return~r;}

-2 bytes gracias a @LeakyNun .
-1 byte gracias a @TheLethalCoder .
-2 bytes gracias a @Nevay .

Explicación:

Pruébalo aquí.

n->{                 // Method with integer as parameter and return-type
  int r=0;           //  Result-integer (starting at 0)
  for(;~-n%--r<1;);  //  Loop as long as `n-1` is divisible by `r-1`
                     //   (after we've first decreased `r` by 1 every iteration)
  return~r;          //  Return `-r-1` as result integer
}                    // End of method
— Kevin Cruijssen
fuente
1
— Leaky Nun
1
41 bytes Acabo de eliminar un byte de la sugerencia de LeakyNun.
— TheLethalCoder
2
— Nevay
4

JavaScript (ES6), 28 bytes

n=>g=(x=2)=>++n%x?--x:g(++x)

Pruébalo

o.innerText=(f=

n=>g=(x=2)=>++n%x?--x:g(++x)

)(i.value=2521)();oninput=_=>o.innerText=f(+i.value)()
<input id=i><pre id=o>
Expandir fragmento

— Lanudo
fuente
3

Cubix , 17 bytes

)uUqI1%?;)qUO(;/@

Pruébalo en línea!

Cubified

    ) u
    U q
I 1 % ? ; ) q U
O ( ; / @ . . .
    . .
    . .
  • I1 configurar la pila con entrada y divisor
  • %? hacer mod y probar
    • ;)qU)uqUsi 0 elimina el resultado e incrementa la entrada y el divisor. Un poco de una ronda sobre el camino para volver a%
    • /;(O@ si no es 0, descartar resultado, decrementar divisor, salida y salir

Míralo correr

— MickyT
fuente
2

dc , 28 bytes

1si[1+dli1+dsi%0=M]dsMxli1-p

Pruébalo en línea!

Esto se siente realmente subóptimo, con el incremento y la disminución final, pero realmente no puedo ver una manera de mejorarlo. Básicamente, simplemente incrementamos un contador iy nuestro valor inicial siempre que el mod de valor icontinúe siendo cero, y una vez que eso no sea cierto, restaremos uno ie imprimiremos.

— brhfl
fuente
2

Gaia , 8 bytes

@1Ė₌)†↺(

Pruébalo en línea!

Explicación

@         Push input (call it n).
 1        Push 1 (call it i).
      ↺   While...
  Ė₌       n is divisible by i:
    )†     Increment both n and i.
       (  Decrement the value of i that failed this test and print.
— Gato de negocios
fuente
2

J, 17 bytes

[:{.@I.>:@i.|i.+]

Pruébalo en línea!

Creo que todavía hay espacio para jugar golf aquí.

Explicación (sin golf)

[: {.@I. >:@i. | i. + ]
                 i. + ]  Range [n,2n)
                 i.       Range [0,n)
                    +     Added to each
                      ]   n
         >:@i. | i. + ]  Divisibility test
         >:@i.            Range [1,n+1)
               |          Modulo (in J, the arguments are reversed)
                 i. + ]   Range [n,2n)
    {.@I.                Get the index of the first non-divisible
       I.                 Indices of non-zero values
    {.                    Head

El cap ( [:) está ahí para asegurarse de que J no trate el último verbo ( {.@I.) como parte de un gancho.

Lo único extraño de esta respuesta es que en I.realidad duplica el índice de cada número distinto de cero tantas veces como el valor de ese número. p.ej

   I. 0 1 0 2 3
1 3 3 4 4 4

Pero no importa, ya que queremos el primer índice de todos modos (y dado que i.da un rango ascendente, sabemos que el primer índice será el valor más pequeño).

Finalmente, aquí hay una prueba muy breve de que es válido verificar la división solo hasta n.

Comenzamos a verificar la divisibilidad con 1 | n, por lo que suponiendo que la racha llegue tan lejos, una vez que lleguemos a verificar la divisibilidad por nlo n | 2n - 1que nunca será cierto ( 2n - 1 ≡ n - 1 (mod n)). Por lo tanto, la racha terminará allí.

— col
fuente
2

Código de máquina x86, 16 bytes

49                 dec    ecx        ; decrement argument
31 FF              xor    edi, edi   ; zero counter

                Loop:
47                 inc    edi        ; increment counter
89 C8              mov    eax, ecx   ; copy argument to EAX for division
99                 cdq               ; use 1-byte CDQ with unsigned to zero EDX
F7 FF              idiv   edi        ; EDX:EAX / counter
85 D2              test   edx, edx   ; test remainder
74 F6              jz     Loop       ; keep looping if remainder == 0

4F                 dec    edi        ; decrement counter
97                 xchg   eax, edi   ; move counter into EAX for return
C3                 ret               ;  (use 1-byte XCHG instead of 2-byte MOV)

La función anterior toma un solo parámetro,, nen el ECXregistro. Calcula su racha de divisibilidad k, y la devuelve a través del EAXregistro. Se ajusta a la convención de llamadas de llamada rápida de 32 bits , por lo que se puede llamar fácilmente desde el código C utilizando compiladores Microsoft o Gnu.

La lógica es bastante simple: solo hace una prueba iterativa a partir de 1. Es funcionalmente idéntica a la mayoría de las otras respuestas aquí, pero optimizada a mano para el tamaño. Un montón de buenos instrucciones de 1 byte allí, incluyendo INC, DEC, CDQ, y XCHG. Los operandos codificados para la división nos hirieron un poco, pero no tanto.

Pruébalo en línea!

— Cody Gray
fuente
2

PHP , 34 bytes

for(;$argv[1]++%++$r<1;);echo$r-1;

Pruébalo en línea!

Suficientemente simple. Comprueba el resto de la división (mod) de cada ciclo mientras incrementa cada valor, sale cuando el número ya no es divisible.

— Xanderhall
fuente
1

SOGL V0.12 , 8 bytes

]e.-ē⁴I\

Pruébalo aquí!

No está mal para un idioma que está hecho para un tipo completamente diferente de desafíos.

Explicación:

]         do .. while top of the stack is truthy
 e          push the variable E contents, by default user input
  .-        subtract the input from it
    ē       push the value of the variable E and then increase the variable
     ⁴      duplicate the item below one in the stack
      I     increase it
       \    test if divides
            if it does divide, then the loop restarts, if not, outputs POP which is `e-input`
— dzaima
fuente
1

Mathematica, 40 bytes

Min@Complement[Range@#,Divisors[#-1]-1]&

Pruébalo en línea! (Matemáticas)

Enfoque matemático, n + k es divisible por k + 1 si y solo si n-1 es divisible por k + 1. Y n-1 no es divisible por n, también lo Range@#son los números.

Originalmente tengo la intención de usar Min@Complement[Range@#,Divisors[#-1]]-1&, pero esto también funciona.

— usuario202729
fuente
¿Por qué aparece el captcha cuando uso el envío de tio?
— user202729
1
Porque lo escribiste (lo copiaste y lo pegaste) demasiado rápido. No se trata de TIO.
— Leaky Nun
1

Julia 0.6.0 (47 bytes) (38 bytes)

n->(i=1;while isinteger(n/i) i+=1;n+=1 end;i-1)

n->(i=1;while n%i<1 i+=1;n+=1end;i-1)

Pruébalo en línea!

Se recortaron 9 bytes gracias a Mr.Xcoder

— Goysa
fuente
2
Normalmente, el enlace "Pruébelo en línea" permite a las personas probar el código definiendo alguna combinación de encabezado, pie de página y argumentos, lo que significa que presionar el botón de reproducción da salida.
— Peter Taylor
@PeterTaylor Por pura suposición, intenté ejecutarlo como tal , y para mi sorpresa funcionó. Recomiendo el OP para editar con la versión comprobable.
— Sr. Xcoder
46 bytes (eliminando un espacio):n->(i=1;while isinteger(n/i) i+=1;n+=1end;i-1)
— Sr. Xcoder
Otra suposición pura permitida es jugar golf hasta 38 bytes:n->(i=1;while n%i<1 i+=1;n+=1end;i-1)
— Sr. Xcoder
@PeterTaylor Lo siento, lo olvidé!
— Goysa
1

Lote, 70 bytes.

@set/an=%1-1,i=0
:l
@set/ai+=1,r=n%%~i
@if %r%==0 goto l
@echo %i%

Todo lo que está haciendo es encontrar el más grande ique LCM(1..i)divide n-1.

— Neil
fuente
1

Aceto , 28 27 bytes

[;`%
I)@]
iIk2I(D(
rk[(&Xpu

Podría guardar un byte si no tengo que salir.

Explicación:

Usamos tres pilas: la pila izquierda contiene un contador que comienza en 2, la derecha contiene el número dado (o sus incrementos), la pila central se usa para realizar las operaciones de módulo. Podríamos, por supuesto, hacer todo en una pila, pero de esta manera podemos configurar las pilas externas para que sean "fijas" (los valores que aparecen no se eliminan realmente) y ahorrarnos muchas operaciones de duplicación. Aquí está el método en detalle:

Lea un número entero, increméntelo, haga que la pila actual sea pegajosa y "muévala" (y a nosotros mismos) a la pila a la izquierda:

iI
rk[

Vaya una pila más hacia la izquierda, presione un literal 2, haga que esta pila sea pegajosa también. Recuerde esta posición en el código ( @), y "mueva" un valor y nosotros a la pila central nuevamente.

  @]
  k2
   (

Ahora probamos: ¿El módulo de los dos números superiores no es 0? Si es así, salte hasta el final, de lo contrario, vaya una pila hacia la derecha, incremente y empuje el valor y nosotros hacia el medio. Luego vaya a la pila izquierda, increméntela también y salte de nuevo a la marca que establecimos antes.

[;`%
I)
    I(
    &

Cuando el resultado del módulo no fue cero, invertimos la posición en la que se mueve la IP, vamos una pila hacia la izquierda (donde vive nuestro contador), decrementamos e imprimimos el valor, luego salimos.

      D(
     Xpu
— L3viatán
fuente
1

Ruby, 34 32 31 bytes

f=->n,d=1{n%d<1?1+f[n+1,d+1]:0}

Una lambda recursiva. Todavía es nuevo en Ruby, así que las sugerencias son bienvenidas.

Pruébalo en línea!

— Yytsi
fuente
1

F #, 86 bytes 84 bytes

let s n = 
    let rec c n1 d r=if n1%d=0 then c(n1+1)(d+1)(r+1)else r
    c n 1 0

Pruébalo en línea!

Editar: -2 personajes de Oliver

— Vladislav Khapin
fuente
Bienvenido a PPCG! ¿Su programa toma stdin? Puede usar TIO , que tiene un intérprete de F # en línea. Además, ¿puede eliminar el espacio en blanco r = if?
— Oliver
1
@Oliver Gracias, cambié el enlace a TIO, así que ahora puedes pasar el argumento para probarlo. :)
— Vladislav Khapin
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.