งานของคุณในที่นี้คือการใช้ฟังก์ชัน¹ที่สร้างการเปลี่ยนรูปแบบของจำนวนเต็มบวก (bijection จากจำนวนเต็มบวกเข้าสู่ตัวเอง) ซึ่งหมายความว่าจำนวนเต็มบวกแต่ละค่าควรปรากฏขึ้นหนึ่งครั้งในการเปลี่ยนแปลง ฟังก์ชัน Catch ของคุณควรมีความน่าจะเป็นในการแสดงผลเป็นเลขคี่มากกว่าจำนวนคู่

ตอนนี้อาจดูแปลกหรือเป็นไปไม่ได้ แน่นอนว่ามีตัวเลขคี่เป็นจำนวนเท่า ๆ กันใช่ไหม? และในขณะที่สัญชาตญาณนี้ถูกต้องสำหรับเซต จำกัด จริง ๆ แล้วมันไม่ถือสำหรับเซตอนันต์ ตัวอย่างเช่นใช้การเปลี่ยนแปลงต่อไปนี้:

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

หากคุณใช้ส่วนย่อยของลำดับที่มีขนาดใหญ่กว่า$1$คุณจะมีเลขคี่เป็นจำนวนคู่อย่างน้อยที่สุดเท่าที่เป็นเลขคู่ดังนั้นดูเหมือนว่าความน่าจะเป็นของคำที่สุ่มใด ๆ ที่เป็นเลขคี่นั้นยิ่งใหญ่กว่าเลขคู่ คุณจะสังเกตเห็นว่าทุกเลขคี่หรือเลขคู่จะปรากฏในลำดับและจะปรากฏเพียงครั้งเดียว ดังนั้นลำดับคือการเปลี่ยนแปลงที่แท้จริง

นิยามของความน่าจะเป็น

เพื่อหลีกเลี่ยงความสับสนหรือความกำกวมฉันจะอธิบายอย่างชัดเจนถึงความน่าจะเป็นในคำถามนี้

ขอให้เราบอกว่าเรามีฟังก์ชั่นF$f$ความน่าจะเป็นของจำนวนคี่จะถูกกำหนดเป็นขีด จำกัด ของอัตราส่วนสมาชิกคี่ของชุดต่อขนาดของชุด$f\{1\dots n\}$ตามที่$n$มีแนวโน้มว่าจะไม่มีที่สิ้นสุด

ยกตัวอย่างเช่นฟังก์ชั่นดังกล่าวจะมีความน่าจะเป็นของความแปลกของ2/3$2/3$

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์น้อยกว่าจะดีกว่า

ความท้าทายพิเศษ

นี่คือความคิดที่สนุกสนานที่จะเล่นกับและอาจลองใช้ เหล่านี้เป็นเพียงเพื่อความสนุกสนานและไม่ส่งผลกระทบต่อการให้คะแนน แต่อย่างใด บางส่วนของเหล่านี้ไม่ได้แก้ปัญหาที่ถูกต้องแม้กับความท้าทายนี้และคำตอบซึ่งรวมถึงโซลูชั่นเพื่อความท้าทาย 2 หรือ 3 ไม่ได้เป็นคำตอบที่ถูกต้องและมีแนวโน้มที่จะถูกลบออก

• เขียนการเปลี่ยนแปลงที่มีความน่าจะเป็นคี่1(เป็นไปได้)$1$

• เขียนการเปลี่ยนแปลงที่มีเลขคี่มากกว่าตัวเลขแม้ในสำหรับการใด ๆแต่มีความน่าจะเป็นคี่ของ1/2$f\{1\dots n\}$$n$$1/2$

• เขียนการเรียงสับเปลี่ยนที่ไม่มีความน่าจะเป็นที่กำหนดไว้ (นั่นคือไม่มีขีด จำกัด )

^{1: ฟังก์ชั่นที่นี่จะหมายถึงโปรแกรมหรือฟังก์ชั่น มันเป็นเพียงส่วนหนึ่งของรหัสที่รับอินพุตและสร้างเอาต์พุต}

เยลลี่ขนาด 7 ไบต์

Æf^<¥4P

สลับ2 s และ3 s ในการแยกตัวประกอบเฉพาะของอินพุต น่าจะเป็นของการต่อรองเป็น2/3

ลองออนไลน์!

มันทำงานอย่างไร

Æ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 ไบต์

-1 ไบต์ขอบคุณ Leo และฟังก์ชั่นที่แตกต่างออกไปเล็กน้อย

นี่มีความน่าจะเป็นที่แปลก 1

!uΣz:NCNİ1

ลองออนไลน์!

มันจัดทำดัชนีลำดับ:

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

คำอธิบาย

!               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 ไบต์

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

[1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...]การดำเนินการตามลำดับตัวอย่าง

ลองออนไลน์!

สำหรับการอ้างอิง: เวอร์ชันเก่า 34 ไบต์ (-1 ไบต์ขอบคุณ @xnor):

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

ลองออนไลน์!

Husk , 8 ไบต์

!uΣzeİ1N

ลองออนไลน์!

สิ่งนี้ใช้ลำดับตัวอย่าง ( 1,3,2,5,7,4...)

คำอธิบาย

!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

ทุกคนทำข้อท้าทาย 1 กันเถอะทำอีกสองข้อ

Perl 6 , 26 bytes - ความท้าทาย 2

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

ลองออนไลน์!

มันเป็นเพียง1 3 2 5 4 7 6...คำศัพท์จำนวนคู่มีจำนวนคี่มากกว่า 2 เสมอเสมอ ในจำนวนคี่, อีก 1 อย่างไรก็ตามเรื่องนี้มีขีด จำกัด (n+2)/(2n+2) -> ½อย่างเห็นได้ชัด

Perl 6 , 70 ไบต์ - ท้า 3

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

ลองออนไลน์!

เป็นที่ยอมรับว่านี่เป็นสนามกอล์ฟที่น่ากลัว มันทำดัชนีลำดับที่มีเลขคี่2⁰จากนั้น2¹คู่จากนั้นคี่2²จากนั้น2³คู่และอื่น ๆ

ความน่าจะเป็นหลังจาก n "บล็อก" เช่นนั้นถ้า n เป็นเลขคี่คือ (2⁰ + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ-1) ผลรวมในตัวเศษมีค่าเท่ากับ⅓ (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1) ดังนั้นความน่าจะเป็นหลังจากจำนวนคี่ของบล็อกคือ⅔ (ในขีด จำกัด )

หากเราเพิ่มบล็อกอีกหนึ่งบล็อก (และนับจำนวนให้นับรวมเป็น n + 1) อย่างไรก็ตามเราไม่ได้เพิ่มตัวเลขคี่ใด ๆ (ตัวเศษยังคงเหมือนเดิม) แต่ตอนนี้มีจำนวนทั้งหมด (2 ^{n + 1} - 1) ทั้งหมด . วงเล็บถูกยกเลิกและเราได้ความน่าจะเป็น⅓ (ตามจำนวนที่กำหนด)

เห็นได้ชัดว่าควรมีจุดคลัสเตอร์ที่แตกต่างกัน 2 จุดคือ⅓และ⅔เพื่อให้แน่ใจว่าไม่มีขีด จำกัด แต่สิ่งนี้ไม่ได้พิสูจน์ได้จริง ความพยายามของฉันจะทำอย่างไรที่เป็นของแข็งหลักฐานอย่างเข้มงวดสามารถพบได้ในคำตอบ Math.SE นี้: https://math.stackexchange.com/a/2416990/174637 ยินดีต้อนรับข้อผิดพลาดทุบตี

Perl 6 , 39 bytes - ความท้าทายหลัก

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

ลองออนไลน์!

แม้ว่าฉันโพสต์คำตอบนี้เนื่องจากความท้าทายที่ 2 และ 3 ที่เสนอปริศนาทางคณิตศาสตร์ที่น่าพอใจเล็ก ๆ น้อย ๆ แต่ก็มีข้อกำหนดที่เข้มงวดสำหรับคำตอบทั้งหมดที่จะมีทางออกสำหรับความท้าทายหลัก นี่ไง

นี่คือลำดับตัวอย่าง

Brain-Flakขนาด 120 ไบต์

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

ลองออนไลน์!

ดำเนินการฟังก์ชันต่อไปนี้:

ฟังก์ชั่นนี้สร้างลำดับ

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

ฟังก์ชั่นมีความน่าจะเป็นแปลก ๆ 1

R, 82 ไบต์ (ความท้าทายพิเศษ 1)

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

ลองออนไลน์!

หากการป้อนข้อมูลเป็นรูปสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบให้เป็นเลขคู่ มิฉะนั้นจะให้ตัวเลขคี่ สี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบมีความหนาแน่นตามธรรมชาติ 0 ซึ่งหมายความว่าลำดับนี้ให้ตัวเลขคี่ด้วยความน่าจะเป็น 1

C (gcc) , 29 ไบต์

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

ลองออนไลน์!

ทุก ๆ หมายเลขที่สี่คือเลขคู่:

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

ความท้าทายพิเศษ 1, 52 ไบต์

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

ลองออนไลน์!

ส่งกลับ 2 * (x + 1) ถ้า n เท่ากับ 2 ^xและตัวเลขคี่ที่ต่อเนื่องกันเป็นอย่างอื่น:

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

Brain-Flak , 140 138 136 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ฟังก์ชันนี้ทำหน้าที่คล้ายกับที่แนะนำในคำถาม

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

มันใช้งานได้เป็นส่วนใหญ่ตามตัวอย่างที่ฉันทำเพื่อม้วนสแต็คสำหรับขนาด 3 กอง

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

เราตั้งสองกองหนึ่งที่มีค่าสะสม (สองแปลกหนึ่งคู่) 4 4 2และเป็นหนึ่งเดียวกับตัวเลข การวนซ้ำแต่ละครั้งเราจะหมุนทั้งสแต็คและเพิ่มด้านบนของสแต็กด้านซ้ายไปด้านบนสุดของสแต็กขวา

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

นี่จะเพิ่มจำนวนคี่แต่ละคูณด้วย 4 และเลขคู่หนึ่งคูณ 2 เมื่อเราวนซ้ำเราจะได้รูปแบบของ 2 คี่ 1 คู่โดยที่จำนวนเต็มบวกทุกค่าจะถูกตี ดังนั้นเราจึงวนรอบnเวลากับnการป้อนข้อมูล นี้มีความน่าจะเป็นของ asymptotic 2/3

เยลลี่ 10 ไบต์

ÆE;0ṭ2/FÆẸ

น่าจะเป็นของการต่อรองเป็น2/3

ลองออนไลน์!

มันทำงานอย่างไร

Æ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 ไบต์

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

การดำเนินการเปลี่ยนแปลงตัวอย่างจากคำถาม

ลองออนไลน์!

แบตช์ 36 ไบต์

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

ใช้ลำดับที่กำหนดในคำถาม

JavaScript ขนาด 23 ไบต์

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

เอาท์พุท: 1, 3, 5, 2, 7, 9, 11, 4, 13, 15, 17, 6, 19, 21, 23, 8 ...

• สำหรับทั้งหมด n = 4k:
  • f (n) = n / 2 = 2k
• สำหรับทั้งหมด n = 4k + b
  • f (n) = n / 2 + b / 2 + n - 1 = 3/2 * (4k + b) + 1/2 * b - 1 = 6k + 2b - 1

ท้าทาย 2:

n=>n^(n>1)

เอาท์พุต: 1, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14

CJam (21 ไบต์)

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

การสาธิตออนไลน์แสดงผลลัพธ์ 32 รายการแรก นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน)

นี่เป็นวิธีแก้ปัญหาที่ท้าทาย 1: ตัวเลขที่แมปกับตัวเลขคือพลังของ 2 ดังนั้นความหนาแน่นของตัวเลขคู่ในเอาต์พุตแรก n คือ lg (n) / n ซึ่งมีแนวโน้มเป็นศูนย์

การผ่า

{         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 ไบต์

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

Brain-Flueue , 88 ไบต์

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

ลองออนไลน์!

คำอธิบาย

นี่ใช้ฟังก์ชั่นเดียวกับคำตอบสุดท้ายของฉันแต่ใช้โมเดล FIFO ของ Brain-Flueue เพื่อตัดมุมบางส่วน ต่อไปนี้เป็นคำศัพท์สองคำแรกที่สร้างขึ้น

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

ส่วนแรกของรหัสเป็นเพียงการตั้งค่าเล็กน้อยเราใส่0,-1,-3ใน stack แรกและ2,4,4ใน stack ที่สอง 2,4,4จะถูกใช้เพื่อวงจรผ่านแม้แต่และแปลกตัวเลขเช่นเดียวกับผมได้ในคำตอบ Brain-Flak ของฉัน

จากนั้นเราวนลูป n ครั้งแต่ละครั้งที่เพิ่มด้านบนของสแต็กด้านซ้ายไปยังสแต็กด้านขวา เนื่องจาก Brain-Flueue ใช้คิวแทนการเรียงซ้อนค่าตามธรรมชาติขณะที่เราสัมผัสพวกมันทำให้ไม่ต้องใช้รหัสเพิ่มเติม

Python 2 , 46 104 55 ไบต์

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

ลองออนไลน์!

เข้าใจผิดคำถามตอนนี้ใช้ฟังก์ชั่นอย่างถูกต้องที่สามารถใช้ในการสร้างลำดับแทนที่จะเป็นหนึ่งที่สร้างลำดับ แยกออก0จากชุดของเอาต์พุตที่เป็นไปได้เช่นกัน

1น่าจะเป็นของการหาจำนวนเต็มบวกคี่ตอนนี้ลู่ไป

เยลลี่ขนาด 9 ไบต์

Ḥ€’ĖUẎQ⁸ị

ลองออนไลน์!

การปฏิบัติ1, 3, 2, 5, 7, 4, 9, 11, 6, ...(ความน่าจะเป็น 2/3)

05AB1E , 11 ไบต์

·ÅÉā‚ø˜Ù¹<è

ลองออนไลน์!

Pyth , 9 ไบต์

*Fmxd<d4P

ลองที่นี่! หรือทดสอบเพิ่มเติมในครั้งเดียว!

คุณสามารถใช้รหัสนี้เพื่อตรวจสอบอัตราส่วนของจำนวนคี่ถึงจุดหนึ่ง ทดแทน10000ด้วยขีด จำกัด ที่คุณต้องการ (อย่าตั้งค่าสูงกว่ามากเพราะเป็นข้อผิดพลาดของหน่วยความจำ)

Km*Fmxk<k4PdS10000clf%T2KlK

ลองได้ที่นี่

ดังกล่าวข้างต้นจะช่วยให้ประมาณ0.667 ความน่าจะเป็นความจริงที่เกิดขึ้นแปลกคือ2/3 วิธีนี้เป็นการใช้คำตอบของเดนนิสที่เท่าเทียมกัน

คำอธิบาย

*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 ไบต์

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

ท่าเรือ@nwellnhof 's คำตอบ
บางสิ่งที่ฉันลองด้วยตัวเองก็จบลงด้วยความยาวไม่กี่ไบต์หรือไม่ถูกต้องเล็กน้อย ..

การดำเนินการ: มีน่าจะเป็นของ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,...
3/4

ลองที่นี่

Lua, 67 53 ไบต์

คำอธิบายมาเมื่อฉันเล่นกอล์ฟเสร็จ :)

โปรแกรมนี้ใช้จำนวนเต็มผ่านอาร์กิวเมนต์บรรทัดคำสั่งเป็นอินพุตและพิมพ์องค์ประกอบที่ n ของลำดับตัวอย่างไปยัง STDOUT

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

คำอธิบาย

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

หมายเลขคู่ของลำดับนี้มีทั้งnเลขคู่และnคูณ 3 ดังนั้นสูตรn%3*2ก็เพียงพอที่จะสร้างได้

สำหรับตัวเลขคี่มันเป็นเรื่องที่ยากขึ้นเล็กน้อย ขึ้นอยู่กับความจริงที่ว่าเราสามารถค้นหาได้ขึ้นอยู่กับปัจจุบันnเรามีตารางต่อไปนี้:

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

ขอเรียกค่าtarget-n iเราจะเห็นว่าทุกครั้งที่n%3==2, iจะเพิ่มขึ้น สูตรของเรามีดังนี้:

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

หมายเลขคี่จะขึ้นอยู่กับที่เราเพิ่มni

ค่าของการiเพิ่มขึ้นในอัตราเดียวกับการหารยูคลีนิคด้วย 3 ด้วยการชดเชย math.floor(n/3)ช่วยให้เรามีอัตราการเพิ่มขึ้นและn%3-1ทำให้เราชดเชยทำให้มันเกิดขึ้นบนแทนn%3==2n%3==0