_{Redivosite es una palabra común inventada con el único propósito de este desafío. Es una mezcla de Reducción, División y Compuesto.}

Definición

Dado un entero N> 6 :

• Si N es primo, N no es un número de redivosita.
• Si N es compuesto:
  • calcular repetidamente N '= N / d + d + 1 hasta que N' sea ​​primo, donde d es el divisor más pequeño de N mayor que 1
  • N es un número de redivosita si y solo si el valor final de N ' es un divisor de N

A continuación se muestran los 100 primeros números de Redivosite (sin entrada OEIS en el momento de la publicación):

14,42,44,49,66,70,143,153,168,169,176,195,204,260,287,294,322,350,414,462,518,553,572,575,592,629,651,702,726,735,775,806,850,869,889,891,913,950,1014,1023,1027,1071,1118,1173,1177,1197,1221,1235,1254,1260,1302,1364,1403,1430,1441,1554,1598,1610,1615,1628,1650,1673,1683,1687,1690,1703,1710,1736,1771,1840,1957,1974,2046,2067,2139,2196,2231,2254,2257,2288,2310,2318,2353,2392,2409,2432,2480,2522,2544,2635,2640,2650,2652,2684,2717,2758,2760,2784,2822,2835

Ejemplos

• N = 13 : 13 es primo, entonces 13 no es un número de redivosita
• N = 32 : 32/2 + 3 = 19; 19 no es un divisor o 32, entonces 32 no es un número de redivosita
• N = 260 : 260/2 + 3 = 133, 133/7 + 8 = 27, 27/3 + 4 = 13; 13 es un divisor o 260, entonces 260 es un número de redivosita

Tu tarea

• Dado un número entero N , devuelve un valor verdadero si es un Número de redivosita o un valor falso de lo contrario. (También puede generar dos valores distintos, siempre que sean coherentes).
• Se garantiza que la entrada sea mayor que 6 .
• Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Haskell, 91 85 83 80 75 74 bytes

n#m=([n#(div m d+d+1)|d<-[2..m-1],mod m d<1]++[mod n m<1&&m<n])!!0
f x=x#x

Pruébalo en línea!

f x=x#x                           -- call # with x for both parameters
n#m               
         |d<-[2..m-1],mod m d<1   -- for all divisors d of m
    [n#(div m d+d+1)           ]  -- make a list of recursive calls to #,
                                  -- but with m set to m/d+d+1
   ++ [mod n m<1&&m<n]            -- append the Redivosite-ness of n (m divides n,
                                  -- but is not equal to n)
                           !!0    -- pick the last element of the list
                                  -- -> if there's no d, i.e. m is prime, the
                                  --    Redivosite value is picked, else the
                                  --    result of the call to # with the smallest d

Editar: -2 bytes gracias a @BMO, -3 bytes gracias a @ H.PWiz y -5 -6 bytes gracias a @ Ørjan Johansen

Casco , 14 bytes

?¬Ṡ¦ΩṗoΓ~+→Πpṗ

Pruébalo en línea!

-3 gracias a H.PWiz .

C (gcc) , 94 89 bytes

m,n;o(k){for(m=1;m++<k;)if(k%m<1)return m;}
F(N){for(n=N;m=o(n),m-n;n=n/m-~m);N=m<N>N%n;}

Pruébalo en línea!

Explicación

m,n;                  // two global integers
o(k){                 // determine k's smallest divisor
 for(m=1;m++<k;)      // loop through integers 2 to n (inclusive)
  if(k%m<1)return m;} // return found divisor
F(N){                 // determine N's redivosity
 for(n=N;             // save N's initial value
  m=o(n),             // calculate n's smallest divisor (no name clash regarding m)
  m-n;                // loop while o(n)!=n, meaning n is not prime
                      //  (if N was prime, the loop will never be entered)
  n=n/m-~m);          // redivosite procedure, empty loop body
 N=m<N>N%n;}          // m<N evaluates to 0 or 1 depending on N being prime,
                      //  N%n==0 determines whether or not N is divisible by n,
                      //  meaning N could be redivosite => m<N&&N%n==0
                      //  <=> m<N&&N%n<1 <=> m<N&&1>N%n <=> (m<N)>N%n <=> m<N>N%n

Jalea , 14 bytes

ÆḌḊ
Ç.ịS‘µÇ¿eÇ

Pruébalo en línea!

Cómo funciona

ÆḌḊ         Helper link. Argument: k

ÆḌ          Yield k's proper (including 1, but not k) divisors.
  Ḋ         Dequeue; remove the first element (1).


Ç.ịS‘µÇ¿eÇ  Main link. Argument: n

     µ      Combine the links to the left into a chain.
      Ç¿    While the helper link, called with argument n, returns a truthy result,
            i.e., while n is composite, call the chain to the left and update n.
Ç             Call the helper link.
 .ị           At-index 0.5; return the elements at indices 0 (last) and 1 (first).
              This yields [n/d, d].
   S          Take the sum.
    ‘         Increment.
        Ç   Call the helper link on the original value of n.
       e    Test if the result of the while loop belongs to the proper divisors.

Python 2 , 97 91 bytes

r=0;e=d=i=input()
while r-e:e=i;r=[j for j in range(2,i+1)if i%j<1][0];i=i/r-~r
d%e<1<d/e<q

Pruébalo en línea!

Salidas a través del código de salida.

Sin golf:

r = 0                             # r is the lowest divisor of the current number,
                                  # initialized to 0 for the while loop condition.
e = d = i = input()               # d remains unchanged, e is the current number
                                  # and i is the next number.
while r != e:                     # If the number is equal to its lowest divisor,
                                  # it is prime and we need to end the loop.
    e = i                         # current number := next number
    r = [j for j in range(2, i+1) # List all divisors of the number in the range [2; number + 1)
         if i%j < 1][0]           # and take the first (lowest) one.
    i = i/r+r+1                   # Calculate the next number.
                                  # We now arrived at a prime number.
print d%e == 0 and d != e         # Print True if our current number divides the input
                                  # and is distinct from the input.
                                  # If our current number is equal to the input,
                                  # the input is prime.

Pruébalo en línea!

05AB1E , 17 16 bytes

[Dp#Òć©sP+>]Ö®p*

Pruébalo en línea!

Explicación

[                  # start loop
 Dp#               # break if current value is prime
    Ò              # get prime factors of current value
     ć©            # extract the smallest (d) and store a copy in register
       sP          # take the product of the rest of the factors
         +>        # add the smallest (d) and increment
           ]       # end loop
            Ö      # check if the input is divisible by the resulting prime
             ®p    # check if the last (d) is prime (true for all composite input)
               *   # multiply

Pyth , 20 bytes

<P_QiI.WtPHh+/ZKhPZK

Pruébalo aquí!

Cómo funciona

iI.WtPHh + / ZKhPZK || Programa completo

  .W || Funcional mientras. Toma dos funciones como argumentos, A y B.
                 || Mientras A (valor) es verdadero, convierta el valor en B (valor). los
                 || El valor inicial es la entrada.
    tPH || Primera función, A. Toma un solo argumento, H.
     PH || .. Los factores primos de H.
    t || .. Cola (eliminar primer elemento). Mientras que la verdad (H es compuesta):
       h + / ZKhPZK || La segunda función, B. Toma un solo argumento, Z:
         / Z || .. Divide Z, por:
           KhP || .. Su factor primo más bajo, y asígnelo a K.   
       h || .. Incremento.
        + K || Y agregue K.
iI || Compruebe si el resultado (último valor) divide la entrada.

Y los primeros 4 bytes ( <P_Q) solo verifican si la entrada no es primo.

Con la ayuda de Emigna , logré guardar 3 bytes.

Python 3 , 149 bytes

def f(N):
	n=N;s=[0]*-~N
	for p in range(2,N):
		if s[p]<1:
			for q in range(p*p,N+1,p):s[q]=s[q]or p
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

Pruébalo en línea!

Usando un enfoque de tamiz. Debe ser rápido ( O(N log log N)= complejidad de tiempo del tamiz de Eratóstenes) incluso con grandes N(pero almacena O(N)enteros en la memoria)

Nota:

• Se puede demostrar que todos los valores intermedios de nno exceden N, y N > 7 ppueden estar en range(2,N)lugar de range(2,N+1)tamizar.
• /no funciona, //debe usarse, debido al índice de la lista.
• El almacenamiento rangeen otra variable no ayuda, desafortunadamente.

Explicación:

• -~N== N+1.
• Al principio, la matriz sse inicializa con N+1ceros (Python es indexación 0, por lo que los índices son 0..N)
• Después de la inicialización, s[n]se espera que sea 0si nes un primo, y ppara pel primo mínimo que divide nsi nes un compuesto. s[0]y los s[1]valores no son importantes.

• Para cada uno pen rango [2 .. N-1]:

  • Si s[p] < 1(es decir s[p] == 0), entonces pes primo, y para cada uno qes múltiplo de py s[q] == 0, asignar s[q] = p.

• Las últimas 2 líneas son sencillas, excepto que n//s[n]-~s[n]== (n // s[n]) + s[n] + 1.

Python 3 , 118 bytes

def f(N):
	n=N;s=[0]*-~N
	for p in range(N,1,-1):s[2*p::p]=(N-p)//p*[p]
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

Pruébalo en línea!

A costa de un rendimiento ligeramente peor. (Este se ejecuta en O(N log N)complejidad de tiempo, suponga una implementación razonable de los segmentos de Python)

El programa completo equivalente es de 117 bytes .

Haskell , 110 bytes

f n|mod(product[1..n-1]^2)n>0=1<0|1>0=n`mod`u n<1
u n|d<-[i|i<-[2..],n`mod`i<1]!!0=last$n:[u$n`div`d+d+1|d/=n]

Pruébalo en línea!

No muy feliz...

Octava , 92 bytes

function r=f(n)k=n;while~isprime(k)l=2:k;d=l(~mod(k,l))(1);k=k/d+d+1;end;r=~mod(n,k)&k<n;end

Pruébalo en línea!

APL (Dyalog) , 50 bytes

{(0=n|⍵)∧⍵>n←{⍬≢k←o/⍨0=⍵|⍨o←2↓⍳⍵:∇1+d+⍵÷d←⌊/k⋄⍵}⍵}

Pruébalo en línea!

Japt, 25 24 bytes

Me temo que podría haber ido en la dirección equivocada con esto, pero me he quedado sin tiempo para intentar un enfoque diferente.

Salidas 0para falso o 1para verdadero.

j ?V©vU :ßU/(U=k g)+°UNg

Intentalo

Perl 5 , 291 + 1 (-a) = 292 bytes

Maldita sea Perl por no tener un primer inspector nativo.

use POSIX;&r($_,$_);
sub p{$n=shift;if($n<=1){return;}if($n==2||$n==3){return 1;}if($n%2==0||$n%3==0){return;}for(5..ceil($n/2)){if($n%$_==0){return;}}return 1;}
sub r{$n=shift;$o=shift;if(&p($n)){print $o%$n==0&&$n!=$o?1:0;last;}for(2..ceil($n/2)){if($n%$_==0){&r(($n/$_)+$_+1, $o);last;}}}

Versión sin golf,

use POSIX;
&r($_,$_);
sub p{
    my $n=shift;
    if($n<=1){
        return;
    }
    if($n==2||$n==3){
        return 1;
    }
    if($n%2==0||$n%3==0){
        return;
    }
    for(5..ceil($n/2)){
        if($n%$_==0){
            return;
        }
    }
    return 1;
}
sub r{
    my $n=shift;
    my $o=shift;
    if(&p($n)){
        print $o%$n==0&&$n!=$o ? 1 : 0;
        last;
    }
    for(2..ceil($n/2)){
        if($n%$_==0){
            &r(($n/$_)+$_+1, $o);
            last;
        }
    }
}

Pruébalo en línea!

Wolfram Language (Mathematica) , 64 bytes

Implementación sencilla con reemplazo de patrón recursivo

(reemplazar "\ [Divide]" con el símbolo "∣" ahorra 7 bytes)

(g=!PrimeQ@#&)@#&&(#//.x_/;g@x:>x/(c=Divisors[x][[2]])+c+1)\[Divides]#&

Pruébalo en línea!

Limpias , 128 117 114 bytes

import StdEnv
@n#v=hd[p\\p<-[2..]|and[gcd p i<2\\i<-[2..p-1]]&&n rem p<1]
|v<n= @(n/v+v+1)=n
?n= @n<n&&n rem(@n)<1

Pruébalo en línea!

J , 35 bytes

(~:*0=|~)(1+d+]%d=.0{q:)^:(0&p:)^:_

Pruébalo en línea!

El divisor mínimo es el primer factor primo robado de la solución Jelly de @ Dennis (anteriormente estaba usando <./@q:).

Debería haber una mejor manera de hacer la iteración, pero parece que no puedo encontrarla. Pensé en evitar hacer la prueba de primalidad ( ^:(0&p:)) y en su lugar usar adversidad, pero parece que será un poco más largo ya que necesitará _2{algunos cambios que podrían no dar una reducción neta.

Realmente siento que también debe haber una manera de evitar tener padres en torno al control de primalidad.

Explicación (expandida)

(~: * 0 = |~)(1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Input: N
             (1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Find the final N'
                                       ^:        ^:_  Do while
                                           0&p:       N is not prime
                                   q:                 Get prime factors (in order)
                               0 {                    Take first (smallest divisor)
                          d =.                        Assign this value to d
             1 + d + ] %  d                           Compute (N/d) + 1 + d
(~: * 0 = |~)                                        Is it redivosite?
      0 = |~                                          N = 0 (mod N'), i.e. N'|N
    *                                                 And
 ~:                                                   N =/= N', i.e. N is not prime

NARS APL, 43 caracteres, 85 bytes

{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}

(esperando que converja para todos los números> 6) prueba:

h←{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
v←⍳100     
v,¨h¨v
   1 0  2 0  3 0  4 0  5 0  6 0  7 0  8 0  9 0  10 0  11 0
   12 0  13 0  14 1  15 0  16 0  17 0  18 0  19 0  20 0  
   21 0  22 0  23 0  24 0  25 0  26 0  27 0  28 0  29 0  
   30 0  31 0  32 0  33 0  34 0  35 0  36 0  37 0  38 0  
   39 0  40 0  41 0  42 1  43 0  44 1  45 0  46 0  47 0  
   48 0  49 1  50 0  51 0  52 0  53 0  54 0  55 0  56 0  
   57 0  58 0  59 0  60 0  61 0  62 0  63 0  64 0  65 0  
   66 1  67 0  68 0  69 0  70 1  71 0  72 0  73 0  74 0  
   75 0  76 0  77 0  78 0  79 0  80 0  81 0  82 0  83 0  
   84 0  85 0  86 0  87 0  88 0  89 0  90 0  91 0  92 0  
   93 0  94 0  95 0  96 0  97 0  98 0  99 0  100 0  

La idea de usar 2 funciones anónimas llego a otra solución Apl.

 {(⍵≤60)∨π⍵:0⋄ -- if arg ⍵ is prime or <=6 return 0
  ⍵{1=⍴t←π⍵:0=⍵|⍺⋄ -- if list of factors ⍵ has length 1 (it is prime)
                    -- then return ⍺mod⍵==0
  ⍺∇1+↑t+⍵÷↑t}⍵}   -- else recall this function with args ⍺ and 1+↑t+⍵÷↑t

Pyt , 44 bytes

←⁻0`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹ṗ⇹3Ș⊽

Consulte el siguiente código para obtener una explicación: las únicas diferencias son (1) que N se disminuye antes para tener en cuenta el incremento al comienzo del ciclo, y (2) usa NOR en lugar de OR.

Pruébalo en línea!

Hice esto antes de volver a leer la pregunta y me di cuenta de que solo quería un verdadero / falso.

Pyt, 52 bytes

60`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹Đṗ⇹3Ș∨ł⇹Đƥ⇹ŕ1ł

Imprime una lista infinita de números Redivosite.

Explicación:

6                                                            Push 6
 0                                                           Push unused character
  `                   ł                     ł      ł         Return point for all three loops
   ŕ                                                         Remove top of stack
    ⁺                                                        Increment top of stack (n)
     ĐĐ                                                      Triplicate top of stack (n)
       ϼ↓                                                    Get smallest prime factor of n (returns 1 if n is prime) 
         Đ                                                   Duplicate top of stack
          3Ș⇹                                                Manipulate stack so that the top is (in descending order): [d,(N,N'),d]
             ÷+⁺                                             Calculates N'=(N,N')/d+d+1
                Đṗ¬                                          Is N' not prime?
                   ⇹⁻⇹                                       Decrement N' (so the increment at the beginning doesn't change the value), and keep the boolean on top - end of innermost loop (it loops if top of stack is true)
                       ŕ                                     Remove top of stack
                        á                                    Convert stack to array
                         Đ                                   Duplicate array
                          0⦋Đ                                Get the first element (N)
                             ↔ĐŁ⁻⦋                           Get the last element ((final N')-1)
                                  ⁺                          Increment to get (final N')
                                   |¬                        Does N' not divide N?
                                     ⇹Đṗ                     Is N prime?
                                        ⇹3Ș∨                 Is N prime or does N' not divide N? - end of second loop (loops if top of stack is true)
                                             ⇹Đƥ⇹ŕ           Print N, and reduce stack to [N]
                                                  1          Push garbage (pushes 1 so that the outermost loop does not terminate)

Pruébalo en línea!