एक शानदार फेरबदल ™ निष्पादित करें

Question

इस प्रश्न के प्रयोजनों के लिए, कार्ड का एक डेक इस तरह से स्वरूपित किया जाता है:

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

कार्ड को हमेशा मूल्य के रूप में स्वरूपित किया जाता है, उसके बाद सूट। जैसे ASहुकुम का इक्का है। दो सिंगल जे जोकर हैं। हम कार्ड के इस डेक को फेरबदल करना चाहते हैं, लेकिन फेरबदल करना शानदार ™ होना चाहिए।

एक शानदार साधा ™ है जिसमें से एक:

• एक ही सूट के दो कार्ड (जोकर को छोड़कर) समीप नहीं हैं।
• कोई भी कार्ड (जोकर्स को छोड़कर) एक ही मूल्य के निकट नहीं है।
• कोई भी कार्ड (जोकर्स को छोड़कर) आसन्न मान में से किसी एक के समीप नहीं है (इस क्रम में उच्च या एक से कम, ए, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K,) ए ध्यान दें कि ऐस 2 या एक राजा के निकट नहीं हो सकता है)।
• जोकर किसी भी स्थिति में हो सकते हैं।
• शानदार फेरबदल ™ की परिभाषा को हर बार अलग-अलग क्रम में कार्ड की आवश्यकता नहीं होती है। जो बहुत शानदार नहीं है, लेकिन यह शानदार ™ है।

क्योंकि वह शानदार ™ है।

एक उदाहरण हो सकता है:

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

---

चुनौती:

• शानदार फेरबदल को अंजाम देने के लिए कुछ कोड लिखें
• किसी भी भाषा का उपयोग करें।
• इनपुट या तो हो सकता है :
  • एक सरणी या अन्य सूची संरचना के रूप में एक ही क्रम में ऊपर वर्णित कार्ड का एक डेक ।
  • कोई इनपुट नहीं (कोड उस क्रम में कार्ड का एक डेक बनाता है)
• जैसा कि ऊपर वर्णित है, आउटपुट को शानदार फेरबदल ™ में कार्ड का एक पूर्ण डेक होना चाहिए।
• सबसे कम संख्या में बाइट्स में अपने शानदार शफ़ल ™ का प्रदर्शन करने का प्रयास करें।
• एक ऑनलाइन दुभाषिया जैसे कि ट्राई इट ऑनलाइन का लिंक पसंद किया जाता है, लेकिन वैकल्पिक है।

खुश फेरबदल!

Comments

कुछ हद तक संबंधित

— झबरा

क्या हम Tइसके बजाय स्थानापन्न कर सकते हैं 10?

— जो राजा

@ जॉकिंग आप नहीं कर सकते। ताश के पत्तों के सवाल पैदा करने की तरह, अलग-अलग स्ट्रिंग लंबाई जटिलता का हिस्सा हैं।

— AJFaraday

क्या हमें प्रत्येक कार्ड को अलग-अलग प्रिंट करने की अनुमति है जैसे चारकोल जवाब करता है, या क्या हमें वास्तव में एक सरणी / सूची वापस करने की आवश्यकता है?

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

@ केविनक्रूजसेन यह ठीक है, जब तक कि यह कार्ड के डेक को उस प्रारूप (मूल्य तब सूट) में ध्यान देने योग्य है।

— AJFaraday

Answer 1

जाप, ६ ५ 4 बाइट्स

हर 16 वें तत्व और समतल के उप-सरणियों में इनपुट सरणी को विभाजित करता है।

óG c

कोशिश करो

Comments

क्या आपको इसे समतल करने की आवश्यकता है?

— ओलिवर

@ ओलिवर, मैं उम्मीद नहीं कर रहा हूँ; एजे के कन्फर्म होने का इंतजार।

— झबरा

Answer 2

रूबी , 31 बाइट्स

->x{(0..53).map{|r|x[r*17%54]}}

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

स्पष्टीकरण:

मैं एक कार्ड चुन रहा हूं, फिर अगले 16 पर स्किप करता हूं और पहले कार्ड से शुरू करता हूं जब मैं डेक के आखिरी कार्ड पर पहुंचता हूं। 17 और 54 पारस्परिक रूप से प्राइम हैं, इसलिए मैं सभी कार्ड चुनना सुनिश्चित करता हूं।

17 वें स्थान पर एक अलग सूट होने की गारंटी है और मूल्य में अंतर कम से कम 2 है: 13 वें (या 15 वें) कार्ड में एक ही मूल्य और एक अलग सूट है, इसलिए अन्य 4 (या 2) को छोड़ कर, मान सही है ।

Comments

इस प्रक्रिया को हर दूसरे जवाब का उपयोग करने पर अच्छी तरह से किया जाता है;)

— AJFaraday

क्या आप बता सकते हैं कि आपने * 17% 54 कैसे पाया? बस परीक्षण और त्रुटि या कुछ स्पष्ट गणित है जो मुझे याद आ रही है?

— डैनियल

@ डैनियल 17 दो अलग-अलग अनुकूल कार्डों के बीच आवश्यक न्यूनतम दूरी है जो समवर्ती रूप से नहीं हैं (दो जोकरों के लिए लेखांकन; उदाहरण के लिए 17 कदम आपको ऐस ऑफ क्लब्स से 3 से हुकुम तक पहुंचते हैं); 54 डेक में कार्ड की संख्या है।

— नरक

Answer 3

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

lambda x:(x*17)[::17]

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

स्पष्टीकरण:

मेरे रूबी जवाब के रूप में एक ही विचार, लेकिन पायथन में भी छोटा: मैं 17 डेक का उपयोग करता हूं, और हर 17 वें कार्ड को चुनता हूं।

Answer 4

जावास्क्रिप्ट, 35 बाइट्स

x=>x.map((a,i)=>i%2?a:x[(i+20)%54])

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

डेक के एक सरणी को इनपुट के रूप में लेना, और प्रत्येक विषम मान को दूसरे कार्ड के साथ बदलना जो डेक पर "20 कार्ड" है।

Comments

अहा, जब मैंने कहा कि मेरे पोस्ट में "सभी" गलत थे; इस तरह से मैं भी गया!

— जोनाथन एलन

Answer 5

जावा 10, 72 65 बाइट्स

d->{var r=d.clone();for(int i=54;i-->0;r[i*7%54]=d[i]);return r;}

इसी प्रकार के रूप में @GB की रूबी जवाब है, लेकिन का उपयोग करके i*7%54परिणाम सरणी पर, के बजाय i*17%54इनपुट सरणी पर एक बाइट को बचाने के लिए।

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

स्पष्टीकरण:

d->{              // Method with String-array as both parameter and return-type
  var r=d.clone();//  Result-String, starting as a copy of the input
  for(int i=54;i-->0;
                  //   Loop `i` in the range (54, 0]
    r[            //    Set an item in the result-array at index:
      i*7%54      //     Index `i` multiplied by 7, and then take modulo-54
     ]=d[i]);     //    To the `i`'th item in the input-Deck
  return r;}      //  Return the result-Array

Comments

दुर्भाग्य से, परिणाम में कई कार्ड हैं जो एक ही सूट के कार्ड से सटे हैं। इसके साथ शुरू होता है AS, 6S, JS, 3D, 8D, KD,।

— AJFaraday

@AJFaraday TIO 7. के बजाय 11 के साथ अभी भी था। क्या आप इसे फिर से जांच सकते हैं। शायद मैं कुछ और याद करता था, लेकिन मुझे लगता है कि यह अब सही होना चाहिए (मुझे उम्मीद है)।

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

यह अब मिल गया है। अच्छा काम!

— AJFaraday

Answer 6

पर्ल 6 , 21 20 18 बाइट्स

ब्रैड गिल्बर्ट b2gills -2 बाइट्स के लिए धन्यवाद

{.[$++*17%$_]xx$_}

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

फिर भी जीबी के उत्तर का एक और पोर्ट । ध्यान दें कि, जबकि ग्लोबल वैरिएबल $!फ़ंक्शंस के बीच रीसेट नहीं होता है, वैल्यू कोई फर्क नहीं पड़ता, क्योंकि आउटपुट का कोई भी ऑर्डर मान्य है। हालांकि, $ है रीसेट।

स्पष्टीकरण:

{                } #Anonymous code block
             xx$_  #Repeat size of inputted array (54) times
 .[         ]      #Get from the inputted array, the value at index
    $++*17%$_         #The incremented variable, multiplied by 17, modded by size of the array

Comments

यह एक अनाम राज्य संस्करण के साथ ही काम करता है जैसा $कि यह $!या इसके साथ करता है $/। इसके अलावा अगर आप इसके $_बजाय इस्तेमाल करते हैं तो आप @_इसे किसी अन्य बाइट .[…]को @_[…]बचाने के बजाय इसके साथ शुरू कर सकते हैं ।

— ब्रैड गिल्बर्ट

Answer 7

05AB1E , 9 7 5 बाइट्स

ā17*è

@GB के रूबी जवाब का पोर्ट , इसलिए उसे सुनिश्चित करें!

-2 बाइट्स को प्रत्येक कार्ड को एक नई-लाइन सीमांकक के साथ प्रिंट करने के बजाय परिणाम-सूची में लपेटने के बजाय
-2 बाइट्स @ Mr.Xcoder के लिए धन्यवाद

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

स्पष्टीकरण:

ā        # 1-indexed length range [1 ... length_of_input_list (54)]
 17*     #  `k`: Multiply each index by 17
    è    #  And then replace each item with the 0-indexed `k`'th card of the input-list
         #  (with automatic wrap-around)

Comments

ā17*è2 और बाइट बचाना चाहिए

— श्री Xcoder

Answer 8

जावास्क्रिप्ट, २ 27

माणिक उत्तर के आधार पर एक और

d=>d.map((_,i)=>d[i*17%54])

एक स्पष्ट लघुकरण में संपादित

Answer 9

टी-एसक्यूएल, 31 बाइट्स

SELECT c FROM t ORDER BY i*7%54

यदि आप आउटपुट में एक अतिरिक्त कॉलम की परवाह नहीं करते हैं तो मैं इसे 29 बाइट्स तक ले जा सकता हूं :

SELECT*FROM t ORDER BY i*7%54

तो आप सत्यापित कर सकते हैं कि मेरा उत्पादन "शानदार" है, यहाँ डेक का उत्पादन होता है:

 J, 5H,  8S, KH, 3D,  8C, JD, AS, 6H,  9S, AC, 4D, 9C, QD, 
2S, 7H, 10S, 2C, 5D, 10C, KD, 3S, 8H,  JS, 3C, 6D, JC, 
AH, 4S,  9H, QS, 4C,  7D, QC, 2H, 5S, 10H, KS, 5C, 8D, 
KC, 3H,  6S, JH, AD,  6C, 9D,  J, 4H,  7S, QH, 2D, 7C, 10D

(नए SQL 2017 जोड़ के उपयोग से उत्पन्न STRING_AGG):

SELECT STRING_AGG(c,', ')WITHIN GROUP(ORDER BY i*7%54)FROM t 

मेरे लिए कठिन हिस्सा चयन कोड नहीं था, यह इनपुट तालिका (जो हमारे IO नियमों के अनुसार SQL के लिए अनुमत है) को पॉप्युलेट कर रहा था ) को ।

क्योंकि एसक्यूएल (यह केवल एक निश्चित क्रम यदि आप एक स्पष्ट शामिल की गारंटी देता है स्वाभाविक अव्यवस्थित है ORDER BYखंड), मैं एक क्षेत्र के रूप में है कि मूल आदेश को शामिल करने के लिए किया था मैं इनपुट तालिका में टी । इसका मतलब यह भी है कि मैं इसे "समान प्राइम" कारक / मॉड प्रक्रिया का उपयोग करके सॉर्ट करने के लिए उपयोग कर सकता हूं, जो हर कोई उपयोग कर रहा है। मैंने पाया कि i*7%54बस के रूप में अच्छी तरह से काम किया i*17%54।

इस संबंधित प्रश्न के मेरे समाधान के आधार पर, इनपुट टेबल टी को स्थापित करने और आबाद करने के लिए यहां कमांड दिए गए हैं :

CREATE TABLE t (i INT IDENTITY(1,1), c VARCHAR(5))

--Insert 52 suited cards
INSERT t(c)
SELECT v.value+s.a as c
FROM STRING_SPLIT('A-2-3-4-5-6-7-8-9-10-J-Q-K','-')v,
     (VALUES('S',1),('D',2),('H',3),('C',4))s(a,b)
ORDER BY s.b

--Insert Jokers
INSERT t(c) SELECT 'J'
INSERT t(c) SELECT 'J'

Comments

क्या iयहां अतिरिक्त इनपुट नहीं माना जाएगा?

— झबरा

@ शग्गी प्रश्न कहता है कि मैं मूल (सूचीबद्ध) क्रम में इनपुट डेक प्राप्त कर सकता हूं। SQL में इसकी गारंटी देने का एकमात्र तरीका इनपुट का स्पष्ट भाग होना है, क्योंकि SQL तालिकाओं में कोई "डिफ़ॉल्ट क्रम" नहीं है । इसलिए, मैं इसे इनपुट के एक आवश्यक घटक के रूप में देखता हूं। लेकिन चिंता न करें, SQL शायद ही कभी प्रतिस्पर्धी है :)

— ब्रैड

Answer 10

जेली ,  5  4 बाइट्स

s⁴ZẎ

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

जिस तरह से यादृच्छिक आदमी कर रहा है, उसे छोड़कर हर कोई अन्य तरीके से मुड़ता है: एक बाइट बचाता है :( अपनी विधि के लिए जीबी को क्रेडिट ।

---

जिस तरह से मैं गया था ...

ṙÐe20

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

कैसे?

हर दूसरे कार्ड को ठीक करें और इसे 20 स्थानों (18 और 22 स्थानों पर छोड़े गए डेक के रोटेशन के साथ इंटरसेप्टर करें) भी काम करता है, इसके अलावा रोटेशन की दिशा या तो विषम या कार्ड को भी ठीक करता है)

ṙÐe20 - Link: list of the card strings (lists of characters)
   20 - place a literal twenty on the right
 Ðe   - apply to even indices:
ṙ     -   rotate left (by 20)

वह है (s के Tलिए 10और rj& के bjलिए उपयोग करना J):

input: AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj
  ṙ20: 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D
ṙÐe20: AS 9D 3S JD 5S KD 7S 2H 9S 4H JS 6H KS 8H 2D TH 4D QH 6D AC 8D 3C TD 5C QD 7C AH 9C 3H JC 5H KC 7H bj 9H 2S JH 4S KH 6S 2C 8S 4C TS 6C QS 8C AD TC 3D QC 5D rj 7D

Answer 11

पावरशेल 3.0, 30 26 बाइट्स

$args[(0..53|%{$_*17%54})]

^-4
30 बाइट्स पर ^Mazzy पुराने कोड के ^{लिए धन्यवाद}

param($d)0..53|%{$d[$_*17%54]}

जीबी की विधि का एक और बंदरगाह।

Comments

26 बाइट्स $args[(0..53|%{$_*17%54})]।

— माज़ी

@Mazzy मुझे लगता है कि इनपुट चश्मा टूट जाता है। यकीन है कि वे $ args में एकत्र हुए हैं, लेकिन आप वास्तव में एक में प्रवेश नहीं कर रहे हैं।

— Veskah

बोली: The input can be either:... in the same order, as *an array*। $argsएक सरणी है। और आप एक दिखावा का उपयोग कर सकते हैं । उदाहरण के लिए $a=@("AS", ..., "J"); &{} @a। कोशिश करो। :)

— माज़ी

अतिरिक्त रूप से, यह मुझे प्रतीत होता है कि पात्रों को गिनने की आवश्यकता नहीं है &{और }। आप param($d)0..53|%{$d[$_*17%54]}किसी फ़ाइल को सहेज सकते हैं । और इस फ़ाइल को बिना कॉल करें&{...}

— mazzy

@ mazzy हाँ, मैं हमेशा थोड़ा अनिश्चित रहा हूँ, जिसे नियंत्रित करने के लिए पुर्जे बनाए जाते हैं ताकि आमतौर पर इसे स्क्रिप्ट ब्लॉक बनाने में चूक हो जाए। मैं इसे भविष्य में छीन लूंगा।

— विस्कह

Answer 12

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

Ｅθ§θ×¹⁷κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। @ GB के रूबी उत्तर का एक और पोर्ट। स्पष्टीकरण:

 θ          Input array
Ｅ           Map over elements
       κ    Current index
     ¹⁷     Literal 17
    ×       Multiply
   θ        Input array
  §         Cyclically index
            Implicitly print each result on its own line

Answer 13

लाल , 44 बाइट्स

func[a][append/dup a a 16 prin extract a 17]

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

जीबी के कोड का एक और इंटरप्रिटेशन। मैं डेक की 16 प्रतियों को अपने पास रखता हूं और फिर प्रत्येक 17 वें कार्ड को निकालता हूं।