একটি তৈরি করতে একটি নিন

Question

চ্যালেঞ্জ

ধনাত্মক পূর্ণসংখ্যার একটি তালিকা দেওয়া আছে, যেখানে কোনও পূর্ণগতির উপস্থিতি রয়েছে কিনা তা খুঁজে বার করুন যেখানে প্রতিটি পূর্ণসংখ্যার থেকে এক বিট পর্যন্ত নেওয়ার সাথে সাথে, সমস্ত বর্গের একটি বাইনারি সংখ্যা 1তৈরি করা যেতে পারে।

ফলাফলের বাইনারি সংখ্যায় বিটের সংখ্যা পূর্ণসংখ্যার তালিকার সর্বোচ্চ এমএসবি এর সমান ।

আউটপুট

আপনার কোড অবশ্যই আউটপুট করবে বা সত্যবাদী / মিথ্যা মানটি ফিরিয়ে আনবে যদি এইরকম অনুমানের উপস্থিতি উপস্থিত থাকে।

উদাহরণ

Truthy:

তালিকা [4, 5, 2]এবং এর বাইনারি উপস্থাপনা সহ [100, 101, 10]আমরা তৈরি করতে যথাক্রমে তৃতীয়, প্রথম এবং দ্বিতীয় বিট ব্যবহার করতে পারি 111:

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

তালিকার সাথে [3, 3, 3], সমস্ত সংখ্যারই প্রথম এবং দ্বিতীয় বিট উভয়ই সেট করা আছে 1, তাই আমরা বাছাইয়ের জন্য একটি সংখ্যা সহ আমাদের বাছাই করতে পারি:

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

Falsey:

তালিকার সাথে [4, 6, 2], কোনও সংখ্যাতেই প্রথম বিট সেট করা নেই 1, তাই বাইনারি সংখ্যা তৈরি করা যায় না:

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

তালিকাটি সহ [1, 7, 1], কেবলমাত্র একটিতে দ্বিতীয় এবং তৃতীয় বিট হিসাবে সেট করা থাকে 1এবং সংখ্যাটি তৈরি করা যায় না:

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

স্পষ্টতই, সেট বিটের সর্বাধিক সংখ্যা যদি পূর্ণসংখ্যার সংখ্যার বেশি হয়, ফলাফল সংখ্যা কখনই তৈরি করা যায় না।

পরীক্ষার মামলা

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]

বিধি

স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ। এটি কোড-গল্ফ হিসাবে , স্বল্পতম এন্ট্রি জয়!

Comments

এর সাথে একটি উপপাদ্য রয়েছে যা

— গাছ নয়

পিপিসিজিতে আপনাকে স্বাগতম! প্রথম প্রথম চ্যালেঞ্জ!

— মিঃ এক্সকডার

@ নোটাত্রি: আচ্ছা, কত সুন্দর। আমাকে স্ত্রী খুঁজে পেতে আমি সবচেয়ে সংক্ষিপ্ত কোডটি ব্যবহার করতে পারি।

— এন্টি 29

দ্বিপক্ষীয় মিল হিসাবে আমার গ্রাফ সমস্যার সূচকগুলিতে যুক্ত হয়েছে।

— পিটার টেলর

Answer 1

জেলি , 11 বাইট

BUT€ŒpṬz0PẸ

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

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

Answer 2

জে , 30 বাইট

সমস্ত কৃতিত্ব আমার সহকর্মী মার্শালের হাতে ।

শনাক্তকরণ উপসর্গ ফাংশন।

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

এটি অনলাইন চেষ্টা করুন!

( @ফাংশন রচনা)

#: antibase-2

|: TRANSPOSE

(… )^:2 নিম্নলিখিত ফাংশনটি দু'বার প্রয়োগ করুন:

 1- বুলিয়ান নেগেট

 >./ সর্বোচ্চ

 @ এর

 $ অক্ষ দৈর্ঘ্য

 {. থেকে (জিরো সহ প্যাডিং) নিতে

 |: স্থানান্তরিত যুক্তি

+./ .* "পাগল নির্ধারক যাদু" *

[: হুক করবেন না (কোনও বিকল্প নেই - বাকি অংশের সাথে পূর্ববর্তী অংশটি রচনা করতে পারে)

---

^{* মার্শালের কথায়।}

Answer 3

জাভাস্ক্রিপ্ট (ES6), 104 ... 93 83 বাইট

রিটার্ন 0বা 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)))

পরীক্ষার মামলা

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

পদ্ধতি

A = [a ₀ , a ₁ , ..., একটি _N-1 ] ইনপুট অ্যারে প্রদত্ত , আমরা একটি অনুক্রমের জন্য [একটি _{পি [0]} , একটি _{পি [1]} , ..., একটি _{পি [এন- 1]} ] এর A এবং পূর্ণসংখ্যা x ≤ N এর মতো:

• s = 1 + (একটি _{পি [0]} এবং 2 ⁰ ) + (একটি _{পি [1]} এবং 2 ¹ ) + ... + (একটি _{পি [এক্স -1]} এবং 2 ^{এক্স -1} ) = 2 ^এক্স
• এবং s এর A বৃহত্তম উপাদান মি এর চেয়ে বড়

ফর্ম্যাট এবং মন্তব্য

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

Answer 4

কাস্তে , 14 বাইট

SöV≡ŀToṁ∂Pmo↔ḋ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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.

Answer 5

05 এ বি 1 ই , 23 22 20 বাইট

মিঃ এক্সকোডারকে -1 বাইট ধন্যবাদ

সত্য: 1, মিথ্যা: 0

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

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

Answer 6

ওল্ফ্রাম ভাষা (গণিত) , 65 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

#~IntegerDigits~2

আমরা সমস্ত ইনপুট বাইনারি তালিকায় রূপান্তর করে শুরু করি।

n=PadLeft[...]

তারপরে অ্যারে আয়তক্ষেত্রাকার করতে আমরা সেই সমস্ত তালিকা বামে শূন্যের সাথে প্যাড করি। ফলাফলটি nপরে সংরক্ষণ করা হয় ।

Permutations[...]

হ্যাঁ, হিংস্র বাহিনী, আসুন ইনপুটটির সমস্ত সম্ভাব্য ক্রমশক্তি পান।

Tr/@...

এটি প্রতিটি অনুক্রমের জন্য ট্রেস পায়, অর্থাত্ ক্রমান্বনে তির্যক উপাদানের যোগফল। অন্য কথায়, আমরা প্রথম নম্বর থেকে এমএসবি, দ্বিতীয় নম্বর থেকে পরের-থেকে-এমএসবি এবং আরও যোগ করি। যদি অনুচ্ছেদটি বৈধ হয় তবে এগুলির সমস্ত 1 হবে এবং বৃহত্তম ইনপুট সংখ্যা প্রশস্ত হওয়ার সাথে সাথে সেখানে অনেকগুলি 1 টি থাকবে।

Max[...]

আমরা সর্বোচ্চ ট্রেস পেতে, কারণ ট্রেস হতে পারে না আরো একটি বৈধ বিন্যাস যে এর চেয়ে।

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

ডান হাতটি কেবল একটি গোলাপী সংস্করণ Length @ First @ n, যেমন এটি আয়তক্ষেত্রাকার অ্যারের প্রস্থ এবং এর ফলে বৃহত্তম ইনপুট সংখ্যার প্রস্থ পায়। আমরা নিশ্চিত করতে চাই যে কিছু ক্রয়ের ক্রম এর সমান হয়।

Answer 7

পিএইচপি, 255 243 160 বাইট

-12 বাইটস, বাছাই করে
-83 বাইট (!) টাইটাসকে ধন্যবাদ জানায়

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

এটি অনলাইন চেষ্টা করুন!

সত্যের জন্য 1 মুদ্রণ করে, মিথ্যের জন্য কিছুই না।

অরিজিনাল করা আসল সংস্করণ:

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

Comments

আমি এটি পরীক্ষা করেছি না, তবে 158 বাইটগুলি একই করা উচিত: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);}

— টাইটাস

@ টিটাস এবং এইভাবে আমরা দেখতে পেয়েছি আমি কোডগল্ফে কতটা ভয়ঙ্কর। এবং কেন বেশিরভাগ প্রশ্নের পিএইচপি-তে আপনার দুর্দান্ত উত্তর রয়েছে। (এবং কয়েকটি অন্যান্য ভাষা)।

— জো।

আপাতত ভয়ঙ্কর। That´sa বেশ ভাল উত্তর; এবং গল্ফিং দক্ষতা অভিজ্ঞতা সঙ্গে আসে।

— টাইটাস

দীর্ঘ স্ট্রিং স্বরলিপি প্রয়োজন নেই, কেবল অন্য কিছু ব্যবহার করুন যা "1" তে অনুবাদ করে তবে পূর্ণসংখ্যা নয়। উদাহরণস্বরূপ একটি বুলিয়ান true: die("1")→ die(!0)।

— manatwork

Answer 8

লুয়া 5.2, 85 বাইট

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

এটি এক্সকে এমন একটি ফাংশন হিসাবে সেট করে যা বৈকল্পিক সংখ্যক ইনপুট গ্রহণ করে (32 বিট ইন্টিজার হিসাবে প্রত্যাশিত) এবং "সত্য" বা "মিথ্যা" হয় না।

ব্যবহার:

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

Comments

হুম, এটি মিথ্যা পরীক্ষার কিছু ক্ষেত্রে ব্যর্থ হবে বলে মনে হচ্ছে? উদাহরণস্বরূপ পরিবর্তে [1,15,3,1]ফিরে বলে মনে হচ্ছে । এখানে আপনার কোড টিআইওর অনলাইন সংকলক। অন্য দুটি পরীক্ষার ক্ষেত্রে ব্যর্থতা হ'ল এবং । অন্যান্য সমস্ত পরীক্ষার ক্ষেত্রে সঠিক ফলাফল পাওয়া যায়। truefalse[1,7,1][15,15,15]

— কেভিন ক্রুইজসেন

Answer 9

পিএইচপি, 121 বাইট

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

এটি অনলাইনে চেষ্টা করুন ।

ভাঙ্গন

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
}

Answer 10

জে , 49 বাইট

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

আমারও কি 'g =।' গণনা করা দরকার? আমি এটি যুক্ত করতে প্রস্তুত।

একটি দীর্ঘ সুস্পষ্ট ক্রিয়া এইবার। আমি একই অ্যালগরিদমের জন্য একটি স্বতন্ত্র চেষ্টা করেছি, তবে এটি এর চেয়ে দীর্ঘতর এবং কৃপণ হয়ে উঠেছে। অ্যাডামের সমাধান থেকে অনেক দূরে।

ব্যাখ্যা: (y ফাংশনের সঠিক যুক্তি)

                                             ,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

এটি অনলাইন চেষ্টা করুন!

Answer 11

পাইথন 3 , 126 120 বাইট

মিঃ এক্সকোডারের কারণে 6 বাইট সংরক্ষণ করা হয়েছে

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)

এটি অনলাইন চেষ্টা করুন!

Comments

আপনি কি একটি অবারিত সংস্করণ যুক্ত করতে পারেন?

— এন্টি 29

[0]+[...]অর্থহীন কি তাই না? any(g(x[:i]+x[i+1:],n-1)for i in range(len(x))if x[i]&2**n)যথেষ্ট করা উচিত

— মিঃ এক্সকোডার

@ মিঃ এক্সকোডার হ্যাঁ, আমি অনুমান করি যে আমি এটি যুক্ত করার সময় সর্বাধিক কার্যকারিতা সম্পর্কে ভাবছিলাম

— হল্ভার্ড হুমেল

Answer 12

জেলি , 17 বাইট

BUz0Œ!ŒD€Ẏ
ṀBo1eÇ

সংখ্যার তালিকা নিয়ে এবং ফেরত 1(সত্যবাদী) বা 0(মিথ্যা) একটি মোনাদিক লিঙ্ক।

এটি অনলাইন চেষ্টা করুন!

এটি প্রতিটি পরীক্ষার মামলার দীর্ঘতম সময়ের জন্য টিআইওতে সময় কাটবে।

কিভাবে?

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    --------------------------------------------------------------------------------------------------------------^

Answer 13

আর , 247 বাইট 221 বাইট

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

এটি অনলাইন চেষ্টা করুন!

উদার সংস্করণ

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
}

আমি বুঝতে পারলাম drop=Fআর্গুমেন্টের সাথে নো-রো চেকটি অপ্রয়োজনীয় was কিছু অদ্ভুত সাদা স্থান মুছে ফেলেছে।

Answer 14

পিএইচপি, 152 বাইট

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

সত্যের জন্য 1 টি মিথ্যের জন্য মুদ্রণ করে না।

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

Answer 15

জেলি , 17 বাইট

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

পরীক্ষা স্যুট.

Answer 16

সি, 79 বাইট

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

Comments

আপনি একটি ব্যাখ্যা যোগ করতে পারেন? এছাড়াও, একটি try it onlineলিঙ্ক দরকারী হবে।

— এন্টি 29

সি: ১ / এ অনেকগুলি চ্যালেঞ্জগুলিতে গল্ফ করার সময় কিছু টিপস (এটি অন্তর্ভুক্ত), আপনাকে একটি সম্পূর্ণ প্রোগ্রামের পরিবর্তে একটি ফাংশন জমা দেওয়ার মঞ্জুরি দেওয়া হয়েছে, ২ / আপনাকে সত্য / মিথ্যা মান আউটপুট করতে হবে, এটি যতক্ষণ না কিছু হতে পারে যেমনটি সামঞ্জস্যপূর্ণ (আপনি "মিথ্যা" / "সত্য" এর পরিবর্তে 0/1 আউটপুট করতে পারেন)। শেষ [1, 7, 1][52, 114, 61, 19, 73, 54, 83, 29]

— অবধি

আপনি ঠিক বলেছেন, আমার খারাপ

— প্রিন্সপলকা