इनपुट

कोई नहीं

उत्पादन

52 कार्ड। कोई नकल नहीं करता। कार्ड को उनके यूनिकोड वर्णों के रूप में दर्शाया जाता है, जैसे un।

यूनिकोड कोड पॉइंट्स निम्न स्वरूप का पालन करें:

पहले तीन अंक हैं 1F0।
अगले अंकों है A, B, C, या Dहुकुम, पान, ईंट और चिडी क्रमशः के लिए।
अगले अंक के 1माध्यम से Cऔर Eविभिन्न संख्याओं / चेहरे कार्ड के लिए है। 1इक्का, है 2- Aसंख्या कार्ड हैं, और B, Dऔर Eजैक, रानी और राजा क्रमशः रहे हैं। ( Cनाइट है, जो अधिकांश डेक में नहीं है।)

उदाहरण आउटपुट:

🂶🃁🃛🃎🂧🂵🃗🂦🂽🂹🂣🃊🃚🂲🂡🂥🂷🃄🃃🃞🂺🂭🃑🃙🂪🃖🂳🃘🃒🂻🃆🂮🃍🂱🂴🃋🂸🃈🃅🃂🂨🃓🃉🂾🃇🂩🂢🂫🃔🃕 🂤🃝

नियम:

यह कोड-गोल्फ है । सबसे छोटा जवाब जीत।
निषिद्ध लूपहोल निषिद्ध हैं।
आपका डेक वास्तव में यादृच्छिक होना चाहिए। यदि 20 बार चलाया जाता है, तो 20 यादृच्छिक (और सबसे अधिक संभावना अद्वितीय) आउटपुट उत्पन्न होने चाहिए।

ध्यान दें

यदि आप केवल बॉक्स देखते हैं, तो DejaVu फोंट स्थापित करें ।

— dkudriavtsev
स्रोत

2

क्या प्रत्येक वर्ण के बीच रिक्त स्थान हो सकते हैं?

— जुआन

3

मुझे लगता है कि आपका मतलब यादृच्छिक होना चाहिए और सभी क्रमपरिवर्तनों में घटना की शून्य संभावना नहीं होनी चाहिए।

— Notts90

4

बक्से का एक गुच्छा कौन देख रहा है?

— SuperJedi224

1

@ मेन्डेलेव आपको एक चेतावनी भी पोस्ट करनी चाहिए कि डाउनलोड लगभग एक गीगाबाइट है!

— नूडल

2

यदि आप केवल बॉक्स देखते हैं, तो Google के Noto फोंट स्थापित करें। हाँ, मैं अपने फोन पर ऐसा नहीं कर सकता ...

— डेनिस

9

जेली , 25 23 21 बाइट्स

62R%⁴g180<11T+“¢¬⁷’ẊỌ

एक निलादिक लिंक जो पात्रों की एक सूची लौटाता है, या एक पूर्ण कार्यक्रम जो कि फेरबदल के डेक को प्रिंट करता है।

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

कैसे?

62R%⁴g180<11T+“¢¬⁷’ẊỌ - Main link: no arguments
62                    - literal 62
  R                   - range(62) -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62]
    ⁴                 - literal 16
   %                  - modulo    -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14]
      180             - literal 180
     g                - G.C.D.    -> [1,2,3,4,5,6,1,4,9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2]
          11          - literal 11
         <            - less than?-> [1,1,1,1,1,1,1,1,1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]
            T         - truthy    -> [1,2,3,4,5,6,7,8,9,10,11,   13,14,       17,18,19,20,21,22,23,24,25,26,27,   29,30,       33,34,35,36,37,38,39,40,41,42,43,   45,46,       49,50,51,52,53,54,55,56,57,58,59,   61,62]
              “¢¬⁷’   - base 250 number 127136
             +        - addition (vectorises) -> card character ordinals
                   Ẋ  - shuffle the list
                    Ọ - convert to characters
                      - full program has an implicit print

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

4

क्यों हमेशा जेली है कि यह जादू करता है?

— ग्रिफन - मोनिका

8

जावास्क्रिप्ट (ईएस 6), 107 106 108 बाइट्स

a=[]
for(S of'ABCD')for(N of'123456789ABDE')a.splice(Math.random()*-~a.length,0,eval(`'\\u\{1F0${S+N}}'`))
a

कोड स्निपेट दिखाएं

a=[]
for(S of'ABCD')for(N of'123456789ABDE')a.splice(Math.random()*-~a.length,0,eval(`'\\u\{1F0${S+N}}'`))
a

o.innerHTML = a.join``

<div id=o style="font-size:80px"></div>

Expand snippet

_{-1 बाईट थैंक्स टू @nderscore}

जावास्क्रिप्ट (ईएस 6), 120 119 121 बाइट्स

पुराना वर्जन।

a=[],[...'ABCD'].map(S=>[...'123456789ABCE'].map(N=>a.splice(Math.random()*-~a.length|0,0,eval("'\\u\{1F0"+S+N+"}'")))),a

— darrylyeo
स्रोत

वाह, [...'ABCD']पहले कभी नहीं देखा । यह अच्छा है :)

— स्टीव बेनेट

@SteveBennett वास्तव में! यह अच्छा है कि तार इस तरह से चार से चलने योग्य हैं। :)

— darrylyeo

लेकिन आप अभी भी चीजों को पसंद नहीं कर सकते हैं "ABCD".map(...)। मुझे यकीन है कि समझदार कारण हैं कि ऐसा क्यों है।

— स्टीव बेनेट

@SteveBennett हाँ, मुझे लगता है कि ऐसा लगता है क्योंकि यह अस्पष्ट है कि क्या इस तरह की विधि एक स्ट्रिंग या एक सरणी लौटाएगी।

— darrylyeo

1

बहुत अच्छा लगा। मैंने अधिक ग्राफिकल आउटपुट के लिए स्निपेट को संशोधित करने की स्वतंत्रता ली, लेकिन बेझिझक रोलबैक किया।

— अरनुलद

7

अजगर ३ , 106 94 बाइट्स

-5 बाइट्स musicman523 के लिए धन्यवाद (1. [पूरी तरह से धन्यवाद के sample(...,52)बराबर एक इनलाइन के रूप में उपयोग करें shuffle; 2. ~v&2इसके बजाय का उपयोग करें)v%4<2 ; एक अंतरिक्ष के रूप में एक परिणाम के रूप में एक और 1 बाइट हटा दिया जा सकता है)

from random import*
print(*sample([chr(v+127137)for v in range(63)if~v&2or~v%16>4],52),sep='')

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

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

2

वैसे मैं अपने खुद के पायथन समाधान को किसी भी बेहतर तरीके से प्राप्त करने में सक्षम नहीं था, लेकिन मैंने पूरी तरह से अमानवीय स्विच करने के लिए 97 का उपयोग किया sample। इसे ऑनलाइन आज़माएं!

— संगीतज्ञ ५२३

1

साथ ही, आप बदल सकते हैं v%4<2करने के लिए ~v&2एक और बाइट को बचाने के लिए।

— संगीतज्ञ ५२३

अच्छी तरह से किया! मैंने सोचा था कि शायद एक और randomसमारोह वहाँ मदद कर सकता है। शीर्ष पर एक और बाइट के रूप में or ~...हो सकता है or~...।

— जोनाथन एलन

6

05AB1E , 22 21 बाइट्स

Carusocomputing के लिए 1 बाइट का धन्यवाद सहेजा गया ।

…1F0A4£14L13KhJâ«Hç.r

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

व्याख्या

…1F0                    # push the string "1F0"
    A4£                 # push the string "abcd"
       14L              # push range [1 ... 14]
          13K           # remove 13
             h          # convert to hexadecimal
              J         # join to string "123456789ABCE"
               â        # cartesian product
                «       # prepend the string to each char in the list
                 H      # convert to decimal
                  ç     # get the chars with those code points
                   .r   # randomize

— Emigna
स्रोत

1

…1F0A4£14L13KhJâ«Hç.r21 बाइट्स के लिए (संपादित क्योंकि मैं शूरवीरों को हटाने के लिए भूल गया)। हालांकि आपको जेली बांधने में मदद करता है।

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

@ क्रूसोकोम्पुटिंग: कॉन्सेप्टेशन से पहले कार्टेशियन करने के लिए अच्छा विचार है, इसलिए हम विभाजन को छोड़ सकते हैं। धन्यवाद!

— 18

6

बैश + कोरुटिल्स, 56 बाइट्स

printf %b\\n \\U1F0{A..D}{{1..9},A,B,D,E}|shuf|tr -d \\n

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

ध्यान दें कि हालांकि कोर्यूटिल्स printfकमांड के लिए ठीक 8 हेक्साडेसिमल अंकों की आवश्यकता होती है \U, लेकिन बैश बिल्ट इन- लीडर ज़ीरोस को printfछोड़ देता है।

— टोबी स्पाईट
स्रोत

मैं जहां तक मिला echo 16iF09F8{2A,2B,38,39}{{1..9},A,B,D,E}0AP|dc|shuf|tr -d \\n, लेकिन तुम्हारा बेहतर है। मैं इसके बारे में नहीं जानता था %b।

— डिजिटल ट्रॉमा

1

@ दिगीतल - न तो मैंने, जब तक यह जवाब नहीं लिखा!

— टोबी स्पाइट

3

पायथन 3 , 112 बाइट्स

from random import*
*a,=map(chr,range(127136,127200))
del a[::16],a[::-15],a[11::14]
shuffle(a)
print(*a,sep='')

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

— एंडर्स कसीगोर
स्रोत

क्या आप डेल स्टेटमेंट में चल रहे जादू की व्याख्या कर सकते हैं? मैं इसे तीन क्रमिक बयानों में तोड़कर यह पता लगाने की कोशिश कर रहा हूं, लेकिन मैं सूची में गलत वस्तुओं को हटा रहा हूं। उदाहरण के लिए, एक [:: 16] मुझे एक कार्ड और तीन निर्विवाद यूनिकोड देता है।

— CCB60

delबयान बाएं से दाएं क्रमिक रूप से टूट करता है। का पहला तत्व a[::16]U + 1F0A0 PLAYING CARD BACK है, जिसे हटा दिया जाना चाहिए। हमें उन नाइट और जोकर कार्ड को हटाने की आवश्यकता है जो सामान्य 52 के बीच में अटके हुए हैं । en.wikipedia.org/wiki/… देखें ।

— एंडर्स कासोर्ग

3

अजगर ३ , 107 बाइट्स

सहेजे गए 6 बाइट्स @totallyhuman को धन्यवाद और 3 @ CCB60 को धन्यवाद!

from random import*
print(*sample([chr(int('1F0'+a+b,16))for a in'ABCD'for b in'123456789ABDE'],52),sep='')

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

— musicman523
स्रोत

इसे थोड़ा गोल्फ। यह तभी मान्य है जब रिक्त स्थान को विभाजक के रूप में अनुमति दी जाती है।

— जुआन

@totallyhuman जोड़ना ,sep=''निश्चित रूप से रिक्त स्थान को ठीक करता है - लेकिन यह 112 बाइट्स बनाता है

— vroomfondel

मैं भूल गया random.sample! मैं रिक्त स्थान के बारे में फैसला करने देता हूँ। मैं ,sep=''उनमें से छुटकारा पाने के लिए जोड़ सकता हूं, और अभी भी 6 बाइट बचा सकता हूं ।

— संगीतज्ञ ५२३

chr (int (f'0x1F0 {a} {b} ', 16)) को 3 बाइट्स से chr तक छोटा किया जा सकता है (int (' 0x1F0 '+ a + b, 16))

— CCB605

@ CCB60 मैं मूर्ख हूं। अच्छी पकड़

— म्यूजिशियन 523

3

PHP > = 7, 102 बाइट्स

for(;$i++<64;)in_array(($c=127136+$i)%16,[0,12,15])?:$q[]=IntlChar::chr($c);shuffle($q);echo join($q);

IntlChar :: chr पद्धति के लिए कोई ऑनलाइन इंटरप्रेटर उपलब्ध नहीं है

PHP , 112 बाइट्स

for(;$n++<4;shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=pack("c*",240,159,131-($n>2),$n*16+112+$i);echo join($r);

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

PHP , 116 बाइट्स

for(;$c=ab89[$n++];shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=hex2bin(f09f8.(2+($n>2)).$c.dechex($i));echo join($r);

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

PHP, 121 बाइट्स

for(;$c=ABCD[$n++];shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=json_decode('"\ud83c\udc'.$c.dechex($i).'"');echo join($r);

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

— जार्ग हुल्सरमैन
स्रोत

3

एपीएल (डायलॉग) , 40 38 बाइट्स

जोनाथन एलन की विधि

⎕UCS((11>180∨16|⍳62)/127136+⍳62)[?⍨52]

(… )निम्न सरणी पर

⍳62 पहले 62 पूर्णांक

127136+ इसमें 127136 जोड़ें

(... )/ कि बूलियन के साथ फ़िल्टर करें

⍳62 पहले 62 पूर्णांक

16| मापांक 16

180∨ 180 का GCD और वह

11> क्या 11 उन से अधिक है

[… ]निम्नलिखित तत्वों का चयन करें

?⍨52 पहले 52 पूर्णांकों को फेरबदल करें (पहले 52 पूर्णांकों के एक बैग से 52 यादृच्छिक पूर्णांकों को चुनें)

⎕UCSयू निकोड सी हैचर एस एट में संबंधित प्रतीकों में परिवर्तित करें

संस्करण 16.0 (वर्तमान में बीटा में) समाधान (33 वर्ण)

⎕UCS(127136+⍸11>180∨16|⍳62)[?⍨52]

(… )निम्न सरणी पर

⍳62 पहले 62 पूर्णांक

16| मापांक 16

180∨ 180 का GCD और वह

11> क्या 11 उन से अधिक है

⍸ सूचकांक जहां सच है

127136+ इसमें 127136 जोड़ें

[… ]निम्नलिखित तत्वों का चयन करें

?⍨52 पहले 52 पूर्णांकों को फेरबदल करें (पहले 52 पूर्णांकों के एक बैग से 52 यादृच्छिक पूर्णांकों को चुनें)

⎕UCSयू निकोड सी हैचर एस एट में संबंधित प्रतीकों में परिवर्तित करें

पुराना हल

⎕UCS(126976+16⊥¨,(9+⍳4)∘.,12~⍨⍳14)[?⍨52]

(… )निम्न सरणी पर

⍳14 पहले 14 पूर्णांक

12~⍨ १२ को छोड़कर

(... )∘., कार्टेसियन को संक्षिप्त रूप से

⍳4 पहले 4 पूर्णांक

9+ 9 में जोड़ा गया

, ravel (समतल) जो

16⊥¨ बेस 16 में प्रत्येक का मूल्यांकन करें

126976+ उसमें 126976 जोड़ें

[… ]निम्नलिखित तत्वों का चयन करें

?⍨52 पहले 52 पूर्णांकों को फेरबदल करें (पहले 52 पूर्णांकों के एक बैग से 52 यादृच्छिक पूर्णांकों को चुनें)

⎕UCSयू निकोड सी हैचर एस एट में संबंधित प्रतीकों में परिवर्तित करें

— एडम
स्रोत

3

चारकोल , 50 बाइट्स

Ａ¹²⁷¹³⁶χＡ⪫Ｅ…χ⁺⁶⁴χ℅ιωσＷσ«Ａ‽σχＡ⪫⪪σχωσ¿﹪﹪﹪℅χ¹⁶¦¹⁵¦¹³χ

इसे ऑनलाइन आज़माएं!लिंक कोड के वर्बोज़ संस्करण के लिए है। ब्लॉक के सभी 64 वर्णों की स्ट्रिंग बनाता है लेकिन अमान्य कार्डों को फ़िल्टर करता है क्योंकि वे यादृच्छिक रूप से चुने जाते हैं। (जिसमें से एक स्ट्रिंग के प्रतिस्थापन के बिना यादृच्छिक चयन केवल 11 बाइट्स है, एक सरणी के लिए 17 की तुलना में।)

संपादित करें: एक सरणी से घटाव और अन्य चारकोल सुधार ने आकार को 41 बाइट्स में कटौती की है: इसे ऑनलाइन आज़माएं!

— नील
स्रोत

2

ऐलिस , 34 बाइट्स

'?rwd.n$@U,!6?44*%a7+-F$K?'🂡+OK

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

व्याख्या

'?r                               push numbers 0-63 onto stack
   w                              store return address (start main loop)
    d                             get stack depth
     .n$@                         if zero, terminate
         U                        random number in [0, depth)
          ,                       move corresponding stack element to top
           !                      store on tape
             ?                    copy back from tape
              44*%                mod 16
                  a7+-            subtract 17
            6         F           does the result divide 6?
                       $K         if so, return to start of main loop
                         ?        copy card number from tape again
                          '🂡+     add 0x1F0A1
                             O    output
                              K   return to start of main loop

— Nitrodon
स्रोत

2

> <> , 49 50 49 बाइट्स

"🂡"v
=?v>:1+}:88+%:c-:3-**?!~{l4d*
{>x
o^>l?!;

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

(यादृच्छिकता को बेहतर बनाने के लिए +1 बाइट)

मैं "यादृच्छिक" की व्याख्या कर रहा हूं, जिसका अर्थ है "हर संभव परिणाम में एक गैर-शून्य संभावना है"। यह एक समान वितरण नहीं है।

इस कोड के दो चरण हैं। सबसे पहले, मछली पहले दो पंक्तियों का उपयोग करके सभी कार्ड्स को स्टैक पर रखती है। हुकुम के इक्का के साथ शुरू, मछली इसे डुप्लिकेट और बढ़ाती है, फिर यह जांचती है कि क्या पिछले कार्ड का हेक्स कोड 0, C या F में x ( x -12) ( x -15) को गुणा करके समाप्त होता है , जहां x charcode mod है 16, और जाँच कि अगर शून्य है। यदि यह है, तो यह स्टैक से आपत्तिजनक कार्ड को हटा देता है। यह तब तक दोहराता है जब तक स्टैक में 52 कार्ड नहीं होते हैं, तब चरण 2 में तैरता है:

  v
{>x
o^>l?!;

इस बिट कोड में फेरबदल और स्टैक प्रिंट करता है। xमछली की दिशा बेतरतीब ढंग से सेट:

यदि मछली तैरती है, तो वह हिट करती है vऔर वापस चली जाती हैx बिना कुछ किए । बाईं दिशा समान है।
यदि मछली दाईं ओर {घूमती है, तो वह पूरी तरह से बाईं ओर घूमती हुई, टकराती है और टकराती है , फिर वापस आती हैx ।
यदि मछली नीचे तैरती है, तो यह कार्ड को स्टैक के सामने प्रिंट करती है और फिर वापस आ जाती है x।

यह स्पष्ट है कि कार्ड के हर संभव क्रम का उत्पादन किया जा सकता है: चरण 2 में किसी भी बिंदु पर, अभी तक मुद्रित नहीं किए गए हर कार्ड को मुद्रित किया जा सकता है यदि मछली सही समय पर पर्याप्त तैरती है। यह फेरबदल तकनीक आमतौर पर कार्डों को बहुत दूर नहीं ले जाती है अगर वे पहले से ही एक दूसरे के पास थे, लेकिन फिर से, न तो हाथ से फेरबदल करता है ।

— पेड़ नहीं
स्रोत

2

आर, 61 बाइट्स

cat(intToUtf8(sample(c(127137:127198)[-c(12,28,44,47,60)])))

बेतरतीब ढंग से कार्ड के यूनीकोड मान (जो utf8ToInt()fucntion से प्राप्त किया जा सकता है ) के पूर्णांक निरूपण के वेक्टर का नमूना लें और अवांछित नाइट / जोकर कार्ड को हटा दें।

— एंड्रयू हेन्स
स्रोत

57 बाइट्स

— ग्यूसेप

1

सी # ( 146 141 बाइट्स)

using System.Linq;()=>Enumerable.Range(0,52).OrderBy(i=>System.Guid.NewGuid()).Aggregate("",(s,i)=>s+"\uD83C"+(char)(56481+i+i/13*3+i%13/12))

ऑनलाइन डेमो

इस के साथ फेरबदल में बेहद खराब शैली का उपयोग करता है Guid.NewGuid(), लेकिन यह कोड-गोल्फ है। यह फिर सरोगेट जोड़े को मैन्युअल रूप से बनाता है।

— पीटर टेलर
स्रोत

क्या यह वास्तव में काम करता है? जब भी मैंने गतिशील इंट को एक चार में ढालने की कोशिश की, यह एक अपवाद फेंक दिया?

— द लीथलकोडर

@TheLethalCoder, I don't have any dynamic values. But as proof that it works, I've attached an Ideone link.

— Peter Taylor

I meant the int created for the second part of the surrogate pair.

— TheLethalCoder

आप अनुगामी अर्धविराम को शामिल न करके एक बाइट को बचा सकते हैं

— TheLethalCoder

147 बाइट्स कहते हैं, 146 के रूप में पढ़ता है

— नील ए।

0

पर्ल 5, 75 बाइट्स

@c=map{7946+$_%4+$_/64}4..51,56..59;print chr(16*splice@c,@c*rand,1)while@c

ध्यान दें कि यह क्वेन्स के लिए कोड बिंदुओं का उपयोग करता है जैसा कि प्रश्न में दिया गया है (अर्थात अंतिम अंक C)। वास्तविक कोड बिंदुओं (अंतिम अंक D) के लिए, के 51,56साथ बदलें 47,52।

— faubi
स्रोत

0

जावा 8, 216 बाइट्स

import java.util.*;()->{List<Long>l=new ArrayList();for(long i=52;i-->0;l.add(i));Collections.shuffle(l);for(Long x:l)System.out.print((char)(x.parseLong("1F0"+(char)(65+x/12)+((x%=4)>9?(char)(x>2?69:65+x):x),16)));}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

नोट: लिंक किए गए फ़ॉन्ट को स्थापित करने के बावजूद भी मुझे पता नहीं है, फिर भी मुझे बॉक्स दिखाई दे रहे हैं। शायद मेरे पीसी या कुछ और पुनः आरंभ करने के लिए ..

import java.util.*;               // Required import for List, ArrayList and Collections
()->{                             // Method without parameter nor return-type
  List<Long>l=new ArrayList();    //  List
  for(long i=52;i-->0;l.add(i));  //  Fill the list with 1 through 52
  Collections.shuffle(l);         //  Randomly shuffle the list
  for(Long x:l)                   //  Loop over the shuffled list
    System.out.print(             //   Print the following character:
      (char)(x.parseLong(         //    Convert the following String to a character:
        "1F0"+                    //     The literal String "1F0" +
         (char)(65+x/12)+         //     either A, B, C or D by using x/12, adding 65,
                                  //      and casting it to a char +
         ((x%=4)>9?               //     If the current item mod-4 is 10 or higher:
            (char)(x>2?69:65+x)   //      Convert it to A, B, C or E
           :                      //     Else (1 through 9):
            x)                    //      Simply add this digit
      ,16))
    );
}                                 // End of method

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

0

Dyalog एपीएल, 35 बाइट्स

⎕ucs(∊127150+(16×⍳4)-⊂2~⍨⍳14)[?⍨52]

Adám के उत्तर पर आधारित है

का उपयोग करता है ⎕io←0

— NGN
स्रोत

0

जाप , 51 41 39 22 बाइट्स

जोनाथन के जेली समाधान से कुछ प्रेरणा के साथ ।

#?ö¬k@B§XuG y#´Ãmd##

इसे आज़माएं (या आउटपुट बढ़ा हुआ देखेंfont-size )

व्याख्या

#?                         :63
  ö¬                       :Random permutation of range [0,63)
    k                      :Remove elements that return true
     @                     :When passed through this function
      B                    :  11
       §                   :  Less than or equal to
        X                  :  Current element
         u                 :  Modulo
          G                :  16
            y              :  GCD
             #´            :  180
               Ã           :End function
                m          :Map
                  ##       :  Add 127136
                 d         :  Get character at that codepoint

— झबरा
स्रोत

कार्डों के फेरबदल वाले डेक को प्रिंट करें

इनपुट

उत्पादन

नियम:

ध्यान दें

जेली , 25 23 21 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 107 106 108 बाइट्स

जावास्क्रिप्ट (ईएस 6), 120 119 121 बाइट्स

अजगर ३ , 106 94 बाइट्स

05AB1E , 22 21 बाइट्स

बैश + कोरुटिल्स, 56 बाइट्स

पायथन 3 , 112 बाइट्स

अजगर ३ , 107 बाइट्स

PHP > = 7, 102 बाइट्स

PHP , 112 बाइट्स

PHP , 116 बाइट्स

PHP, 121 बाइट्स

एपीएल (डायलॉग) , 40 38 बाइट्स

जोनाथन एलन की विधि

संस्करण 16.0 (वर्तमान में बीटा में) समाधान (33 वर्ण)

पुराना हल

चारकोल , 50 बाइट्स

ऐलिस , 34 बाइट्स

व्याख्या

> <> , 49 50 49 बाइट्स

आर, 61 बाइट्स

सी # ( 146 141 बाइट्स)

पर्ल 5, 75 बाइट्स

जावा 8, 216 बाइट्स

Dyalog एपीएल, 35 बाइट्स

जाप , 51 41 39 22 बाइट्स

व्याख्या