Skolem क्रम उत्पन्न करें

10

स्कोल्म क्रम

एक Skolem अनुक्रम का एक क्रम है 2nसंख्या जहां हर संख्या iके बीच 1और nवास्तव में दो बार होता है, और के दो घटनाओं के बीच की दूरी iठीक है iचरणों। यहाँ Skolem दृश्यों के कुछ उदाहरण दिए गए हैं:

1 1
1 1 4 2 3 2 4 3
16 13 15 12 14 4 7 3 11 4 3 9 10 7 13 12 16 15 14 11 9 8 10 2 6 2 5 1 1 8 6 5

निम्नलिखित क्रम स्कोल्म अनुक्रम नहीं हैं :

1 2 1 2      (The distance between the 1's is 2, not 1)
3 1 1 3      (The number 2 is missing)
1 1 2 1 1 2  (There are four 1's)

उद्देश्य

किसी दिए गए लम्बाई के सभी Skolem दृश्यों की संख्या की गणना करने के लिए एक कार्यक्रम, फ़ंक्शन या अभिव्यक्ति लिखें। अधिक स्पष्ट रूप से, आपका इनपुट एक पूर्णांक है n, और आपका आउटपुट लंबाई के स्कोलम अनुक्रमों की संख्या है 2n। इस अनुक्रम में OEIS प्रविष्टि है । के लिए n = 0, आप 0या तो वापस आ सकते हैं 1। से शुरू होने वाले पहले कुछ मान 0हैं

0, 1, 0, 0, 6, 10, 0, 0, 504, 2656, 0, 0, 455936, 3040560, 0, 0, 1400156768

नियम और स्कोरिंग

यह कोड गोल्फ है। आउटपुट स्वरूप कारण के भीतर ढीला है।

code-golf math sequence

— boothby
स्रोत

बस जिज्ञासु, लेकिन 0, 1, 0, 0, 6...आपके प्रश्न में क्या है ? क्या वह कोड स्निपेट है, यदि हां तो वह कौन सी भाषा है?

— फीनोटपी

2

आपके आउटपुट में पहला आइटम क्यों है 0? यदि आप 0एक वैध इनपुट के रूप में स्वीकार करने जा रहे हैं तो आउटपुट होना चाहिए 1।

— पीटर टेलर

1

कुछ (मेरे कोड सहित) मानते हैं कि शून्य खाली क्रम हैं। यदि 1 आपको बेहतर महसूस कराता है, तो उसे वापस कर दें।

— बूथ

2

AFAIK हर संदर्भ में आप मानते हैं कि एक और केवल एक खाली अनुक्रम / अशक्त वस्तु / खाली सेट आदि / फ़ंक्शन-से / से-खाली-सेट / खाली ग्राफ़ / जो भी हो।

— बाकुरिउ

1

@boothby, क्या आपने केवल नूथ को मूर्ख कहा है?

— पीटर टेलर

8

GolfScript, 48 46 वर्ण

:b,1,{)2\?){{.2$&!{.2$|@@}*.+.4b?<}do;;}+%}@/,

तेज संस्करण ( ऑनलाइन प्रयास करें ) - उचित तेजी से चलता है, उदाहरण के n=8लिए लगभग दो सेकंड लगते हैं। और चुना हुआ दृष्टिकोण वास्तव में कुछ वर्ण लेता है।

यह संस्करण बिटमास्क के साथ भी काम करता है। यह संभव परिणाम सरणी को 1 से ऊपर की ओर बनाता है, अर्थात n=3:

1: 000011        000110 001100 011000 110000
2: 010111 101011 101110        011101 110101 111010

जबकि कुछ परिणामों (जैसे 000011) में दो संभावित निरंतरताएं हैं, अन्य (यानी 001100) में कोई नहीं है और परिणाम सरणी से हटा दिए गए हैं।

कोड की व्याख्या:

:b           # save the input into variable b for later use
,            # make the list 0..b-1 (the outer loop)
1,           # puts the list [0] on top of the stack - initially the only possible
             # combination
{)           # {...}@/ does the outer loop counting from i=1 to b
  2\?)       # computes the smalles possible bit mask m=2^i+1 with two bits set 
             # and distance of those equal to i (i.e. i=1: 11, i=2: 101, ...)
  {          # the next loop starts with this bitmask (prepended to code via
             # concatination {...}+
             # the loop itself iterates the top of the stack, i.e. at this point 
             # the result array                 
             # stack here contains item of result array (e.g. 00000011)
             # and bitmask (e.g. 00000101)
    {        # the inner-most loop tries all masks with the current item in the result set
      .2$&!  # do item and result set share not single bit? then - {...}*
      {
        .2$| # then generate the new entry by or-ing those two
        @@   # push it down on the stack (i.e. put working items to top)
      }*
      .+     # shift the bit mask left by one
      .4b?<  # if still in the range loop further
    }do;;    # removes the remainders of the loop (i.e. item processed and mask)
  }+%        # stack now contains the new result array
}@/
,            # length of result array, i.e. the number of Skolem sequences

— हावर्ड
स्रोत

बंधे हुए समाधानों के तेजी से स्वीकार करना।

— बूथ

6

जे अभिव्यक्ति, 47 वर्ण

 +/*/"1((=&{:+.2-#@])#;.2)\"1~.(i.!+:y)A.,~>:i.y

उदाहरण:

    y=:5
    +/*/"1((=&{:+.2-#@])#;.2)\"1~.(i.!+:y)A.,~>:i.y
10

y=:5मेरी मशीन पर लगभग 30 सेकंड लगते हैं ।

एल्गोरिथ्म जितना धीमा हो सकता है:

~.(i.!+:y)A.,~>:i.yके हर क्रमांकन को उत्पन्न करता है 1 2 .. y 1 2 .. yऔर डुप्लिकेट प्रविष्टियों को हटाता है
((=&{:+.2-#@])#;.2)\"1 computes:
- (...)\"1 हर पंक्ति के प्रत्येक उपसर्ग के लिए:
  - #;.2 अंतिम तत्व की प्रत्येक घटना से पहले तत्वों को गिना जाता है
  - #@] मायने रखता है की संख्या (यानी अंतिम तत्व की घटनाओं की संख्या)
  - =&{: गणना सूची और मूल सूची के "अंतिम तत्व" के "समानता" को निर्धारित करता है।
  - +.एक तार्किक OR है। =&{:+.2-#@]पढ़ता है "या तो अंतिम तत्व [गिनती सूची और मूल सूची] के बराबर हैं, या दो के बजाय केवल एक तत्व [गिनती सूची में] है"।
*/"1 मल्टीप्लीज (तार्किक और) स्थिति तालिका की पंक्तियों पर, यह निर्धारित करते हुए कि कौन से क्रमांकन स्कोम अनुक्रम हैं।
+/ एक साथ और शून्य को जोड़ते हैं।

— जॉन ड्वोरक
स्रोत

6

GolfScript (46 वर्ण)

:&1,\,{0,2@)?)2&*{2${1$^}%@+\2*}*;+}/{4&?(=},,

यह एक अभिव्यक्ति है जो स्टैक पर इनपुट लेता है। इसे एक पूर्ण कार्यक्रम में बदलने के लिए जो स्टड पर इनपुट लेता है, पूर्व निर्धारित करें~

यह काफी अकुशल है - ज्यादातर बचत जो मैंने इसे 56 चरस से नीचे गिराने में की थी, वो अनधिकृत तरीके से छोरों की सीमा का विस्तार करके की गई थी, जो गलत परिणाम पेश नहीं करते लेकिन बेकार गणना करते हैं।

दृष्टिकोण कार्टिसियन उत्पादों के बिटवाइज़ मास्किंग है। जैसे (बिना मास्क के बाइनरी का उपयोग) n=4अनलॉल्फ कोड के लिए कार्टेशियन उत्पाद में प्रत्येक तत्व के एक्सर की गणना करेगा [00000011 00000110 ... 11000000] x [00000101 00001010 ... 10100000] x ... x [00010001 ... 10001000]। 8 बिट्स के साथ कोई भी परिणाम केवल गैर-अतिव्यापी मास्क द्वारा प्राप्त किया जा सकता है।

गति के बजाय आकार के लिए अनुकूलन करने के लिए, कोड आंशिक उत्पादों को जमा करता है ( S1 u S1xS2 u S1xS2xS3 ...) और प्रत्येक उत्पाद को 2nतत्वों के बजाय सिर्फ एक बनाता है 2n-1-iजो वास्तव में एक वैध अनुक्रम में योगदान कर सकता है।

गति

n=5मेरे कंप्यूटर पर 10 सेकंड के लिए गोल्फ का संस्करण चलता है , और 5 मिनट से अधिक के लिए n=6। मूल ungolfed संस्करण n=5एक सेकंड से भी कम समय n=6में और लगभग 1 मिनट में गणना करता है । मध्यवर्ती परिणामों पर एक साधारण फिल्टर के साथ, यह n=830 सेकंड में गणना कर सकता है । मैंने इसे 66 वर्णों (एक कार्यक्रम के रूप में - 65 वर्णों को एक अभिव्यक्ति के रूप में) में रखा है, जबकि छोरों को यथासंभव सीमित रखा है और मध्यवर्ती टकरावों को छान रहा है:

~:&1,\,{0,\).2\?)2&*@-{.{[\].~^.@~+<{;}*}+3$%@+\2*}*;\;}/{4&?(=},,

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

अरे नहीं। बस जब मैंने सोचा कि मेरा 48char J सॉल्यूशन पोस्ट किया जाना अच्छा था।

— जॉन ड्वोरक

अरे नहीं। हमारा 47-कैरेक्टर टाई बहुत लंबा नहीं चला। +1

— जॉन ड्वोरक

5

GolfScript, 49 अक्षर

~:/..+?:d(,{d+/base(;:w;/,{.w?)w>1$?=},,/=},,/1=+

एसटीडीआईएन पर संख्या की nअपेक्षा करता है। यह कोड-गोल्फ है - n5 से अधिक के साथ कोड की कोशिश न करें ।

— हावर्ड
स्रोत

आउच, 5 से अधिक नहीं?

— बूथबी

@ बॉथबी यह पहला, प्रत्यक्ष प्रयास था। हमें अक्सर निर्णय गति बनाम आकार लेना पड़ता है - और कोड-गोल्फ आकार के बारे में है। इसलिए मैंने तेज संस्करण भी जोड़ा - जो मूल रूप से बहुत लंबा था लेकिन अब और भी छोटा है।

— हावर्ड

0

ऋषि, ,०

यह मेरे मूल से थोड़ा छोटा है।

sum(1for i in DLXCPP([(i-1,j,i+j)for i in[1..n]for j in[n..3*n-i-1]]))

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

0/1 मैट्रिक्स को देखते हुए, उस मैट्रिक्स के लिए सटीक कवर समस्या उन पंक्तियों का एक सबसेट ढूंढना है जो सभी (वेक्टरों के रूप में) योग के रूप में है। उदाहरण के लिए,

एक समाधान है

10100
01001
00010

समस्याओं के लिए मेरा पसंदीदा दृष्टिकोण उन्हें एक सटीक कवर समस्या में डालना है। Skolem क्रम कुशलता से यह सुविधा। मैं एक सटीक कवर समस्या बनाता हूं जहां समाधान लंबाई के स्कोलम क्रम के साथ आपत्ति में हैं 2n। उदाहरण के लिए, समस्या की एक पंक्ति n=6है

  a   |  b  
001000|001001000000 # S[b] = S[b+a+1] = a

जहां स्थिति में 1 का a < nअर्थ है कि प्रतीक aका उपयोग किया जाता है। शेष स्थान अनुक्रम में वास्तविक स्थानों के अनुरूप हैं। एक सटीक कवर प्रत्येक प्रतीक से मेल खाता है जिसका उपयोग एक बार किया जा रहा है, और प्रत्येक स्थान को एक बार भरा जा रहा है। निर्माण के द्वारा, किसी kस्थान का कोई भी प्रतीक kउसके साथी से दूर होता है।

साधु में, DLXCPP"डांसिंग लिंक्स" कार्यान्वयन है - यह एक असाधारण सुंदर तरीके से सटीक कवर समस्या को हल करता है। यह मेरे पसंदीदा एल्गोरिदम में से एक है, और सेज में सतह पर सही होने के कारण कॉम्बिनेटरियल एन्यूमरेशन को एक खुशी बना देता है।

— boothby
स्रोत

वाह, डांसिंग लिंक। उपयोग len(list(...))से 4 वर्ण बचेंगे।

— रे

अगर मैं len(list(...))n = 16 के लिए गणना करता हूं, तो मेरा कंप्यूटर बस मर जाएगा । और यह पूरी तरह से रनटाइम को मार देगा।

— बूथ

यह सही है, क्योंकि एक जनरेटर को सूची में परिवर्तित करने में कई मेमोरी खर्च होती हैं।

— रे