Ihre Aufgabe hier ist es, eine Funktion ¹ zu implementieren , die eine Permutation auf die positiven Ganzzahlen bildet (eine Bijektion von den positiven Ganzzahlen auf sich selbst). Dies bedeutet, dass jede positive Ganzzahl in der Permutation genau einmal vorkommen sollte. Der Haken ist, dass Ihre Funktion eine größere Wahrscheinlichkeit haben sollte, eine ungerade Zahl als eine gerade Zahl auszugeben.

Nun mag dies seltsam oder unmöglich erscheinen. Sicher gibt es genauso viele ungerade Zahlen wie gerade Zahlen? Und während diese Intuition für endliche Mengen korrekt ist, gilt sie tatsächlich nicht für unendliche Mengen. Nehmen Sie zum Beispiel die folgende Permutation:

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

Wenn Sie einen Unterabschnitt der Sequenz mit einer Größe größer als Sie mindestens so viele ungerade Zahlen wie gerade Zahlen haben, so dass die Wahrscheinlichkeit, dass ein zufälliger Ausdruck ungerade ist, größer ist als die Wahrscheinlichkeit, dass er gerade ist. Sie werden auch feststellen, dass jede ungerade oder gerade Zahl irgendwann in der Sequenz erscheint und nur einmal vorkommen kann. Somit ist die Sequenz eine echte Permutation.$1$

Definition der Wahrscheinlichkeit

Um Unklarheiten oder Unklarheiten zu vermeiden, werde ich deutlich machen, was mit Wahrscheinlichkeit in dieser Frage gemeint ist.

Nehmen wir an, wir haben eine Funktion . Die Wahrscheinlichkeit, dass eine Zahl ungerade ist, wird als die Grenze des Verhältnisses ungerader Elemente der Menge zur Größe der Menge da gegen unendlich tendiert.$f$$f\{1\dots n\}$$n$

Zum Beispiel würde die oben erwähnte Funktion eine Wahrscheinlichkeit von haben, ungerade zu sein .$2/3$

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Zusätzliche Herausforderungen

Hier einige lustige Ideen, mit denen Sie herumspielen und vielleicht versuchen können, sie umzusetzen. Diese dienen nur zum Spaß und haben keinerlei Einfluss auf die Wertung. Einige davon sind nicht einmal gültige Lösungen für diese Herausforderung, und eine Antwort, die nur Lösungen für die Herausforderungen 2 oder 3 enthält, ist keine gültige Antwort und kann gelöscht werden .

• Schreiben Sie eine Permutation mit einer ungeraden Wahrscheinlichkeit von . (Das ist möglich)$1$

• Schreiben Sie eine Permutation mit mehr ungeraden als geraden Zahlen in für jedes aber einer ungeraden Wahrscheinlichkeit von .$f\{1\dots n\}$$n$$1/2$

• Schreiben Sie eine Permutation ohne definierte Wahrscheinlichkeit (dh es gibt kein Limit).

^{1: Funktion bedeutet hier Programm oder Funktion. Es ist nur ein Teil des Codes, der Eingaben entgegennimmt und Ausgaben erzeugt.}

Gelee , 7 Bytes

Æf^<¥4P

Vertauscht 2 s und 3 s in der Primfaktor-Faktorisierung des Eingangs. Die Wahrscheinlichkeit einer Quote beträgt 2/3 .

Probieren Sie es online!

Wie es funktioniert

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

Schale , 11 bis 10 Bytes

-1 Byte dank Leo und einer etwas anderen Funktion

Dies hat eine merkwürdige Wahrscheinlichkeit von 1

!uΣz:NCNİ1

Probieren Sie es online!

Es indiziert die Sequenz:

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

Erläuterung

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

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

Implementiert die Beispielsequenz [1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...].

Probieren Sie es online!

Als Referenz: alte Version, 34 Bytes (-1 Bytes dank @xnor):

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

Probieren Sie es online!

Schale , 8 Bytes

!uΣzeİ1N

Probieren Sie es online!

Dies implementiert die Beispielsequenz ( 1,3,2,5,7,4...).

Erläuterung

!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

Jeder macht Challenge 1, also machen wir die anderen beiden.

Perl 6 , 26 Bytes - Herausforderung 2

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

Probieren Sie es online!

Es ist nur 1 3 2 5 4 7 6...in einer geraden Anzahl von Begriffen, gibt es immer 2 mehr ungerade Zahlen als gerade. In einer ungeraden Zahl 1 mehr. Dies hat jedoch eindeutig Grenzen (n+2)/(2n+2) -> ½.

Perl 6 , 70 Bytes - Herausforderung 3

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

Probieren Sie es online!

Zugegeben, das ist schrecklich golfen. Es indiziert eine Sequenz, die 2⁰ ungerade Zahlen, dann 2¹ gerade, dann 2² ungerade, dann 2³ gerade usw. enthält.

Die Wahrscheinlichkeit nach n solcher "Blöcke" ist (2 n + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ-1), wenn n ungerade ist. Die Summe im Zähler ist gleich ⅓ (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1). Die Wahrscheinlichkeit nach einer ungeraden Anzahl von Blöcken ist also ⅔ (in der Grenze).

Wenn wir einen weiteren Block hinzufügen (und eine gerade Anzahl von ihnen n + 1 anschlagen), haben wir jedoch keine ungeraden Zahlen hinzugefügt (Zähler bleibt gleich), aber es gibt jetzt insgesamt (2 ^{n + 1} - 1) Zahlen . Die Klammern löschen sich und wir erhalten die Wahrscheinlichkeit von ⅓ (im Limit).

Dies soll anscheinend 2 verschiedene Clusterpunkte haben, ⅓ und ⅔, um sicherzustellen, dass das Limit nicht existiert, aber das beweist es nicht wirklich. Mein Versuch, einen soliden, strengen Beweis zu erbringen, ist in dieser Math.SE-Antwort zu finden: https://math.stackexchange.com/a/2416990/174637 . Schlagfehler sind willkommen.

Perl 6 , 39 Bytes - Die Kernherausforderung.

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

Probieren Sie es online!

Obwohl ich diese Antwort aufgrund der Herausforderungen 2 und 3 gepostet habe, die ein angenehmes kleines mathematisches Rätsel boten, müssen alle Antworten eine Lösung für die Kernherausforderung enthalten. Hier ist es dann.

Dies ist die Beispielsequenz.

Brain-Flak , 120 Bytes

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

Probieren Sie es online!

Führt die folgende Funktion aus:

Diese Funktion generiert die Sequenz

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

Die Funktion hat eine ungerade Wahrscheinlichkeit von 1

R, 82 Bytes (Extra Herausforderung 1)

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

Probieren Sie es online!

Wenn die Eingabe ein perfektes Quadrat ist, wird eine gerade Zahl angegeben. Ansonsten ergibt sich eine ungerade Zahl. Die perfekten Quadrate haben eine natürliche Dichte von 0, was bedeutet, dass diese Folge mit Wahrscheinlichkeit 1 ungerade Zahlen ergibt.

C (gcc) , 29 Bytes

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

Probieren Sie es online!

Jede vierte Zahl ist gerade:

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

Zusätzliche Herausforderung 1, 52 Bytes

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

Probieren Sie es online!

Gibt 2 * (x + 1) zurück, wenn n 2 ^x entspricht, andernfalls ungerade aufeinanderfolgende Zahlen:

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

Brain-Flak , 140 138 136 Bytes

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

Probieren Sie es online!

Erläuterung

Dies hat eine ähnliche Funktion wie die in der Frage vorgeschlagene.

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

Es funktioniert hauptsächlich auf der Grundlage eines Schnipsel, das ich erstellt habe, um den Stapel für Stapel der Größe 3 zu rollen.

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

Wir richten zwei Stapel ein, einen mit Akkumulatorwerten (zwei ungerade gerade) und einen mit den Zahlen 4 4 2. Bei jeder Iteration rollen wir beide Stapel und fügen den oberen Rand des linken Stapels zum oberen Rand des rechten Stapels hinzu.

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

Dies erhöht jede ungerade Zahl um 4 und die eine gerade Zahl um 2. Während wir durchlaufen, erhalten wir ein Muster von 2 ungeraden 1 geraden, wobei jede positive ganze Zahl getroffen wird. Also schleifen wir einfach nmal mit nder Eingabe. Dies hat eine asymptotische Wahrscheinlichkeit von 2/3 .

Gelee , 10 Bytes

ÆE;0ṭ2/FÆẸ

Die Wahrscheinlichkeit einer Quote beträgt 2/3 .

Probieren Sie es online!

Wie es funktioniert

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

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

Implementierung der Beispielpermutation aus der Frage.

Probieren Sie es online!

Batch, 36 Bytes

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

Implementiert die in der Frage angegebene Reihenfolge.

JavaScript, 23 Byte

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

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

• Für alle n = 4k:
  • f (n) = n / 2 = 2k
• Für alle ist n = 4k + b
  • f (n) = n / 2 + b / 2 + n - 1 = 3/2 * (4k + b) + 1/2 * b - 1 = 6k + 2b - 1

Herausforderung 2:

n=>n^(n>1)

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

CJam (21 Bytes)

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

Online-Demo mit den ersten 32 Ausgängen. Dies ist ein anonymer Block (Funktion).

Dies ist auch eine Lösung, um 1 herauszufordern: Die auf gerade Zahlen abgebildeten Zahlen sind die Potenzen von 2, sodass die Dichte der geraden Zahlen in den ersten n Ausgaben lg (n) / n ist, was gegen Null tendiert.

Präparation

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

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

Brain-Flueue , 88 Bytes

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

Probieren Sie es online!

Erläuterung

Dies implementiert die gleiche Funktion wie meine letzte Antwort , verwendet jedoch das FIFO-Modell von Brain-Flueue, um einige Ecken zu kürzen. Hier sind die ersten Begriffe, die es generiert.

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

Der erste Teil des Codes ist nur ein bisschen Setup, wir legen 0,-1,-3den ersten Stapel und 2,4,4den zweiten Stapel auf. Mit dem 2,4,4werden gerade und ungerade Zahlen durchlaufen, so wie ich es in meiner Brain-Flak-Antwort getan habe.

Dann wiederholen wir n-mal, wobei wir jeweils den oberen Rand des linken Stapels zum rechten Stapel addieren. Da in Brain-Flueue Warteschlangen anstelle von Stapeln verwendet werden, rollen die Werte beim Berühren auf natürliche Weise, sodass kein zusätzlicher Code erforderlich ist.

Python 2 , 46 104 55 Bytes

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

Probieren Sie es online!

Verstehen Sie die Frage falsch, und implementieren Sie jetzt ordnungsgemäß eine Funktion, mit der eine Sequenz generiert werden kann, anstatt einer, die eine Sequenz generiert. Ebenfalls 0aus der Reihe der möglichen Ausgaben ausgeschlossen.

Die Wahrscheinlichkeit, eine ungerade positive ganze Zahl zu finden, konvergiert jetzt gegen 1.

Gelee , 9 Bytes

Ḥ€’ĖUẎQ⁸ị

Probieren Sie es online!

Anbaugeräte 1, 3, 2, 5, 7, 4, 9, 11, 6, ...(Wahrscheinlichkeit 2/3).

05AB1E , 11 Bytes

·ÅÉā‚ø˜Ù¹<è

Probieren Sie es online!

Pyth , 9 Bytes

*Fmxd<d4P

Probieren Sie es hier aus! oder Testen Sie mehr auf einmal!

Mit diesem Code können Sie das Verhältnis von ungeraden Zahlen bis zu einem bestimmten Punkt überprüfen. Ersetzen Sie 10000durch Ihr gewünschtes Limit (stellen Sie es nicht viel höher ein, da es Speicherfehler gibt).

Km*Fmxk<k4PdS10000clf%T2KlK

Probieren Sie es hier aus .

Das obige ergibt ungefähr 0,667 . Die wahre Wahrscheinlichkeit für seltsame Vorkommnisse liegt bei 2/3 . Dieser Ansatz ist eine äquivalente Umsetzung der Antwort von Dennis .

Erläuterung

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

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

Port of @nwellnhofs C Antwort .
Einige Dinge, die ich selbst ausprobiert habe, waren ein paar Bytes länger oder etwas falsch.

Anbaugeräte: 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,...
mit einer Wahrscheinlichkeit von 3/4.

Probieren Sie es hier aus.

Lua, 67 53 Bytes

Erklärung kommt, wenn ich damit fertig bin :)

Dieses Programm verwendet eine Ganzzahl über Befehlszeilenargumente als Eingabe und gibt das n-te Element der Beispielsequenz an STDOUT aus

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

Erklärungen

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

Die geraden Zahlen dieser Folge sind sowohl die ngerade Zahl als auch das nVielfache von 3, daher ist die Formel n%3*2ausreichend, um sie zu erzeugen.

Bei ungeraden Zahlen ist es etwas schwieriger. Basierend auf der Tatsache, dass wir sie abhängig von der Stromstärke finden können n, haben wir die folgende Tabelle:

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

Nennen wir den Wert target-n i, können wir sehen , dass jedes Mal n%3==2, ierhöht wird. Da geht unsere Formel:

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

Die ungeraden Zahlen basieren nauf denen wir hinzufügen i.

Der Wert von iInkrementen mit der gleichen Rate wie die euklidische Division durch 3 mit einem Versatz. math.floor(n/3)gibt uns die Rate der Zunahme und n%3-1gibt uns den Versatz, so dass es auf geschieht n%3==2statt n%3==0.