सबसेट-सम पर एन-बिट भिन्नता


14

एक और चुनौती के लिए मैं लिख रहा हूं, मुझे यह सत्यापित करने की आवश्यकता है कि परीक्षण के मामले बाध्य पूर्णांक के साथ हल करने योग्य हैं। विशेष रूप से, मुझे पूर्णांक Aऔर एक पूर्णांक बिट चौड़ाई के गैर-रिक्त सरणी के लिए, निम्न को सत्यापित करने की आवश्यकता है n:

  1. संतुष्ट aमें सभी पूर्णांक ( दो-के पूरक पूर्णांक के साथ प्रतिनिधित्व करने योग्य )।A-2**(n-1) <= a < 2**(n-1)n
  2. की लंबाई से Aकम है 2**n
  3. Aसंतोष का योग -2**(n-1) <= sum(A) < 2**(n-1)
  4. Aउपरोक्त सभी स्थितियों को पूरा करने में तत्वों के सभी संयोजन ।

स्वाभाविक रूप से, मैंने इस समस्या को आपको आउटसोर्स करने का निर्णय लिया है!

पूर्णांक की एक सरणी Aऔर एक सकारात्मक पूर्णांक बिट चौड़ाई को देखते हुए n, सत्यापित करें कि Aउपरोक्त शर्तों को संतुष्ट करता है।

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

[0, 0, 0], 2: True
[0, 0, 0, 0], 2: False (violates #2)
[1, 2, 3, 4, 5], 8: True
[1, 2, 3, 4, 5], 2: False (violates all conditions)
[1, 2, 3, 4, 5], 5: True
[-3, 4, 1], 4: True
[10, 0, -10], 4: False (violates #1 and #4)
[27, -59, 20, 6, 10, 53, -21, 16], 8: False (violates #4)
[-34, 56, 41, -4, -14, -54, 30, 38], 16: True
[-38, -1, -11, 127, -35, -47, 28, 89, -8, -12, 77, 55, 75, 75, -80, -22], 7: False (violates #4)
[-123, -85, 6, 121, -5, 12, 52, 31, 64, 0, 6, 101, 128, -72, -123, 12], 12: True

संदर्भ कार्यान्वयन (पायथन 3)

#!/usr/bin/env python3
from itertools import combinations
from ast import literal_eval


def check_sum(L, n):
  return -2**(n-1) <= sum(L) < 2**(n-1)


def check_len(L, n):
  return len(L) < 2**n


def check_elems(L, n):
  return all(-2**(n-1) <= a < 2**(n-1) for a in L)


A = literal_eval(input())
n = int(input())
OUTPUT_STR = "{}, {}: {}".format(A, n, "{}")

if not (check_elems(A, n) and check_len(A, n) and check_sum(A, n)):
  print(OUTPUT_STR.format(False))
  exit()

for k in range(1, len(A)):
  for b in combinations(A, k):
    if not check_sum(b, n):
      print(OUTPUT_STR.format(False))
      exit()

print(OUTPUT_STR.format(True))

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



क्या हमें खाली सूची को संभालना चाहिए?
मिस्टर एक्सकोडर

@ Mr.Xcoder नहीं, मैं स्पष्ट करूँगा।
मेगो

जवाबों:


7

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

Max[x=2Tr/@Subsets@#,-x-1,Tr[1^#]]<2^#2&

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

हालत 1 सभी तत्वों के लिए शर्त 3 ​​की जाँच करके निहित है, जिसमें एक तत्व शामिल हैं। इसलिए हम इसका अधिकतम लाभ उठाते हैं

  • प्रत्येक सबसेट का दोगुना,
  • प्रत्येक सबसेट के योग के नकारात्मक से कम से कम दो बार, और
  • पूरे सेट की लंबाई

और जांचें कि क्या यह कम है 2^#2(जहां #2बिट-चौड़ाई इनपुट है)।

केवल 6 अधिक बाइट्स की लागत में, हम जगह ले सकता है Subsets@#के साथ GatherBy[#,Arg]है, जो बहुत अधिक कुशल है, क्योंकि यह केवल दो बुरी से बुरी हालत सबसेट गणना करता है: सभी गैर नकारात्मक मूल्यों के सबसेट, और सभी नकारात्मक मूल्यों के सबसेट। (यह काम करता है क्योंकि पूर्व और उत्तरार्द्ध पर Argएक मूल्य है ।)0π


3

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

ŒPS€;⁸L¤ḟ⁹’2*$ŒRṖ¤Ṇ

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

यह जांचने के mapped sum of powerset + length of setलिए आवश्यक सीमा में है।


1
मुझे लगता है (हालांकि मुझे यकीन नहीं है) आप ( ÆẸ2*$
अप्राप्त

@ Mr.Xcoder यह काम करता है।
user202729

3

05AB1E , 13 12 11 बाइट्स

श्री एक्सकोडर को 1 बाइट का धन्यवाद दिया

æO·D±¹gMIo‹

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

व्याख्या

æ             # powerset of first input
 O            # sum each subset
  ·           # multiply each element by 2
   D          # duplicate
    ±         # bitwise negation of each element in the copy
     ¹g       # push length of first input
       M      # get the maximum value on the stack
        Io    # push 2**<second input>
          ‹   # compare

@ Mr.Xcoder: ओह हाँ, धन्यवाद! (मैं इसके बारे में भूल जाता हूं ±)
Emigna

2

जावास्क्रिप्ट (ईएस 6), 75 63 58 बाइट्स

a=>n=>!a.some(e=>(a.length|2*(e<0?l-=e:u+=e))>>n,u=0,l=-1)

aनकारात्मक और nonngative तत्वों के योगों के बीच झूठ के किसी भी सबसेट का योग , इसलिए मामले को छोड़कर सब कुछ के लिए दो योगों की जाँच करें। संपादित करें: @Arnauld के लिए धन्यवाद 12 17 बाइट्स सहेजे गए।


मेरे भोले दृष्टिकोण से बहुत बेहतर। :-) इसे 61 बाइट्स
Arnauld

दरअसल, हम 56 बाइट्स के लिए लूप के भीतर परीक्षण की प्रक्रिया कर सकते हैं ।
अरनौलड

हैक किया गया ([-2, -1, -2]) (3)
l4m2

@ l4m2 अच्छी पकड़। सुझाया गया फिक्स (57 बाइट्स)
अर्नुलड

@ अरनल्ड यहां समस्या यह है कि [-2, -2], 3सच होना चाहिए, नहीं?
नील

1

जेली , 21 20 बाइट्स

»0,«0$S€~2¦Ḥ;LṀ<2*Ɠ¤

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

रैखिक समय जटिलता समाधान। यह पता चला है कि मैंने समय की जटिलता का अनुमान लगाया है

उन्नीसवीं बाइट में, 2017-12-11 13-15-03Z, user202729 द्वारा

@NewSandboxedPosts "Real" सबसेट सम समस्या बहुत कठिन है। यह एक रैखिक समय में किया जा सकता है ...

क्योंकि अब मुझे एहसास हुआ कि सरणी को छांटना पूरी तरह अनावश्यक है।


स्पष्टीकरण:

»0,«0$S€~2¦Ḥ;LṀ<2*Ɠ¤    Main link. Example list: [-1, 0, 1]
»0                      Maximize with 0. Get [0, 0, 1]
  ,                     Pair with
   «0$                    minimize with 0. Get [-1, 0, 0]
      S€                Sum €ach. Get [1, -1]
        ~               Inverse
          ¦               at element
         2                2. (list[2] = ~list[2]) Get [-1, 2]
           Ḥ            Unhalve (double, ×2). Get [-2, 4]
            ;           Concatenate with
             L            Length (3). Get [-2, 4, 3]
              Ṁ         Maximum of the list (4).
               <   ¤    Still less than
                2         two
                 *        raise to the power of
                  Ɠ       eval(input())


लगता है कि ~2¦हो सकता है ;~। संपादित करें: किया।
user202729

@ user202729 गलत है। फिर भी, ;~$काम करेंगे।
user202729

1

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

करी सिंटैक्स में इनपुट लेता है (A)(n)। एक बूलियन देता है।

A=>n=>!(A.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).some(a=>(s=eval(a.join`+`),s<0?~s:s)>>n-1)|A.length>>n)

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



1

क्लोजर, 121 117 बाइट्स

#(let[l(int(Math/pow 2(dec %2)))](every?(set(range(- l)l))(cons(count %)(for[i(vals(group-by pos? %))](apply + i)))))

ठीक है कि एक सा गूंगा था, सकारात्मक और नकारात्मक मूल्यों में विभाजित करना छँटाई से बहुत बेहतर है। मूल, लेकिन आश्चर्यजनक रूप से ज्यादा लंबा नहीं:

#(let[l(int(Math/pow 2(dec %2)))S(sort %)R reductions](every?(set(range(- l)l))(concat[(count S)](R + S)(R +(into()S)))))

यह आरोही और अवरोही क्रम में अनुक्रम के उपसर्गों की जाँच करके काम करता है, मुझे लगता है कि तत्वों के सभी संयोजनों को उत्पन्न करना आवश्यक नहीं है A

(into () S)प्रभाव में है (reverse S), जैसा कि सूचियाँ सिर से बढ़ती हैं। जब दो सूचियाँ हैं cons, concatतो मैं इसके बजाय उपयोग करने का एक तरीका नहीं निकाल सका cons। : /


1

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

ŒPS€Ḥ;~$;LṀl2<Ɠ

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

व्याख्या

ŒPS€Ḥ;~$;LṀl2<Ɠ ~ Monadic full program.

ŒP              ~ Powerset.
  S€            ~ The sum of each subset.
    Ḥ           ~ Double (element-wise).
     ;~$        ~ Append the list of their bitwise complements.
        ;L      ~ Append the length of the first input.
          Ṁ     ~ And get the maximum.
           l2   ~ Base-2 logarithm.
             <Ɠ ~ Is smaller than the second input (from stdin)?

सहेजे गए 1 बाइट के लिए धन्यवाद caird coinheringaahing (CLA के बजाय STDIN से दूसरा इनपुट पढ़ना)।



0

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

≥Lḋ▲ṁ§eLöa→DΣṖ

सभी सब्लिस्ट्स पर लूपिंग करके ब्रूट फोर्स के साथ जाना, क्योंकि पॉजिटिव और नेगेटिव भागों में विभाजित होने से अधिक बाइट्स लगते हैं। इसे ऑनलाइन आज़माएं!

व्याख्या

≥Lḋ▲ṁ§eLöa→DΣṖ  Implicit inputs, say A=[1,2,3,4,5] and n=5
             Ṗ  Powerset of A: [[],[1],[2],[1,2],..,[1,2,3,4,5]]
    ṁ           Map and concatenate:
                  Argument: a sublist, say S=[1,3,4]
            Σ     Sum: 8
           D      Double: 16
          →       Increment: 17
        öa        Absolute value: 17
     §eL          Pair with length of S: [3,17]
                Result is [0,1,1,3,1,5,2,7,..,5,31]
   ▲            Maximum: 31
  ḋ             Convert to binary: [1,1,1,1,1]
 L              Length: 5
≥               Is it at most n: 1

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