16

पहली जादू कार्ड ट्रिक जिसे मैंने एक बच्चे के रूप में सीखा था वह निम्नलिखित थी:

कार्ड के 1 डेक है जहां पीठ पर पैटर्न लंबवत सममित नहीं है।
एक दिशा का सामना करने के लिए सभी कार्ड व्यवस्थित करें।
किसी व्यक्ति से, "कोई भी कार्ड, कोई भी कार्ड चुनें, उसे याद रखें और उसे आपको वापस दे दें"।
इसे डेक (गलत दिशा में) में रखने के लिए आगे बढ़ें।
ज़ोर से हिलाओ, यह भ्रम देते हुए कि तुम्हें पता नहीं होगा कि उनका कार्ड कहाँ है।
उनके कार्ड को उनके विस्मय में बनाएँ।

यह ट्रिक जाहिर तौर पर अब थोड़े दिनों में थोड़ी कम कमी वाली है, लेकिन यह एक अच्छी चुनौती है। एक प्रोग्राम लिखें, कि जब कोई इनपुट नहीं दिया जाता है, तो कार्डों में से एक के साथ बेतरतीब ढंग से फेरबदल के डेक को आउटपुट करता है, जिसे यादृच्छिक पर चुना जाता है, उलटा होता है। हालाँकि, जब इनपुट कार्ड का एक डेक होता है जिसमें एक कार्ड उलटा होता है, तो आपको उल्टा कार्ड (सही क्रम में) आउटपुट करना होगा।

कार्ड का डेक

कार्डों के एक डेक को परिभाषित किया जाता है:

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

एक कार्ड को इसकी संख्या के रूप में परिभाषित किया गया है, फिर इसके सूट का पहला अक्षर। एक कार्ड का उल्टा इसके विपरीत है, इसके सूट का पहला अक्षर एक नंबर के बाद है।

द ड्रोन कार्ड

उदाहरण के लिए, यदि कार्ड को हमने बेतरतीब ढंग से रिवर्स करने के लिए चुना था 4 of Clubs (4C), तो हम (बिना फेरबदल के, स्पष्ट रूप से) समाप्त कर देंगे:

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

फेरबदल

फिर, फेरबदल के बाद:

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

यह एक मान्य आउटपुट है जिसे खाली इनपुट दिया जाता है।

डेक इनपुट

हालांकि, इसके विपरीत, जब हमारे कार्यक्रम को इनपुट के रूप में उपरोक्त आउटपुट प्राप्त होता है, तो इसे आउटपुट करना चाहिए 4C। एक इनपुट के लिए, यह कहना है:

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

जब तक आप उलटा कार्ड नहीं ढूंढते हैं, तब तक आप इसे पुन: व्यवस्थित करते हैं, और इसे वापस लौटाते हैं, वापस सामान्य अवस्था में लौट आते हैं। तो यहाँ हम C4जानेंगे, कि C एक नंबर नहीं है, और इसे उसी रूप में लौटाएं 4C, जो सही है।

नियम

आप किसी भी बाहरी स्रोतों से डेक को लोड नहीं कर सकते हैं।
एक खाली इनपुट में 1 यादृच्छिक कार्ड के साथ एक बेतरतीब ढंग से फेरबदल डेक का परिणाम होना चाहिए।
1 कार्ड के साथ कार्ड का एक डेक उलट कार्ड के परिणामस्वरूप इनपुट होना चाहिए।
किसी भी अन्य आदानों के परिणामस्वरूप फ्यूजलिस्टिक ट्यूब के माध्यम से विस्फोटक लैलास सवारी सेगवे में परिणाम कर सकते हैं।
- या उस मुद्दे के लिए कुछ और भी।
चुने गए कार्ड और फेरबदल क्रम दोनों को समान रूप से यादृच्छिक होना चाहिए।
- IE सभी कार्डों को उलट कर चुने जाने की समान संभावना है।
- IE कार्ड के सभी संयोजनों में प्रदर्शित होने का एक समान मौका है।
आप सूट के लिए उपयोग SHCDकर सकते हैं, या shcdसुसंगत हो सकते हैं:
- यदि आप अपरकेस सूट चुनते हैं ( SHCD) तो आपको भी उपयोग करना चाहिए TJQKA।
- यदि आप लोवरकेस सूट चुनते हैं ( shcd) तो आपको भी इस्तेमाल करना चाहिए tjqka।
यह कोड-गोल्फ है , विजेता सबसे कम बाइट्स है।

code-golf random card-games

— जादू ऑक्टोपस Urn
स्रोत

2

@ लैबेला - गोडोआ इस Fha के बहुत सारे रूपांतर है। मुझे याद है कि मेरे पिताजी ने लंबवत सममित कार्डों का उपयोग करके और एक अलग चाल चलकर मेरे दिमाग को उड़ा दिया था, लेकिन मुझे लगता है कि यह एक था।

— मैजिक ऑक्टोपस Urn

13

"विस्फोटक लामा एक फ्यूचरिस्टिक ट्यूब के माध्यम से सेगवे की सवारी करते हैं" - मैं आपकी अगली अस्की-आर्ट चैलेंज की प्रतीक्षा कर रहा हूं ...

— लेवल रिवर सेंट

3

पूरे डेक को 0 से 51 तक की एक यादृच्छिक ऑफसेट से घुमाकर समावेशी स्थिति को संतुष्ट करता है कि "सभी कार्डों को फेरबदल वाले डेक में कहीं भी प्रदर्शित होने का समान मौका है", लेकिन शायद इसे यादृच्छिक फेरबदल नहीं माना जाना चाहिए। क्या आपका मतलब है कि सभी (52!) आदेश लगभग समान रूप से होने की संभावना है?

— एशप्लर

1

बस जो @aschepler ने कहा था उस पर विस्तार करने के लिए: कई भाषाओं में डिफ़ॉल्ट PRNG की अवधि के साथ, 52 में से अधिकांश ! संभावित फेरबदल शून्य के बराबर दिखने की संभावना है (हालांकि यह फेरबदल एल्गोरिथ्म के आधार पर बेहतर या खराब हो सकता है)।

— Arnauld

1

क्या एक दलाई लामा एक डोली पर लामा की सवारी भी स्वीकार्य है? मैं सेगवेज़ और विस्फोटकों से बाहर हूँ, लेकिन मुझे कैंडी कीड़े मिले हैं ... i.imgur.com/gEkVR5P.gif

— Tschallacka

7

रेटिना , 61 60 59 बाइट्स

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

इसे ऑनलाइन आज़माएं! संपादित करें: @MartinEnder के लिए 1 2 बाइट्स सहेजे गए। स्पष्टीकरण:

G`[HCDS].

सभी अपरिवर्तित कार्ड हटाएं। यह एक उलटा कार्ड या कोई कार्ड नहीं छोड़ना चाहिए।

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

यदि इनपुट (अभी) खाली है, तो कार्ड का एक पैकेट बनाएं।

@V`

बेतरतीब ढंग से एक कार्ड का चयन करें और इसे उलट दें (एकल उलट कार्ड को अपरिवर्तित करता है)।

O?`

कार्ड को फेरबदल करें।

— नील
स्रोत

4

05AB1E , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

। • •k {? •W • 9LJ `#` उन दो को एक साथ सेक करने के लिए कुछ बाइट्स बचाएंगे।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: 1 और 2 को हटाने के बाद, यह एक ही बायटेकाउंट पर समाप्त होता है?

— एमिगा

इसे ऑनलाइन आज़माएं! - 28, सही?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: दुर्भाग्य से नहीं। आप दोनों में 1और aवहाँ है।

— एमिगा

गलत मतलब निकालने की मेरे लिए छोड़ दो Y9ŸJके रूप में9LJ

— जादू ऑक्टोपस कलश

3

PowerShell v2 या बाद में, 175 बाइट्स

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

दीर्घ संस्करण:

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

उपयोग:

एक फेरबदल डेक बनाएँ और इसे एक चर में संग्रहीत करें:

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

उदाहरण के लिए, चर का निरीक्षण करें

$Deck -join ','

स्क्रिप्ट में डेक को वापस लाएँ:

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

— user314159
स्रोत

2

पायथन 2 , 175 बाइट्स

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)

इसे ऑनलाइन आज़माएं! खाली इनपुट के रूप में चिह्नित किया जाता है[]

— OVS
स्रोत

2

> <> , 215 193 बाइट्स

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/

इसे ऑनलाइन आज़माएं!

पृथक कार्ड के रूप में इनपुट नहीं लेता है, और आउटपुट भी उसी के समान है (उदा KCAC5C6S...)

परीक्षण करना आसान बनाने के लिए, यहां एक संस्करण है जो अल्पविराम के रूप में इनपुट लेता है और न्यूलाइन के रूप में अलग हो जाता है।

सभी x0एस केवल एक अर्ध-समान यादृच्छिक संख्या जनरेटर बनाने का प्रयास कर रहे हैं। उनमें से अधिक संभव मूल्यों की सीमा को बढ़ाते हैं, और कम के लिए विपरीत। उनमें से 10 हैं जहां मैंने इसे यादृच्छिक रूप से पर्याप्त होने के लिए आंका था।

ध्यान दें कि यह उस में नियमों का पालन करता है:

सभी कार्डों को उलट कर चुने जाने की समान संभावना है।
सभी कार्डों में फेरबदल किए गए डेक में कहीं भी दिखने की समान संभावना होती है।

लेकिन सभी फेरबदल संयोजन संभव आउटपुट नहीं हैं (और वास्तव में, विशाल बहुमत नहीं हैं)।

— मजाक कर रहा है
स्रोत

2

जेली , 26 बाइट्स

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

वर्णों की सूची (0 कार्ड्स का स्टब या एक कार्ड के साथ 52 कार्डों का एक पूर्ण डेक) की एक सूची को स्वीकार करते हुए एक मोनडिक लिंक (वर्णों की सूचियों की सूची लौटाता है (1 उलट कार्ड का एक स्टब लेकिन आगे या पूर्ण) -एक बेतरतीब कार्ड के साथ उलट)।

इसे ऑनलाइन आज़माएं! (इनपुट और आउटपुट रिप्रेजेंटेशन मैच बनाने के लिए पाद लेख - एक पूर्ण कार्यक्रम के रूप में जेली कोड पायथन ने तर्क दिया और आउटपुट के लिए पात्रों को एक साथ मिटाता है)

कैसे?

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

— जोनाथन एलन
स्रोत

यह हमेशा दस दिलों को उल्टा लगता है। यह एक यादृच्छिक कार्ड नहीं होना चाहिए?

— एमिगा

आह, धन्यवाद, हाँ एक बग है - इसे Ẋपहले एक अतिरिक्त के साथ तय किया जा सकता है U(शायद मैं शून्य बाइट्स के लिए ठीक कर सकता हूं) लेकिन बाद में इसे करना होगा ...

— जोनाथन एलन

चूंकि यह एक फ़ंक्शन है, इसलिए मुझे यकीन नहीं है कि इनपुट न होने पर आप एकल कार्ड का प्रतिनिधित्व करने के [[number, suit]]बजाय वापस आ सकते हैं [number, suit]।

— एर्गेलफर को एरिक करें

इसके अलावा, नहीं, मुझे नहीं लगता कि इसके लिए कोई 0-बाइट फिक्स है।

— 12

@EriktheOutgolfer मैं नहीं देखता कि क्यों, एक अकेला कार्ड सब के बाद सिर्फ एक कार्ड का एक स्टब (छोटा डेक) है।

— जोनाथन एलन

1

रूबी , 95 (या 100) बाइट्स

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

खाली सरणी को इनपुट के रूप में देखते हुए, डेक को स्ट्रिंग्स के एक सरणी के रूप में देता है। एक गैर-रिक्त सरणी को इनपुट के रूप में देखते हुए, फ़्लिप किए गए कार्ड को एक एकल स्ट्रिंग वाले सरणी के रूप में देता है। फ़्लिप कार्ड के बजाय स्ट्रिंग वाली एक एकल तत्व सरणी की तुलना में एक स्ट्रिंग के रूप में की आवश्यकता है, निम्नलिखित 5 बाइट्स जोड़ता है: परिवर्तन s-nकरने के लिए(s-n)[0]

इसे ऑनलाइन आज़माएं!

पहली पंक्ति एक मानक डेक उत्पन्न करती है। दूसरी पंक्ति निम्नानुसार टूट जाती है

 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
}

— स्तर नदी सेंट
स्रोत

1

जावा 8, 275 274 259 बाइट्स

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

इनपुट एक स्ट्रिंग है, आउटपुट या तो स्ट्रिंग है या java.util.Listइनपुट पर निर्भर करता है।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं।

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

— केविन क्रूज़सेन
स्रोत

1

पायथ, 45 बाइट्स

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

खाली इनपुट के लिए खाली सूची लेता है।
इसे ऑनलाइन आज़माएं

व्याख्या

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.

1

आर , 177 171 बाइट्स

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

इसे ऑनलाइन आज़माएं!

खाली इनपुट को देखते हुए, ( fबिना इनपुट के कॉल करें ), हम डिफॉल्ट करते हैं l=1और इस तरह mडेक का एक यादृच्छिक क्रमांकन बनाते हैं । यह मानते हुए sampleकि वास्तव में यादृच्छिक है, इस सूची में किसी भी कार्ड के पहले होने की समान संभावना है। इसलिए हम पहले एक को संशोधित करते हैं, और फिर फेरबदल करते हैं, सूची वापस करते हैं।

इसे SDHCउल्टा करते हुए , हम एक कार्ड की तलाश करते हैं जिसमें से एक के साथ शुरू होता है और इसे उल्टा करता है।

— ग्यूसेप
स्रोत

1

पायथन 2 , 135 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कार्ड के ट्यूपल हैं (value,suit)

खाली इनपुट है []

— TFeld
स्रोत

मैजिक कार्ड ट्रिक देखना चाहते हैं?

नियम

रेटिना , 61 60 59 बाइट्स

05AB1E , 29 बाइट्स

PowerShell v2 या बाद में, 175 बाइट्स

उपयोग:

पायथन 2 , 175 बाइट्स

> <> , 215 193 बाइट्स

जेली , 26 बाइट्स

कैसे?

रूबी , 95 (या 100) बाइट्स

जावा 8, 275 274 259 बाइट्स

पायथ, 45 बाइट्स

व्याख्या

आर , 177 171 बाइट्स

पायथन 2 , 135 बाइट्स