Trik sulap kartu sulap pertama yang saya pelajari sejak kecil adalah sebagai berikut:

• Memiliki 1 deck kartu di mana pola di bagian belakang tidak simetris secara vertikal.
• Atur semua kartu agar menghadap satu arah.
• Minta seseorang untuk, "mengambil kartu, kartu apa saja, menghafalkannya dan mengembalikannya kepada Anda".
• Lanjutkan untuk memasukkannya ke dalam dek (ke arah yang salah).
• Kocoklah dengan kuat, berikan ilusi bahwa Anda tidak akan tahu di mana kartu mereka.
• Hasilkan kartu mereka dengan takjub.

Trik ini jelas sedikit kurang berkilau di alam sekarang-a-hari, namun itu membuat tantangan yang baik. Tulis sebuah program, yang ketika tidak diberi input, mengeluarkan setumpuk kartu yang dikocok secara acak dengan salah satu kartu, dipilih secara acak, terbalik. Namun, ketika input adalah setumpuk kartu dengan satu kartu terbalik, Anda harus mengeluarkan kartu yang terbalik (dalam urutan yang benar).

Dek Kartu

Setumpuk kartu didefinisikan sebagai:

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

Kartu didefinisikan sebagai nomornya, lalu huruf pertama dari kartu itu. Kebalikan dari kartu adalah kebalikannya, huruf pertama dari suitnya diikuti oleh angka.

Kartu yang Diambil

Contoh, jika kartu yang kami pilih secara terbalik adalah 4 of Clubs (4C), kami akan berakhir dengan (tanpa mengocok, jelas):

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

The Shuffling

Lalu, setelah mengocok:

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

Ini adalah output yang valid diberikan input kosong.

Input Dek

Namun, sebaliknya, ketika program kami menerima output di atas sebagai input, seharusnya output 4C. Artinya, untuk masukan dari:

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

Anda mengulangi sampai Anda menemukan kartu yang terbalik, dan mengembalikannya, kembali ke keadaan normal. Jadi di sini kita akan menemukan C4, tahu bahwa C bukan angka, dan kembalikan sebagai 4C, yang benar.

Aturan

• Anda tidak boleh memuat deck dari sumber eksternal apa pun.
• Input kosong harus menghasilkan dek acak acak dengan 1 kartu acak terbalik.
• Setumpuk kartu dengan 1 kartu terbalik sebagai input akan menghasilkan kartu terbalik.
• Input lain apa pun dapat menghasilkan ledakan llama yang mengendarai segway melalui pipa futuristik.
  • Atau yang lainnya, dalam hal ini.
• Baik kartu yang dipilih dan urutan pengocokan harus acak secara acak.
  • IE semua kartu memiliki peluang yang sama untuk dipilih untuk dibalik.
  • Semua kombinasi kartu memiliki peluang yang sama untuk muncul.
• Anda dapat menggunakan SHCDatau shcduntuk jas, tetapi konsisten:
  • Jika Anda memilih huruf besar ( SHCD) Anda juga harus menggunakan TJQKA.
  • Jika Anda memilih huruf kecil ( shcd) Anda juga harus menggunakan tjqka.
• Ini adalah kode-golf , pemenangnya adalah byte terendah.

Retina , 61 60 59 byte

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

Cobalah online! Sunting: Disimpan 1 2 byte berkat @MartinEnder. Penjelasan:

G`[HCDS].

Hapus semua kartu yang tidak dapat dikembalikan. Ini harus meninggalkan satu kartu terbalik atau tidak ada kartu.

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

Jika inputnya (sekarang) kosong, buat satu pak kartu.

@V`

Pilih satu kartu secara acak dan balikkan (membatalkan kartu tunggal terbalik).

O?`

Kocok kartu.

05AB1E , 29 byte

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

Cobalah online!

PowerShell v2 atau lebih baru, 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}}

Versi panjang:

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

Pemakaian:

Buat dek acak dan simpan dalam variabel:

$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}}

Periksa variabel sesuka hati, misalnya

$Deck -join ','

Pipa kembali deck ke skrip:

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

Cobalah online! input kosong dilambangkan sebagai[]

> <> , 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/

Cobalah online!

Mengambil input sebagai kartu yang tidak terpisah, dan menghasilkan yang sama (mis. KCAC5C6S...)

Untuk membuatnya lebih mudah untuk diuji, inilah versi yang mengambil input sebagai dipisahkan koma dan output sebagai baris baru dipisahkan.

Semua x0ini hanyalah upaya untuk membuat generator angka acak semi-seragam. Semakin banyak dari mereka meningkatkan rentang nilai yang mungkin, dan sebaliknya untuk kurang. 10 dari mereka adalah tempat saya menilainya cukup acak.

Perhatikan bahwa itu mengikuti aturan dalam hal itu:

• Semua kartu memiliki peluang yang sama untuk dipilih untuk dibalik.
• Semua kartu memiliki peluang yang sama untuk muncul di mana saja di geladak yang dikocok.

Tetapi tidak semua kombinasi yang dikocok adalah output yang mungkin (dan pada kenyataannya, sebagian besar tidak).

Jelly , 26 byte

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

Tautan monadik yang menerima daftar daftar karakter (sebuah rintisan 0 kartu atau setumpuk penuh 52 kartu dengan satu kartu dibalik) dan mengembalikan daftar daftar karakter (sebuah rintisan dari 1 kartu terbalik tetapi maju atau penuh -deck dengan satu kartu acak terbalik).

Cobalah online! (footer untuk membuat representasi input dan output cocok - sebagai program penuh kode Jelly Python-evals argumen dan menghancurkan karakter bersama untuk output)

Bagaimana?

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 (atau 100) byte

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

Diberikan array kosong sebagai input, mengembalikan dek sebagai array string. Diberikan array yang kosong sebagai input, mengembalikan kartu yang dibalik sebagai array yang berisi string tunggal. Jika kartu yang dibalik diperlukan sebagai string daripada array elemen tunggal yang mengandung string, berikut ini menambah 5 byte: ubah s-nke(s-n)[0]

Cobalah online!

Baris pertama menghasilkan dek standar. Baris kedua rusak sebagai berikut

 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");}

Input adalah sebuah String, output adalah sebuah String atau java.util.Listtergantung pada input.

Penjelasan:

Cobalah online.

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

Pyth, 45 byte

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

Mengambil daftar kosong untuk input kosong.
Cobalah online

Penjelasan

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

Cobalah online!

Diberikan input kosong, (panggilan ftanpa input), kami default ke l=1dan dengan demikian membuat permutasi acak mdari dek. Dengan asumsi samplebenar-benar acak, ada probabilitas yang sama dari kartu apa pun yang menjadi yang pertama dalam daftar ini. Jadi kami memodifikasi yang pertama, dan kemudian mengocok lagi, mengembalikan daftar.

Membalikkannya, kami mencari kartu yang dimulai dengan salah satu SDHCdan membalikkannya.

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

Cobalah online!

Kartu adalah tupel dari (value,suit)

Masukan kosong adalah []