बाइनरी नंबर मैजिक ट्रिक


28

चुनौती बस है; निम्नलिखित छह 2D पूर्णांक सरणियों का उत्पादन:

[[ 1, 11, 21, 31, 41, 51],
 [ 3, 13, 23, 33, 43, 53],
 [ 5, 15, 25, 35, 45, 55],
 [ 7, 17, 27, 37, 47, 57],
 [ 9, 19, 29, 39, 49, 59]]

[[ 2, 11, 22, 31, 42, 51],
 [ 3, 14, 23, 34, 43, 54],
 [ 6, 15, 26, 35, 46, 55],
 [ 7, 18, 27, 38, 47, 58],
 [10, 19, 30, 39, 50, 59]]

[[ 4, 13, 22, 31, 44, 53],
 [ 5, 14, 23, 36, 45, 54],
 [ 6, 15, 28, 37, 46, 55],
 [ 7, 20, 29, 38, 47, 60],
 [12, 21, 30, 39, 52]]

[[ 8, 13, 26, 31, 44, 57],
 [ 9, 14, 27, 40, 45, 58],
 [10, 15, 28, 41, 46, 59],
 [11, 24, 29, 42, 47, 60],
 [12, 25, 30, 43, 56]]

[[16, 21, 26, 31, 52, 57],
 [17, 22, 27, 48, 53, 58],
 [18, 23, 28, 49, 54, 59],
 [19, 24, 29, 50, 55, 60],
 [20, 25, 30, 51, 56]]

[[32, 37, 42, 47, 52, 57],
 [33, 38, 43, 48, 53, 58],
 [34, 39, 44, 49, 54, 59],
 [35, 40, 45, 50, 55, 60],
 [36, 41, 46, 51, 56]]

ये 2D पूर्णांक सरणियाँ क्या हैं? इन संख्याओं वाले कार्ड के साथ मैजिक ट्रिक में उपयोग किए जाने वाले नंबर हैं:

यहाँ छवि विवरण दर्ज करें

मैजिक ट्रिक किसी को रेंज [1, 60] में एक नंबर के बारे में सोचने के लिए कहती है, और मैजिक ट्रिक को करने वाले सभी कार्ड को देती है जिसमें यह नंबर होता है। जादू की चाल का प्रदर्शन करने वाले व्यक्ति को उस नंबर के लिए शीर्ष-बाईं संख्या (सभी 2 की एक शक्ति) प्राप्त हो सकती है, जिस संख्या के बारे में वह सोच रहा था। यह काम क्यों किया जा सकता है, इसके बारे में कुछ अतिरिक्त व्याख्या।

चुनौती नियम:

  • आप किसी भी उचित प्रारूप में छह 2D पूर्णांक सरणियों का उत्पादन कर सकते हैं। सीमांकक के साथ मुद्रित किया जा सकता है; एक 3D पूर्णांक सरणी हो सकती है जिसमें छह 2D पूर्णांक सरणियाँ होती हैं; लाइनों की एक स्ट्रिंग-सूची हो सकती है; आदि।
  • आपको अंतिम चार कार्डों के निचले सही स्थान को श्रेणी [-60, -1]या वर्ण में ऋणात्मक मान के साथ भरने की अनुमति है '*'बजाय इसे छोड़ने के लिए 2D पूर्णांक सरणियों आयताकार matrices (नहीं, आपको उन्हें 0या गैर के साथ भरने की अनुमति नहीं है -इनटेगर जैसे null/ undefinedके विकल्प के साथ, के अपवाद के साथ* बाद से एक स्टार का वास्तविक कार्ड में भी उपयोग किया जाता है)।
  • मेट्रिसेस में संख्याओं का क्रम अनिवार्य है। यद्यपि यह भौतिक जादू की चाल के लिए कोई फर्क नहीं पड़ता है, मैं इस चुनौती को मुख्य रूप से एक - एक के रूप में देखता हूं , इसलिए आदेश पर प्रतिबंध है।
    खुद को आउटपुट सूची में मैट्रिसेस का क्रम किसी भी क्रम में हो सकता है, क्योंकि यह शीर्ष-बाएं कार्ड से स्पष्ट है कि कौन सा मैट्रिक्स है।

सामान्य नियम:

  • यह , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट ढीले निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

सम्बंधित। (जैसा कि, यह एक ही जादू की चाल का जिक्र है, लेकिन इस चुनौती से प्रेरणा पाने के लिए वास्तव में उपयोगी नहीं है, मुझे लगता है। यह चुनौती एक सत्य / गलत मूल्य को आउटपुट करने के लिए कहती है चाहे संख्या।nk 'वें कार्ड पर दिखाई देती है ; जहां मेरी चुनौती एक चुनौती है) केसी-चैलेंज छह मैट्रिसेस को आउटपुट करने के लिए।)
केविन क्रूज़सेन

1
@DigitalTrauma Hm, मुझे यकीन नहीं है कि अगर यह वास्तव में एक डुप्लिकेट है, क्योंकि आपकी चुनौती एससीआई -आर्ट है (जैसे टैग नहीं है, लेकिन यह है), जबकि यह आपको एक तरह से सरणी को और अधिक आकर्षक प्रारूप में आउटपुट करने की अनुमति देता है (सिर्फ चार अनिवार्य रूप से समान तरीके नहीं)। मैं फिर से खोलने के लिए वोट नहीं कर सकता, क्योंकि मेरे पास एक हथौड़ा है।
एरिक आउटोलॉफ़र

@EriktheOutgolfer Woops .. भूल गए कि मेरे पास एक हथौड़ा भी है>> कभी-कभी हथौड़ा बंद / खुला करने में सक्षम होना बहुत कष्टप्रद होता है .. हालांकि इसमें पहले से ही 2 वोट थे, इसलिए आपके और मेरे अलावा 4 खुले वोट थे। लेकिन अगर कोई इसे फिर से बंद करना चाहता है तो मुझे कोई आपत्ति नहीं है। वे वास्तव में बहुत समान हैं, हालांकि उनकी चुनौती वास्तव में [ascii-art]सख्त (एमडी 5) आउटपुट नियमों के साथ एक चुनौती है, जहां मेरा बहुत लचीला है (और पंक्तियों / स्तंभों की अदला-बदली की जाती है, और सीमा [1,60]इसके बजाय [1,63]बहुत मामूली अंतर है, लेकिन अभी भी)।
केविन क्रूज़सेन

लगता है कि आपने "यह मेरी अनमोल चुनौती है" के रवैये के साथ VTRO की कोशिश नहीं की !!! कम से कम ...: पी
आउटगोल्फर

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

जवाबों:


6

MATL , 12 11 बाइट्स

-1 बाइट के लिए धन्यवाद खुद गुरु :)

60:B"@fQ6eq

स्पष्टीकरण:

60:           % create a vector [1,2,3,...,60]
   B          % convert to binary matrix (each row corresponds to one number)
    "         % loop over the columns and execute following commands:
     @f       % "find" all the nonzero entries and list their indices
       Q      % increment everything
        6e    % reshape and pad with a zero at the end
          q   % decrement (reverts the increment and makes a -1 out of the zero
              % close loop (]) implicitly
              % display the entries implicitly

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



7

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

r=range;print[[[i for i in r(61)if i&2**k][j::5]for j in r(5)]for k in r(6)]

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

यहाँ की विधि सभी संभावित संख्याओं की सूची बनाना है r(61) और फिर एक कार्ड के लिए नंबरों की सूची के लिए नीचे की ओर व्हॉट्सi&2**k

फिर, सूची स्लाइसिंग का उपयोग करके, संख्याओं की 1D सूची को सही 6x5 कार्ड आकार में पुन: व्यवस्थित किया जाता है [card nums][j::5]for j in r(5)

फिर, यह जनरेटर सिर्फ 6 कार्ड के लिए दोहराया जाता है for k in r(6)


जबकि मुझे 76 बाइट्स से कम कोई समाधान नहीं मिला, यहाँ दो अन्य हैं जो 76 बाइट्स भी हैं:

r=range;print[[[i for i in r(61)if i&1<<k][j::5]for j in r(5)]for k in r(6)]

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

यह अगला जोनाथन एलन से प्रेरित है ।

k=32
while k:print[[i for i in range(61)if i&k][j::5]for j in range(5)];k/=2

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

किसी भी टिप्पणी की बहुत सराहना की है।


6

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

E⁶E⁵⪫E⁶§⁺§⪪Φ⁶¹&πX²ι⁵ν⟦*⟧λ 

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मैंने सीधे प्रविष्टियों की गणना करने की कोशिश की लेकिन *नीचे दाईं ओर समायोजित करने से पहले यह 27 बाइट्स थी । आउटपुट प्रत्येक पंक्ति रिक्त स्थान और कार्ड के बीच एक रिक्त लाइन के साथ जुड़ गए। स्पष्टीकरण:

E⁶                          Loop over 6 cards
  E⁵                        Loop over 5 rows
     E⁶                     Loop over 6 columns
           Φ⁶¹              Filter over 0..60 where
               π            Current value
              &             Bitwise And
                 ²          Literal 2
                X           Raised to power
                  ι         Card index
          ⪪        ⁵        Split into groups of 5
         §          ν       Indexed by column
        ⁺                   Concatenated with
                      *     Literal string `*`
                     ⟦ ⟧    Wrapped in an array
       §                λ   Indexed by row
    ⪫                       Joined with spaces
                            Implicitly print

मैंने *वास्तविक कार्ड पर सितारों को देखने के बाद उस नियम को मनोरंजन के लिए जोड़ा । सोच रहा था कि क्या इसका उपयोग करने वाली कोई भाषा होगी, लेकिन मुझे कम से कम एक को देखकर खुशी हुई। :) अच्छा जवाब!
केविन क्रूज़सेन

1
@ केविनक्रूजसेन चारकोल के पास एक ट्रांसजेंडर ऑपरेटर नहीं है, और गोल्फस्टॉप ट्रांसजेस को ज्ञात आकार के एक आयताकार सरणी की आवश्यकता होती है, इसलिए मुझे आकार बनाने के लिए कुछ जोड़ना होगा, और *कम से कम उतना ही छोटा होगा जितना कि कुछ और होगा।
नील

मुझे नहीं लगता कि यह 26 बाइट्स है ...
Tvde1

@ Tvde1 चारकोल, इस साइट पर कई एसोलंग की तरह, एक कस्टम कोड पेज का उपयोग करता है। उस पृष्ठ के वर्णों की लागत 1 बाइट होती है, जबकि अन्य वर्णों की लागत 4 बाइट तक होती है।
नील

6

05AB1E , 16 बाइट्स

60L2вíƶ0ζε0K5ô®ζ

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

व्याख्या

60L                 # push [1 ... 60]
   2в               # convert each to a list of binary digits
     í              # reverse each
      ƶ             # multiply each by its 1-based index
       0ζ           # transpose with 0 as filler
         ε          # apply to each list
          0K        # remove zeroes
            5ô      # split into groups of 5
              ®ζ    # zip using -1 as filler

05AB1E , 17 बाइट्स

6F60ÝNoôāÈϘ5ô®ζ,

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

व्याख्या

6F                  # for N in [0 ... 5] do
  60Ý               # push [0 ... 60]
     Noô            # split into groups of 2^N numbers
        āÈÏ         # keep every other group
           ˜        # flatten
            5ô      # split into groups of 5
              ®ζ    # transpose with -1 as filler
                ,   # print

5

भूसी , 13 बाइट्स

ṠMöTC5Wnünḣ60

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

व्याख्या

          ḣ60  Range [1..60]
        ü      Uniquify using equality predicate
         n     bitwise AND: [1,2,4,8,16,32]
 M             For each number x in this list,
Ṡ     W        take the indices of elements of [1..60]
       n       that have nonzero bitwise AND with x,
    C5         cut that list into chunks of length 5
  öT           and transpose it.

5

पायथन 2 , 82 80 78 74 बाइट्स

i=1 
exec"print zip(*zip(*[(n for n in range(61)+[-1]if n&i)]*5));i*=2;"*6

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

-4 बाइट्स, जोनाथन एलन के लिए धन्यवाद


3
अच्छा लगा। iterक्योंकि कीवर्ड यहां बेमानी है एक जनरेटर बस के रूप में अच्छी तरह से काम करेगा
जोनाथन एलन

@JonathanAllan कूल, धन्यवाद: D
TFeld


4

जावास्क्रिप्ट (ईएस 6),  90  88 बाइट्स

_=>[1,2,4,8,16,32].map(n=>(g=i=>i<60?g(++i,i&n?m[y%5]=[...m[y++%5]||[],i]:0):m)(y=m=[]))

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

टिप्पणी की गई

_ =>                        // anonymous function taking no argument
  [1, 2, 4, 8, 16, 32]      // list of powers of 2, from 2**0 to 2**5
  .map(n =>                 // for each entry n in this list:
    ( g = i =>              //   g = recursive function taking a counter i
      i < 60 ?              //     if i is less than 60:
        g(                  //       recursive call:
          ++i,              //         increment i
          i & n ?           //         if a bitwise AND between i and n is non-zero:
            m[y % 5] =      //           update m[y % 5]:
            [ ...m[y++ % 5] //             prepend all previous values; increment y
              || [],        //             or prepend nothing if it was undefined so far
              i             //             append i
            ]               //           end of update
          :                 //         else:
            0               //           do nothing
        )                   //       end of recursive call
      :                     //     else:
        m                   //       return m[]
    )(y = m = [])           //   initial call to g with i = y = m = []
                            //   (i and y being coerced to 0)
  )                         // end of map()


4

सी (जीसीसी) , 95 बाइट्स

i,j,k;f(int o[][5][6]){for(i=6;i;)for(o[--i][4][5]=j=k=-1;j<60;)++j&1<<i?o[i][++k%5][k/5]=j:0;}

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

ओ में 3 डी इंट सरणी के रूप में मेट्रिसेस लौटाता है।

पिछले 4 मेट्रिसेस में -1 उनके अंतिम मूल्य के रूप में है।

केविन क्रूज़सेन के लिए धन्यवाद 2 बाइट्स बचाए।

सहेजा गया 7 8 बाइट्स अर्नुल्ड के लिए धन्यवाद।


आप को बदलने के द्वारा 2 बाइट्स बचा सकते हैं o[i][4][5]=-1;for(j=k=0;करने के लिए for(o[i][4][5]=-1,j=k=0;तो कोष्ठक हटाया जा सकता है। मुझसे अच्छा जवाब btw, +1।
केविन क्रूज़सेन


(ध्यान दें कि मैं नहीं कर रहा हूँ 100% पहले से ही सही आयामों के साथ आवंटित एक 3 डी सरणी गुजर अनुमति यकीन है कि अगर है लेकिन मैं दूँगा नियमित सी गोल्फरों कि के बारे में बेहतर जानकारी प्रदान करते हैं।।)
Arnauld

@Arnauld मैं उस बारे में सोच रहा था, लेकिन इसके खिलाफ फैसला किया।
मतेज मुलज

बाहर जाने के लिए बेहतर है #includeयह दिखाने के लिए कि यह इसके बिना काम करता है
ASCII- केवल

3

CJam (18 बाइट्स)

6{61{2A#&},5/zp}fA

ऑनलाइन डेमो । यह एक पूर्ण कार्यक्रम है जो stdout को आउटपुट करता है।

विच्छेदन

6{             }fA    # for A = 0 to 5
  61{2A#&},           #   filter [0,61) by whether bit 2^A is set
           5/z        #   break into chunks of 5 and transpose to get 5 lists
              p       #   print

3

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

60&ƇⱮs€5LÐṂZ€

एक निलादिक लिंक जो (6) पूर्णांकों की सूचियों की सूची तैयार करता है। (यह कोई *या नकारात्मक भराव होने के डिफ़ॉल्ट विकल्प का उपयोग कर आउटपुट करता है ।)

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

कैसे?

60 जो एकल सेट-बिट को शीर्ष-बाएँ (न्यूनतम) संख्या के साथ साझा करती हैं।

यह कार्यक्रम पहले सभी बनाता है।60[1,60] जो किसी भी सेट-बिट (s) को उनकी अनुक्रमणिका संख्या के साथ साझा करते हैं। यह तब प्रत्येक को विखंडू में विभाजित करता है5

60&ƇⱮs€5LÐṂZ€ - Link: no arguments
60            - set the left argument to 60
    Ɱ         - map across ([1..60]) with:  (i.e. [f(60,x) for x in [1..60]])
   Ƈ          -   filter keep if:  (N.B. 0 is falsey, while non-zeros are truthy)
  &           -     bitwise AND
      €       - for each:
     s 5      -   split into chunks of five
         ÐṂ   - keep those with minimal:
        L     -   length
           Z€ - transpose each

15 वीं के बहुत सारे "फाइव्स में विभाजित होने पर लंबाई द्वारा न्यूनतम" की प्राप्ति के बिना। चाल:

5Ż2*Ɱ60&ƇⱮs€5Z€
6µ’2*60&Ƈ)s€5Z€
60&ƇⱮ`LÞḣ6s€5Z€

... और, छोटे को खोजने का प्रयास करते हुए, मुझे एक और 13 मिल गया जो बिना किसी चाल की जरूरत के:

60B€Uz0Ts5ZƊ€

3

वोल्फ्राम भाषा (गणितज्ञ) , 88 बाइट्स

Transpose@Partition[#~Append~-1,5]&/@Last@Reap[Sow[,NumberExpand[,2]]~Do~{,60},Except@0]

मैंने एक TIO लिंक जोड़ने की स्वतंत्रता ली ( @ J42161217 के उत्तर पर आधारित )। मुझ से +1।
केविन क्रूज़सेन


@ Mr.Xcoder धन्यवाद। मैंने इस ~ट्रिक को एक और जगह पर प्रयोग किया है और वेरिएबल kको बदल दिया है Null। क्षमा करें, tio लिंक जोड़ने का कोई समय नहीं है।
ब्रूनो ले फ्लो

2

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 99 बाइट्स

Transpose@Partition[#~FromDigits~2&/@Last@GatherBy[{0,1}~Tuples~6,#[[-k]]&],5]~Table~{k,6}/. 61->-1

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


आप कुछ चार बचा सकते हैं: के Transpose@बजाय कर Transpose[...]; विभाजन से पहले 30 प्रविष्टियों के लिए पैडिंग; Table[...,{k,6}]ज़रूरत से बचने के लिए उपयोग करना k=#
ब्रूनो ले फ्लोच

@ ब्रूनो ले फ़्लो टेबल एक बाइट बचा सकता है। क्या आपने @ पारगमन की कोशिश की? क्योंकि अगर आप ध्यान से देखें तो यह काम नहीं करता है। मैं
afk

क्षमा करें, Transpose@आपके PadRightअंदर जाने के बाद काम करता है Partition। एक और टिप्पणी यह ​​है कि प्रश्न ""प्लेसहोल्डर के लिए अनुमति नहीं देता है ; आप इसे -1बिना किसी बाइट को खोए बदल सकते हैं ।
ब्रूनो ले फ्लोच


2

आर , 73 बाइट्स

`!`=as.raw;lapply(0:5,function(i)matrix(c((a=1:60)[(!a&!2^i)>0],-1),5,6))

मुझे पूरी तरह से यकीन नहीं है कि अगर मुझे ऑर्डर की आवश्यकता पूरी हो गई है, क्योंकि R डिफ़ॉल्ट रूप से कॉलम द्वारा मैट्रिसेस भरता है, इसलिए कार्ड पर भौतिक रूप से दिखाई देने वाला ऑर्डर वैसा ही होता है, जिस तरह से मैट्रिस को आर में आवंटित किया जाता है।

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


आउटपुट अच्छा लग रहा है। और यदि R लगभग सभी अन्य भाषाओं की तरह कॉलम से पहले पंक्ति के बजाय कॉलम से मैट्रिसेस को भरता है, तो इसका मतलब है कि मुझे इस चुनौती के लिए उपयोग करने के लिए एक अच्छी प्रोग्रामिंग भाषा है। :)
केविन क्रूज़सेन

2

टी-एसक्यूएल, ( 1,168) 1,139 बाइट्स)

मैं सिर्फ यह जानना चाहता था कि मैं यह कर सकता हूं।

अनुकूलित संस्करण

 WITH g AS(SELECT 1 AS n UNION ALL SELECT n+1 FROM g WHERE n+1<61),B as(SELECT cast(cast(n&32 as bit)as CHAR(1))+cast(cast(n&16 as bit)as CHAR(1))+cast(cast(n&8 as bit)as CHAR(1))+cast(cast(n&4 as bit)as CHAR(1))+cast(cast(n&2 as bit)as CHAR(1))+cast(cast(n&1 as bit)as CHAR(1))as b FROM g),P as(SELECT * from (values(1), (2), (4), (8), (16), (32)) as Q(p)),S as(select distinct p,p+(substring(b,6,1)*1)*(case when p=1 then 0 else 1 end)+(substring(b,5,1)*2)*(case when p=2 then 0 else 1 end)+(substring(b,4,1)*4)*(case when p=4 then 0 else 1 end)+(substring(b,3,1)*8)*(case when p=8 then 0 else 1 end)+(substring(b,2,1)*16)*(case when p=16 then 0 else 1 end)+(substring(b,1,1)*32)*(case when p=32 then 0 else 1 end)as e from P cross apply B),D as(select * from S where e>=p and e<61),R as(select p,(row_number()over(partition by p order by cast(e as int)))%5 as r,e from D),H as(select k.p,'['+stuff((select','+cast(l.e as varchar)from R l where l.p=k.p and l.r=k.r for xml path('')),1,1,'')+']'as s from R k group by k.p,k.r)select stuff((select','+cast(x.s as varchar)from H x where x.p=z.p for xml path('')),1,1,'')from H z group by z.p

ऑनलाइन डेमो

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

वर्बोज़ संस्करण - एसक्यूएल टिप्पणियों के रूप में नोट्स के साथ

WITH gen -- numbers 1 to 60
AS (
    SELECT 1 AS num
    UNION ALL
    SELECT num+1 FROM gen WHERE num+1<=60
),
BINARIES -- string representations of binaries 000001 through 111111
as (
SELECT 
    +cast( cast(num & 32 as bit) as CHAR(1))
    +cast( cast(num & 16 as bit)  as CHAR(1))
    +cast( cast(num & 8 as bit)  as CHAR(1))
    +cast( cast(num & 4 as bit)  as CHAR(1))
    +cast( cast(num & 2 as bit)   as CHAR(1))
    +cast(cast(num & 1 as bit)  as CHAR(1)) as binry FROM gen
),
POWERS -- first 6 powers of 2
as (
SELECT * from (values(1), (2), (4), (8), (16), (32)) as Q(powr)
),
SETELEMENTS -- cross apply the six powers of 2 against the binaries
-- returns 2 cols. col 1 = the power of 2 in question.
-- col 2 is calculated as that power of 2 plus the sum of each power of 2 other than the current row's power value, 
-- but only where a given power of 2 is switched "on" in the binary string, 
-- ie. where the first digit in the string represents 32, the second represents 16 and so on. 
-- That is, if the binary is 100100 then the number will be 
-- the sum of (32 x 1) + (16 x 0) + (8 x 0) + (4 x 1) + (2 x 0) + (1 x 0) 
-- but if the current row's power is 32 or 4, then just that number (32 or 4) is excluded from the sum.
-- rows are distinct.
as (
select distinct powr,
powr+
 (substring(binry,6,1) * 1) * (case when powr = 1 then 0 else 1 end)
 +(substring(binry,5,1) * 2) * (case when powr = 2 then 0 else 1 end)
 +(substring(binry,4,1) * 4) * (case when powr = 4 then 0 else 1 end)
 +(substring(binry,3,1) * 8) * (case when powr = 8 then 0 else 1 end)
 +(substring(binry,2,1) * 16) * (case when powr = 16 then 0 else 1 end)
 +(substring(binry,1,1) * 32) * (case when powr = 32 then 0 else 1 end) as elt
from POWERS cross apply BINARIES
),
DISTINCTELEMENTS -- purge calculated numbers smaller than the power of 2 or greater than 60
as (
select * from SETELEMENTS where elt >= powr and elt < 61
)--,
,
ROWNUMBERED -- for each power, number the rows repeatedly from 0 through 5, then back to 0 through 5 again, etc
as (
select powr, (row_number() over (partition by powr order by cast(elt as int)))%5 as r, elt  from DISTINCTELEMENTS
),
GROUPEDSETS -- for each row number, within each power, aggregate the numbers as a comma-delimited list and wrap in square brackets - the inner arrays
as (
select r1.powr, '['+stuff((select ',' + cast(r2.elt as varchar) from ROWNUMBERED r2 where r2.powr = r1.powr and r2.r = r1.r for xml path('')),1,1,'')+']' as s
from ROWNUMBERED r1
group by r1.powr,r1.r
)
select -- now aggregate all the inner arrays per power
stuff((select ',' + cast(g2.s as varchar) from GROUPEDSETS g2 where g2.powr = g1.powr for xml path('')),1,1,'')
from GROUPEDSETS g1
group by g1.powr

देखा!

नोट 1: कुछ तर्क वर्ग कोष्ठक और अल्पविराम प्रदान करने से संबंधित हैं।

नोट 2: SQLServer के नए संस्करणों में कॉमा-सीमांकित सूची बनाने के लिए अधिक कॉम्पैक्ट दृष्टिकोण हैं। (यह SQL सर्वर 2016 पर बनाया गया था।)

नोट 3: दिए गए कार्ड के लिए एरर्स को छांटा नहीं गया है (जो कि प्रति युक्ति ठीक है)। एक सरणी के भीतर संख्याओं को सही ढंग से क्रमबद्ध किया गया है। इस मामले में, प्रश्न का प्रत्येक "कार्ड", परिणामों में एक अलग पंक्ति पर अपनी सरणियों का प्रतिपादन करता है।

हार्ड-कोड सरणियों के लिए छोटा?

हाँ।

मुझे बाइट करो।


जीजा, क्या यह केवल परिणाम को हार्डकोड करने के लिए छोटा नहीं होगा?
जो किंग

Haha। न तो मस्ती के रूप में, न ही एक्सटेंसिबल।
youcantryreachingme

मुझे पूरी तरह से समझ नहीं है - क्या आप कह रहे हैं कि आपका समाधान केवल संयोग से काम करता है या क्या आप आश्वस्त हैं कि आपने विनिर्देशों का सही ढंग से पालन किया है?
जोनाथन फ्रेच

@JonathanFrech - मैंने संख्याओं के क्रम के लिए स्पष्ट रूप से कोड नहीं दिया है, हालांकि भाषा में एक अंतर्निहित शर्त हो सकती है जिसके परिणामस्वरूप एक गारंटीकृत आदेश होगा। वे सही आरोही क्रम में प्रस्तुत करते हैं। अलग-अलग, पोस्ट करने के बाद, मुझे एहसास हुआ कि मुझे गलतफहमी हो गई थी कि डेटा कैसे प्रस्तुत किया जाना चाहिए (प्रति कार्ड में एक एकल सेट के बजाय धारीदार सरणियों में) - तो अभी तक उस समस्या को हल करना बाकी है। इस प्रकार, परिणाम वर्तमान में सही संख्या प्रदान करता है, आरोही क्रम में, 6 अपेक्षित सेटों में से प्रत्येक में - लिंक किए गए वर्ग फ़ेल्ड देखें। अभी भी करना है: सेट को 5 सबसेट में तोड़ें।
youcantryreachingme

मैं आपके प्रयास की सराहना करता हूं लेकिन यदि आपका समाधान सही नहीं है, तो कृपया इसे ठीक करें या अपनी पोस्ट हटा दें। हम आमतौर पर अवैध जवाब के लिए अनुमति नहीं देते हैं।
जोनाथन फ्रीच




1

MATLAB, 155 बाइट्स

cellfun(@disp,cellfun(@(x)x-repmat(62,5,6).*(x>60),cellfun(@(x)reshape(find(x,30),[5 6]),mat2cell(dec2bin(1:62)-48,62,ones(1,6)),'Uniform',0),'Uniform',0))

यह कई लाइनों के रूप में छोटा हो सकता है लेकिन मैं इसे कोड की एक पंक्ति में करना चाहता था।


1
क्या आप शायद टेस्ट कोड के साथ एक TIO लिंक जोड़ सकते हैं, इसलिए मैं आउटपुट को सत्यापित कर सकता हूं?
केविन क्रूज़सेन

1

05AB1E , 14 बाइट्स

žOε60LDNo&ĀÏ5ι

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


1
क्यों žOसिर्फ इसके बजाय 6L? मुझे पता है कि आप उन्हें अपने मानचित्र में उपयोग नहीं कर रहे हैं, लेकिन मैं उत्सुक हूं कि आपने aeiouy6 मानों के साथ एक सूची बनाने का उपयोग क्यों किया है। xD अच्छा जवाब, btw!
केविन क्रूजसेन

1
@KevinCruijssen कोई विशेष कारण, मैं सिर्फ सोचा था कि यह तुलना में मजेदार था 6L, , , , या 9!
ग्रिम्मी

यह निश्चित रूप से मेरी आँख पकड़ा, यह सुनिश्चित करने के लिए है। ;)
केविन क्रूज़सेन

@KevinCruijssen मैं सिर्फ महसूस किया тœ, ₅œ, ₁œ:, भी काम करते हैं, उन सुंदर भी शांत कर रहे हैं (
ग्रिमी

₆bसाथ ही काम करेगा;)
केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.