Meydan okuma

Olumlu tamsayıların bir listesi göz önüne alındığında, tamsayıların her birinden bir bit alarak, her 1s'den oluşan bir ikili sayı oluşturulabilen bir izin olup olmadığını bulun .

Elde edilen ikili sayıdaki bit sayısı, tamsayılar listesindeki en yüksek MSB'ye eşittir .

Çıktı

Kodunuz, böyle bir izin olup olmadığını belirten bir truthy / falsey değeri vermeli veya döndürmelidir .

Örnekler

Truthy:

Liste [4, 5, 2]ve ikili gösterimi ile [100, 101, 10], aşağıdakileri oluşturmak için sırasıyla üçüncü, birinci ve ikinci bitleri kullanabiliriz 111:

4  ->  100  ->  100  ->  1
5  ->  101  ->  101  ->    1
2  ->  010  ->  010  ->   1
Result                   111

Listede [3, 3, 3], tüm sayılar hem birinci hem de ikinci bit olarak ayarlanmıştır 1, bu yüzden seçimimizi boşa almak için bir sayı ile alabiliriz:

3  ->  11  ->  11  ->  1
3  ->  11  ->  11  ->   1
3  ->  11  ->  11  ->
Result                 11

Falsey:

Listede [4, 6, 2], sayıların hiçbiri ilk biti ayarlamaz 1, bu nedenle ikili sayı oluşturulamaz:

4  ->  100
6  ->  110
2  ->  010

Listede [1, 7, 1], sayılardan yalnızca biri olarak ayarlanan ikinci ve üçüncü bitlere sahiptir 1ve sayı oluşturulamaz:

1  ->  001
7  ->  111
1  ->  001

Açıkça, eğer maksimum set bit sayısı, tamsayı sayısını aşıyorsa, sonuç numarası asla oluşturulamaz.

Test durumları

Truthy:

[1]
[1, 2]
[3, 3]
[3, 3, 3]
[4, 5, 2]
[1, 1, 1, 1]
[15, 15, 15, 15]
[52, 114, 61, 19, 73, 54, 83, 29]
[231, 92, 39, 210, 187, 101, 78, 39]

Falsey:

[2]
[2, 2]
[4, 6, 2]
[1, 7, 1]
[15, 15, 15]
[1, 15, 3, 1]
[13, 83, 86, 29, 8, 87, 26, 21]
[154, 19, 141, 28, 27, 6, 18, 137]

kurallar

Standart boşluklar yasaktır. Bu kod golf olduğu için en kısa giriş kazanır!

Jöle , 11 bayt

BUT€ŒpṬz0PẸ

Çevrimiçi deneyin!

Nasıl çalışır

BUT€ŒpṬz0PẸ  Main link. Argument: A (array)

             Example: A = [4, 5, 2]
B            Binary; convert each n in A to base 2.
                      [[1, 0, 0], [1, 0, 1], [1, 0]]
 U           Upend; reverse all arrays of binary digits.
                      [[0, 0, 1], [1, 0, 1], [0, 1]]
  T€         Truth each; for each binary array, get all indices of 1's.
                      [[3], [1, 3], [2]]
    Œp       Take the Cartesian product of all index arrays.
                      [[3, 1, 2], [3, 3, 2]
      Ṭ      Untruth; map each index array to a binary arrays with 1's at
             at the specified indices.
                      [[1, 1, 1], [0, 1, 1]]
       z0    Zip/transpose the resulting 2D array, filling shorter rows with 0's.
                      [[1, 0], [1, 1], [1, 1]]
         P   Take the columnwise product.
                      [1, 0]
          Ẹ  Any; yield 1 if any of the products is non-zero, 0 otherwise.
                      1

J , 30 bayt

Tüm kredi meslektaşım Marshall'a gidiyor .

Adsız tacit önek işlevi.

[:+./ .*(1->./@${.|:)^:2@|:@#:

Çevrimiçi deneyin!

( @işlev bileşimidir)

#: antibase-2

|: devrik

(… )^:2 Aşağıdaki işlevi iki kez uygulayın:

 1- Boole ihmali

 >./ maksimum

 @ arasında

 $ eksen uzunlukları

 {. (sıfır ile doldurma) almak

 |: aktarılan argüman

+./ .* "çılgın determinant sihir" *

[: takma (no-op - geri kalan kısmı ile önceki kısmı oluşturmaya yarar)

^{* Marshall'ın sözleriyle.}

JavaScript (ES6), 104 ... 93 83 bayt

0Veya döndürür 1.

f=(a,m=Math.max(...a),s=1)=>s>m|a.some((n,i)=>n&s&&f(b=[...a],m,s*2,b.splice(i,1)))

Test durumları

f=(a,m=Math.max(...a),s=1)=>s>m|a.some((n,i)=>n&s&&f(b=[...a],m,s*2,b.splice(i,1)))

console.log('Truthy')
console.log(f([1]))
console.log(f([1, 2]))
console.log(f([3, 3]))
console.log(f([3, 3, 3]))
console.log(f([4, 5, 2]))
console.log(f([1, 1, 1, 1]))
console.log(f([15, 15, 15, 15]))
console.log(f([52, 114, 61, 19, 73, 54, 83, 29]))
console.log(f([231, 92, 39, 210, 187, 101, 78, 39]))

console.log('Falsy')
console.log(f([2]))
console.log(f([2, 2]))
console.log(f([4, 6, 2]))
console.log(f([1, 7, 1]))
console.log(f([15, 15, 15]))
console.log(f([1, 15, 3, 1]))
console.log(f([13, 83, 86, 29, 8, 87, 26, 21]))
console.log(f([154, 19, 141, 28, 27, 6, 18, 137]))

Yöntem

A = [a ₀ , a ₁ , ..., _N-1 ] giriş dizisine bakılırsa, bir permütasyona bakıyoruz [a _{p [0]} , a _{p [1]} , ..., _{p [N- 1]} ] ve A ve bir tam sayıdır x ≤ N , öyle ki:

• s = 1 + (a _{p [0]} VE 2 ⁰ ) + (a _{p [1]} AND 2 ¹ ) + ... + (a _{p [x-1]} VE 2 ^x-1 ) = 2 ^x
• ve s büyük elemanı daha büyük olan m ve A

Biçimlendi ve yorumlandı

f = (                 // f = recursive function taking:
  a,                  //   - a = array
  m = Math.max(...a), //   - m = greatest element in a
  s = 1               //   - s = current power of 2, starting at 1
) =>                  //
  s > m               // success condition (see above) which is
  |                   // OR'd with the result of this some():
  a.some((n, i) =>    // for each element n at position i in a:
    n & s &&          //   provided that the expected bit is set in n,
    f(                //   do a recursive call with:
      b = [...a],     //     b = copy of a
      m,              //     m unchanged
      s * 2,          //     s = next power of 2
      b.splice(i, 1)  //     the current element removed from b
    )                 //   end of recursive call
  )                   // end of some()

Kabuğu , 14 bayt

SöV≡ŀToṁ∂Pmo↔ḋ

Çevrimiçi deneyin!

açıklama

SöV≡ŀToṁ∂Pmo↔ḋ  Implicit input, say [4,5,2].
          m  ḋ  Convert each to binary
           o↔   and reverse them: x = [[0,0,1],[1,0,1],[0,1]]
         P      Take all permutations of x
      oṁ∂       and enumerate their anti-diagonals in y = [[0],[0,1],[1,0,0],[1,1],[1]..
S    T          Transpose x: [[0,1,0],[0,0,1],[1,1]]
    ŀ           Take the range up to its length: z = [1,2,3]
                Then z is as long as the longest list in x.
 öV             Return the 1-based index of the first element of y
   ≡            that has the same length and same distribution of truthy values as z,
                i.e. is [1,1,1]. If one doesn't exist, return 0.

05AB1E , 23 22 20 bayt

Mr.Xcoder sayesinde -1 bayt

Doğru: 1, Yanlış: 0

2вí0ζœεvyƶNè})DgLQ}Z

Çevrimiçi deneyin!

açıklamalar:

2вí0ζœεvyƶNè})DgLQ}Z   Full program (implicit input, e.g. [4, 6, 2])
2в                     Convert each to binary ([1,0,0], [1,1,0], [1,0])
  í                    Reverse each ([0,0,1], [0,1,1], [0,1])
   0ζ                  Zip with 0 as a filler ([0,0,0],[0,1,1],[1,1,0])
     œ                 Get all sublists permutations
      ε           }    Apply on each permutation...
       vyƶNè}            For each sublist...
        yƶ                  Multiply each element by its index
          Nè                Get the element at position == sublist index
             )           Wrap the result in a list
              DgLQ       1 if equal to [1,2,...,length of item]
                   Z   Get max item of the list (1 if at least 1 permutations fill the conditions)
                       -- implicit output

Wolfram Dili (Mathematica) , 65 bayt

Max[Tr/@Permutations[n=PadLeft[#~IntegerDigits~2]]]==Tr[1^#&@@n]&

Çevrimiçi deneyin!

açıklama

#~IntegerDigits~2

Tüm girdileri ikili listelere dönüştürerek başlıyoruz.

n=PadLeft[...]

Sonra diziyi dikdörtgen yapmak için tüm bu listeleri sol tarafa getiriyoruz. Sonuç ndaha sonra için saklanır .

Permutations[...]

Yay, kaba kuvvet, girişin tüm olası izinlerini alalım.

Tr/@...

Bu, her permütasyon için izini alır, yani permütasyondaki diyagonal elementlerin toplamını. Başka bir deyişle, ilk numaradan MSB'yi, ikinci numaradan MSB'nin yanına vb. Ekleriz. Eğer permütasyon geçerliyse, bunların hepsi 1 olacak ve en büyük giriş sayısı geniş olduğu kadar 1 sn olacaktır .

Max[...]

Maksimum izi alıyoruz, çünkü iz hiçbir zaman geçerli bir permütasyondan daha fazla olamaz.

...==Tr[1^#&@@n]

Sağ taraf sadece golf sahası versiyonudur Length @ First @ n, yani dikdörtgen dizinin genişliğini ve dolayısıyla en büyük giriş sayısının genişliğini alır. Bazı permütasyon izlerinin buna eşit olduğundan emin olmak istiyoruz.

PHP, 255 243 160 bayt

-12 bayt, sıralaması çıkardı
-83 bayt (!) Titus sayesinde

<?function f($a,$v=NULL,$b=[]){($v=$v??(1<<log(max($a),2)+1)-1)||die("1");if($p=array_pop($a))while($p-=$i)($b[$i=1<<log($p,2)]|$v<$i)||f($a,$v-$i,[$i=>1]+$b);}

Çevrimiçi deneyin!

Doğruluk için 1, falsey için hiçbir şey yok.

Orijinal sürüm ungolfed:

<?php
unset($argv[0]);                                                   // remove filename from arguments
$max = pow(2,floor(log(max($argv),2))+1)-1;                        // get target number (all bits set to 1)
solve($argv,$max,[]);
function solve($array,$value,$bits){
  if(!$value){                                                     // if we've reached our target number (actually subtracted it to zero)
    die("1");                                                      // print truthy
  }
  if(count($array)){                                               // while there are arguments left to check
    $popped = array_pop($array);                                   // get the largest argument
    while($popped > 0 && ($mybit = pow(2,floor(log($popped,2))))){ // while the argument hasn't reached zero, get the highest power of 2 possible
      $popped -= $mybit;                                           // subtract power from argument
      if($value >= $mybit && !$bits[$i]){                          // if this bit can be subtracted from our argument, and we haven't used this bit yet
        $copy = $bits;                                             // create a copy to pass to the function
        $copy[$mybit] = 1;                                         // mark the bit as used in the copy
        solve($array,$value-$mybit,$copy);                         // recurse
      }
    }
  }
}

Lua 5.2, 85 bayt

m=math
x=function(...)print(bit32.bor(...)==2^(m.floor(m.log(m.max(...),2))+1)-1)end

Bu, x değişken sayıdaki girişleri (32 bit tam sayı olması beklenen) kabul eden bir işlev olarak ayarlar ve "doğru" veya "yanlış" olarak stdout'a yazdırır.

Kullanımı:

x(13, 83, 86, 29, 8, 87, 26, 21) -- Prints "false"

PHP, 121 bayt

function f($a,$s=0){($v=array_pop($a))||(0|$g=log($s+1,2))-$g||die("1");for($b=.5;$v<=$b*=2;)$v&$b&&~$s&$b&&f($a,$s|$b);}

Çevrimiçi deneyin .

Yıkmak

function f($a,$s=0)
{
    ($v=array_pop($a))          # pop element from array
    ||                          # if nothing could be popped (empty array)
    (0|$g=log($s+1,2))-$g       # and $s+1 is a power of 2
        ||die("1");                 # then print "1" and exit
    for($b=.5;$v>=$b*=2;)       # loop through the bits:
        $v&$b                       # if bit is set in $v
        &&~$s&$b                    # and not set in $s
            &&f($a,$s|$b);              # then set bit in $s and recurse
}

J , 49 bayt

g=.3 :'*+/*/"1+/"2((#y){.=i.{:$#:y)*"2#:(i.!#y)A.,y'

'G =' değerini de saymam gerekiyor mu? Eklemeye hazırım.

Bu sefer çok açık bir fiil. Aynı algoritma için bir tane denedim, ancak bundan daha uzun ve daha çirkin olduğu ortaya çıktı. Adám'ın çözümünden çok uzak.

Açıklama: (y, işlevin doğru argümanıdır)

                                             ,y - adds a leading axis to the argument 
                                             (if it's scalar becomes an array of length 1)
                                          .A    - finds the permutations according to the left argument
                                   (i.!#y)      - factorial of the length of the argument, for all permutations
                                 #:             - convert each element to binary
                             *"2                - multiply each cell by identity matrix
           (                )                   - group 
                   =i.{:$#:y                    - identity matrix with size the length
                                                  of the binary representation of the argument 
             (#y){.                             - takes as many rows from the identity matrix 
                                                  as the size of the list (pad with 0 if neded)
    */"1+/"2                                    - sums the rows and multiplies the items
                                                  to check if forms an identity matrix
 *+/                                            - add the results from all permutations and
                                                  returns 1 in equal or greater then 1

Çevrimiçi deneyin!

Python 3 , 126 120 bayt

Bay Xcoder nedeniyle 6 bayt kaydedildi

lambda x:g(x,max(map(len,map(bin,x)))-3)
g=lambda x,n:n<0 or any(g(x[:i]+x[i+1:],n-1)for i in range(len(x))if x[i]&2**n)

Çevrimiçi deneyin!

Jöle , 17 bayt

BUz0Œ!ŒD€Ẏ
ṀBo1eÇ

Sayıların listesini alan ve dönen 1(truthy) veya 0( falsey) bir monadik bağlantı .

Çevrimiçi deneyin!

Bu, her test vakasının en uzun süre TIO'da zaman aşımına uğrayacaktır.

Nasıl?

BUz0Œ!ŒD€Ẏ - Link 1, possibilities (plus some shorter ones & duplicates): list of numbers
                                     e.g. [4, 5, 2]
B          - to binary list (vectorises)  [[1,0,0],[1,0,1],[1,0]]
 U         - upend                        [[0,0,1],[1,0,1],[0,1]]
   0       - literal zero                  0
  z        - transpose with filler        [[0,1,0],[0,0,1],[1,1,0]]
    Œ!     - all permutations             [[[0,1,0],[0,0,1],[1,1,0]],[[0,1,0],[1,1,0],[0,0,1]],[[0,0,1],[0,1,0],[1,1,0]],[[0,0,1],[1,1,0],[0,1,0]],[[1,1,0],[0,1,0],[0,0,1]],[[1,1,0],[0,0,1],[0,1,0]]]
      ŒD€  - diagonals of €ach            [[[0,0,0],[1,1],[0],[1],[0,1]],[[0,1,1],[1,0],[0],[0],[1,0]],[[0,1,0],[0,0],[1],[1],[0,1]],[[0,1,0],[0,0],[1],[0],[1,1]],[[1,1,1],[1,0],[0],[0],[0,0]],[[1,0,0],[1,1],[0],[0],[0,1]]]
         Ẏ - tighten                      [[0,0,0],[1,1],[0],[1],[0,1],[0,1,1],[1,0],[0],[0],[1,0],[0,1,0],[0,0],[1],[1],[0,1],[0,1,0],[0,0],[1],[0],[1,1],[1,1,1],[1,0],[0],[0],[0,0],[1,0,0],[1,1],[0],[0],[0,1]]

ṀBo1eÇ - Main link: list of numbers  e.g. [4, 5, 2]
Ṁ      - maximum                           5
 B     - to binary list                   [1,0,1]
   1   - literal one                       1
  o    - or (vectorises)                  [1,1,1]
     Ç - last link as a monad             [[0,0,0],[1,1],[0],[1],[0,1],[0,1,1],[1,0],[0],[0],[1,0],[0,1,0],[0,0],[1],[1],[0,1],[0,1,0],[0,0],[1],[0],[1,1],[1,1,1],[1,0],[0],[0],[0,0],[1,0,0],[1,1],[0],[0],[0,1]]
    e  - exists in?                        1    --------------------------------------------------------------------------------------------------------------^

R , 247 bayt 221 bayt

function(i){a=do.call(rbind,Map(`==`,Map(intToBits,i),1));n=max(unlist(apply(a,1,which)));any(unlist(g(a[,1:n,drop=F],n)))}
g=function(a,p){if(p==1)return(any(a[,1]));Map(function(x){g(a[x,,drop=F],p-1)},which(a[,p])*-1)}

Çevrimiçi deneyin!

Ungolfed versiyonu

f=function(i){                                   #anonymous function when golfed
  a=do.call(rbind,Map(`==`,Map(intToBits,i),1))  #convert integers to binary, then logical
                                                 #bind results together in matrix
  n=max(unlist(apply(a,1,which)))                #determine max number of bits
  any(unlist(g(a[,1:n,drop=F],n)))               #apply recursive function
}

g=function(a,p){
  if(p==1)return(any(a[,1]))                   #check if first bit is available still
  Map(function(x){g(a[x,,drop=F],p-1)},which(a[,p])*-1) #strip row used for current bit
                                                        #and apply the function recursively
}

Sırasız kontrolün drop=Fargümanlarla gereksiz olduğunu anladım . Ayrıca biraz sinir bozucu boşluk kaldı.

PHP, 152 bayt

<?function b($a,$b,$s){$a[$s]=0;$r=$b-1;foreach($a as$i=>$v)if($v&1<<$b)$r=max(b($a,$b+1,$i),$r);return$r;}$g=$argv;$g[0]=0;echo!(max($g)>>b($g,0,0)+1);

Yanlış için hiçbir şey yazdırmaz, gerçek için 1 yazdırır.

Ungolfed:

<?

// Search an array for a value having a bit set at the given bit index.
// For each match, search for a next higher bit index excluding the current match.
// This way it "climbs up" bit by a bit, finally returning the highest bit index reached.
function bitSearch($valArr, $bitInd, $skipInd) {
    unset($valArr[$skipInd]);
    $result = $bitInd - 1;
    foreach ($valArr as $ind => $v) {
        if ($v & (1 << $bitInd)) {
            $result = max(bitSearch($valArr, $bitInd + 1, $ind), $result);
        }
    }
    return $result;
}

$argv[0] = 0;
$r = bitSearch($argv, 0, 0);
// Check if the highest bit index reached was highest in the largest value given.
if (max($argv) >> ($r + 1)) {
    echo("False\n");
} else {
    echo("True\n");
}

Jöle , 17 bayt

BUz0×J$€ŒpṢ=JPƲ€Ẹ

Test odası.

C, 79 bayt

b,i;main(a){for(;~scanf("%d",&a);i++)b|=a;puts("false\0true"+(b==(1<<i)-1)*6);}