definizioni

• Un biiezione da un insieme Sad un insieme Tè una funzione da Sa Ttale che un elemento Tè mappato da esattamente un elemento S.

• Una biiezione all'interno di un set S è una biiezione da Sa S.

• I numeri naturali sono numeri interi che sono maggiori o uguali a 0.

• Un sottoinsieme di un set Sè un set in modo tale che anche ogni elemento nel set sia presente S.

• Un sottoinsieme proprio di un insieme Sè un insieme di Scui non è uguale S.

Compito

Scrivi un programma / funzione che accetta un numero naturale come input e genera un numero naturale. Deve essere una biiezione e l'immagine dei numeri primi nel programma / funzione {f(p) : p ∈ ℙ}deve essere un sottoinsieme proprio di ℙ, dove ℙsono i numeri primi.

punteggio

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

Mathematica, 54 48 byte

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

Definisce la seguente biiezione:

 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'idea di base è mappare ciascun numero primo con il successivo, per assicurarsi che siano mappati su un sottoinsieme corretto. Ciò si traduce in un "gap" a 2 . Per riempire quel vuoto, vogliamo mappare da 4 a 2 e poi ogni altro numero composto al precedente numero composto, per " riempire " il vuoto. Poiché 2 e 3 sono gli unici due numeri primi adiacenti, possiamo esprimere entrambi questi mapping come " n-1 o se è un numero primo allora n-2 ". Infine, questa mappatura finisce per inviare da 1 a 0 e facciamo in modo che restituisca 0 a 1 prendendo il valore assoluto di n-1 .

MATL , 21 byte

Grazie a Emigna per aver individuato un errore, ora corretto

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

Provalo online!

Questo implementa la seguente biiezione. Scrivi i numeri primi di seguito e i non primi di seguito:

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

Quindi l'output si ottiene seguendo la freccia dall'input:

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

Codice spiegato

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)

Gelatina , 14 byte

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

Provalo online!

Utilizza l'algoritmo di Luis.

JavaScript (ES6), 82 77 75 byte

Implementa la stessa logica della risposta di 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

Formattato e commentato

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

dimostrazione

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

Gelatina , 12 byte

Æn_ḍ@¡ÆP?2»0

Provalo online!

Come funziona

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