सबसेट सम ऑर्डर

22

nसकारात्मक संख्याओं के एक सेट में 2^nसबसेट है। यदि कोई भी उपसमुच्चय समान राशि का है तो हम एक सेट "अच्छा" कहेंगे। {2, 4, 5, 8}ऐसा ही एक अच्छा सेट है। चूँकि किसी भी उपसमुच्चय के पास एक ही राशि नहीं है, इसलिए हम सबसे उपसमुच्चय को छाँट सकते हैं:

[{}, {2}, {4}, {5}, {2, 4}, {2, 5}, {8}, {4, 5}, {2, 8}, {2, 4, 5}, {4, 8}, {5, 8}, {2, 4, 8}, {2, 5, 8}, {4, 5, 8}, {2, 4, 5, 8}]

यदि हम बढ़ते क्रम में [2, 4, 5, 8]प्रतीकों के साथ संख्याओं को लेबल करते हैं [a, b, c, d], तो हमें निम्नलिखित सार आदेश प्राप्त होते हैं:

[{}, {a}, {b}, {c}, {a, b}, {a, c}, {d}, {b, c}, {a, d}, {a, b, c}, {b, d}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}]

सकारात्मक संख्याओं का एक और अच्छा सेट एक ही सार आदेश, या एक अलग हो सकता है। उदाहरण के लिए, [3, 4, 8, 10]एक अलग अमूर्त आदेश के साथ एक अच्छा सेट है:

[{}, {a}, {b}, {a, b}, {c}, {d}, {a, c}, {b, c}, {a, d}, {b, d}, {a, b, c}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}]

इस चुनौती में, आपको nसकारात्मक संख्याओं के अच्छे सेटों के अलग-अलग सार क्रमों की गिनती करनी चाहिए । यह क्रम OEIS A009997 है , और ज्ञात मूल्य, पर शुरू n=1कर रहे हैं:

1, 1, 2, 14, 516, 124187, 214580603

उदाहरण के लिए, n=3निम्नलिखित दो संभावित सार क्रम हैं:

[{}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}]
[{}, {a}, {b}, {a, b}, {c}, {a, c}, {b, c}, {a, b, c}]

के लिए n=4, निम्नलिखित 14 संभव सार orderings, प्लस कि आदेश देने के साथ एक उदाहरण अच्छा सेट कर रहे हैं:

[{}, {a}, {b}, {a, b}, {c}, {a, c}, {b, c}, {a, b, c}, {d}, {a, d}, {b, d}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 4, 2, 1]                                       
[{}, {a}, {b}, {a, b}, {c}, {a, c}, {b, c}, {d}, {a, b, c}, {a, d}, {b, d}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 6, 3, 2]                                      
[{}, {a}, {b}, {a, b}, {c}, {a, c}, {d}, {b, c}, {a, d}, {a, b, c}, {b, d}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 7, 4, 2]                                      
[{}, {a}, {b}, {a, b}, {c}, {a, c}, {d}, {a, d}, {b, c}, {a, b, c}, {b, d}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 6, 4, 1]                                       
[{}, {a}, {b}, {a, b}, {c}, {d}, {a, c}, {b, c}, {a, d}, {b, d}, {a, b, c}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 8, 4, 3]                                      
[{}, {a}, {b}, {a, b}, {c}, {d}, {a, c}, {a, d}, {b, c}, {b, d}, {a, b, c}, {a, b, d}, {c, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 7, 4, 2]                                       
[{}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}, {d}, {a, d}, {b, d}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 4, 3, 2]                                      
[{}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {d}, {a, b, c}, {a, d}, {b, d}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 4, 3, 2]                                       
[{}, {a}, {b}, {c}, {a, b}, {a, c}, {d}, {b, c}, {a, d}, {a, b, c}, {b, d}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 5, 4, 2]                                       
[{}, {a}, {b}, {c}, {a, b}, {a, c}, {d}, {a, d}, {b, c}, {a, b, c}, {b, d}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 7, 6, 2]                                      
[{}, {a}, {b}, {c}, {a, b}, {d}, {a, c}, {b, c}, {a, d}, {b, d}, {a, b, c}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 6, 4, 3]                                       
[{}, {a}, {b}, {c}, {a, b}, {d}, {a, c}, {a, d}, {b, c}, {b, d}, {a, b, c}, {c, d}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [10, 8, 6, 3]                                      
[{}, {a}, {b}, {c}, {d}, {a, b}, {a, c}, {b, c}, {a, d}, {b, d}, {c, d}, {a, b, c}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [8, 6, 5, 4]                                       
[{}, {a}, {b}, {c}, {d}, {a, b}, {a, c}, {a, d}, {b, c}, {b, d}, {c, d}, {a, b, c}, {a, b, d}, {a, c, d}, {b, c, d}, {a, b, c, d}], [7, 6, 5, 3]

निम्नलिखित एक मान्य अमूर्त क्रम नहीं है:

{}, {a}, {b}, {c}, {d}, {a,b}, {e}, {a,c}, {b,c}, {a,d}, {a,e}, {b,d}, {b,e}, {c,d}, {a,b,c}, {a,b,d}, {c,e}, {d,e}, {a,b,e}, {a,c,d}, {a,c,e}, {b,c,d}, {b,c,e}, {a,d,e}, {b,d,e}, {a,b,c,d}, {c,d,e}, {a,b,c,e}, {a,b,d,e}, {a,c,d,e}, {b,c,d,e}, {a,b,c,d,e}

इस आदेश का अर्थ है कि:

d < a + b
b + c < a + d
a + e < b + d
a + b + d < c + e

इन असमानताओं को समेटना:

2a + 2b + c + 2d + e < 2a + 2b + c + 2d + e

जो एक विरोधाभास है। आपके कोड को इस आदेश की गिनती नहीं करनी चाहिए। इस तरह के प्रतिवाद सबसे पहले दिखाई देते हैं n=5। इस पेपर से उदाहरण , पेज 3 पर उदाहरण 2.5।

यह आदेश इस तथ्य के बावजूद अमान्य है कि A < Bइसका तात्पर्य A U C < B U Cकिसी भी Cअसहमति के लिए Aऔर B।

आपका कोड या प्रोग्राम इतना तेज़ होना चाहिए कि आप उसे n=4सबमिट करने से पहले उसे पूरा कर सकें।

प्रस्तुतियाँ हमेशा की तरह कार्यक्रम, कार्य आदि हो सकती हैं।

मानक Loopholes निषिद्ध हैं, हमेशा की तरह। यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है। टिप्पणियों में स्पष्ट सवाल पूछने के लिए स्वतंत्र महसूस करें।

code-golf  arithmetic  subsequence 
— isaacg
स्रोत
लंबे समय से कोई इजाक नहीं है!
— orlp
P,QP≤QP⊆Q∀p∈P,q∈Q(p≤q)a≤b≤c≤…
∀p∈P,q∈Q(p≤q){a,c},{b,c}
@orlp वापस होना अच्छा है! मुझे लगता है कि मैं भविष्य के भविष्य के लिए ज्यादातर सवाल कर रहा हूँ
— isaacg
क्या आप n = 4 के लिए 14 संभावित ऑर्डर भी जोड़ सकते हैं?
— पीटर टेलर

जवाबों:

11

पायथन 3 + साइंसपी, 396 390 385 351 336 355 बाइट्स

from scipy.optimize import*
n=int(input())
r=range(n)
def f(u):
 s=linprog(r,u,[-n]*len(u),options={'tol':.1});c=s.success;y=sorted(range(c<<n),key=lambda a:s.x.round()@[a>>i&1for i in r])
 for a,b in zip(y,y[1:]):
  v=[(a>>i&1)-(b>>i&1)for i in r]
  if~-(v in u):c+=f(u+[[-z for z in v]]);u+=v,
 return+c
print(f([[(i==j-1)-(i==j)for i in r]for j in r]))

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

यह अब n = 5 के लिए लगभग 5 सेकंड में चलता है । if~-(v in u):-18 बाइट्स लेकिन एक विशाल प्रदर्शन की सजा के लिए हटाया जा सकता है।

यदि आप सभी अमूर्त आदेशों को प्रिंट करना चाहते हैं, जैसा कि उन्हें सिर्फ गिनने के बजाय पाया जाता है, if c:print(s.x.round(),y)तो forलूप से पहले जोड़ें । (सब्सक्रिप्शन बाइनरी पूर्णांक द्वारा दर्शाया जाता है, जहां प्रत्येक बिट एक तत्व की उपस्थिति या अनुपस्थिति से मेल खाती है: { a , c , d } ₂ 1101↔ = 13.)

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

fपुनर्संरचना में दी गई बाधाओं की सूची को संतुष्ट करते हुए अमूर्त आदेशों को गिना जाता है। हम बाधाओं के साथ शुरू n ≤ एक , एक + n ≤ ख , ख + n ≤ सी , सी + n ≤ घ । रैखिक प्रोग्रामिंग का उपयोग करते हुए, हम बाधाओं का समाधान ढूंढते हैं (या यदि कोई नहीं है तो 0 लौटाएं) -इस मामले में हमें a = 4, b = 8, c = 12, d = 16 मिलता है। हम पूर्णांकों के लिए समाधान को गोल करते हैं , तब अपने सभी सबसेट को उनकी राशि से छाँटकर एक संदर्भ क्रम की गणना करें:

{ a }, { b }, { c }, { a , b }, { d }, { a , c }, { a , d }, { b , c }, { b , d }, { a , b , सी }, { सी , डी }, { ए , बी , डी }, { ए , सी , डी }, { बी , सी , डी }, {ए , बी , सी , डी }

गोलाई किसी भी बाधाओं को n / 2 से अधिक के उल्लंघन का कारण नहीं बन सकता है , यही कारण है कि हमने n का एक मार्जिन जोड़ा है ।

चूंकि पायथन के sortedस्थिर होने के कारण, सबसेट के बीच कोई भी संबंध उसी रिवर्स-लेक्सोग्राफ़िक क्रम में टूट गया है जिसमें हमने उन्हें उत्पन्न किया था। इसलिए हम { a a , b , c , d } को { a · 2 ^ n + 2 ^ 0, b · 2 ^ n + 2 ^ 1, c · 2 ^ n + 2 ^ 2, d · 2 ^ के साथ प्रतिस्थापित करने की कल्पना कर सकते हैं । n + 2 ^ 3} बिना किसी संबंध के समान ऑर्डर प्राप्त करने के लिए।

योजना विश्लेषण के आधार पर अन्य सभी अमूर्त आदेशों को श्रेणीबद्ध करने के लिए है, जहां वे संदर्भ आदेश देने से पहले असहमत हैं:

या तो { a }> { b },
या { a } <{ b }> { c },
या { a } <{ b } <{ c }> { a , b },
या { a } <{ b } < { ग } <{ एक , ख }> { घ },
⋮

प्रत्येक मामले के भीतर, हम इन नए अवरोधों को n के एक मार्जिन के साथ जोड़ते हैं , और fजोड़े गए नए अवरोधों के साथ पुनरावर्ती कॉल करते हैं।

टिप्पणियाँ

थोड़ी देर के लिए मैंने अनुमान लगाया (लेकिन यह नहीं माना) कि बाधाओं पर मार्जिन 1 के साथ रैखिक कार्यक्रम समाधान हमेशा पूर्णांक होगा। यह गलत साबित होता है: n = 7 के साथ एक प्रतिधारण {2.5, 30, 62.5, 73.5, 82, 87.5, 99.5} है।

पायथन, 606 बाइट्स (तेज़, कोई बाहरी लाइब्रेरी नहीं)

n=int(input())
r=range(n)
e=enumerate
def l(u,x):
 for i,v in e(u):
  for j,a in e(v):
   if a<0:break
  else:return[0]*len(x)
  if sum(b*x[k]for k,b in e(v))>0:
   x=l([[b*w[j]-a*w[k]for k,b in e(v)if k!=j]for w in u[:i]],x[:j]+x[j+1:]);x.insert(j,0)
   for k,b in e(v):
    if k!=j:x[j]+=b*x[k];x[k]*=-a
 return x
def f(u,x):
 x=l(u,x);c=any(x);y=sorted(range(c<<n),key=lambda a:sum(x[i]*(a>>i&1)for i in r))
 for a,b in zip(y,y[1:]):
  v=[(a>>i&1)-(b>>i&1)for i in r]+[1]
  if~-(v in u):c+=f(u+[[-z for z in v[:-1]]+[1]],x);u+=v,
 return+c
print(f([[(i==j-1)-(i==j)for i in r]+[1]for j in r],[1]*(n+1)))

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

यह एक सेकंड के एक तिमाही में n = 5 के लिए चलता है , और 230 सेकंड (PyPy में 75 सेकंड) में n = 6 है।

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

— एंडर्स कसीगोर
स्रोत
— मिस्टर एक्सकोडर
@ Mr.Xcoder ज़रूर, धन्यवाद!
— एंडर्स कासोर्ग
@Lynn धन्यवाद! मैंने थोड़ा समझौता किया क्योंकि मैं इसे बहुत धीमा नहीं करना चाहता हूं - यह पहले से ही n = 5. के लिए लगभग 3 मिनट का समय लेता है
— एंडर्स केसेर्ग
1
@AlonAmit लगता है जैसे n = 6 के लिए लगभग 55 मिनट लगते हैं। SciPy LP में सर्वश्रेष्ठ नहीं है; मेरे पास SciPy के बजाय GLPK का उपयोग करने वाला एक संस्करण है जो 70 सेकंड में n = 6 करता है। अधिक स्पष्ट रूप से, SciPy संस्करण को गलत उत्तर मिला (और GLPK द राइट वन) ... तो उह, यह ... दिलचस्प है ... मुझे आश्चर्य है कि अगर यह SciPy # 6690 है ?
— एंडर्स कासोर्ग
1
@AlonAmit # 6690 है ना। लेकिन मैंने जोड़ा options={'tol':.1}, जो समस्या का ध्यान रखता है।
— एंडर्स कासोर्ग
0

रूबी, 308 बाइट्स, बहुत तेज

केस को ~ 150ms में 4 चलाता है। किसी विशेष पुस्तकालय का उपयोग नहीं किया जाता है।

->n{t=2**(n-1)
n==0 ?[[0]]:P[n-1].map{|a|b=a.map{|i|i+t}
[*0..t].repeated_combination(t).select{|m|m[0]>=a.index(n-1)}.map{|m|c,d=a.dup,b.dup;m.reverse.map{|i|c.insert(i,d.pop)};c}}.flatten(1).select{|p|p.combination(2).all?{|(x,y)|x&~y==0||y&~x!=0&&n.times.all?{|i|x!=y<<i+1}&&p.index(x&~y)<p.index(y&~x)}}}

उदाहरण के लिए, यह एक मामूली मामले के पुनरावर्ती परिणाम को दर्शाता है

[{}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}]

एक अतिरिक्त तत्व के साथ इसी सबसेट के साथ - उन्हें समान सापेक्ष क्रम रखना होगा। यह यह भी सुनिश्चित करता है कि नए सिंगलटन को पिछले सभी सिंगलटन के बाद जोड़ा जाए।

अनुपालन के लिए जांच करने वाला हिस्सा पहले जैसा है, लेकिन परीक्षण के लिए संयोजन बहुत कम नहीं है।

विस्तारित और टिप्पणी संस्करण:

->n{
    t=2**(n-1)
    if n==0
        [[0]]
    else
        # for each one of the previous nice orderings
        P[n-1].map { |a|
            # create the missing sets, keep order
            b = a.map{|i|i+t}
            # intersperse the two sets
            [*0..t].repeated_combination(t) # select t insertion points
                .select do |m|
                    # ensure the new singleton is after the old ones
                    m[0] >= a.index(n-1)
                end
                .map do |m|
                    # do the interspersion
                    c,d=a.dup,b.dup
                    m.reverse.map{|i|c.insert(i, d.pop)}
                    c
                end
        }.flatten(1).select{ |p|
            # check if the final ordering is still nice
            p.combination(2).all? { |(x,y)|
                (x&~y==0) || 
                (y&~x!=0) && 
                n.times.all?{|i|x!=y<<i+1} && 
                (p.index(x&~y)<p.index(y&~x))
            }
        }
    end
}

रूबी, 151 बाइट्स, काफी धीमी

(तीन तत्वों का मामला << 1s, चार का मामला अभी भी चल रहा है)

->n{[*1...2**n-1].permutation.select{|p|p.combination(2).all?{|(x,y)|x&~y==0||y&~x!=0&&n.times.all?{|i|x!=y<<i+1}&&p.index(x&~y)<p.index(y&~x)}}.count}

यह सबसेट्स के बिटफील्ड प्रतिनिधित्व पर काम करता है, इसलिए यदि सब्सेट्स को स्वयं प्रदर्शित करने की आवश्यकता हो तो किसी को आउटपुट की मालिश करनी पड़ सकती है।

स्वरूपित:

-> n {
  [*1...2**n-1]. # prepare permutations of non-empty and non-full sets
    permutation.
    select { |p|
      p.combination(2). # check all ordered pairs
        all? { |(x, y)|
          # first is subset of second 
          x &~ y == 0 ||
          # second is not subset of first
          y &~ x != 0 &&
          # first is not a right shift of second
          # (this normalizes the ordering on atoms)
          n.times.all? { |i| x != y << i+1 } &&
          # after taking out common elements, ordering agrees 
          p.index(x &~ y) < p.index(y &~ x)
        }
    }.
    count
}
— फिर से लिखा
स्रोत
मैं इसे अपनी मशीन पर 3 से ऊपर का परीक्षण नहीं कर सकता, लेकिन यह (139 बाइट्स) कार्यात्मक रूप से आपके समाधान के समान होना चाहिए। परिवर्तन: ...x-1=> ..x-2, .select{...}.count=> .count{...}, |(x,y)|=> |x,y|, x&~y==0||y&~x!=0=> x&~y<1||y&~x>0क्योंकि a&~bमैं गलत नहीं हूँ तो नकारात्मक नहीं हो सकता
— Asone Tuhid
1
n=5काउंटरटेम्प्लम को देखो मैंने अभी जोड़ा है। अगर मैं गलत नहीं हूँ, तो आपका कोड इसे स्वीकार करेगा।
— इसहाक
2
TIO लिंक यह दिखा रहा है कि यह प्रतिरूप पर सही ढंग से काम नहीं करता है: इसे ऑनलाइन आज़माएं!
— ईसैक
1
आपका नया संस्करण एक पुनरावर्ती फ़ंक्शन कहा जाता है P, इसलिए यह अनाम नहीं हो सकता है। इसके अलावा, मुझे लगता है कि यह अभी भी मेरे द्वारा पोस्ट किए गए प्रतिसाद के कारण विफल है।
— isaacg
1
तेज़ समाधान के लिए: 280 बाइट्स इसे ऑनलाइन आज़माएं! । ध्यान दें कि आपको पुनरावर्ती फ़ंक्शन ( P=) का नाम शामिल करना होगा । इसके अलावा, मुझे लगता है कि आपको एक नंबर वापस करना होगा ताकि आपको .sizeकहीं न कहीं इसमें शामिल होना पड़े ।
— असोन तुहिद
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.