Pierwszą sztuczką z magiczną kartą, której nauczyłem się jako dziecko, była:

• Posiadaj 1 talię kart, w której wzór na odwrocie nie jest symetryczny w pionie.
• Ułóż wszystkie karty tak, aby były skierowane w jednym kierunku.
• Poproś osobę, by „wybrała kartę, dowolną kartę, zapamiętaj ją i oddaj tobie”.
• Przejdź do umieszczenia go na pokładzie (w złym kierunku).
• Energicznie tasuj, dając iluzję, że nie będziesz wiedział, gdzie jest ich karta.
• Wykaż swoją kartę ku ich zdumieniu.

Ta sztuczka jest oczywiście nieco pozbawiona blasku w przyrodzie, jednak stanowi spore wyzwanie. Napisz program, który jeśli nie otrzyma danych wejściowych, generuje losowo potasowaną talię kart z jedną z losowo wybranych kart odwróconą. Jednakże, gdy wejściem jest talia kart z odwróconą jedną kartą, musisz wydać odwróconą kartę (we właściwej kolejności).

Talia kart

Talia kart jest zdefiniowana jako:

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

Kartę definiuje się jako jej liczbę, a następnie pierwszą literę jej koloru. Odwrotna strona karty jest dokładnie odwrotna, pierwsza litera koloru, po której następuje liczba.

Wyciągnięta karta

Przykład: jeśli karta, którą losowo wybraliśmy do odwrócenia, byłaby taka 4 of Clubs (4C), otrzymalibyśmy (bez tasowania, oczywiście):

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

Tasowanie

Następnie po przetasowaniu:

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

To jest prawidłowy wynik, biorąc pod uwagę puste dane wejściowe.

Wejście na pokład

Jednak odwrotnie, gdy nasz program odbiera powyższe dane wyjściowe jako dane wejściowe, powinien on generować dane wyjściowe 4C. To znaczy, dla danych wejściowych:

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

Powtarzaj, dopóki nie znajdziesz odwróconej karty, i zwróć ją z powrotem do normalnego stanu. Przekonamy się więc C4, że C nie jest liczbą i zwracamy ją jako 4C, co jest poprawne.

Zasady

• Nie możesz ładować talii z jakichkolwiek zewnętrznych źródeł.
• Puste wejście powinno spowodować losowo potasowaną talię z odwróconą 1 losową kartą.
• Talia kart z odwróconą 1 kartą jako wejściem powinna skutkować odwróconą kartą.
• Wszelkie inne wkłady mogą spowodować wybuchowe lamy jeżdżące segwayami przez futurystyczną rurkę.
  • Lub cokolwiek innego, jeśli o to chodzi.
• Zarówno wybrana karta, jak i kolejność losowania muszą być jednakowo losowe.
  • IE wszystkie karty mają równe szanse, że zostaną wybrane do odwrócenia.
  • IE wszystkie kombinacje kart mają jednakową szansę pojawienia się.
• Możesz użyć SHCDlub shcddo garniturów, ale zachowaj spójność:
  • Jeśli wybierzesz wielkie litery ( SHCD), musisz także użyć TJQKA.
  • Jeśli wybierzesz małe litery ( shcd), musisz także użyć tjqka.
• To jest golf golfowy , zwycięzca ma najmniej bajtów.

Siatkówka , 61 60 59 bajtów

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

Wypróbuj online! Edycja: Zapisano 1 2 bajty dzięki @MartinEnder. Wyjaśnienie:

G`[HCDS].

Usuń wszystkie nieodwrócone karty. To powinno zostawić jedną odwróconą kartę lub nie mieć żadnej karty.

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

Jeśli wejście jest (teraz) puste, utwórz paczkę kart.

@V`

Losowo wybierz jedną kartę i odwróć ją (odwraca pojedynczą odwróconą kartę).

O?`

Potasuj kartę (karty).

05AB1E , 29 bajtów

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

Wypróbuj online!

PowerShell v2 lub nowszy, 175 bajtów

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

Długa wersja:

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

Stosowanie:

Utwórz potasowaną talię i przechowuj ją w zmiennej:

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

Na przykład sprawdź zmienną do woli

$Deck -join ','

Wklej talię z powrotem do skryptu:

$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 bajtów

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)

Wypróbuj online! puste wejście jest oznaczone jako[]

> <> , 215 193 bajtów

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/

Wypróbuj online!

Pobiera dane wejściowe jako nierozdzielone karty i dane wyjściowe jako takie same (np KCAC5C6S... )

Aby ułatwić testowanie, oto wersja która pobiera dane wejściowe jako oddzielone przecinkami, a dane wyjściowe - jako separację nowego wiersza.

Wszystkie x0 s to tylko próba stworzenia półjednolitego generatora liczb losowych. Więcej z nich zwiększa zakres możliwych wartości, a wręcz przeciwnie za mniej. 10 z nich uznałem za wystarczająco losowe.

Pamiętaj, że przestrzega następujących zasad:

• Wszystkie karty mają równe szanse na to, że zostaną wybrane do odwrócenia.
• Wszystkie karty mają równe szanse pojawienia się w dowolnym miejscu w tasowanej talii.

Ale nie wszystkie tasowane kombinacje są możliwymi wyjściami (a tak naprawdę zdecydowana większość nie jest).

Galaretka , 26 bajtów

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

Monadyczny link akceptujący listę list znaków (odcinek 0 kart lub pełna talia 52 kart z odwróconą jedną kartą) i zwracający listę list znaków (odcinek 1 odwróconej karty, ale do przodu lub pełna - pokład z odwróconą jedną losową kartą).

Wypróbuj online!(stopka do dopasowania reprezentacji wejściowych i wyjściowych - jako pełny program Python-kod Jelly analizuje argument i rozbija znaki razem dla wyniku)

W jaki sposób?

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

Rubinowy , 95 (lub 100) bajtów

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

Biorąc pod uwagę pustą tablicę jako dane wejściowe, zwraca talię jako tablicę ciągów znaków. Biorąc pod uwagę niepustą tablicę jako dane wejściowe, zwraca odwróconą kartę jako tablicę zawierającą pojedynczy ciąg. Jeśli odwrócona karta jest wymagana jako ciąg, a nie tablica jednoelementowa zawierająca ciąg, poniższe dodaje 5 bajtów: zmień s-nna(s-n)[0]

Wypróbuj online!

Pierwsza linia generuje standardową talię. Druga linia dzieli się w następujący sposób

 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 bajtów

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

Dane wejściowe to ciąg java.util.Listznaków , dane wyjściowe to ciąg znaków lub zależnie od danych wejściowych.

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Pobiera pustą listę dla pustych danych wejściowych.
Wypróbuj online

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Biorąc pod uwagę puste dane wejściowe (wywołanie fbez danych wejściowych), domyślnie ustawiamy l=1losową permutacjęm talii. Zarozumiałysample jest naprawdę losowy, istnieje prawdopodobieństwo, że każda karta będzie pierwsza na tej liście. Więc modyfikujemy pierwszy, a następnie ponownie tasujemy, zwracając listę.

Odwracając go, szukamy karty zaczynającej się od jednej SDHCi odwracamy ją.

Python 2 , 135 bajtów

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

Wypróbuj online!

Karty są krotkami po (value,suit)

Puste wejście to []