Il tuo compito qui sarà quello di implementare una funzione ¹ che forma una permutazione sugli interi positivi (una biiezione dagli interi positivi su se stessi). Ciò significa che ogni numero intero positivo dovrebbe apparire esattamente una volta nella permutazione. Il trucco è che la tua funzione dovrebbe avere una maggiore probabilità di emettere un numero dispari rispetto a un numero pari.

Ora questo può sembrare strano o impossibile. Sicuramente ci sono tanti numeri dispari quanti numeri pari? E mentre questa intuizione è corretta per insiemi finiti, in realtà non vale per insiemi infiniti. Ad esempio, prendi la seguente permutazione:

1 3 2 5 7 4 9 11 6 13 15 8 17 19 10 21 23 12 25 27 14 29 31 16 33 35 18 37 39 20 41 43 22 45 47 24 49 51 26 53 55 ...

Se prendi una sottosezione della sequenza con dimensioni maggiori di $1$ avrai almeno tanti numeri dispari quanti numeri pari, quindi la probabilità che un termine casuale sia dispari è maggiore di quella di essere pari. Noterai anche che ogni numero pari o dispari apparirà alla fine nella sequenza e può apparire solo una volta. Quindi la sequenza è una vera permutazione.

Definizione di probabilità

Per evitare confusione o ambiguità, esporrò chiaramente cosa si intende per probabilità in questa domanda.

Diciamo che abbiamo una funzione $f$ . La probabilità che un numero sia dispari sarà definita come il limite del rapporto tra i membri dispari dell'insieme e la dimensione dell'insieme $f\{1\dots n\}$ come $n$ tende all'infinito.

Ad esempio la suddetta funzione avrebbe una probabilità di essere dispari di $2/3$ .

Questo è code-golf, quindi le risposte verranno classificate in byte con meno byte migliori.

Sfide extra

Ecco alcune idee divertenti con cui giocare e forse provare a implementare. Questi sono solo per divertimento e non influiscono in alcun modo sul punteggio. Alcune di queste non sono nemmeno valide soluzioni a questa sfida e una risposta che include solo soluzioni alle sfide 2 o 3 non è una risposta valida ed è suscettibile di essere eliminata .

• Scrivi una permutazione con una probabilità dispari di . (questo è possibile)$1$

• Scrivi una permutazione che ha più numeri dispari di numeri pari in per qualsiasi ma ha una probabilità dispari di .$f\{1\dots n\}$$n$$1/2$

• Scrivi una permutazione che non ha una probabilità definita (ovvero che non esiste un limite).

^{1: Qui funzione significa programma o funzione. È solo un pezzo di codice che accetta input e produce output.}

Gelatina , 7 byte

Æf^<¥4P

Swap 2 s e 3 s in primo fattorizzazione dell'ingresso. La probabilità di probabilità è di 2/3 .

Provalo online!

Come funziona

Æf^<¥4P  Main link. Argument: n

Æf       Compute all prime factors of n, with duplicates.
    ¥4   Combine the two links to the left into a dyadic chain and call it with
         right argument 4.
   <       Compare each prime factor with 4. Yields 1 for 2 and 3, 0 otherwise.
  ^        Bitwise XOR the results with the corresponding prime factors.
         This maps 2 to 3, 3 to 2, and all other primes to themselves.
      P  Take the product of the resulting primes.

Buccia , 11 10 byte

-1 byte grazie a Leo e una funzione leggermente diversa

Questa ha una probabilità strana di 1

!uΣz:NCNİ1

Provalo online!

Indica la sequenza:

[1,2,3,5,7,9,11,4,13,15,17,19,21,23,25,27,29,6,31,33]
1 odd, 1 even, 5 odd, 1 even, 9 odd, 1 even, 13 odd...

Spiegazione

!               Index the following sequence (1-indexed)
 u              remove duplicates                     [1,2,3,5,7,9,11,4,13,15...]
  Σ              Concatenate                          [1,1,2,3,5,3,7,9,11,4,13..]
   z:            Zipwith append                       [[1,1],[2,3,5],[3,7,9,11]..
     N          Natural numbers
      CNİ1      Odd numbers cut into lists of lengths [[1],[3,5],[7,9,11]...]
                corresponding to the Natural numbers

Haskell, 35 34 32 byte

f n=n:2*n+1:2*n+3:f(n+2)
(f 0!!)

Implementa la sequenza di esempio [1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...].

Provalo online!

Per riferimento: versione precedente, 34 byte (-1 byte grazie a @xnor):

(!!)$do e<-[0,2..];[e,2*e+1,2*e+3]

Provalo online!

Buccia , 8 byte

!uΣzeİ1N

Provalo online!

Questo implementa la sequenza di esempio ( 1,3,2,5,7,4...).

Spiegazione

!uΣzeİ1N
   ze       zip together
     İ1       the odd numbers
       N      with the natural (positive) numbers
  Σ         flatten the resulting list
 u          remove duplicates
!           index into the obtained sequence with the input

Tutti sfidano 1, quindi facciamo gli altri due.

Perl 6 , 26 byte - Sfida 2

{($_==1)+$_-(-1)**($_%%2)}

Provalo online!

È solo 1 3 2 5 4 7 6...in un numero pari di termini, ci sono sempre 2 numeri dispari in più rispetto a pari. In un numero dispari, 1 altro. Tuttavia, questo ha chiaramente un limite di (n+2)/(2n+2) -> ½.

Perl 6 , 70 byte - Sfida 3

{((1,),(2,4),->@a,@ {@(map(@a[*-1]+2*(*+1),^(4*@a)))}...*).flat[$_-1]}

Provalo online!

Certo, questo è orribilmente giocato a golf. Indicizza una sequenza che contiene 2⁰ numeri dispari, quindi 2¹ pari, quindi 2² dispari, quindi 2³ pari e così via.

La probabilità dopo n di tali "blocchi", se n è dispari, è (2⁰ + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ-1). La somma nel numeratore è uguale a ⅓ (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1). Quindi la probabilità dopo un numero dispari di blocchi è ⅔ (nel limite).

Se aggiungiamo un altro blocco (e ne segniamo un conteggio pari n + 1), tuttavia, non aggiungiamo numeri dispari (il numeratore rimane lo stesso) ma ora ci sono (2 ^{n + 1} - 1) numeri in totale . Le parentesi si annullano e si ottiene la probabilità di ⅓ (nel limite).

Apparentemente si suppone che questo abbia 2 punti cluster diversi, ⅓ e ⅔, per assicurarsi che il limite non esista, ma questo non lo dimostra. Il mio tentativo di fare una prova solida e rigorosa può essere trovato in questa risposta Math.SE: https://math.stackexchange.com/a/2416990/174637 . Accettare errori è il benvenuto.

Perl 6 , 39 byte - La sfida principale.

{my$l=$_ div 3;$_%3??2*($_-$l)-1!!2*$l}

Provalo online!

Anche se ho pubblicato questa risposta a causa delle sfide 2 e 3 che offrivano un piacevole piccolo rompicapo, è necessario che tutte le risposte contengano una soluzione alla sfida principale. Eccolo allora.

Questa è la sequenza di esempio.

Brain-Flak , 120 byte

(({})<{{({}[()]<({}(()[{}]))>)}{}({}[({})]<({}<>{}<({}())>)><>)}>)<>({}[()]){{}((<>{}<>[{}]){}[()])<>}{}{(({}){})<>{}}<>

Provalo online!

Svolge la seguente funzione:

Questa funzione genera la sequenza

2 4 1 6 3 5 7 8 9 11 13 15 17 19 21 10 23 25 27 29...

La funzione ha una probabilità dispari di 1

R, 82 byte (sfida aggiuntiva 1)

f<-function(n){if(sqrt(n)==floor(sqrt(n))){2*sqrt(n)}else{2*(n-floor(sqrt(n)))-1}}

Provalo online!

Se l'input è un quadrato perfetto, fornisce un numero pari. Altrimenti, dà un numero dispari. I quadrati perfetti hanno una densità naturale 0, il che significa che questa sequenza fornisce numeri dispari con probabilità 1.

C (gcc) , 29 byte

f(n){return n&3?n+n/2|1:n/2;}

Provalo online!

Ogni quarto numero è pari:

1 3 5   7 9 11   13 15 17   19 21 23   25 27 29
      2        4          6          8          10

Sfida extra 1, 52 byte

f(n,i){for(i=0;n>>i/2;i+=2);return n&n-1?2*n-i-1:i;}

Provalo online!

Restituisce 2 * (x + 1) se n è uguale a 2 ^x e numeri dispari consecutivi altrimenti:

    1   3 5 7   9 11 13 15 17 19 21    23 25
2 4   6       8                     10      

Brain-Flak , 140 138 136 byte

({}<(((()())()()))((<>[()])[()()])>){({}[()]<(({}(({}({}))[({}[{}])]))[({}[{}])]<>(({}(({}({}))[({}[{}])]))[({}[{}])])<>)>)}{}({}<{}{}>)

Provalo online!

Spiegazione

Ciò svolge una funzione simile a quella suggerita nella domanda.

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

Funziona principalmente basato su uno snippet che ho creato per arrotolare la pila per pile di dimensioni 3.

(({}(({}({}))[({}[{}])]))[({}[{}])])

Abbiamo impostato due pile una con i valori dell'accumulatore (due dispari uno pari) e una con i numeri 4 4 2. Ogni iterazione facciamo rotolare entrambe le pile e aggiungiamo la parte superiore della pila sinistra alla cima della pila destra.

(({}(({}({}))[({}[{}])]))[({}[{}])]<>(({}(({}({}))[({}[{}])]))[({}[{}])])<>)

Questo aumenterà ogni numero dispari di 4 e l'unico numero pari di 2. Man mano che passiamo attraverso, otteniamo uno schema di 2 pari dispari, con ogni numero intero positivo che viene colpito. Quindi abbiamo solo dei ntempi in loop con nl'input. Ciò ha una probabilità asintotica di 2/3 .

Gelatina , 10 byte

ÆE;0ṭ2/FÆẸ

La probabilità di probabilità è di 2/3 .

Provalo online!

Come funziona

ÆE;0ṭ2/FÆẸ  Main link. Argument: n

ÆE          Compute the exponents of n's prime factorization.
  ;0        Append a 0.
     2/     Reduce all pairs by...
    ṭ         tack, appending the left argument to the right one.
            This inverts all non-overlapping pairs of exponents.
       F    Flatten the result.
        ÆẸ  Consider the result a prime factorization and compute the corresponding
            integer.

C, 80 byte

#define R if(k++==n)return
i,j,k;f(n){for(i=k=1,j=2;;i+=4,j+=2){R i;R i+2;R j;}}

Implementazione della permutazione di esempio dalla domanda.

Provalo online!

Lotto, 36 byte

@cmd/cset/an=%1*2,(-~n*!!(n%%3)+n)/3

Implementa la sequenza indicata nella domanda.

JavaScript, 23 byte

n=>n/2+n/2%2+(n%4&&n-1)

Uscita: 1, 3, 5, 2, 7, 9, 11, 4, 13, 15, 17, 6, 19, 21, 23, 8 ...

• Per tutti n = 4k:
  • f (n) = n / 2 = 2k
• Per tutti n = 4k + b
  • f (n) = n / 2 + b / 2 + n - 1 = 3/2 * (4k + b) + 1/2 * b - 1 = 6k + 2b - 1

Sfida 2:

n=>n^(n>1)

Uscita: 1, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14

CJam (21 byte)

{2b_(&!\_,2*\1$~+2b?}

Demo online che mostra i primi 32 output. Questo è un blocco anonimo (funzione).

Questa è anche una soluzione per sfidare 1: i numeri associati ai numeri pari sono i poteri di 2, quindi la densità dei numeri pari nelle prime n uscite è lg (n) / n che tende a zero.

Dissezione

{         e# Declare a block; let's call the input x
  2b      e#   Convert to base 2
  _(&     e#   Copy, pull out first digit (1) and set intersection with rest
  !       e#   Boolean not, so empty set (i.e. power of 2) maps to 1 and non-empty
          e#   to 0
  \_,2*   e#   Take another copy, find its length, and double it
  \1$~+   e#   Take the original base 2 array and append ~(2L) = -2L-1
  2b      e#   Convert from base 2, to get 2x-2L-1
  ?       e#   Take the 2L if it was a power of 2, and the 2x-2L-1 otherwise
}

Perl 40 byte

$,=$";$i=4;{say$i-3,$i/2,($i+=4)-5;redo}

Brain-Flueue , 88 byte

({}<(((<>)[()])[()()])>)<>(((()())()()))<>{({})({})({})({}[()]<({}<>({})<>)>)}{}{}({}){}

Provalo online!

Spiegazione

Questo implementa la stessa funzione della mia ultima risposta, ma usa il modello FIFO di Brain-Flueue per tagliare alcuni angoli. Ecco i primi termini di coppia che genera.

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

La prima parte del codice è solo un po 'di installazione, mettiamo 0,-1,-3sul primo stack e 2,4,4sul secondo stack. La 2,4,4saranno utilizzati per passare da numeri pari e dispari proprio come ho fatto nella mia risposta Brain-Flak.

Quindi eseguiamo il ciclo n volte, aggiungendo ogni volta la parte superiore della pila a sinistra alla pila a destra. Poiché Brain-Flueue utilizza le code anziché impilare i valori naturalmente rotolano quando li tocchiamo impedendo la necessità di un codice aggiuntivo.

Python 2 , 46 104 55 byte

lambda n:2*((n-int(n**.5))+.5,n**.5-1)[n!=1>0==n**.5%1]

Provalo online!

Ho letto male la domanda, ora implementata correttamente una funzione che può essere utilizzata per generare una sequenza invece di una che genera una sequenza. Inoltre escluso 0dall'insieme delle possibili uscite.

La probabilità di trovare un numero intero dispari positivo ora converge in 1.

Gelatina , 9 byte

Ḥ€’ĖUẎQ⁸ị

Provalo online!

Attrezzi 1, 3, 2, 5, 7, 4, 9, 11, 6, ...(probabilità 2/3).

05AB1E , 11 byte

·ÅÉā‚ø˜Ù¹<è

Provalo online!

Pyth , 9 byte

*Fmxd<d4P

Provalo qui! o prova di più in una volta sola!

È possibile utilizzare questo codice per verificare il rapporto tra numeri dispari fino a un certo punto. Sostituisci 10000con il limite desiderato (non impostarlo molto più alto, perché errori di memoria).

Km*Fmxk<k4PdS10000clf%T2KlK

Provalo qui .

Quanto sopra dà circa 0,667 . La vera probabilità di eventi dispari è di 2/3 . Questo approccio è un'implementazione equivalente della risposta di Dennis .

Spiegazione

*Fmxd<d4P   Full program.

        P   Prime factors.
  m         Map over ^.
   x        Bitwise XOR between:
    d          The current prime factor.
     <d4       The integer corresponding to the boolean value of current factor < 4.
*F          Product of the list.

Java 8, 20 byte

n->n%4>0?n+n/2|1:n/2

Risposta C del porto di @nwellnhof .
Alcune cose che ho provato sono finite per essere qualche byte più lunghe o leggermente errate.

Attrezzi: 1,3,5,2,7,9,11,4,13,15,17,6,19,21,23,8,25,27,29,10,31,33,35,12,37,...
con una probabilità di 3/4.

Provalo qui.

Lua, 67 53 byte

Spiegazione in arrivo quando ho finito di giocare a golf :)

Questo programma accetta un numero intero tramite argomenti della riga di comando come input e stampa l'ennesimo elemento della sequenza di esempio su STDOUT

n=...print(n%3<1 and n/3*2or n+math.floor(n/3)+n%3-1)

spiegazioni

n=...                              -- shorthand for the argument
print(                             -- prints out the result of the following ternary
     n%3<1                         -- if n is divisible by 3
       and n/3*2                   -- prints out the corresponding even number
       or n+math.floor(n/3)+n%3-1) -- else prints out the odd number

I numeri pari di questa sequenza sono sia il nnumero pari che il nmultiplo di 3, quindi la formula n%3*2è sufficiente per generarli.

Per i numeri dispari, è un po 'più difficile. Sulla base del fatto che possiamo trovarli a seconda della corrente n, abbiamo la seguente tabella:

n       |  1   2   4   5   7   8   10   11  
target  |  1   3   5   7   9   11  13   15
target-n|  +0  +1  +1  +2  +2  +3  +3   +4

Chiamiamo il valore target-n i, possiamo vederlo ogni volta n%3==2, iviene incrementato. Ecco la nostra formula:

n+math.floor(n/3)+n%3-1

I numeri dispari si basano nsu cui aggiungiamo i.

Il valore degli iincrementi alla stessa velocità della divisione euclidea di 3, con un offset. math.floor(n/3)ci dà il tasso di incremento e n%3-1ci dà l'offset, facendolo accadere n%3==2invece di n%3==0.