Définitions

• Une bijection d'un ensemble Sà un ensemble Test une fonction de Sà Ttelle qu'un élément dans Test mappé par exactement un élément dans S.

• Une bijection dans un ensemble S est une bijection de Sà S.

• Les nombres naturels sont les entiers supérieurs ou égaux à 0.

• Un sous - ensemble d'un ensemble Sest un ensemble tel que chaque élément de l'ensemble se trouve également dans S.

• Un sous - ensemble correct d'un ensemble Sest un ensemble dont un sous-ensemble Sn'est pas égal à S.

Tâche

Écrivez un programme / une fonction qui prend un nombre naturel en entrée et génère un nombre naturel. Ce doit être une bijection, et l'image des nombres premiers sous le programme / fonction {f(p) : p ∈ ℙ}, doit être un sous-ensemble approprié de ℙ, où ℙsont les nombres premiers.

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte. Des échappatoires standard s'appliquent .

Mathematica, 54 48 octets

±(t=x_?PrimeQ)=NextPrime@x
±n_:=Abs[n-1]/.t:>x-1

Définit la bijection suivante:

 n  0, 1, 2, 3, 4, 5, 6,  7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, ...
±n  1, 0, 3, 5, 2, 7, 4, 11, 6, 8,  9, 13, 10, 17, 12, 14, 15, 19, ...

L'idée de base est de mapper chaque nombre premier au suivant, pour s'assurer qu'ils sont mappés à un sous-ensemble approprié. Il en résulte un «écart» à 2 . Pour combler cet écart, nous voulons mapper 4 à 2 , puis chaque autre nombre composite au nombre composite précédent, pour «faire bouillonner» l'écart. Puisque 2 et 3 sont les deux seuls nombres premiers adjacents, nous pouvons exprimer ces deux correspondances comme " n-1 ou si c'est un nombre premier alors n-2 ". Enfin, ce mappage finit par envoyer 1 à 0 et nous lui faisons renvoyer 0 à 1 en prenant la valeur absolue de n-1 .

MATL , 21 octets

Merci à Emigna d' avoir repéré une erreur, maintenant corrigée

tZp?_Yq}q:Zp~fX>sG~E+

Essayez-le en ligne!

Cela implémente la bijection suivante. Écrivez les nombres premiers consécutifs et les nombres non premiers ci-dessous:

2  3  5  7 11 13 17 ...
0  1  4  6  8  9 10 ...

Ensuite, la sortie est obtenue en suivant la flèche de l'entrée:

2 > 3 > 5 > 7 > 11 > 13 > 17 ...
^
0 < 1 < 4 < 6 <  8 <  9 < 10 ...

Code expliqué

t       % Implicit input. Duplicate
Zp      % Is it a prime? Gives true / false
?       % If so
  _Yq   %   Next prime
}       % Else
  q     %   Subtract 1
  :     %   Range from 1 to that
  Zp~   %   Is each entry not a prime? Gives an array of true / false
  f     %   Find non-zero entries, i.e. non-primes. Will be empty for input 1
  X>    %   Maximum. This gives the greatest non-prime less than the input.
        %   Will be empty for input 1
  s     %   Sum. This is to transform empty into 0
  G~E   %   Push input, negate, times 2. This gives 2 for input 0, or 0 otherwise
  E     %   Add. This handles the case of input 0, so that it outputs 2
        % End (implicit). Display (implicit)

Gelée , 14 octets

Æn’’ÆP¿$ÆP?2¹?

Essayez-le en ligne!

Utilise l'algorithme de Luis.

JavaScript (ES6), 82 77 75 octets

Implémente la même logique que la réponse de Luis Mendo .

f=(n,i=(P=(n,x=n)=>n%--x?P(n,x):x==1||-1)(x=n))=>x?x==n|P(n)-i?f(n+i,i):n:2

Formaté et commenté

f = (                   // given:
  n,                    // - n = input
  i =                   // - i = 'direction' to move towards
    (P = (n, x = n) =>  // - P = function that returns:
      n % --x ?         //   - 1 when given a prime
        P(n, x)         //   - -1 when given a composite number
      :                 //
        x == 1 || -1    //
    )(x = n)            // - x = copy of the original input
) =>                    //
  x ?                   // if the input is not zero:
    x == n | P(n) - i ? //   if n equals the input or doesn't match its primality:
      f(n + i, i)       //     do a recursive call in the chosen direction
    :                   //   else:
      n                 //     return n
  :                     // else:
    2                   //   return 2

Démo

f=(n,i=(P=(n,x=n)=>n%--x?P(n,x):x==1||-1)(x=n))=>x?x==n|P(n)-i?f(n+i,i):n:2

for(n = 0; n < 50; n++) {
  console.log(n, '->', f(n));
}

Gelée , 12 octets

Æn_ḍ@¡ÆP?2»0

Essayez-le en ligne!

Comment ça fonctionne

Æn_ḍ@¡ÆP?2»0  Main link. Argument: n (non-negative integer)

      ÆP?     If the input is prime:
Æn                Compute the next prime after n.
              Else:
   ḍ@¡   2        Do once if n is divisible by 2, zero times if not.
  _      2        Subtract 2.
              So far, we've mapped all primes to the next prime, all even integers
              (except 2) to the previous even integer, and all composite, odd,
              positive integers to themselves. In particular, 0 -> 2, but 0 doesn't
              have a preimage, so we need 0 -> 0.
          »0  Take the maximum of the result and 0, mapping 0 -> max(-2, 0) = 0.