トリッキーなGoogleインタビューの質問
友人が仕事のために面接しています。面接の質問の1つが私に考えさせられ、ただフィードバックを望みました。
Iとjの2つの非負整数があります。次の式が与えられた場合、出力がソートされるようにiとjを反復する（最適な）解を見つけます。
2^i * 5^j
したがって、最初の数ラウンドは次のようになります。
2^0 * 5^0 = 1
2^1 * 5^0 = 2
2^2 * 5^0 = 4
2^0 * 5^1 = 5
2^3 * 5^0 = 8
2^1 * 5^1 = 10
2^4 * 5^0 = 16
2^2 * 5^1 = 20
2^0 * 5^2 = 25
パターンを見ることができません。あなたの考え？
ダイクストラは、「A Discipline of Programming」で雄弁な解決策を導き出しました。彼は問題をハミングに帰します。これがダイクストラのソリューションの私の実装です。
int main()
{
const int n = 20; // Generate the first n numbers
std::vector<int> v(n);
v[0] = 1;
int i2 = 0; // Index for 2
int i5 = 0; // Index for 5
int x2 = 2 * v[i2]; // Next two candidates
int x5 = 5 * v[i5];
for (int i = 1; i != n; ++i)
{
int m = std::min(x2, x5);
std::cout << m << " ";
v[i] = m;
if (x2 == m)
{
++i2;
x2 = 2 * v[i2];
}
if (x5 == m)
{
++i5;
x5 = 5 * v[i5];
}
}
std::cout << std::endl;
return 0;
}
これを行うためのより洗練された方法があります（つまり、以前の答えよりも洗練されています）。
数字が行列に配置されていると想像してください。
0 1 2 3 4 5 -- this is i
----------------------------------------------
0| 1 2 4 8 16 32
1| 5 10 20 40 80 160
2| 25 50 100 200 400 800
3| 125 250 500 1000 2000 ...
4| 625 1250 2500 5000 ...
j on the vertical
必要なのは、(0,0)から始まるこのマトリックスを「ウォーク」することです。次の動きの可能性を追跡する必要もあります。 (0,0)から開始する場合、(0,1)または(1,0)の2つのオプションしかありません。(0,1)の値が小さいため、それを選択します。次に、次の選択(0,2)または(1,0)に対して同じことを行います。これまでのところ、次のリストがあります：1, 2, 4。次の動きは(1,0)です。そこの値は(0,3)よりも小さいからです。ただし、次の移動にはthreeの選択肢があります：(0,3)、または(1,1)、または(2,0)のいずれか。
リストを取得するためにマトリックスは必要ありませんが、すべての選択肢を追跡する必要があります（つまり、125以上になったら、4つの選択肢があります）。
最小ヒープを使用します。
置く1。
抽出分。 xを取得したとします。
2xと5xをヒープにプッシュします。
繰り返す。
X = 2 ^ i * 5 ^ jを保存する代わりに、（i、j）を保存して、カスタム比較関数を使用できます。
FIFOベースのソリューションでは、ストレージ容量が少なくて済みます。 Python code。
F = [[1, 0, 0]] # FIFO [value, i, j]
i2 = -1; n2 = n5 = None # indices, nexts
for i in range(1000): # print the first 1000
last = F[-1][:]
print "%3d. %21d = 2^%d * 5^%d" % Tuple([i] + last)
if n2 <= last: i2 += 1; n2 = F[i2][:]; n2[0] *= 2; n2[1] += 1
if n5 <= last: i2 -= 1; n5 = F.pop(0); n5[0] *= 5; n5[2] += 1
F.append(min(n2, n5))
出力：
0. 1 = 2^0 * 5^0
1. 2 = 2^1 * 5^0
2. 4 = 2^2 * 5^0
...
998. 100000000000000000000 = 2^20 * 5^20
999. 102400000000000000000 = 2^27 * 5^17
これは、関数型言語でO(n)を実行するのが非常に簡単です。 2^i*5^j番号のリストlは、単に1として定義し、次に2*lと5*lをマージすることができます。 Haskellでの表示は次のとおりです。
merge :: [Integer] -> [Integer] -> [Integer]
merge (a:as) (b:bs)
| a < b = a : (merge as (b:bs))
| a == b = a : (merge as bs)
| b > a = b : (merge (a:as) bs)
xs :: [Integer]
xs = 1 : merge (map(2*)xs) (map(5*)xs)
merge関数は、一定の時間で新しい値を提供します。 mapも同様であり、したがってlも同様です。
あなたはそれらの個々の指数、そしてそれらの合計がどうなるかを追跡しなければなりません
したがって、f(0,0) --> 1から始めて、そのうちの1つをインクリメントする必要があります。
f(1,0) = 2
f(0,1) = 5
したがって、2が次であることがわかります。合計が5になるまで、iの指数をインクリメントできることもわかります。
あなたは、あなたが望むラウンド数になるまで、このように行き来し続けます。
動的プログラミングを使用すると、O（n）でこれを実行できます。グラウンドトゥルースは、iとjの値が0を与えることはできず、1を得るには両方の値が0でなければならないということです。
TwoCount[1] = 0
FiveCount[1] = 0
// function returns two values i, and j
FindIJ(x) {
if (TwoCount[x / 2]) {
i = TwoCount[x / 2] + 1
j = FiveCount[x / 2]
}
else if (FiveCount[x / 5]) {
i = TwoCount[x / 2]
j = FiveCount[x / 5] + 1
}
}
この関数を呼び出すたびに、iとjが設定されているかどうかをチェックし、nullでない場合は、TwoCountとFiveCountを設定します
C++の答え。悪いコーディングスタイルで申し訳ありませんが、私は急いでいます:(
#include <cstdlib>
#include <iostream>
#include <vector>
int * TwoCount;
int * FiveCount;
using namespace std;
void FindIJ(int x, int &i, int &j) {
if (x % 2 == 0 && TwoCount[x / 2] > -1) {
cout << "There's a solution for " << (x/2) << endl;
i = TwoCount[x / 2] + 1;
j = FiveCount[x / 2];
} else if (x % 5 == 0 && TwoCount[x / 5] > -1) {
cout << "There's a solution for " << (x/5) << endl;
i = TwoCount[x / 5];
j = FiveCount[x / 5] + 1;
}
}
int main() {
TwoCount = new int[200];
FiveCount = new int[200];
for (int i = 0; i < 200; ++i) {
TwoCount[i] = -1;
FiveCount[i] = -1;
}
TwoCount[1] = 0;
FiveCount[1] = 0;
for (int output = 2; output < 100; output++) {
int i = -1;
int j = -1;
FindIJ(output, i, j);
if (i > -1 && j > -1) {
cout << "2^" << i << " * " << "5^"
<< j << " = " << output << endl;
TwoCount[output] = i;
FiveCount[output] = j;
}
}
}
明らかに、ストレージなどを動的に増やすために配列以外のデータ構造を使用できます。これは、それが機能することを証明するための単なるスケッチです。
これを他の方向から見てみませんか。カウンターを使用して、元の式に対して可能な回答をテストします。擬似コードでごめんね。
for x = 1 to n
{
i=j=0
y=x
while ( y > 1 )
{
z=y
if y divisible by 2 then increment i and divide y by 2
if y divisible by 5 then increment j and divide y by 5
if y=1 then print i,j & x // done calculating for this x
if z=y then exit while loop // didn't divide anything this loop and this x is no good
}
}
これ はOEISの関連エントリです。
最初のいくつかの用語を生成することにより、順序付けされたシーケンスを取得することが可能と思われます。
1 2 4 5
そして、2番目の項から始めて、4と5を掛けて次の2つを取得します
1 2 4 5 8 10
1 245 8 1016 20
1 2 458 10 16 2025
等々...
直感的には、これは正しいように見えますが、もちろん証拠はありません。
Log_2（5）= 2.32であることがわかります。このことから、2 ^ 2 <5および2 ^ 3> 5であることに注意してください。
考えられる答えのマトリックスを見てみましょう。
j/i 0 1 2 3 4 5
0 1 2 4 8 16 32
1 5 10 20 40 80 160
2 25 50 100 200 400 800
3 125 250 500 ...
さて、この例では、順番に数字を選択します。注文は次のとおりです。
j/i 0 1 2 3 4 5
0 1 2 3 5 7 10
1 4 6 8 11 14 18
2 9 12 15 19 23 27
3 16 20 24...
すべての行は、それを開始する行の2列後ろで開始することに注意してください。たとえば、i = 0 j = 1はi = 2 j = 0の直後に来ます。
したがって、このパターンから導出できるアルゴリズムは（j> iと仮定）です。
int i = 2;
int j = 5;
int k;
int m;
int space = (int)(log((float)j)/log((float)i));
for(k = 0; k < space*10; k++)
{
for(m = 0; m < 10; m++)
{
int newi = k-space*m;
if(newi < 0)
break;
else if(newi > 10)
continue;
int result = pow((float)i,newi) * pow((float)j,m);
printf("%d^%d * %d^%d = %d\n", i, newi, j, m, result);
}
}
注：ここのコードは、iおよびjの指数の値を10未満に制限します。このアルゴリズムを簡単に拡張して、他の任意の境界に適合することができます。
注：このアルゴリズムの実行時間は、最初のn個の回答に対してO(n)です。
注：このアルゴリズムのスペースの複雑さはO（1）です
私の実装は、次のアイデアに基づいています。
- 両方とも1で初期化された2つのキューQ2とQ5を使用します。両方のキューをソートされた順序で保持します。
- すべてのステップで、Q2またはQ5から最小数要素MINをデキューし、印刷します。 Q2とQ5の両方に同じ要素がある場合-両方を削除します。この番号を印刷します。これは、基本的に2つのソートされた配列のマージです。各ステップで最小の要素を選択し、進めます。
- MIN * 2をQ2に、MIN * 5をQ5にエンキューします。 MINは以前のMIN番号よりも大きいため、この変更により、ソートされるQ2/Q5の不変式が壊れることはありません。
例：
Start with 1 and 1 (to handle i=0;j=0 case):
Q2: 1
Q5: 1
Dequeue 1, print it and enqueue 1*2 and 1*5:
Q2: 2
Q5: 5
Pick 2 and add 2*2 and 2*5:
Q2: 4
Q5: 5 10
Pick 4 and add 4*2 and 4*5:
Q2: 8
Q5: 5 10 20
....
Javaのコード：
public void printNumbers(int n) {
Queue<Integer> q2 = new LinkedList<Integer>();
Queue<Integer> q5 = new LinkedList<Integer>();
q2.add(1);
q5.add(1);
for (int i = 0; i < n; i++) {
int a = q2.peek();
int b = q5.peek();
int min = Math.min(a, b);
System.out.println(min);
if (min == a) {
q2.remove();
}
if (min == b) {
q5.remove();
}
q2.add(min * 2);
q5.add(min * 5);
}
}
私の直感：
I = 0、j = 0で初期値を1にすると、（2 ^ 1）（5 ^ 0）、（2 ^ 2）（5 ^ 0）、（2 ^ 0）*（5 ^ 1）、...すなわち2,4,5 ..
任意の時点で私の数がxであるとしましょう次の方法で次の番号を作成できます。
- x * 2
- x * 4
- x * 5
説明：
Since new numbers can only be the product with 2 or 5.
But 4 (pow(2,2)) is smaller than 5, and also we have to generate
Numbers in sorted order.Therefore we will consider next numbers
be multiplied with 2,4,5.
Why we have taken x*4 ? Reason is to pace up i, such that it should not
be greater than pace of j(which is 5 to power). It means I will
multiply my number by 2, then by 4(since 4 < 5), and then by 5
to get the next three numbers in sorted order.
テスト実行
We need to take an Array-list of Integers, let say Arr.
Also put our elements in Array List<Integers> Arr.
Initially it contains Arr : [1]
X = 1から始めましょう。
次の3つの数字は1 * 2、1 * 4、1 * 5 [2,4,5]です。到着[1,2,4,5]
今x = 2
次の3つの数字は[4,8,10] {4がすでに発生しているので無視します} [8,10]; Arr [1,2,4,5,8,10]
現在x = 4
次の3つの数字[8,16,20] {8はすでに発生し、無視します} [16,20] Arr [1,2,4,5,8,10,16,20]
x = 5
次の3つの数字[10,20,25] {10,20}はすでに[25]が追加されていますArr [1,2,4,5,8,10,16,20,25]
終了条件
Terminating condition when Arr last number becomes greater
than (5^m1 * 2^m2), where m1,m2 are given by user.
分析
Time Complexity : O(K) : where k is numbers possible between i,j=0 to
i=m1,j=m2.
Space Complexity : O(K)
私は間違っている可能性が高いことを知っていますが、2,3,5のような多くの数値を含まないため、ここには非常に単純なヒューリスティックがあります。任意のi、jに対して、2 ^ i * 5 ^ jの次のシーケンスは2 ^（i-2）* 5 ^（j + 1）になることがわかっています。グーグルqであるため、シンプルなソリューションが必要です。
def func(i, j):
print i, j, (2**i)*(5**j)
imax=i=2
j=0
print "i", "j", "(2**i)*(5**j)"
for k in range(20):
func(i,j)
j=j+1; i=i-2
if(i<0):
i = imax = imax+1
j=0
これにより、出力が生成されます。
i j (2**i)*(5**j)
2 0 4
0 1 5
3 0 8
1 1 10
4 0 16
2 1 20
0 2 25
5 0 32
3 1 40
1 2 50
6 0 64
4 1 80
2 2 100
0 3 125
7 0 128
5 1 160
3 2 200
1 3 250
8 0 256
6 1 320
ここに私の解決策があります
#include <stdio.h>
#include <math.h>
#define N_VALUE 5
#define M_VALUE 5
int n_val_at_m_level[M_VALUE];
int print_lower_level_val(long double val_of_higher_level, int m_level)
{
int n;
long double my_val;
for( n = n_val_at_m_level[m_level]; n <= N_VALUE; n++) {
my_val = powl(2,n) * powl(5,m_level);
if(m_level != M_VALUE && my_val > val_of_higher_level) {
n_val_at_m_level[m_level] = n;
return 0;
}
if( m_level != 0) {
print_lower_level_val(my_val, m_level - 1);
}
if(my_val < val_of_higher_level || m_level == M_VALUE) {
printf(" %Lf n=%d m = %d\n", my_val, n, m_level);
} else {
n_val_at_m_level[m_level] = n;
return 0;
}
}
n_val_at_m_level[m_level] = n;
return 0;
}
main()
{
print_lower_level_val(0, M_VALUE); /* to sort 2^n * 5^m */
}
結果：
1.000000 n = 0 m = 0
2.000000 n = 1 m = 0
4.000000 n = 2 m = 0
5.000000 n = 0 m = 1
8.000000 n = 3 m = 0
10.000000 n = 1 m = 1
16.000000 n = 4 m = 0
20.000000 n = 2 m = 1
25.000000 n = 0 m = 2
32.000000 n = 5 m = 0
40.000000 n = 3 m = 1
50.000000 n = 1 m = 2
80.000000 n = 4 m = 1
100.000000 n = 2 m = 2
125.000000 n = 0 m = 3
160.000000 n = 5 m = 1
200.000000 n = 3 m = 2
250.000000 n = 1 m = 3
400.000000 n = 4 m = 2
500.000000 n = 2 m = 3
625.000000 n = 0 m = 4
800.000000 n = 5 m = 2
1000.000000 n = 3 m = 3
1250.000000 n = 1 m = 4
2000.000000 n = 4 m = 3
2500.000000 n = 2 m = 4
3125.000000 n = 0 m = 5
4000.000000 n = 5 m = 3
5000.000000 n = 3 m = 4
6250.000000 n = 1 m = 5
10000.000000 n = 4 m = 4
12500.000000 n = 2 m = 5
20000.000000 n = 5 m = 4
25000.000000 n = 3 m = 5
50000.000000 n = 4 m = 5
100000.000000 n = 5 m = 5
Iを行、jを列として行列を描くと、パターンを見ることができます。 i = 0で開始し、マトリックスの最上部に到達するまで（j> = 0）、2行、右1列上に移動して、マトリックスを走査します。その後、i + 1などに進みます...
したがって、i = 7の場合、次のように旅行します。
7, 0 -> 5, 1 -> 3, 2 -> 1, 3
そしてi = 8の場合：
8, 0 -> 6, 1 -> 4, 2 -> 2, 3 -> 0, 4
ここでは、Java i = 9まで）にあります。行列の位置（i、j）と値を出力します。
for(int k = 0; k < 10; k++) {
int j = 0;
for(int i = k; i >= 0; i -= 2) {
int value = (int)(Math.pow(2, i) * Math.pow(5, j));
System.out.println(i + ", " + j + " -> " + value);
j++;
}
}
Scalaでの私の試みは次のとおりです。
case class IndexValue(twosIndex: Int, fivesIndex: Int)
case class OutputValues(twos: Int, fives: Int, value: Int) {
def test(): Boolean = {
Math.pow(2, twos) * Math.pow(5, fives) == value
}
}
def run(last: IndexValue = IndexValue(0, 0), list: List[OutputValues] = List(OutputValues(0, 0, 1))): List[OutputValues] = {
if (list.size > 20) {
return list
}
val twosValue = list(last.twosIndex).value * 2
val fivesValue = list(last.fivesIndex).value * 5
if (twosValue == fivesValue) {
val lastIndex = IndexValue(last.twosIndex + 1, last.fivesIndex + 1)
val outputValues = OutputValues(value = twosValue, twos = list(last.twosIndex).twos + 1, fives = list(last.fivesIndex).fives + 1)
run(lastIndex, list :+ outputValues)
} else if (twosValue < fivesValue) {
val lastIndex = IndexValue(last.twosIndex + 1, last.fivesIndex)
val outputValues = OutputValues(value = twosValue, twos = list(last.twosIndex).twos + 1, fives = list(last.twosIndex).fives)
run(lastIndex, list :+ outputValues)
} else {
val lastIndex = IndexValue(last.twosIndex, last.fivesIndex + 1)
val outputValues = OutputValues(value = fivesValue, twos = list(last.fivesIndex).twos, fives = list(last.fivesIndex).fives + 1)
run(lastIndex, list :+ outputValues)
}
}
val initialIndex = IndexValue(0, 0)
run(initialIndex, List(OutputValues(0, 0, 1))) foreach println
出力：
OutputValues(0,0,1)
OutputValues(1,0,2)
OutputValues(2,0,4)
OutputValues(0,1,5)
OutputValues(3,0,8)
OutputValues(1,1,10)
OutputValues(4,0,16)
OutputValues(2,1,20)
OutputValues(0,2,25)
OutputValues(5,0,32)
OutputValues(3,1,40)
OutputValues(1,2,50)
OutputValues(6,0,64)
OutputValues(4,1,80)
OutputValues(2,2,100)
OutputValues(0,3,125)
OutputValues(7,0,128)
OutputValues(5,1,160)
OutputValues(3,2,200)
OutputValues(1,3,250)
OutputValues(8,0,256)
Edsger Dijkstraによってuser515430によって実装されたアルゴリズム（http://www.cs.utexas.edu/users/EWD/ewd07xx/EWD792.PDF）は、おそらくあなたが得ることができる限り高速です。 _2^i * 5^j_の形式であるすべての番号を「特別な番号」と呼びます。 vladsの答えはO(i*j)になりますが、ダブルアルゴリズムを使用すると、特別な番号O(i*j)を生成し、1つをソートします（リンクされた記事によるとO(i*j) 。
しかし、ダイクストラのアルゴリズムを確認しましょう（以下を参照）。この場合、nは生成する特殊な数値の量なので、_i*j_と等しくなります。 _1 -> n_を1回ループし、すべてのループで一定のアクションを実行します。したがって、このアルゴリズムもO(i*j)です。また、非常に高速な定数も使用できます。
GMP（C++ラッパー）を使用したC++での実装、および_boost::lexical_cast_への依存関係は簡単に削除できます（私は怠け者で、Boostを使用しないのは誰ですか？）。 _g++ -O3 test.cpp -lgmpxx -o test_でコンパイルされています。 Q6600ではUbuntu 10.10 _time ./test 1000000_は_1145ms_を返します。
_#include <iostream>
#include <boost/lexical_cast.hpp>
#include <gmpxx.h>
int main(int argc, char *argv[]) {
mpz_class m, x2, x5, *array, r;
long n, i, i2, i5;
if (argc < 2) return 1;
n = boost::lexical_cast<long>(argv[1]);
array = new mpz_class[n];
array[0] = 1;
x2 = 2;
x5 = 5;
i2 = i5 = 0;
for (i = 1; i != n; ++i) {
m = std::min(x2, x5);
array[i] = m;
if (x2 == m) {
++i2;
x2 = 2 * array[i2];
}
if (x5 == m) {
++i5;
x5 = 5 * array[i5];
}
}
delete [] array;
std::cout << m << std::endl;
return 0;
}
_結果を計算し、iとjの値とともにソートされたリストに入れます
式2^i * 5^jでiまたはjをインクリメントするときに実際に何が起こっているのかを見ると、別の2または別の5を乗算していることになります。次に大きな値を見つけたら、解決策が明らかになります。
非常に直感的に列挙できるルールは次のとおりです。
- 式に2のペア（
i > 1）が含まれる場合は、それらを5に置き換えて次の最大数を取得する必要があります。したがって、i -= 2およびj += 1です。 - それ以外の場合、5（
j > 0）がある場合は、3つの2に置き換える必要があります。j -= 1とi += 3です。 - それ以外の場合は、値を最小限に増やすために、さらに2を指定するだけです。
i += 1。
Rubyのプログラムは次のとおりです。
i = j = 0
20.times do
puts 2**i * 5**j
if i > 1
j += 1
i -= 2
elsif j > 0
j -= 1
i += 3
else
i += 1
end
end
Java Collectionを使用することが許可されている場合、O（n ^ 2）にこれらの番号を含めることができます。
public static void main(String[] args) throws Exception {
int powerLimit = 7;
int first = 2;
int second = 5;
SortedSet<Integer> set = new TreeSet<Integer>();
for (int i = 0; i < powerLimit; i++) {
for (int j = 0; j < powerLimit; j++) {
Integer x = (int) (Math.pow(first, i) * Math.pow(second, j));
set.add(x);
}
}
set=set.headSet((int)Math.pow(first, powerLimit));
for (int p : set)
System.out.println(p);
}
ここで、powerLimitは非常に慎重に初期化する必要があります!!必要な数に応じて。
来週はどうなるのか興味があり、この質問を見つけました。
考えは、5 ^ jほどの大きなステップではなく、2 ^ iの増加だと思います。したがって、次のjステップが大きくならない限り、iを増やします。
C++の例（Qtはオプション）：
QFile f("out.txt"); //use output method of your choice here
f.open(QIODevice::WriteOnly);
QTextStream ts(&f);
int i=0;
int res=0;
for( int j=0; j<10; ++j )
{
int powI = std::pow(2.0,i );
int powJ = std::pow(5.0,j );
while ( powI <= powJ )
{
res = powI * powJ;
if ( res<0 )
break; //integer range overflow
ts<<i<<"\t"<<j<<"\t"<<res<<"\n";
++i;
powI = std::pow(2.0,i );
}
}
出力：
i j 2^i * 5^j
0 0 1
1 1 10
2 1 20
3 2 200
4 2 400
5 3 4000
6 3 8000
7 4 80000
8 4 160000
9 4 320000
10 5 3200000
11 5 6400000
12 6 64000000
13 6 128000000
14 7 1280000000