एक्सर्सस्पेस की खोज

Question

Xorspace पूर्णांकों का एक सेट की है कि हमेशा की तरह बिटवाइज़ XOR ऑपरेटर के साथ शुरू पूर्णांकों के संयोजन के द्वारा प्राप्त किया जा सकता सभी पूर्णांकों का सेट है ( ^)। उदाहरण के लिए, का xorspace (8, 4)है (0, 4, 8, 12): 0 है 4 ^ 4, 12 है 4 ^ 8, और कोई अन्य संख्या तक नहीं पहुंचा जा सकता है। ध्यान दें कि शुरुआती संख्या हमेशा इस परिभाषा द्वारा शामिल की जाती है (उदाहरण के लिए, 4 4 ^ 4 ^ 4)।

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

• मानक खामियों को मना किया जाता है।
• इनपुट और आउटपुट किसी भी सामान्य प्रारूप में हो सकते हैं । इनपुट को मान्य, गैर-रिक्त और बिना डुप्लिकेट के होने की गारंटी है।
• आपका कोड एक दिन से भी कम समय में सभी परीक्षण मामलों को संसाधित करने में सक्षम होना चाहिए ।

परीक्षण के मामलों

Input: 0
Output: 1

Input: 6
Output: 2

Input: 8 4
Ouput: 4

Input: 0 256
Output: 2

Input: 256 259 3
Output: 4

Input: 60 62 94 101 115
Output: 32

Input: 60 62 94 101 115 40 91
Output: 32

Input: 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 63
Output: 64

Input: 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384
Output: 32768

Answer 1

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

lu{+xM*Q

परीक्षण सूट

स्पष्टीकरण:

Xorspace जेनरेट करने के लिए, हम हर जोड़े को हर संख्या में जोड़ते हुए और घटाते हुए संख्याओं के xor को लेने का निर्धारण करते हैं। फिर, हम परिणाम की लंबाई लेते हैं। यह अंतिम परीक्षण मामले पर 20 सेकंड (केवल ऑफ़लाइन) में चलता है।

lu{+xM*Q
lu{+xM*QGGQ    Implicit variable introduction
 u        Q    Find the fixed point of the following, starting with the input,
               where the current value is G.
      *QG      Form the Cartesian product of Q (input) and G (current)
    xM         Take the xor of every pair
   +           Add the current values
  {            Deduplicate
l              Output the length of the result.

---

पैक्ड , 7 बाइट्स

Hexdump:

0000000: d9d7 dabf 1355 51                        .....UQ

7-बिट ASCII एन्कोडिंग के साथ ऊपर जैसा ही है।

उपरोक्त को किसी फ़ाइल में रखें xxd -r, और इसे निम्नानुसार चलाएं:

py packed-pyth.py xorspace.ppyth '[256, 259, 3]'

Comments

मुझे लगता है कि आप कर सकते हैं l{mxFdy।

— xnor

y63 टेस्ट केस के माध्यम से 1 में लागू @xnor बहुत धीमा है। मेरे पास 2 ^ 63 मेमोरी नहीं है।

— इसहाक

Answer 2

MATL , 11 बाइट्स

t"G!Z~Ghu]n

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

आखिरी परीक्षण का मामला स्मृति सीमाओं के कारण ऑनलाइन दुभाषिया में नहीं चलता है, लेकिन आधुनिक कंप्यूटर पर 2 सेकंड से भी कम समय में ऑफ़लाइन चलता है।

व्याख्या

आकार के इनपुट के लिए n, यह निम्न कार्य करता है:

1. इनपुट करने के लिए परिणाम आरंभ करें।
2. दोहराएँ nबार:
   1. वर्तमान परिणाम और इनपुट से प्रविष्टियों के सभी जोड़े के लिए बिटवाइर XOR लागू करें।
   2. परिणाम के लिए इनपुट मान संलग्न करें।
   3. Deduplicate।
3. आउटपुट अंतिम परिणाम के तत्वों की संख्या है।

टिप्पणी कोड।

t      % Implicit input: row vector. Duplicate
"      % For each (i.e. do as many times as the input size)
  G!   %   Push input as a column vector
  Z~   %   Bitwise XOR with broadcast, i.e. for all pairs of entries of the
       %   two arguments. The first argument is the accumulated result
       %   from the previous iteration, the second is the input vector
  G    %   Push input again
  h    %   Postpend
  u    %   Unique values. Gives a row vector
]      % End
n      % Number of entries. Implicitly display

उदाहरण

इनपुट के लिए मध्यवर्ती परिणाम (चरण 2.1 और 2.3) [256 259 3]हैं:

पहला पुनरावृत्ति: [256 259 3]साथ [256 259 3]: बिटवाइज़-एक्सओआर के सभी युग्मों की गणना करके मैट्रिक्स देता है

  0   3 259
  3   0 256
259 256   0

संलग्न करना [256 259 3]और समर्पण करना

0 3 259 256

दूसरा पुनरावृत्ति: वर्तमान परिणाम के [0 3 259 256]साथ [256 259 3]। कटौती के बाद यह फिर से देता है

0 3 259 256

तीसरा पुनरावृत्ति: फिर से

0 3 259 256

तो आउटपुट है 4(परिणाम की प्रविष्टियों की संख्या)।

Comments

कृपया स्पष्टीकरण दें? आप O (2 ^ n) का उपयोग नहीं कर सकते।

— आउटगोल्फ

मुझे नहीं पता कि यह कैसे काम करता है, लेकिन यह निश्चित रूप से ओ (2 ^ एन) नहीं है। यह वास्तव में (1 2 3… 63) परीक्षण-मामले को बहुत जल्दी हल करता है, भले ही यह जानवर-बल विधि के लिए सबसे खराब स्थिति है।

— ग्रैमी

यह इतनी जल्दी कैसे है? मैं जेली में बहुत कुछ करने की कोशिश कर रहा हूं, लेकिन पहला प्रयास 19 मिनट के बाद मार दिया गया ... (अब अधिक रैम के साथ कोशिश कर रहा है।)

— डेनिस

मेरा मानना है कि यह है ओ (2ⁿ) सबसे खराब स्थिति; यह सिर्फ इतना है कि परीक्षण में यह अभ्यास, एन केवल 15 है, इसलिए कार्यक्रम अभी भी काफी जल्दी चलता है।

@ ais523 बिटवाइज़-एक्सओआर से प्राप्त इंटरमीडिएट संख्या इनपुट में अधिकतम संख्या से अधिक कभी नहीं मिल सकती है, इसे कॉल करें M। तो मध्यवर्ती परिणामों के वेक्टर का आकार कभी भी अधिक नहीं होता है M, और जटिलता ओ ( M*M) है। ओपी ने कहा है कि nकोई फर्क नहीं पड़ता है, इसलिए यदि मैं परिभाषित nकरता Mहूं कि मैं इसे ओ ( n*n) होने का दावा कर सकता हूं ।

— लुइस मेन्डो

Answer 3

हास्केल , 64 बाइट्स

f पूर्णांकों की सूची लेता है और पूर्णांक लौटाता है।

import Data.Bits
f l|m<-maximum l,m>0=2*f(min<*>xor m<$>l)|0<1=1

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

यह एक खाली सूची को संभालता नहीं है, इसके लिए आप $0:अंतरिक्ष के बजाय कर सकते हैं maximum।

यह काम किस प्रकार करता है

• यदि mसूची की अधिकतम संख्या शून्य है, तो 1 लौटाता है।
• अन्यथा, अधिकतम के साथ हर तत्व xors।
  • यदि परिणाम तत्व से छोटा है, तो तत्व को इसके द्वारा प्रतिस्थापित किया जाता है।
  • यह जरूरी सूची में कहीं भी सबसे महत्वपूर्ण बिट सेट को शून्य करता है।
  • फिर परिणामी सूची पर पुनरावृत्ति होती है, पुनरावृत्ति के परिणाम को दोगुना कर देती है।
• यह प्रक्रिया अनिवार्य रूप से गौसियन उन्मूलन (हालांकि उन्हें 0 पर सेट करके अंतिम पंक्तियों को फेंक देती है) modulo 2, मैट्रिक्स पर जिनकी पंक्तियां संख्याओं की सूची का थोड़ा प्रतिनिधित्व करती हैं। "Xorspace" के बिट अभ्यावेदन का सेट वेक्टर स्पेस मॉडुलो 2 है जिसे इस मैट्रिक्स की पंक्तियों द्वारा देखा जाता है, और जिनके तत्वों की संख्या मैट्रिक्स की पंक्ति रैंक की शक्ति से 2 है।
• यह एल्गोरिथ्म बहुपद समय है, इसलिए निश्चित रूप से O (2 ^ n) से बेहतर होना चाहिए।

Comments

यह मूल रूप से एल्गोरिथ्म है जिसके बारे में मैं सोच रहा था (जटिलता की सीमाओं के लिए), हालांकि यह प्रतिनिधित्व करने के लिए एक विशेष रूप से सुरुचिपूर्ण तरीका है। इसे ठीक से गोल्फ के उत्तर में देखना अच्छा है।

Answer 4

गणितज्ञ, 52 बाइट्स

2^MatrixRank[PadLeft@IntegerDigits[#,2],Modulus->2]&

Comments

आपने अपने Pari / GP उत्तर को क्यों हटाया? ऐसा लग रहा था कि यह ठीक काम करेगा। संपादित करें: कभी नहीं, यह वास्तव में कुछ परीक्षण-मामलों में विफल रहा।

— ग्रैमी

@Grimy आपने मेरा जवाब क्यों स्वीकार किया? यह एक कोड-गोल्फ है, सबसे छोटा कोड जीतता है।

— एलेफल्फा

क्षमा करें, मैंने 7 बाइट्स पैक किए गए पाइथ को स्वीकार किए गए उत्तर को बदल दिया।

— ग्रम्मी

Answer 5

05AB1E , 8 बाइट्स

vDy^ìÙ}g

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

सभी परीक्षण-मामले TIO पर 1 मिनट से कम समय में समाप्त हो जाते हैं।

Comments

यह अंतिम मानदंड विफल रहता है: «आपका कोड एक दिन से भी कम समय में सभी परीक्षण मामलों को संसाधित करने में सक्षम होना चाहिए (कोई ओ (2 ** एन) सामान)। »

— ग्रैमी

@ जिमी: 2^nभाग पढ़ा नहीं : /

— Emigna

@Grimy: अब 1 मिनट से कम समय में (और कम बाइट्स के साथ) सभी टेस्ट-केस खत्म करने के लिए अपडेट किया गया

— Emigna

सोच âü^Ùgरहा था जब तक मैंने देखा कि आप एक से अधिक बार अच्छा समाधान कर सकते हैं।

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

@carusocomputing: यह एक बाइट बचाता है, लेकिन मैं जटिलता के बारे में निश्चित नहीं हूं।

— इमीना

Answer 6

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

r={0}
for n in input():r|={x^n for x in r}
print len(r)

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

कार्यों को समाप्त करता है:

f=lambda l,r={0}:l and f(l[1:],r|{x^l[0]for x in r})or len(r)
f=lambda l:len(reduce(lambda r,n:r|{x^n for x in r},l,{0}))

---

अर्जन जोहान्सन की सुंदर पंक्ति उन्मूलन विधि एक बाइट कम है।

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

f=lambda l:1-any(l)or 2*f([min(x,x^max(l))for x in l])

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

Answer 7

जेली , ९ by बाइट्स

0œ|⁺^¥/L

TIO पर 8 सेकंड से कम समय में सभी परीक्षण मामलों को नगण्य स्मृति आवश्यकताओं के साथ खत्म कर देता है ।

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

यह काम किस प्रकार करता है

0œ|⁺^¥/L  Main link. Argument: A (array)

0œ|       Perform multiset union with 0, prepending 0 if A doesn't contain it.
      /   Reduce A by the link to the left.
     ¥      Combine the previous two links into a dyadic chain.
            Left argument: V (array). Right argument: n (integer)
    ^           Bitwise XOR each element in V with n.
   ⁺            This quick refers to the previous link, making it a shorthand for
                the link 'œ|'. Thus, it performs multiset union on V and the array
                of bitwise XORs.
       L  Compute the length of the result.

Answer 8

अजगर, 113 बाइट्स

def f(x):
 u,s=[0],{0}
 while u:
	a=u.pop()
	for b in x:
	 c=a^b
	 if c not in s:u+=[c]
	 s.add(c)
 return len(s)

Comments

यह काम करता है, लेकिन मैं 113 बाइट्स गिन रहा हूं; क्या मैं कुछ भुल गया?

— ग्रिम्मी

@totallyhuman शायद ऐसा इसलिए है क्योंकि आप एक ही बाइट के बजाय 8 बाइट्स के रूप में सारणीयन गिन रहे हैं।

— ग्रिम्मी

यदि पहला इंडेंटेशन एक स्थान है, तो अगला एक टैब है, और अंतिम एक टैब + एक स्पेस (या 2 टैब) है, तो यह 113 बाइट्स है

— daniero

@Grimy वास्तव में प्रत्येक टैब 4 रिक्त स्थान नहीं है। 8.

— आउटगोल्फर

एक पूर्ण कार्यक्रम कम होगा, क्योंकि यह एक मुट्ठी भर इंडेंटेशन बचाता है। साथ ही, लूप के लिए एक लाइन में संघनित किया जा सकता है, जैसा u+=[c][c in s:]कि आपके ifकथन के बराबर है ।

— डेनिस