Thử thách

Đưa ra một danh sách các số nguyên dương, tìm xem có tồn tại một hoán vị trong đó lấy tối đa một bit từ mỗi số nguyên hay không, một số nhị phân bao gồm tất cả các 1s có thể được tạo.

Số lượng bit trong số nhị phân kết quả bằng với MSB cao nhất trong danh sách các số nguyên.

Đầu ra

Mã của bạn phải xuất hoặc trả về giá trị trung thực / falsey cho biết nếu tồn tại hoán vị như vậy.

Ví dụ

Sự thật:

Với danh sách [4, 5, 2]và biểu diễn nhị phân của nó [100, 101, 10], chúng ta có thể sử dụng các bit thứ ba, thứ nhất và thứ hai tương ứng để tạo 111:

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

Với danh sách [3, 3, 3], tất cả các số có cả bit thứ nhất và thứ hai được đặt là 1, vì vậy chúng ta có thể chọn một số để dự phòng:

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

Falsey:

Với danh sách [4, 6, 2], không có số nào có bit đầu tiên được đặt 1, vì vậy số nhị phân không thể được tạo:

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

Với danh sách [1, 7, 1], chỉ một trong các số có bit thứ hai và thứ ba được đặt là 1và số không thể được tạo:

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

Rõ ràng, nếu số bit được đặt tối đa vượt quá số nguyên, số kết quả không bao giờ có thể được tạo.

Các trường hợp thử nghiệm

Sự thật:

[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]

Quy tắc

Sơ hở tiêu chuẩn bị cấm. Vì đây là môn đánh gôn , nên bài dự thi ngắn nhất!

Thạch , 11 byte

BUT€ŒpṬz0PẸ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

Tất cả tín dụng thuộc về đồng nghiệp Marshall của tôi .

Chức năng tiền tố ngầm không tên.

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

Hãy thử trực tuyến!

( @là thành phần chức năng)

#: kháng thể-2

|: hoán vị

(... )^:2 áp dụng các chức năng sau hai lần:

 1- Boolean phủ định

 >./ giá trị lớn nhất

 @ của

 $ độ dài trục

 {. lấy (đệm với số không) từ

 |: đối số chuyển

+./ .* "ma thuật quyết định điên rồ" *

[: không hook (no-op - phục vụ để soạn phần trước với phần còn lại)

^{* Theo lời của Marshall.}

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

Trả về 0hoặc 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)))

Các trường hợp thử nghiệm

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]))

phương pháp

Cho mảng đầu vào A = [a ₀ , a ₁ , ..., _N-1 ] , chúng tôi tìm hoán vị [a _{p [0]} , a _{p [1]} , ..., a _{p [N- 1]} ] của A và một số nguyên x ≤ N sao cho:

• s = 1 + (a _{p [0]} VÀ 2 ⁰ ) + (a _{p [1]} VÀ 2 ¹ ) + ... + (a _{p [x-1]} VÀ 2 ^x-1 ) = 2 ^x
• và s lớn hơn phần tử m lớn nhất của A

Định dạng và nhận xét

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

Husk , 14 byte

SöV≡ŀToṁ∂Pmo↔ḋ

Hãy thử trực tuyến!

Giải trình

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 byte

-1 byte nhờ Mr.Xcoder

Đúng: 1, Sai: 0

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

Hãy thử trực tuyến!

Giải thích:

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

Ngôn ngữ Wolfram (Mathicala) , 65 byte

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

Hãy thử trực tuyến!

Giải trình

#~IntegerDigits~2

Chúng tôi bắt đầu bằng cách chuyển đổi tất cả các đầu vào thành danh sách nhị phân.

n=PadLeft[...]

Sau đó, chúng tôi đệm tất cả các danh sách có số không ở bên trái để tạo mảng hình chữ nhật. Kết quả được lưu trữ ncho sau này.

Permutations[...]

Yay, lực lượng vũ phu, chúng ta hãy có được tất cả các hoán vị có thể có của đầu vào.

Tr/@...

Điều này nhận được dấu vết cho mỗi hoán vị, tức là tổng các phần tử đường chéo trong hoán vị. Nói cách khác, chúng tôi cộng MSB từ số thứ nhất, MSB tiếp theo từ số thứ hai, v.v. Nếu hoán vị là hợp lệ, tất cả các giá trị này sẽ là 1 và sẽ có nhiều 1 giây khi số đầu vào lớn nhất rộng.

Max[...]

Chúng tôi nhận được dấu vết tối đa, bởi vì dấu vết không bao giờ có thể nhiều hơn dấu vết hoán vị hợp lệ.

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

Phía bên tay phải chỉ là một phiên bản golf Length @ First @ n, tức là nó có chiều rộng của mảng hình chữ nhật, và do đó chiều rộng của số đầu vào lớn nhất. Chúng tôi muốn đảm bảo rằng dấu vết của một số hoán vị bằng với điều này.

PHP, 255 243 160 byte

-12 byte, lấy ra sắp xếp
-83 byte (!) Nhờ Titus

<?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);}

Hãy thử trực tuyến!

In 1 cho sự thật, không có gì cho falsey.

Phiên bản gốc chưa được chỉnh sửa:

<?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 byte

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

Điều này đặt x là một hàm chấp nhận số lượng đầu vào thay đổi (dự kiến ​​là số nguyên 32 bit) và in ra thiết bị xuất chuẩn "đúng" hoặc "sai".

Sử dụng:

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

PHP, 121 byte

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);}

Hãy thử trực tuyến .

phá vỡ

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 byte

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

Tôi có cần tính cả 'g =.' Không? Tôi đã sẵn sàng để thêm nó.

Một động từ rõ ràng dài thời gian này. Tôi đã thử một thuật toán ngầm cho cùng một thuật toán, nhưng hóa ra nó còn dài hơn và xấu hơn thế này. Cách xa giải pháp của Adám.

Giải thích: (y là đối số đúng của hàm)

                                             ,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

Hãy thử trực tuyến!

Python 3 , 126 120 byte

Đã lưu 6 byte do ông Xcoder

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)

Hãy thử trực tuyến!

Thạch , 17 byte

BUz0Œ!ŒD€Ẏ
ṀBo1eÇ

Một liên kết đơn âm lấy một danh sách các số và trả về 1(trung thực) hoặc 0(falsey).

Hãy thử trực tuyến!

Điều này sẽ hết thời gian trên TIO trong thời gian dài nhất của mỗi trường hợp thử nghiệm.

Làm sao?

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 byte 221 byte

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)}

Hãy thử trực tuyến!

Phiên bản ung dung

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
}

Tôi nhận ra việc kiểm tra không có hàng là không cần thiết với các drop=Fđối số. Cũng loại bỏ một số khoảng trắng pesky.

PHP, 152 byte

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

In không có gì sai, 1 cho đúng.

Ung dung:

<?

// 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");
}

Thạch , 17 byte

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

Bộ thử nghiệm.

C, 79 byte

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