Herausforderung

Suchen Sie anhand einer Liste positiver Ganzzahlen, ob es eine Permutation gibt, bei der von jeder Ganzzahl bis zu einem Bit benötigt wird, und 1erstellen Sie eine Binärzahl, die aus allen s besteht.

Die Anzahl der Bits in der resultierenden Binärzahl entspricht dem höchsten MSB in der Liste der ganzen Zahlen.

Ausgabe

Ihr Code muss einen Wert für " truthy / falsey" ausgeben oder zurückgeben, der angibt, ob eine solche Permutation vorhanden ist.

Beispiele

Wahrheit:

Mit der Liste [4, 5, 2]und ihrer binären Darstellung [100, 101, 10]können wir das dritte, erste und zweite Bit verwenden, um Folgendes zu erstellen 111:

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

In der Liste [3, 3, 3]sind für alle Zahlen sowohl das erste als auch das zweite Bit als gesetzt 1, sodass wir uns eine Nummer aussuchen können, die noch übrig ist:

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

Falsey:

In der Liste [4, 6, 2]ist für keine der Zahlen das erste Bit gesetzt 1, sodass die Binärzahl nicht erstellt werden kann:

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

Mit der Liste [1, 7, 1] ist nur für eine der Nummern das zweite und dritte Bit festgelegt 1, und die Nummer kann nicht erstellt werden:

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

Wenn die maximale Anzahl der gesetzten Bits die Anzahl der ganzen Zahlen überschreitet, kann die Ergebnisnummer natürlich nie erstellt werden.

Testfälle

Wahrheit:

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

Regeln

Standardlücken sind verboten. Da dies Codegolf ist , gewinnt der kürzeste Einstieg!

Jelly , 11 Bytes

BUT€ŒpṬz0PẸ

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Alles Lob geht an meinen Kollegen Marshall .

Unbenannte implizite Präfixfunktion.

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

Probieren Sie es online!

( @Ist Funktionszusammensetzung)

#: Antibase-2

|: transponieren

(… )^:2 Wenden Sie die folgende Funktion zweimal an:

 1- Boolesche Negation

 >./ das Maximum

 @ des

 $ Achslängen

 {. nimm (mit Nullen auffüllend) aus

 |: das transponierte Argument

+./ .* "verrückte Determinantenmagie" *

[: nicht einhaken (no-op - dient dazu, den vorherigen Teil mit dem Rest zusammenzusetzen)

^{* In Marshalls Worten.}

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

Rückgabe 0oder 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)))

Testfälle

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

Methode

Wenn das Eingangsarray A = [a ₀ , a ₁ , ..., a _N-1 ] ist , suchen wir nach einer Permutation [a _{p [0]} , a _{p [1]} , ..., a _{p [N- 1]} ] von A und einer ganzen Zahl x ≤ N, so dass:

• s = 1 + (a _{p [0]} UND 2 ⁰ ) + (a _{p [1]} UND 2 ¹ ) + ... + (a _{p [x-1]} UND 2 ^x-1 ) = 2 ^x
• und s ist größer als das größte Element m von A

Formatiert und kommentiert

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

Schale , 14 Bytes

SöV≡ŀToṁ∂Pmo↔ḋ

Probieren Sie es online!

Erläuterung

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 Bytes

-1 Byte dank Mr.Xcoder

Wahr: 1, Falsch: 0

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

Probieren Sie es online!

Erklärungen:

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 Language (Mathematica) , 65 Byte

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

Probieren Sie es online!

Erläuterung

#~IntegerDigits~2

Wir beginnen mit der Konvertierung aller Eingaben in Binärlisten.

n=PadLeft[...]

Dann füllen wir alle diese Listen mit Nullen links auf, um das Array rechteckig zu machen. Das Ergebnis wird nfür später gespeichert .

Permutations[...]

Yay, Brute Force, lassen Sie uns alle möglichen Permutationen der Eingabe erhalten.

Tr/@...

Dies liefert die Spur für jede Permutation, dh die Summe der diagonalen Elemente in der Permutation. Mit anderen Worten, wir addieren das MSB von der ersten Zahl, das neben dem MSB von der zweiten Zahl und so weiter. Wenn die Permutation gültig ist, sind alle 1 und es gibt so viele 1 s als die größte Eingangsnummer breit ist.

Max[...]

Wir erhalten die maximale Ablaufverfolgung, da die Ablaufverfolgung niemals mehr als die einer gültigen Permutation sein kann.

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

Die rechte Seite ist nur eine Golfversion von Length @ First @ n, dh sie erhält die Breite des rechteckigen Arrays und damit die Breite der größten Eingangszahl. Wir wollen sicherstellen, dass die Spur einer Permutation dieser entspricht.

PHP, 255 243 160 Bytes

-12 Bytes, hat die Sortierung
-83 Bytes (!) Dank Titus entfernt

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

Probieren Sie es online!

Druckt 1 für wahr, nichts für falsch.

Originalversion 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 Bytes

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

Dies setzt x auf eine Funktion, die eine variable Anzahl von Eingaben akzeptiert (voraussichtlich 32-Bit-Ganzzahlen) und auf stdout entweder "true" oder "false" druckt.

Verwendung:

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

PHP, 121 Bytes

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

Probieren Sie es online aus .

Nervenzusammenbruch

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 Bytes

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

Muss ich auch das 'g =.' Zählen? Ich bin bereit, es hinzuzufügen.

Diesmal ein langes explizites Verb. Ich habe einen stillschweigenden für denselben Algorithmus ausprobiert, aber es stellte sich heraus, dass er noch länger und hässlicher war. Weit weg von Adáms Lösung.

Erklärung: (y ist das richtige Argument der Funktion)

                                             ,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

Probieren Sie es online!

Python 3 , 126 120 Bytes

6 Bytes durch Mr. Xcoder eingespart

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)

Probieren Sie es online!

Gelee , 17 Bytes

BUz0Œ!ŒD€Ẏ
ṀBo1eÇ

Ein monadischer Link, der eine Liste von Zahlen 1aufnimmt und (wahrheitsgemäß) oder 0(falsch) zurückgibt.

Probieren Sie es online!

Bei TIO wird dies für den längsten der Testfälle unterbrochen.

Wie?

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

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

Probieren Sie es online!

Ungolfed-Version

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
}

Ich erkannte, dass die Prüfung ohne Zeilen mit den drop=FArgumenten unnötig war . Auch einige lästige Leerzeichen entfernt.

PHP, 152 Bytes

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

Gibt nichts für falsch, 1 für wahr aus.

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

Gelee , 17 Bytes

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

Testsuite.

C 79 Bytes

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