Thủ thuật đánh bài ma thuật đầu tiên tôi từng học khi còn nhỏ là:

• Có 1 cỗ bài trong đó hoa văn ở mặt sau không đối xứng theo chiều dọc.
• Tổ chức tất cả các thẻ để được đối mặt với một hướng.
• Yêu cầu một cá nhân, "chọn một thẻ, bất kỳ thẻ nào, ghi nhớ nó và trả lại cho bạn".
• Tiến hành đặt nó vào boong (sai hướng).
• Xáo trộn mạnh mẽ, tạo ảo giác rằng bạn sẽ không biết thẻ của họ ở đâu.
• Sản xuất thẻ của họ đến kinh ngạc của họ.

Thủ thuật này rõ ràng là một chút thiếu ánh sáng trong tự nhiên ngày nay, tuy nhiên nó làm cho một thách thức tốt. Viết một chương trình, khi không có đầu vào, sẽ tạo ra một cỗ bài được xáo trộn ngẫu nhiên với một trong các thẻ, được chọn ngẫu nhiên, đảo ngược. Tuy nhiên, khi đầu vào là một cỗ bài có một thẻ bị đảo ngược, bạn phải xuất ra thẻ đảo ngược (theo đúng thứ tự).

Bộ bài

Một bộ bài được định nghĩa là:

[2S,3S,4S,5S,6S,7S,8S,9S,TS,JS,QS,KS,AS,
 2D,3D,4D,5D,6D,7D,8D,9D,TD,JD,QD,KD,AD,
 2H,3H,4H,5H,6H,7H,8H,9H,TH,JH,QH,KH,AH,
 2C,3C,4C,5C,6C,7C,8C,9C,TC,JC,QC,KC,AC]

Một thẻ được định nghĩa là số của nó, sau đó là chữ cái đầu tiên của bộ đồ. Mặt trái của thẻ hoàn toàn ngược lại, chữ cái đầu tiên của bộ đồ theo sau là một số.

Thẻ rút

Ví dụ: nếu thẻ chúng tôi chọn ngẫu nhiên đảo ngược là 4 of Clubs (4C), chúng tôi sẽ kết thúc (rõ ràng là không xáo trộn):

[2S,3S,4S,5S,6S,7S,8S,9S,TS,JS,QS,KS,AS,
 2D,3D,4D,5D,6D,7D,8D,9D,TD,JD,QD,KD,AD,
 2H,3H,4H,5H,6H,7H,8H,9H,TH,JH,QH,KH,AH,
 2C,3C,C4,5C,6C,7C,8C,9C,TC,JC,QC,KC,AC]

Sự xáo trộn

Sau đó, sau khi xáo trộn:

[2H,2C,6S,4D,QH,6C,TD,8C,7H,5H,C4,3D,7S,7C,KC,QD,QC,JS,7D,6D,2S,5C,KD,3C,3S,2D,8H,KH,6H,AH,8S,JH,TS,AD,5D,9H,4H,JD,QS,4S,JC,3H,8D,TC,AS,TH,KS,AC,9C,9S,5S,9D]

Đây là một đầu ra hợp lệ cho đầu vào trống.

Đầu vào sàn

Tuy nhiên, ngược lại, khi chương trình của chúng tôi nhận đầu ra ở trên làm đầu vào, nó sẽ xuất ra 4C. Điều đó có nghĩa là, đối với đầu vào của:

[2H,2C,6S,4D,QH,6C,TD,8C,7H,5H,C4,3D,7S,7C,KC,QD,QC,JS,7D,6D,2S,5C,KD,3C,3S,2D,8H,KH,6H,AH,8S,JH,TS,AD,5D,9H,4H,JD,QS,4S,JC,3H,8D,TC,AS,TH,KS,AC,9C,9S,5S,9D]

Bạn lặp đi lặp lại cho đến khi bạn tìm thấy thẻ đảo ngược và trả lại, đảo ngược trở lại trạng thái bình thường. Vì vậy, ở đây chúng tôi tìm thấy C4, biết rằng C không phải là một số và trả về nó 4Clà đúng.

Quy tắc

• Bạn không thể tải bộ bài từ bất kỳ nguồn bên ngoài.
• Một đầu vào trống sẽ dẫn đến một cỗ bài được xáo trộn ngẫu nhiên với 1 thẻ ngẫu nhiên được đảo ngược.
• Bộ bài có 1 thẻ được đảo ngược làm đầu vào sẽ dẫn đến thẻ bị đảo ngược.
• Bất kỳ đầu vào nào khác có thể dẫn đến llamas nổ đi xe đạp thông qua một ống tương lai.
  • Hoặc bất cứ điều gì khác cho vấn đề đó.
• Cả hai thẻ được chọn và thứ tự xáo trộn phải được thống nhất ngẫu nhiên.
  • IE tất cả các thẻ có cơ hội bình đẳng được chọn để được đảo ngược.
  • IE tất cả các kết hợp thẻ có cơ hội xuất hiện như nhau.
• Bạn có thể sử dụng SHCDhoặc shcdcho các bộ quần áo, nhưng phải nhất quán:
  • Nếu bạn chọn bộ chữ hoa ( SHCD) bạn cũng phải sử dụng TJQKA.
  • Nếu bạn chọn phù hợp với chữ thường ( shcd) bạn cũng phải sử dụng tjqka.
• Đây là mã golf , người chiến thắng là byte thấp nhất.

Võng mạc , 61 60 59 byte

G`[HCDS].
^$
23456789TJQK
/^2/&L$`.
$&H¶$&D¶$&C¶$&S
@V`
O?`

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 1 2 byte nhờ @MartinEnder. Giải trình:

G`[HCDS].

Xóa tất cả các thẻ chưa được đảo ngược. Điều này sẽ để lại một thẻ đảo ngược hoặc không có thẻ.

^$
23456789TJQK
/^2/&L$`.
$&H¶$&D¶$&C¶$&S

Nếu đầu vào trống (bây giờ) trống, hãy tạo một gói thẻ.

@V`

Chọn ngẫu nhiên một thẻ và đảo ngược nó (hủy bỏ thẻ đảo ngược duy nhất).

O?`

Thẻ bị xáo chộn).

05AB1E , 29 byte

Y9ŸJ.•§®т•«.•öB•âsKDgiëDΩÂ:.r

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

PowerShell v2 trở lên, 175 byte

%{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Phiên bản dài:

ForEach-Object {
    $s = [char[]]'SDHC'                         # Create a character array with the suits
    if ($_) {                                   # If there's pipeline input ...
        $_ |                                    # ... write it to the output pipeline ...
            Where-Object {$s -contains $_[0]} | # ... but let only those input elements pass where the first letter appears in the suits ...
            ForEach-Object {$_[1] + $_[0]}      # ... and swap the two elements
    } else {
        $d = $s | ForEach-Object {              # Assign $d to the output of the suits, processing each element first.
                $e = $_                         # Store the current suit element for use in the inner loop
                [char[]]'23456789TJQKA' | ForEach-Object {$_ + $e}  # Process each of the numbers, joining it with the current suit, ...
            } | Get-Random -Count 52            # ... and the resulting 2-char-strings goes back into the output to be shuffled
        $r = Get-Random -Maximum 52
        $d[$r] = $d[$r][1] + $d[$r][0]          # Swap the two chars of a random array element in $d
        $d                                      # Write $d to the output pipeline
    }
}

Sử dụng:

Tạo một cỗ bài xáo trộn và lưu trữ nó trong một biến:

$Deck = %{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Kiểm tra biến theo ý muốn, ví dụ

$Deck -join ','

Đưa bộ bài trở lại vào kịch bản:

$Deck | %{$s=[char[]]'SDHC';if($_){$_|?{$s-contains$_[0]}|%{$_[1]+$_[0]}}else{$d=$s|%{$e=$_;[char[]]'23456789TJQKA'|%{$_+$e}}|random -c 52;$r=random 52;$d[$r]=$d[$r][1]+$d[$r][0];$d}}

Python 2 , 175 byte

from random import*
s='SHCD';c='23456789TJQKA'
d=input()
if d:print[b+a for a,b in d if a in s];q
k=sample
r=k(c,1)+k(s,1)
print k([(a+b,b+a)[r==a+b]for a in c for b in s],52)

Hãy thử trực tuyến! đầu vào trống được ký hiệu là[]

> <> , 215 193 byte

i:0)?\~"CHSD":"2"$:"3"$:"4"$:"5"$:"6"$:"7"$:"8"$:"9"$:"T"$:"J"$:"Q"$:"K"$:"A"$&105&"S"=?.~~~{c0.
=+i$?\i$:::"B")$"I"(*$"S"
_oo$~/;
x0
x0
x0
x0
x0
x0
x0
x0
x0
x0
\l&>?!<
>&"3"%:?\~$>o<
\  }}&-1/

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

Lấy đầu vào là các thẻ không tách rời và đầu ra giống nhau (ví dụ KCAC5C6S...)

Để dễ kiểm tra hơn, đây là phiên bản lấy đầu vào được phân tách bằng dấu phẩy và đầu ra dưới dạng dòng mới được phân tách.

Tất cả x0chỉ là một nỗ lực để tạo ra một bộ tạo số ngẫu nhiên bán đồng nhất. Nhiều trong số chúng làm tăng phạm vi của các giá trị có thể, và ngược lại với giá thấp hơn. 10 trong số đó là nơi tôi đánh giá nó là đủ ngẫu nhiên.

Lưu ý rằng nó tuân theo các quy tắc trong đó:

• Tất cả các thẻ có cơ hội bình đẳng được lựa chọn để được đảo ngược.
• Tất cả các thẻ có cơ hội như nhau xuất hiện bất cứ nơi nào trong bộ bài xáo trộn.

Nhưng không phải tất cả các kết hợp được xáo trộn là kết quả đầu ra có thể (và trên thực tế, phần lớn không có).

Thạch , 26 byte

9ḊṾ€;“AJKQT”p“CDHS”ḟ⁸ẊU-¦Ẋ

Một liên kết đơn âm chấp nhận danh sách các danh sách các ký tự (còn sơ khai 0 thẻ hoặc toàn bộ 52 thẻ với một thẻ đảo ngược) và trả về danh sách các danh sách các ký tự (còn sơ khai của 1 thẻ đảo ngược nhưng chuyển tiếp hoặc đầy đủ -deck với một thẻ ngẫu nhiên đảo ngược).

Hãy thử trực tuyến! (chân trang để làm cho các biểu diễn đầu vào và đầu ra khớp nhau - như một chương trình đầy đủ Mã Jelly Python-evals đối số và đập các ký tự với nhau cho đầu ra)

Làm sao?

9ḊṾ€;“AJKQT”p“CDHS”ḟ⁸ẊU-¦Ẋ - Link: list of lists of characters, Z
9Ḋ                         - nine dequeued = [2,3,4,5,6,7,8,9]
  Ṿ€                       - unevaluate €ach = ['2','3','4','5','6','7','8','9']
     “AJKQT”               - literal list of characters = ['A','J','K','Q','T']
    ;                      - concatenate = ['2','3','4','5','6','7','8','9','A','J','K','Q','T']
             “CDHS”        - literal list of characters = ['C','D','H','S']
            p              - Cartesian product = [['2','C'],['2','D'],...,['T','S']]
                           -   a full deck of forward cards
                    ⁸      - chain's left argument, Z
                   ḟ       - filter discard
                           -   leaving either that deck or the 1 reversed card in the input
                     Ẋ     - shuffle
                        ¦  - sparse application...
                       -   - ...to index: -1 (which doesn't exist when the length is only 1)
                      U    - ...do: upend (reverses the penultimate card of the deck)
                         Ẋ - shuffle

Ruby , 95 (hoặc 100) byte

->n{s=(0..51).map{|i|"A23456789TJQK"[i/4]+"HCDS"[i%4]}
n[0]?s-n:s[rand 52].reverse!&&s.shuffle}

Đưa ra một mảng trống làm đầu vào, trả về bộ bài dưới dạng một chuỗi các chuỗi. Đưa ra một mảng không trống làm đầu vào, trả về thẻ lật như một mảng chứa một chuỗi. Nếu thẻ lật được yêu cầu dưới dạng một chuỗi chứ không phải là một mảng phần tử đơn chứa chuỗi, sau đây thêm 5 byte: thay đổi s-nthành(s-n)[0]

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

Dòng đầu tiên tạo ra một sàn tiêu chuẩn. Dòng thứ hai bị phá vỡ như sau

 n[0]?                  #If the input array is not empty (contains a truthy first element)
  s-n:                  #Find the contents of s with the contents of n removed. The only card remaining from the standard deck corresponds to the flipped card in the input.
                        #ELSE 
  s[rand 52].reverse!&& #Flip one card in place in the array s. As the result is truthy, whatever is next will be returned.
 s.shuffle              #shuffle the deck and return the shuffled deck with one element flipped
}

Java 8, 275 274 259 byte

import java.util.*;s->{if(s==null){List l=new Stack();char i=52,r=i,x,y;for(r*=Math.random();i-->0;y="23456789TJQKA".charAt(i%13),l.add(i==r?x+""+y:y+""+x))x="HSDC".charAt(i&3);Collections.shuffle(l);return l;}return s.replaceAll(".*,(.)([^HSDC]).*","$2$1");}

Đầu vào là một Chuỗi, đầu ra là Chuỗi hoặc là java.util.Listtùy thuộc vào đầu vào.

Giải trình:

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

import java.util.*;          // Required import for List, Stack and Collections
s->{                         // Method with String parameter and Object return-type
  if(s==null){               //  If the input is `null`:
    char i=52,               //   Index-integer
         r=i,                //   Random-integer
         x,y;                //   Temp characters
    List l=new Stack();      //   Create a List
    for(r*=Math.random();    //   Determine the random integer in the range (0;52]
        i-->0                //   Loop `i` 52 times:
        ;                    //     After every iteration:
         y="23456789TJQKA".charAt(i%13)
                             //      Set `y` to one of 23456789TJQKA based on `i` modulo-13
         ,l.add(i==r?        //      If the random integer equals the current `i`
                 x+""+y      //       Add the current card reversed
                :            //      Else:
                 y+""+x))    //       Add the current card as is
      x="HSDC".charAt(i&3);  //    Set `x` to one of HSDC based on `i` bitwise-AND 3
    Collections.shuffle(l);  //   Shuffle the generated Deck
    return l;}               //   And return this Deck as result
                             //  If the input was a Deck instead:
  return s.replaceAll(".*,(.)([^HSDC]).*",
                             //   Get the reversed card from the Deck,
            "$2$1");}        //   and output it non-reversed

Bình thường, 45 byte

J"CDHS"KO52=NsM.S*+c"AKQJT"1S9J|f}hTJQXNK_@NK

Đưa danh sách trống cho đầu vào trống.
Dùng thử trực tuyến

Giải trình

J"CDHS"KO52=NsM.S*+c"AKQJT"1S9J|f}hTJQXNK_@NK
J"CDHS"                                        Save the suits as J.
       KO52                                    Save a random index as K.
           =NsM.S*+c"AKQJT"1S9J                Save a shuffled deck as N.
                                f}hTJQ         Find all cards with suit first.
                               |      XNK_@NK  If there aren't any, flip a card.

R , 177 171 byte

function(l=1,F="(.)(.)",R="\\2\\1",S=sample)if(l>1)sub(F,R,grep("^[SDHC]",l,v=T))else{m=S(outer(c(2:9,"T","J","Q","K"),c("S","D","H","C"),paste0))
m[1]=sub(F,R,m[1])
S(m)}

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

Với đầu vào trống, (cuộc gọi fkhông có đầu vào), chúng tôi mặc định l=1và do đó tạo ra một hoán vị ngẫu nhiên mcủa bộ bài. Giả sử samplelà thực sự ngẫu nhiên, có một xác suất tương đương với bất kỳ thẻ nào là người đầu tiên trong danh sách này. Vì vậy, chúng tôi sửa đổi cái đầu tiên, và sau đó xáo trộn một lần nữa, trả lại danh sách.

Đảo ngược nó, chúng tôi tìm kiếm một thẻ bắt đầu bằng một SDHCvà đảo ngược nó.

Python 2 , 135 byte

from random import*
s=shuffle
d=zip('A23456789TJQK'*4,'SCDH'*13)
s(d)
D=input()
if D:d=list(set(D)-set(d))
d[0]=d[0][::-1]
s(d)
print d

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

Thẻ là bộ (value,suit)

Đầu vào trống là []