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

• Basado en el problema del proyecto Euler 601
• Esta secuencia se puede encontrar en OEIS , desplazada hacia abajo por 1.

Reglas

• Puede suponer que la entrada es mayor que 1.

Tanteo

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

Pyth , 6 5 bytes

f%tQh

Pruébalo en línea!

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

Haskell , 35 bytes

f n=[k|k<-[1..],rem(n+k)(k+1)>0]!!0

Pruébalo en línea!

El uso untiltambién es de 35 bytes

f n=until(\k->rem(n+k)(k+1)>0)(+1)1

Casco , 7 bytes

ḟ§%→+⁰N

Pruébalo en línea!

05AB1E , 7 6 bytes

Ý+āÖ0k

Pruébalo en línea!

Soluciones alternativas de 7 bytes:
<DLÖγнg
Ls<ÑKн<

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>

Mathematica, 30 27 bytes

0//.i_/;(i+1)∣(#+i):>i+1&

Una función sin nombre que toma un argumento entero.

Pruébalo en Wolfram Sandbox

Uso:

0//.i_/;(i+1)∣(#+i):>i+1&[2521]

10

Perl 5 , 23 21 + 1 (-p) = 22 bytes

1until$_++%++$\}{$\--

Pruébalo en línea!

Python 2 , 35 bytes

f=lambda n,x=1:n%x<1and-~f(n+1,x+1)

Pruébalo en línea!

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

Python 2 , 43 41 bytes

¡Ahorré 2 bytes gracias a Leaky Nun !

i=input();k=1
while~-i%-~k<1:k+=1
print k

Pruébalo en línea!

Python 2 , 40 bytes

f=lambda i,k=1:~-i%-~k<1and f(i,k+1)or k

Pruébalo en línea!

Python 2 , 44 40 bytes

-4 bytes gracias a Leaky Nun.

f=lambda n,x=1:~-n%-~x and x or f(n,x+1)

Pruébalo en línea!

Swift 4 , 56 bytes

Esta es una función completa f, con un parámetro entero ique imprime la salida.

func f(i:Int){var k=0;while(i-1)%(k+1)<1{k+=1};print(k)}

Pruébalo aquí.

Swift 4 , 56 bytes

Esta es una función anónima, que devuelve el resultado.

{var k=0;while($0-1)%(k+1)<1{k+=1};return k}as(Int)->Int

Pruébalo aquí.

¡Mira la suite de prueba!

C # (Mono) , 41 39 bytes

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

Esencialmente un puerto de la respuesta Java 8 de @Kevin Cruijssen con más golf.

Pruébalo en línea!

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.

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.

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

Japt , 7 bytes

õ b!%UÉ

¡Pruébelo en línea!

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!

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.

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`

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.

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

C (gcc) , 34 bytes

i;f(n){for(i=1;++n%++i<1;);n=i-1;}

Pruébalo en línea!

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.

R , 43 bytes

function(n,k=0:n)which((n+k)%%(k+1)>0)[1]-1

Función anónima.

¡Verifique todos los casos de prueba!

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

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!

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

Befunge , 19 bytes

#v_1+::&+1-\%
1<@.-

Pruébalo en línea!