_{Redivosite est un mot-valise inventé dans le seul but de ce défi. C'est un mélange de réduction, de division et de composite.}

Définition

Étant donné un entier N> 6 :

• Si N est premier, N n'est pas un nombre de redivosite.
• Si N est composite:
  • calculer à plusieurs reprises N '= N / d + d + 1 jusqu'à ce que N' soit premier, où d est le plus petit diviseur de N supérieur à 1
  • N est un nombre redivosite si et seulement si la valeur finale de N ' est un diviseur de N

Voici les 100 premiers numéros de redivosite (aucune entrée OEIS au moment de la publication):

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

Exemples

• N = 13 : 13 est premier, donc 13 n'est pas un nombre redivosite
• N = 32 : 32/2 + 3 = 19; 19 n'est pas un diviseur ou 32, donc 32 n'est pas un nombre redivosite
• N = 260 : 260/2 + 3 = 133, 133/7 + 8 = 27, 27/3 + 4 = 13; 13 est un diviseur ou 260, donc 260 est un nombre redivosite

Ta tâche

• Étant donné un entier N , renvoyer une valeur véridique s'il s'agit d'un nombre redivosite ou d'une valeur fausse sinon. (Vous pouvez également générer deux valeurs distinctes, tant qu'elles sont cohérentes.)
• L'entrée est garantie supérieure à 6 .
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte!

Haskell, 91 85 83 80 75 74 octets

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

Essayez-le en ligne!

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

Edit: -2 octets grâce à @BMO, -3 octets grâce à @ H.PWiz et -5 -6 octets grâce à @ Ørjan Johansen

Husk , 14 octets

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

Essayez-le en ligne!

-3 merci à H.PWiz .

C (gcc) , 94 89 octets

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

Essayez-le en ligne!

Explication

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

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça marche

ÆḌḊ         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 octets

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

Essayez-le en ligne!

Sorties via code de sortie.

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

Essayez-le en ligne!

05AB1E , 17 16 octets

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

Essayez-le en ligne!

Explication

[                  # 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 octets

<P_QiI.WtPHh+/ZKhPZK

Essayez-le ici!

Comment ça marche

iI.WtPHh + / ZKhPZK || Programme complet.

  .W || Fonctionnel tout en. Il prend deux fonctions comme arguments, A et B.
                 || Alors que A (valeur) est véridique, transformez la valeur en B (valeur). le
                 || la valeur de départ est l'entrée.
    tPH || Première fonction, A. Prend un seul argument, H.
     PH || .. Les facteurs premiers facteurs de H.
    t || .. Queue (retirer le premier élément). Bien que véridique (H est composite):
       h + / ZKhPZK || La deuxième fonction, B. Prend un seul argument, Z:
         / Z || .. Divisez Z, par:
           KhP || .. Son facteur premier le plus bas, et attribuez-le à K.   
       h || .. Incrément.
        + K || Et ajoutez K.
iI || Vérifiez si le résultat (dernière valeur) divise l'entrée.

Et les 4 premiers octets ( <P_Q) vérifient simplement si l'entrée n'est pas première.

Avec l'aide d' Emigna , j'ai réussi à économiser 3 octets.

Python 3 , 149 octets

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

Essayez-le en ligne!

Utiliser une approche par tamisage. Devrait être rapide ( O(N log log N)= complexité temporelle du tamis d'Eratosthène) même avec de grands N(mais stocke des O(N)entiers en mémoire)

Remarque:

• Il peut être prouvé que toutes les valeurs intermédiaires de nne dépassent pas Net N > 7 ppeuvent être au range(2,N)lieu de range(2,N+1)tamiser.
• /ne fonctionne pas, //doit être utilisé, en raison de l'index de liste.
• rangeMalheureusement, le stockage dans une autre variable n'aide pas.

Explication:

• -~N== N+1.
• Au début, le tableau sest initialisé avec des N+1zéros (Python est à 0 indexation, donc les indices le sont 0..N)
• Après l'initialisation, s[n]on s'attend à ce que 0if nsoit un nombre premier, et ppour ple nombre minimum premier qui se divise nsi nest un composite. s[0]et les s[1]valeurs ne sont pas importantes.

• Pour chacun pdans la gamme [2 .. N-1]:

  • Si s[p] < 1(c'est-à-dire s[p] == 0), alors pest un nombre premier, et pour chacun qétant un multiple de pet s[q] == 0, attribuez s[q] = p.

• Les 2 dernières lignes sont simples, sauf que n//s[n]-~s[n]== (n // s[n]) + s[n] + 1.

Python 3 , 118 octets

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

Essayez-le en ligne!

Au prix d'une performance légèrement pire. (Celui-ci s'exécute dans la O(N log N)complexité du temps, supposons une implémentation raisonnable des tranches Python)

Le programme complet équivalent est de 117 octets .

Haskell , 110 octets

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]

Essayez-le en ligne!

Pas très content ...

Octave , 92 octets

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

Essayez-le en ligne!

APL (Dyalog) , 50 octets

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

Essayez-le en ligne!

Japt, 25 24 octets

Je crains de ne pas être allé dans la bonne direction avec cela, mais je n'ai plus de temps pour essayer une approche différente.

Sorties 0pour faux ou 1pour vrai.

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

Essayez-le

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

Darn Perl pour ne pas avoir de vérificateur principal natif.

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

Version non golfée,

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 64 octets

Implémentation simple en utilisant le remplacement de modèle récursif

(le remplacement de "\ [Divides]" par le symbole "∣" économise 7 octets)

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

Essayez-le en ligne!

Propre , 128 117 114 octets

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

Essayez-le en ligne!

J , 35 octets

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

Essayez-le en ligne!

Le diviseur minimum étant le premier facteur premier a été volé à la solution @ Dennis's Jelly (que j'utilisais auparavant <./@q:).

Il devrait y avoir une meilleure façon de faire l'itération, mais je n'arrive pas à la trouver. J'ai pensé à éviter de faire le test de primalité ( ^:(0&p:)) et d'utiliser plutôt adverse, mais il semble que cela sera un peu plus long car vous aurez besoin d'un _2{et de quelques changements qui pourraient ne pas donner une réduction nette.

J'ai vraiment l'impression qu'il doit aussi y avoir un moyen d'éviter d'avoir des parens autour du contrôle de primalité.

Explication (développée)

(~: * 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

APL NARS, 43 caractères, 85 octets

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

(en espérant qu'il converge pour tous les nombres> 6) test:

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  

L'idée d'utiliser 2 fonctions anonymes me donne accès à une autre solution 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 octets

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

Voir le code ci-dessous pour une explication - les seules différences sont (1) que N est décrémenté avant pour tenir compte de l'incrémentation au début de la boucle, et (2) il utilise NOR au lieu de OR.

Essayez-le en ligne!

Je l'ai fait avant de relire la question et j'ai remarqué qu'il ne voulait qu'un vrai / faux.

Pyt, 52 octets

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

Imprime une liste infinie de nombres Redivosite.

Explication:

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)

Essayez-le en ligne!