Nhiệm vụ của bạn ở đây sẽ là thực hiện hàm ¹ tạo thành một hoán vị trên các số nguyên dương (Một mệnh đề từ các số nguyên dương lên chính chúng). Điều này có nghĩa là mỗi số nguyên dương sẽ xuất hiện chính xác một lần trong hoán vị. Bắt là hàm của bạn sẽ có xác suất xuất ra số lẻ lớn hơn số chẵn.

Bây giờ điều này có vẻ lạ hoặc không thể. Chắc chắn chỉ có nhiều số lẻ như số chẵn? Và trong khi trực giác này là chính xác cho các tập hữu hạn, nó thực sự không giữ cho các tập hợp vô hạn. Ví dụ: hoán vị sau:

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

Nếu bạn lấy bất kỳ phần phụ nào của dãy có kích thước lớn hơn $1$ bạn sẽ có ít nhất nhiều số lẻ bằng số chẵn, do đó, có vẻ như xác suất của bất kỳ thuật ngữ ngẫu nhiên nào là lẻ đều lớn hơn so với số chẵn. Bạn cũng sẽ lưu ý mọi số lẻ hoặc số chẵn cuối cùng sẽ xuất hiện trong chuỗi và chỉ có thể xuất hiện một lần. Do đó, chuỗi là một hoán vị thực sự.

Định nghĩa xác suất

Để tránh nhầm lẫn hoặc mơ hồ, tôi sẽ trình bày rõ ràng ý nghĩa của xác suất trong câu hỏi này.

Hãy để chúng tôi nói chúng tôi có một chức năng $f$ . Xác suất của một số bị lẻ sẽ được định nghĩa là giới hạn tỷ lệ các thành viên kỳ lạ của các thiết lập để kích thước của tập $f\{1\dots n\}$ như $n$ có xu hướng hướng tới vô cùng.

Ví dụ, hàm đã nói ở trên sẽ có xác suất lẻ là .$2/3$

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Thử thách thêm

Dưới đây là một số ý tưởng thú vị để chơi xung quanh và có lẽ cố gắng thực hiện. Đây chỉ là cho vui và không ảnh hưởng đến việc ghi bàn dưới bất kỳ hình thức nào. Một số trong số này thậm chí không phải là giải pháp hợp lệ cho thử thách này và một câu trả lời chỉ bao gồm các giải pháp cho thử thách 2 hoặc 3 không phải là câu trả lời hợp lệ và có thể bị xóa .

• Viết một hoán vị với xác suất lẻ là . (điều này là khả thi)$1$

• Viết một hoán vị có nhiều số lẻ hơn số chẵn trong cho bất kỳ nhưng có xác suất lẻ là .$f\{1\dots n\}$$n$$1/2$

• Viết một hoán vị không có xác suất xác định (đó là không có giới hạn).

^{1: Ở đây chức năng sẽ có nghĩa là chương trình hoặc chức năng. Nó chỉ là một đoạn mã nhận đầu vào và tạo đầu ra.}

Thạch , 7 byte

Æf^<¥4P

Hoán đổi 2 giây và 3 giây trong hệ số nguyên tố đầu vào. Xác suất tỷ lệ cược là 2/3 .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

-1 byte nhờ Leo và một chức năng hơi khác

Điều này có xác suất kỳ lạ là 1

!uΣz:NCNİ1

Hãy thử trực tuyến!

Nó lập chỉ mục trình tự:

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

Giải trình

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

Thực hiện trình tự ví dụ [1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...].

Hãy thử trực tuyến!

Để tham khảo: phiên bản cũ, 34 byte (-1 byte nhờ @xnor):

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

Hãy thử trực tuyến!

Husk , 8 byte

!uΣzeİ1N

Hãy thử trực tuyến!

Điều này thực hiện chuỗi ví dụ ( 1,3,2,5,7,4...).

Giải trình

!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

Mọi người đều thực hiện Thử thách 1, vì vậy hãy thực hiện hai điều còn lại.

Perl 6 , 26 byte - Thử thách 2

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

Hãy thử trực tuyến!

Đó chỉ 1 3 2 5 4 7 6...là số lượng chẵn, luôn có 2 số lẻ nhiều hơn số chẵn. Trong một số lẻ, thêm 1. Tuy nhiên điều này có giới hạn rõ ràng (n+2)/(2n+2) -> ½.

Perl 6 , 70 byte - Thử thách 3

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

Hãy thử trực tuyến!

Phải thừa nhận rằng, đây là golf khủng khiếp. Nó lập chỉ mục một chuỗi chứa 2⁰ số lẻ, sau đó 2 chẵn, sau đó 2² lẻ, sau đó 2³ chẵn, v.v.

Xác suất sau n "khối" như vậy, nếu n là số lẻ, là (2⁰ + 2² + 2⁴ + ... + 2ⁿ⁻¹) / (2ⁿ - 1). Tổng trong tử số bằng (4 ^{½ (n + 1)} - 1) = ⅓ (2 ^{n + 1} - 1). Vậy xác suất sau số khối lẻ là ⅔ (trong giới hạn).

Tuy nhiên, nếu chúng tôi thêm một khối nữa (và tấn công số chẵn của chúng n + 1), tuy nhiên, chúng tôi đã không thêm bất kỳ số lẻ nào (tử số vẫn giữ nguyên) nhưng hiện tại có tổng số (2 ^{n + 1} - 1) . Các dấu ngoặc đơn hủy và chúng ta có xác suất (trong giới hạn).

Điều này rõ ràng được cho là có 2 điểm cụm khác nhau, và, để đảm bảo rằng giới hạn không tồn tại, nhưng điều này không thực sự chứng minh điều đó. Nỗ lực của tôi để làm một bằng chứng vững chắc, nghiêm ngặt có thể được tìm thấy trong câu trả lời Math.SE này: https://math.stackexchange.com/a/2416990/174637 . Bashing sai lầm được chào đón.

Perl 6 , 39 byte - Thách thức cốt lõi.

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

Hãy thử trực tuyến!

Mặc dù tôi đã đăng câu trả lời này vì các thử thách 2 và 3 đưa ra một câu đố toán học nhỏ thú vị, nhưng có một yêu cầu khắt khe đối với tất cả các câu trả lời để chứa một giải pháp cho thử thách cốt lõi. Đây rồi.

Đây là trình tự ví dụ.

Brain-Flak , 120 byte

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

Hãy thử trực tuyến!

Thực hiện chức năng sau:

Hàm này tạo ra chuỗi

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

Hàm có xác suất lẻ là 1

R, 82 byte (Thử thách thêm 1)

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

Hãy thử trực tuyến!

Nếu đầu vào là một hình vuông hoàn hảo, hãy cho một số chẵn. Nếu không, đưa ra một số lẻ. Các hình vuông hoàn hảo có mật độ tự nhiên 0, có nghĩa là chuỗi này cho các số lẻ với xác suất 1.

C (gcc) , 29 byte

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

Hãy thử trực tuyến!

Mọi số thứ tư đều chẵn:

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

Thử thách thêm 1, 52 byte

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

Hãy thử trực tuyến!

Trả về 2 * (x + 1) nếu n bằng 2 ^x và các số lẻ liên tiếp khác:

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

Brain-Flak , 140 138 136 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này thực hiện một chức năng tương tự như một gợi ý trong câu hỏi.

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

Nó hoạt động chủ yếu dựa trên đoạn trích tôi đã thực hiện để cuộn ngăn xếp cho kích thước 3 ngăn xếp.

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

Chúng tôi thiết lập hai ngăn xếp một với các giá trị tích lũy (hai số lẻ chẵn) và một ngăn có các số 4 4 2. Mỗi lần lặp, chúng ta cuộn cả hai ngăn xếp và thêm đỉnh của ngăn xếp bên trái vào đầu ngăn xếp bên phải.

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

Điều này sẽ tăng mỗi số lẻ lên 4 và một số chẵn bằng 2. Khi chúng tôi lặp lại, chúng tôi nhận được một mẫu 2 số lẻ 1 chẵn, với mỗi số nguyên dương được nhấn. Vì vậy, chúng tôi chỉ lặp nthời gian với nđầu vào. Điều này có xác suất tiệm cận là 2/3 .

Thạch , 10 byte

ÆE;0ṭ2/FÆẸ

Xác suất tỷ lệ cược là 2/3 .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Thực hiện các hoán vị ví dụ từ câu hỏi.

Hãy thử trực tuyến!

Mẻ, 36 byte

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

Thực hiện trình tự được đưa ra trong câu hỏi.

JavaScript, 23 byte

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

Đầu ra: 1, 3, 5, 2, 7, 9, 11, 4, 13, 15, 17, 6, 19, 21, 23, 8 ...

• Với mọi n = 4k:
  • f (n) = n / 2 = 2k
• Với mọi n = 4k + b
  • f (n) = n / 2 + b / 2 + n - 1 = 3/2 * (4k + b) + 1/2 * b - 1 = 6k + 2b - 1

Thử thách 2:

n=>n^(n>1)

Đầu ra: 1, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14

CJam (21 byte)

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

Bản demo trực tuyến hiển thị 32 đầu ra đầu tiên. Đây là một khối ẩn danh (chức năng).

Đây cũng là một giải pháp cho thách thức 1: các số được ánh xạ tới các số chẵn là lũy thừa của 2, vì vậy mật độ của các số chẵn trong n đầu ra đầu tiên là lg (n) / n có xu hướng bằng không.

Mổ xẻ

{         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

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

Hãy thử trực tuyến!

Giải trình

Điều này thực hiện chức năng tương tự như câu trả lời cuối cùng của tôi nhưng sử dụng mô hình FIFO của Brain-Flueue để cắt một số góc. Dưới đây là vài thuật ngữ đầu tiên mà nó tạo ra.

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

Phần đầu tiên của mã chỉ là một chút thiết lập, chúng tôi đặt 0,-1,-3vào ngăn xếp đầu tiên và 2,4,4trên ngăn xếp thứ hai. Nó 2,4,4sẽ được sử dụng để chuyển qua các số chẵn và số lẻ giống như tôi đã làm trong câu trả lời Brain-Flak của mình.

Sau đó, chúng tôi lặp lại n lần, mỗi lần thêm đỉnh của ngăn xếp bên trái vào ngăn xếp bên phải. Vì Brain-Flueue sử dụng hàng đợi thay vì sắp xếp các giá trị cuộn tự nhiên khi chúng ta chạm vào chúng, ngăn không cần thêm mã.

Python 2 , 46 104 55 byte

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

Hãy thử trực tuyến!

Đọc sai câu hỏi, giờ đây đã thực hiện đúng một chức năng có thể được sử dụng để tạo một chuỗi thay vì một chuỗi tạo ra một chuỗi. Cũng loại trừ 0khỏi tập hợp các đầu ra có thể.

Xác suất tìm thấy một số nguyên dương lẻ hiện hội tụ đến 1.

Thạch , 9 byte

Ḥ€’ĖUẎQ⁸ị

Hãy thử trực tuyến!

Thực hiện 1, 3, 2, 5, 7, 4, 9, 11, 6, ...(xác suất 2/3).

05AB1E , 11 byte

·ÅÉā‚ø˜Ù¹<è

Hãy thử trực tuyến!

Bình thường , 9 byte

*Fmxd<d4P

Hãy thử nó ở đây! hoặc Kiểm tra thêm trong một lần!

Bạn có thể sử dụng mã này để xác minh tỷ lệ số lẻ lên đến một điểm nhất định. Thay thế 10000với giới hạn mong muốn của bạn (không đặt nó cao hơn nhiều vì lỗi bộ nhớ).

Km*Fmxk<k4PdS10000clf%T2KlK

Hãy thử nó ở đây .

Ở trên cho khoảng 0,667 . Xác suất thực sự của sự cố lẻ là 2/3 . Cách tiếp cận này là một cách thực hiện tương đương với câu trả lời của Dennis .

Giải trình

*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

Câu trả lời C của cảng @nwellnhof .
Một số điều tôi đã cố gắng tự mình kết thúc là một vài byte dài hơn hoặc hơi không chính xác ..

Thực hiện: 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,...
với xác suất 3/4.

Hãy thử nó ở đây.

Lua, 67 53 byte

Giải thích sắp tới khi tôi chơi golf này :)

Chương trình này lấy một số nguyên thông qua các đối số dòng lệnh làm đầu vào và in ra phần tử thứ n của chuỗi mẫu cho STDOUT

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

Giải thích

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

Các số chẵn của dãy này là cả nsố chẵn và nbội số của 3, do đó công thức n%3*2là đủ để tạo ra chúng.

Đối với số lẻ, khó khăn hơn một chút. Dựa trên thực tế là chúng ta có thể tìm thấy chúng tùy thuộc vào hiện tại n, chúng ta có bảng sau:

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

Chúng ta hãy gọi giá trị target-n i, chúng ta có thể thấy rằng mỗi lần n%3==2, iđược tăng lên. Có công thức của chúng tôi:

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

Các số lẻ được dựa ntrên đó chúng tôi thêm vào i.

Giá trị của igia số ở cùng tốc độ với phép chia eidianidian bằng 3, với phần bù. math.floor(n/3)cung cấp cho chúng tôi tỷ lệ tăng và n%3-1cung cấp cho chúng tôi bù đắp, làm cho nó xảy ra trên n%3==2thay vì n%3==0.