Yazdığım başka bir zorluk için, test senaryolarının sınırlı tamsayılarla çözülebilir olduğunu doğrulamam gerekiyor. Özellikle, boş olmayan Abir tamsayı dizisi ve bir tamsayı bit genişliği için aşağıdakileri doğrulamalıyım n:

1. Tüm tamsayılar aiçinde ATatmin -2**(n-1) <= a < 2**(n-1)(ile gösterilebilen n-bit ikinin tamamlayıcısı tamsayılar).
2. Uzunluğu Adaha az 2**n.
3. Toplamı Atatmin -2**(n-1) <= sum(A) < 2**(n-1).
4. Tüm element kombinasyonları Ayukarıdaki koşulların tümünü karşılar.

Doğal olarak, bu sorunu sizin için dış kaynak kullanmaya karar verdim!

Bir tamsayı dizisi Ave pozitif bir tamsayı bit genişliği nverildiğinde A, yukarıdaki koşulları karşıladığından emin olun .

Test Durumları

[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

Referans Uygulama (Python 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))

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 40 bayt

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

Çevrimiçi deneyin!

Koşul 1, tek elemanlı olanlar da dahil olmak üzere tüm altkümeler için koşul 3'ün kontrol edilmesiyle ima edilir. Bu yüzden maksimum

• her alt kümenin toplamının iki katı,
• her altkümenin toplamının iki katından daha az negatif ve
• tüm setin uzunluğu

ve bunun daha küçük olup olmadığını kontrol edin 2^#2( #2bit genişliği girişi nerede ).

Sadece 6 daha bayt ücret karşılığında biz yerini alabilir Subsets@#ile GatherBy[#,Arg]tüm negatif olmayan değerler alt kümesi ve tüm negatif değerlerin alt kümesi: Yalnızca iki kötü durum alt kümelerini hesaplar nedeniyle çok daha verimli olan. (Bu işe yarar çünkü birincisi ve ikincisi üzerinde Argbir değeri vardır .)0π

Jöle , 19 bayt

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

Çevrimiçi deneyin!

mapped sum of powerset + length of setGerekli aralıkta olup olmadığını kontrol etmek yeterlidir .

05AB1E , 13 12 11 bayt

Bay Xcoder sayesinde 1 bayt tasarruf edildi

æO·D±¹gMIo‹

Çevrimiçi deneyin!

açıklama

æ             # 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

JavaScript (ES6), 75 63 58 bayt

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

Herhangi bir ayalan alt kümesinin toplamı , negatif ve negatif olmayan elemanların toplamları arasındadır, bu nedenle iki toplamın kontrol edilmesi, durum 2 dışındaki her şey için yeterlidir. Düzenleme: @Arnauld sayesinde 12 17 bayt kaydedildi.

Jöle , 21 20 bayt

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

Çevrimiçi deneyin!

Doğrusal zaman karmaşıklığı çözümü. Zaman karmaşıklığını fazla tahmin ettiğim ortaya çıkıyor

içinde Ondokuzuncu Bayt, 2017-12-11 13-15-03Z, user202729 tarafından

@NewSandboxedPosts "Gerçek" alt küme toplamı sorunu çok daha zordur. Bu lineermik zamanda yapılabilir ...

çünkü şimdi diziyi sıralamanın tamamen gereksiz olduğunu anlıyorum.

Açıklama:

»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())

JavaScript (ES6), 114 bayt

Körili sözdiziminde girdi alır (A)(n). Bir boole döndürür.

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)

Test senaryoları

let f =

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)

console.log('[Truthy]')
console.log(f([0, 0, 0])(2))
console.log(f([1, 2, 3, 4, 5])(8))
console.log(f([1, 2, 3, 4, 5])(5))
console.log(f([-3, 4, 1])(4))
console.log(f([-34, 56, 41, -4, -14, -54, 30, 38])(16))
console.log(f([-123, -85, 6, 121, -5, 12, 52, 31, 64, 0, 6, 101, 128, -72, -123, 12])(12))

console.log('[Falsy]')
console.log(f([0, 0, 0, 0])(2)) // violates #2
console.log(f([1, 2, 3, 4, 5])(2)) // violates all conditions
console.log(f([10, 0, -10])(4)) // violates #1 and #4
console.log(f([27, -59, 20, 6, 10, 53, -21, 16])(8)) // violates #4
console.log(f([-38, -1, -11, 127, -35, -47, 28, 89, -8, -12, 77, 55, 75, 75, -80, -22])(7)) // violates #4

Pyth , 20 bayt

>EleS++KyMsMyQmt_dKl

Burada deneyin!

Clojure, 121 117 bayt

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

Bu biraz aptalcaydı, pozitif ve negatif değerlere bölmek sıralamadan çok daha iyi. Orijinal, ama şaşırtıcı derecede daha uzun değil:

#(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)))))

Bu, dizinin önek toplamlarını artan ve azalan sırada kontrol ederek çalışır, bence tüm eleman kombinasyonlarını oluşturmak gerekli değildir A.

(into () S)aslında (reverse S)listeler baştan büyüdükçe aynıdır . Ben kullanmanın bir yolunu çözemedim consyerine concatiki listelerine varken consiçin. : /

Jöle , 15 bayt

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

Çevrimiçi deneyin!

açıklama

Œ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)?

Kalabalık paraşütle atlama (CLA yerine STDIN'den ikinci girişi okuma) sayesinde 1 bayt kaydedildi .

Kabuk , 14 bayt

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

Pozitif ve negatif parçalara ayrılmak daha fazla bayt gerektirdiğinden, tüm alt listelerde döngü yaparak kaba kuvvetle gitmek. Çevrimiçi deneyin!

açıklama

≥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

Python 2 , 72 71 70 bayt

def f(x,n):t=2*sum(k*(k<0)for k in x);max(2*sum(x)-t,~t,len(x))>>n>0>_

Çıktı bir hatanın varlığı / yokluğu yoluyla gerçekleşir .

Çevrimiçi deneyin!