十分なメモリがあれば、O(1)の数値のバイナリ表現で1の数をカウントする効率的な方法。これはオンラインフォーラムで見つけたインタビューの質問ですが、答えはありませんでした。誰かが何かを提案できますか、O(1)時間内にそれを行う方法を考えることはできませんか?
それが Hamming weight 問題、別名人口カウントです。リンクには効率的な実装が記載されています。引用:
無制限のメモリを使用すると、64ビット整数ごとのハミング重みの大きなルックアップテーブルを簡単に作成できます。
O(Number of 1's)
時間のビットをカウントするソリューションがあります:
bitcount(n):
count = 0
while n > 0:
count = count + 1
n = n & (n-1)
return count
最悪の場合(数値が2 ^ n-1の場合、すべて1がバイナリの場合)、すべてのビットがチェックされます。
編集:ビットカウントのための非常に素晴らしい定数時間、定数メモリアルゴリズムを見つけました。これはCで書かれています。
int BitCount(unsigned int u)
{
unsigned int uCount;
uCount = u - ((u >> 1) & 033333333333) - ((u >> 2) & 011111111111);
return ((uCount + (uCount >> 3)) & 030707070707) % 63;
}
その正確さの証拠を見つけることができます こちら 。
N&(n-1)は常に最下位の1を常に除去するという事実に注意してください。
したがって、次のように1の数を計算するコードを記述できます。
count=0;
while(n!=0){
n = n&(n-1);
count++;
}
cout<<"Number of 1's in n is: "<<count;
プログラムの複雑さは次のようになります:nの1の数(常に32未満)。
私は別のウェブサイトから次の解決策を見ました:
int count_one(int x){
x = (x & (0x55555555)) + ((x >> 1) & (0x55555555));
x = (x & (0x33333333)) + ((x >> 2) & (0x33333333));
x = (x & (0x0f0f0f0f)) + ((x >> 4) & (0x0f0f0f0f));
x = (x & (0x00ff00ff)) + ((x >> 8) & (0x00ff00ff));
x = (x & (0x0000ffff)) + ((x >> 16) & (0x0000ffff));
return x;
}
public static void main(String[] args) {
int a = 3;
int orig = a;
int count = 0;
while(a>0)
{
a = a >> 1 << 1;
if(orig-a==1)
count++;
orig = a >> 1;
a = orig;
}
System.out.println("Number of 1s are: "+count);
}
countBits(x){
y=0;
while(x){
y += x & 1 ;
x = x >> 1 ;
}
}
それでおしまい?
それは私のSO人生で最も短い答えになります:lookup table。
どうやら、私は少し説明する必要があります。「あなたが遊ぶのに十分なメモリがあるなら」ということは、私たちが必要とするすべてのメモリを持っていることを意味します(技術的な可能性を考えないでください)。これで、ルックアップテーブルを1〜2バイト以上保存する必要がなくなりました。技術的にはO(1)ではなくΩ(log(n))になりますが、必要な数値を読み取るだけでΩ(log(n))になります。したがって、それが問題であれば、答えは不可能 —これはさらに短い。
面接であなたから期待される2つの答えのうち、誰も知りません。
さらに別のトリックがあります:エンジニアは数値を取得してΩ(log(n))(nは数値)について話すことができますが、コンピューター科学者は実際に実行時間を関数length入力なので、エンジニアがΩ(log(n))と呼ぶものは実際にはΩ(k)です。ここで、kはバイト数です。それでも、前に言ったように、数値を読むだけでΩ(k)なので、それ以上に良い方法はありません。
以下も同様に機能します。
nofone(int x) {
a=0;
while(x!=0) {
x>>=1;
if(x & 1)
a++;
}
return a;
}
Javascriptでそうするための最良の方法は
function getBinaryValue(num){
return num.toString(2);
}
function checkOnces(binaryValue){
return binaryValue.toString().replace(/0/g, "").length;
}
ここで、binaryValueはバイナリ文字列です。例:1100
以下は、これを行うことができる多くの中での2つの簡単な例(C++)です。
__builtin_popcount()を使用して、設定ビット(1)を単純にカウントできます。
int numOfOnes(int x) { return __builtin_popcount(x); }
整数内のすべてのビットをループし、ビットが設定されているかどうかを確認してから、カウント変数をインクリメントします。
int hammingDistance(int x) { int count = 0 for(int i = 0; i < 32; i++) if(x & (1 << i)) count++; return count; }
お役に立てれば!
この関数はint
を取り、バイナリ表現で1の数を返します
public static int findOnes(int number)
{
if(number < 2)
{
if(number == 1)
{
count ++;
}
else
{
return 0;
}
}
value = number % 2;
if(number != 1 && value == 1)
count ++;
number /= 2;
findOnes(number);
return count;
}
以下は、ビット演算子を使用したCソリューションです。
int numberOfOneBitsInInteger(int input) {
int numOneBits = 0;
int currNum = input;
while (currNum != 0) {
if ((currNum & 1) == 1) {
numOneBits++;
}
currNum = currNum >> 1;
}
return numOneBits;
}
以下は、2の累乗を使用したJavaソリューションです。
public static int numOnesInBinary(int n) {
if (n < 0) return -1;
int j = 0;
while ( n > Math.pow(2, j)) j++;
int result = 0;
for (int i=j; i >=0; i--){
if (n >= Math.pow(2, i)) {
n = (int) (n - Math.pow(2,i));
result++;
}
}
return result;
}
Rubyの実装
def find_consecutive_1(n)
num = n.to_s(2)
arr = num.split("")
counter = 0
max = 0
arr.each do |x|
if x.to_i==1
counter +=1
else
max = counter if counter > max
counter = 0
end
max = counter if counter > max
end
max
end
puts find_consecutive_1(439)
2つの方法::
/* Method-1 */
int count1s(long num)
{
int tempCount = 0;
while(num)
{
tempCount += (num & 1); //inc, based on right most bit checked
num = num >> 1; //right shift bit by 1
}
return tempCount;
}
/* Method-2 */
int count1s_(int num)
{
int tempCount = 0;
std::string strNum = std::bitset< 16 >( num ).to_string(); // string conversion
cout << "strNum=" << strNum << endl;
for(int i=0; i<strNum.size(); i++)
{
if('1' == strNum[i])
{
tempCount++;
}
}
return tempCount;
}
/* Method-3 (algorithmically - boost string split could be used) */
1) split the binary string over '1'.
2) count = vector (containing splits) size - 1
使用法::
int count = 0;
count = count1s(0b00110011);
cout << "count(0b00110011) = " << count << endl; //4
count = count1s(0b01110110);
cout << "count(0b01110110) = " << count << endl; //5
count = count1s(0b00000000);
cout << "count(0b00000000) = " << count << endl; //0
count = count1s(0b11111111);
cout << "count(0b11111111) = " << count << endl; //8
count = count1s_(0b1100);
cout << "count(0b1100) = " << count << endl; //2
count = count1s_(0b11111111);
cout << "count(0b11111111) = " << count << endl; //8
count = count1s_(0b0);
cout << "count(0b0) = " << count << endl; //0
count = count1s_(0b1);
cout << "count(0b1) = " << count << endl; //1
以下の方法でも、負の数の1の数をカウントできます。
private static int countBits(int number) {
int result = 0;
while(number != 0) {
result += number & 1;
number = number >>> 1;
}
return result;
}
ただし、-1のような数値は11111111111111111111111111111111111としてバイナリで表されるため、多くのシフトが必要になります。小さい負の数に対してそれほど多くのシフトを行いたくない場合、別の方法は次のようになります。
private static int countBits(int number) {
boolean negFlag = false;
if(number < 0) {
negFlag = true;
number = ~number;
}
int result = 0;
while(number != 0) {
result += number & 1;
number = number >> 1;
}
return negFlag? (32-result): result;
}
これをRubyでゴルフしなければならず、結局
l=->x{x.to_s(2).count ?1}
使用法 :
l[2**32-1] # returns 32
明らかに効率的ではありませんが、トリックを行います:)
JSの文字列操作を使用することにより、次のようにできます。
0b1111011.toString(2).split(/0|(?=.)/).length // returns 6
または
0b1111011.toString(2).replace("0","").length // returns 6
私は実際に少し手の込んだ方法を使用してこれを実行しました。16エントリの単一のルックアップテーブルで十分であり、必要なのはバイナリrepをニブル(4ビットタプル)に分割することだけです。実際、複雑さはO(1)であり、必要な整数のサイズ(#ビット単位)に特化したC++テンプレートを作成しました。不定ではなく定数式にします。
(i&-i)LSの1ビットを返すだけで、整数がゼロになるまで毎回lsbitを除去するというループを使用できますが、これは古いパリティトリックです。
O(1)でこのタスクを達成するために考えることができる唯一の方法があります...それは「チート」し、物理デバイスを使用することです(線形または並列プログラミングでも、制限はO(log(k))ここで、kは数値のバイト数を表します)。
ただし、各ビットを出力ラインに0/1の電圧で接続する物理デバイスを非常に簡単に想像できます。次に、O(1)の「合計」行の総電圧を電子的に読み取ることができます。いくつかの基本的な回路要素を使用してこの基本的なアイデアをよりエレガントにし、任意の形式の出力(バイナリエンコード出力など)を生成することは非常に簡単ですが、基本的なアイデアは同じで、電子回路は正しい出力を生成します固定時間の状態。
量子コンピューティングの可能性も考えられますが、それが許されれば、簡単な電子回路がより簡単な解決策だと思います。
pythonまたはその他のビン文字列への変換で、 '0'で分割して0を取り除き、結合して長さを取得します。
len(''.join(str(bin(122011)).split('0')))-1