Votre tâche ici sera de mettre en oeuvre une fonction ¹ qui forme une permutation sur les entiers positifs (une bijection des entiers positifs sur eux-mêmes). Cela signifie que chaque entier positif doit apparaître exactement une fois dans la permutation. La capture est votre fonction devrait avoir une plus grande probabilité de sortir un nombre impair qu'un nombre pair.

Maintenant, cela peut sembler étrange ou impossible. Il y a sûrement autant de nombres impairs que de nombres pairs? Et, bien que cette intuition soit correcte pour des ensembles finis, elle ne tient pas pour des ensembles infinis. Par exemple, prenons la permutation suivante:

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

Si vous prenez une sous-section de la suite dont la taille est supérieure à vous aurez au moins autant de nombres impairs que de nombres pairs; il semble donc que la probabilité qu'un terme aléatoire soit impair est supérieure à celle d'être pair. Vous noterez également que chaque nombre pair ou impair apparaîtra dans la séquence et ne peut apparaître qu'une seule fois. Ainsi, la séquence est une vraie permutation.$1$

Définition de probabilité

Pour éviter toute confusion ou ambiguïté, je vais expliquer clairement ce que l’on entend par probabilité dans cette question.

Disons que nous avons une fonction . La probabilité qu'un nombre soit impair sera définie comme la limite du ratio membres impairs de l'ensemble à la taille de l'ensemble car tend vers l'infini.$f$$f\{1\dots n\}$$n$

Par exemple, la fonction susmentionnée aurait une probabilité d'être impair de $2/3$ .

C'est un code-golf, donc les réponses seront notées en octets, moins d'octets étant meilleurs.

Défis supplémentaires

Voici quelques idées amusantes à jouer et peut-être à essayer de mettre en œuvre. Ce sont juste pour le plaisir et n'affectent en aucune façon la notation. Certaines d'entre elles ne constituent même pas des solutions valables à ce défi, et une réponse qui ne comprend que des solutions aux défis 2 ou 3 n'est pas une réponse valable et est susceptible d'être supprimée .

• Écris une permutation avec une probabilité étrange de $1$ . (c'est possible)

• Ecrivez une permutation qui a plus de nombres impairs que de nombres pairs dans pour tout mais qui a une probabilité impaire de .$f\{1\dots n\}$$n$$1/2$

• Écris une permutation qui n’a pas de probabilité définie (c’est-à-dire qu’il n’ya pas de limite).

^{1: Ici, fonction signifie programme ou fonction. C'est juste un morceau de code qui prend une entrée et produit une sortie.}

Gelée , 7 octets

Æf^<¥4P

Échange 2 s et 3 s dans la factorisation première de l'entrée. La probabilité de probabilité est de 2/3 .

Essayez-le en ligne!

Comment ça marche

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

Husk , 11 à 10 octets

-1 octet grâce à Leo et une fonction légèrement différente

Cela a une probabilité étrange de 1

!uΣz:NCNİ1

Essayez-le en ligne!

Il indexe la séquence:

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

Explication

!               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 octets

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

Implémente la séquence d'exemple [1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...].

Essayez-le en ligne!

Pour référence: ancienne version, 34 octets (-1 octet grâce à @xnor):

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

Essayez-le en ligne!

Coque , 8 octets

!uΣzeİ1N

Essayez-le en ligne!

Ceci implémente l'exemple de séquence ( 1,3,2,5,7,4...).

Explication

!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

Tout le monde fait le défi 1, alors faisons les deux autres.

Perl 6 , 26 octets - Challenge 2

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

Essayez-le en ligne!

C'est juste 1 3 2 5 4 7 6...Dans un nombre pair de termes, il y a toujours 2 plus de nombres impairs que pairs. Dans un nombre impair, 1 de plus. Cependant cela a clairement limite de (n+2)/(2n+2) -> ½.

Perl 6 , 70 bytes - Challenge 3

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

Essayez-le en ligne!

Certes, c'est horriblement joué au golf. Il indexe une séquence qui contient 2⁰ nombres impairs, puis 2¹ pairs, puis 2² impairs, puis 2³ pairs et ainsi de suite.

La probabilité après n de tels "blocs", si n est impair, est de (2⁰ + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ-1). La somme au numérateur est égale à ⅓ (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1). Donc, la probabilité après le nombre impair de blocs est (dans la limite).

Si nous ajoutons un bloc supplémentaire (et en comptons un nombre pair n + 1), nous n’ajoutons aucun nombre impair (le numérateur reste identique), mais il y a maintenant (2 ^{n + 1} - 1) nombres au total. . Les parenthèses s'annulent et nous obtenons la probabilité de (dans la limite).

Ceci est apparemment supposé avoir 2 points de cluster différents, et ⅔, pour s'assurer que la limite n'existe pas, mais cela ne le prouve pas vraiment. Ma tentative de réaliser une preuve solide et rigoureuse se trouve dans cette réponse de Math.SE: https://math.stackexchange.com/a/2416990/174637 . Les erreurs sont bienvenues.

Perl 6 , 39 octets - Le principal défi.

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

Essayez-le en ligne!

Bien que j’ai posté cette réponse en raison des défis 2 et 3 qui offraient un joli petit casse-tête mathématique, il est impératif que toutes les réponses contiennent une solution au défi principal. La voici alors.

Ceci est la séquence d'exemple.

Brain-Flak , 120 octets

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

Essayez-le en ligne!

Effectue la fonction suivante:

Cette fonction génère la séquence

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

La fonction a une probabilité étrange de 1

R, 82 octets (défi supplémentaire 1)

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

Essayez-le en ligne!

Si l'entrée est un carré parfait, donne un nombre pair. Sinon, donne un nombre impair. Les carrés parfaits ont une densité naturelle de 0, ce qui signifie que cette séquence donne des nombres impairs avec une probabilité de 1.

C (gcc) , 29 octets

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

Essayez-le en ligne!

Chaque chiffre est pair:

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

Défi supplémentaire 1, 52 octets

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

Essayez-le en ligne!

Retourne 2 * (x + 1) si n est égal à 2 ^x et des nombres impairs consécutifs sinon:

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

Brain-Flak , 140 138 136 octets

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

Essayez-le en ligne!

Explication

Cela remplit une fonction similaire à celle suggérée dans la question.

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

Cela fonctionne principalement sur un extrait que j'ai fait rouler la pile pour les piles de taille 3.

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

Nous configurons deux piles, l’une avec les valeurs d’accumulateur (deux impaires paires) et l’autre avec les nombres 4 4 2. A chaque itération, nous lançons les deux piles et ajoutons le haut de la pile de gauche au sommet de la pile de droite.

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

Cela incrémentera chaque nombre impair de 4 et le nombre pair de 2. En effectuant une boucle, nous obtenons un motif de 2 impairs pairs, avec chaque entier positif touché. Ainsi, nous ne faisons que boucler les ntemps avec nl’entrée. Cela a une probabilité asymptotique de 2/3 .

Gelée , 10 octets

ÆE;0ṭ2/FÆẸ

La probabilité de probabilité est de 2/3 .

Essayez-le en ligne!

Comment ça marche

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

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

Mise en œuvre de l'exemple de permutation de la question.

Essayez-le en ligne!

Lot, 36 octets

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

Implémente la séquence donnée dans la question.

JavaScript, 23 octets

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

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

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

Défi 2:

n=>n^(n>1)

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

CJam (21 octets)

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

Démo en ligne montrant les 32 premières sorties. Ceci est un bloc anonyme (fonction).

C'est également une solution pour relever le défi 1: les nombres mappés en nombres pairs sont les puissances de 2, de sorte que la densité des nombres pairs dans les n premières sorties est lg (n) / n, ce qui tend à zéro.

Dissection

{         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 octets

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

Brain-Flueue , 88 octets

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

Essayez-le en ligne!

Explication

Ceci implémente la même fonction que ma dernière réponse mais utilise le modèle FIFO de Brain-Flueue pour couper certains coins. Voici le premier couple de termes qu’il génère.

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

La première partie du code est juste un peu d’installation, nous mettons 0,-1,-3la première pile et 2,4,4la deuxième pile. Le 2,4,4sera utilisé pour parcourir les nombres pairs et impairs, exactement comme je l’ai fait dans ma réponse Brain-Flak.

On boucle ensuite n fois, en ajoutant chaque fois le haut de la pile de gauche à la pile de droite. Étant donné que Brain-Flueue utilise les files d'attente plutôt que les piles, les valeurs se déroulent naturellement lorsque nous les touchons, ce qui évite d'avoir besoin de code supplémentaire.

Python 2 , 46 104 55 octets

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

Essayez-le en ligne!

A mal interprété la question, elle a correctement implémenté une fonction qui peut être utilisée pour générer une séquence au lieu de celle qui en génère une. Également exclu 0de l'ensemble des sorties possibles.

La probabilité de trouver un entier positif impair converge maintenant vers 1.

Gelée , 9 octets

Ḥ€’ĖUẎQ⁸ị

Essayez-le en ligne!

Implements 1, 3, 2, 5, 7, 4, 9, 11, 6, ...(probabilité 2/3).

05AB1E , 11 octets

·ÅÉā‚ø˜Ù¹<è

Essayez-le en ligne!

Pyth , 9 octets

*Fmxd<d4P

Essayez-le ici! ou testez plus d'un coup!

Vous pouvez utiliser ce code pour vérifier le rapport des nombres impairs jusqu'à un certain point. Remplacez 10000par la limite souhaitée (ne la définissez pas beaucoup plus haut, car cela entraînerait des erreurs de mémoire).

Km*Fmxk<k4PdS10000clf%T2KlK

Essayez ici .

Ce qui précède donne environ 0,667 . La probabilité réelle d’occurrences impaires est de 2/3 . Cette approche est une implémentation équivalente de la réponse de Dennis .

Explication

*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 octets

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

Réponse C du port de @nwellnhof .
Certaines choses que j'ai moi-même essayées ont fini par être plus longues ou légèrement incorrectes.

Implémente: 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,...
avec une probabilité de 3/4.

Essayez ici.

Lua, 67 53 octets

Explication à venir quand j'ai fini de jouer au golf :)

Ce programme prend en entrée un entier via des arguments de ligne de commande et affiche le nième élément de la séquence exemple dans STDOUT.

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

Des explications

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

Les nombres pairs de cette séquence sont à la fois le nnombre pair et le nmultiple de 3, la formule n%3*2suffit donc à les générer.

Pour les nombres impairs, c'est un peu plus difficile. Basé sur le fait que nous pouvons les trouver en fonction du courant n, nous avons le tableau suivant:

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

Appelons la valeur target-n i, nous pouvons voir que chaque fois n%3==2, iest incrémenté. Voilà notre formule:

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

Les nombres impairs sont basés nsur ceux que nous ajoutons i.

La valeur des iincréments au même taux que la division euclidienne de 3, avec un décalage. math.floor(n/3)nous donne le taux d'incrément et n%3-1le décalage, ce qui permet de le faire n%3==2au lieu de n%3==0.