[英]How to find 3 numbers in increasing order and increasing indices in an array in linear time
[英]Printing numbers of the form 2^i * 5^j in increasing order
如何以递增的顺序打印表格2^i * 5^j
数字。
For eg:
1, 2, 4, 5, 8, 10, 16, 20
这实际上是一个非常有趣的问题,特别是如果你不希望这是N ^ 2或NlogN的复杂性。
我要做的是以下内容:
通过选择正确的数据结构和集合,可以轻松调整性能。 例如,在C ++中,您可以使用std :: map,其中键是公式的结果,值是对(i,j)。 取最小值然后只取地图中的第一个实例(* map.begin())。
我快速编写了以下应用程序来说明它(它有效!但不包含其他评论,抱歉):
#include <math.h>
#include <map>
#include <iostream>
typedef __int64 Integer;
typedef std::pair<Integer,Integer> MyPair;
typedef std::map<Integer,MyPair> MyMap;
Integer result(const MyPair &myPair)
{
return pow((double)2,(double)myPair.first) * pow((double)5,(double)myPair.second);
}
int main()
{
MyMap myMap;
MyPair firstValue(0,0);
myMap[result(firstValue)] = firstValue;
while (true)
{
auto it=myMap.begin();
if (it->first < 0) break; // overflow
MyPair myPair = it->second;
std::cout << it->first << "= 2^" << myPair.first << "*5^" << myPair.second << std::endl;
myMap.erase(it);
MyPair pair1 = myPair;
++pair1.first;
myMap[result(pair1)] = pair1;
MyPair pair2 = myPair;
++pair2.second;
myMap[result(pair2)] = pair2;
}
}
这非常适合函数式编程风格。 在F#中:
let min (a,b)= if(a<b)then a else b;;
type stream (current, next)=
member this.current = current
member this.next():stream = next();;
let rec merge(a:stream,b:stream)=
if(a.current<b.current) then new stream(a.current, fun()->merge(a.next(),b))
else new stream(b.current, fun()->merge(a,b.next()));;
let rec Squares(start) = new stream(start,fun()->Squares(start*2));;
let rec AllPowers(start) = new stream(start,fun()->merge(Squares(start*2),AllPowers(start*5)));;
let Results = AllPowers(1);;
适用于结果,然后是具有当前值和下一个方法的流类型。
走过它:
结果是合并越来越多的流,因此您合并以下流
1,2,4,8,16,32 ......
5,10,20,40,80,160 ......
25,50,100,200,400 ......
。
。
。 通过尾递归和编译器优化等来合并所有这些变得相当有效。
这些可以像这样打印到控制台:
let rec PrintAll(s:stream)=
if (s.current > 0) then
do System.Console.WriteLine(s.current)
PrintAll(s.next());;
PrintAll(Results);
let v = System.Console.ReadLine();
类似的事情可以在任何语言中完成,它允许递归并将函数作为值传递(如果你不能将函数作为变量传递,它只会稍微复杂一些)。
对于O(N)解决方案,您可以使用到目前为止找到的数字列表和两个索引:一个代表下一个要乘以2的数字,另一个代表下一个要乘以5的数字。然后在每次迭代中有两个候选值来选择较小的一个。
在Python中:
numbers = [1]
next_2 = 0
next_5 = 0
for i in xrange(100):
mult_2 = numbers[next_2]*2
mult_5 = numbers[next_5]*5
if mult_2 < mult_5:
next = mult_2
next_2 += 1
else:
next = mult_5
next_5 += 1
# The comparison here is to avoid appending duplicates
if next > numbers[-1]:
numbers.append(next)
print numbers
所以我们有两个循环,一个递增i
,第二个递增j
从零开始,对吧? (乘以符号在问题的标题中令人困惑)
你可以做一些非常简单的事情:
或者你需要一个更多数学分析的其他解决方案?
编辑:利用Merge Sort问题的相似性,提供更智能的解决方案
如果我们将2^i
和5^j
无限数组想象为两个独立的流/列表,则此问题看起来与众所周知的合并排序问题非常相似。
所以解决方案步骤是:
就是这样! ;)
PS:合并的复杂性排序always
O(n*log(n))
我将该问题可视化为矩阵M
,其中M(i,j) = 2^i * 5^j
。 这意味着行和列都在增加。
考虑按递增顺序在条目中画一条线,显然从条目(1,1)
。 当您访问条目时,行和列增加条件可确保由这些单元格形成的形状始终为整数分区 (英文表示法)。 跟踪这个分区( mu = (m1, m2, m3, ...)
,其中mi
是第i
行中较小条目的数量 - 因此m1 >= m2 >= ...
)。 然后,您需要比较的唯一条目是可以添加到分区的条目。
这是一个粗略的例子。 假设你已经访问了所有x
s( mu = (5,3,3,1)
),那么你只需要检查@
s:
x x x x x @
x x x @
x x x
x @
@
因此,检查的数量是可添加单元格的数量(相当于如果你想要以posets方式思考的话,以Bruhat顺序上升的方式的数量)。
给定分区mu
,很容易确定可添加状态是什么。 在最后一个正面条目之后成像0
秒的无限字符串。 那么当且仅当m(i-1) > mi
你可以将mi
增加1
。
回到例子,对于mu = (5,3,3,1)
我们可以增加m1 (6,3,3,1)
或m2 (5,4,3,1)
或m4 (5,3,3,2)
或m5 (5,3,3,1,1)
。
然后,问题的解决方案找到正确的分区序列(饱和链)。 在伪代码中:
mu = [1,0,0,...,0];
while (/* some terminate condition or go on forever */) {
minNext = 0;
nextCell = [];
// look through all addable cells
for (int i=0; i<mu.length; ++i) {
if (i==0 or mu[i-1]>mu[i]) {
// check for new minimum value
if (minNext == 0 or 2^i * 5^(mu[i]+1) < minNext) {
nextCell = i;
minNext = 2^i * 5^(mu[i]+1)
}
}
}
// print next largest entry and update mu
print(minNext);
mu[i]++;
}
我在Maple中写了这个,经过12次迭代后停止:
1, 2, 4, 5, 8, 10, 16, 20, 25, 32, 40, 50
并输出了输出的细胞序列,得到了这个:
1 2 3 5 7 10
4 6 8 11
9 12
对应于此矩阵表示:
1, 2, 4, 8, 16, 32...
5, 10, 20, 40, 80, 160...
25, 50, 100, 200, 400...
我相信现在每个人都可能得到了答案,但只是想给这个解决方案指明方向..
这是来自http://www.careercup.com/question?id=16378662的Ctrl C + Ctrl V.
void print(int N)
{
int arr[N];
arr[0] = 1;
int i = 0, j = 0, k = 1;
int numJ, numI;
int num;
for(int count = 1; count < N; )
{
numI = arr[i] * 2;
numJ = arr[j] * 5;
if(numI < numJ)
{
num = numI;
i++;
}
else
{
num = numJ;
j++;
}
if(num > arr[k-1])
{
arr[k] = num;
k++;
count++;
}
}
for(int counter = 0; counter < N; counter++)
{
printf("%d ", arr[counter]);
}
}
提出的问题是返回一组无限的解决方案。 我考虑使用树木,但觉得在确定何时收获和修剪树木时存在问题,因为i&j具有无限数量的值。 我意识到可以使用筛分算法。 从零开始,确定每个正整数是否具有i和j的值。 通过转动answer =(2 ^ i)*(2 ^ j)并解决i来促进这一点。 这给了我i = log2(答案/(5 ^ j))。 这是代码:
class Program
{
static void Main(string[] args)
{
var startTime = DateTime.Now;
int potential = 0;
do
{
if (ExistsIandJ(potential))
Console.WriteLine("{0}", potential);
potential++;
} while (potential < 100000);
Console.WriteLine("Took {0} seconds", DateTime.Now.Subtract(startTime).TotalSeconds);
}
private static bool ExistsIandJ(int potential)
{
// potential = (2^i)*(5^j)
// 1 = (2^i)*(5^j)/potential
// 1/(2^1) = (5^j)/potential or (2^i) = potential / (5^j)
// i = log2 (potential / (5^j))
for (var j = 0; Math.Pow(5,j) <= potential; j++)
{
var i = Math.Log(potential / Math.Pow(5, j), 2);
if (i == Math.Truncate(i))
return true;
}
return false;
}
}
首先,(正如其他人已经提到的)这个问题很模糊!
不过,我打算根据你的模糊方程和模式作为预期结果。 因此,我不确定以下内容是否适用于您正在尝试的内容,但是它可能会让您对Java集合有所了解!
import java.util.List;
import java.util.ArrayList;
import java.util.SortedSet;
import java.util.TreeSet;
public class IncreasingNumbers {
private static List<Integer> findIncreasingNumbers(int maxIteration) {
SortedSet<Integer> numbers = new TreeSet<Integer>();
SortedSet<Integer> numbers2 = new TreeSet<Integer>();
for (int i=0;i < maxIteration;i++) {
int n1 = (int)Math.pow(2, i);
numbers.add(n1);
for (int j=0;j < maxIteration;j++) {
int n2 = (int)Math.pow(5, i);
numbers.add(n2);
for (Integer n: numbers) {
int n3 = n*n1;
numbers2.add(n3);
}
}
}
numbers.addAll(numbers2);
return new ArrayList<Integer>(numbers);
}
/**
* Based on the following fuzzy question @ StackOverflow
* http://stackoverflow.com/questions/7571934/printing-numbers-of-the-form-2i-5j-in-increasing-order
*
*
* Result:
* 1 2 4 5 8 10 16 20 25 32 40 64 80 100 125 128 200 256 400 625 1000 2000 10000
*/
public static void main(String[] args) {
List<Integer> numbers = findIncreasingNumbers(5);
for (Integer i: numbers) {
System.out.print(i + " ");
}
}
}
如果你能在O(nlogn)中做到这一点,这里有一个简单的解决方案:
Get an empty min-heap
Put 1 in the heap
while (you want to continue)
Get num from heap
print num
put num*2 and num*5 in the heap
你有它。 通过min-heap,我的意思是min-heap
作为一名数学家,在看这样的事情时,我总是会想到的第一件事是“会对数有帮助吗?”。
在这种情况下它可能。
如果我们的系列A增加,则系列日志(A)也在增加。 由于A的所有项都是2 ^ i.5 ^ j的形式,因此系列log(A)的所有成员的形式为i.log(2)+ j.log(5)
然后我们可以查看系列log(A)/ log(2),它也在增加,其元素的形式为i + j。(log(5)/ log(2))
如果我们计算出生成最后一个系列的完整有序列表的i和j(称之为B),那么i和j也将正确生成A系列。
这只是改变了问题的本质,但希望能够更容易解决。 在每一步,您可以增加i并减少j,反之亦然。
看看你可以做出的一些早期变化(我可能会将其称为i,j的变换或只是变换)为我们提供了一些我们前进的线索。
显然将i增加1将使B增加1.然而,假设log(5)/ log(2)约为2.3然后将j增加1而将i减小2将增加仅0.3。 那么问题是在每个阶段找到B对于i和j的变化的最小可能增加。
为了做到这一点,我只保留了一个记录,因为我增加了i和j的最有效变换(即从每个变换中添加和减去的变换)以获得系列中可能的最小增量。 然后应用任何一个有效的(即确保i和j不变为负数)。
因为在每个阶段你可以减少i或减少j,实际上有两类变换可以单独检查。 新的转换不一定要包含在我们未来的检查中,只比其他同类产品更好。
为了测试我的思想,我在LinqPad中编写了一个程序。 需要注意的一点是,Dump()方法只是将对象输出到屏幕,并且语法/结构对于真正的c#文件无效。 如果你想运行它,转换它应该很容易。
希望任何未明确解释的内容都可以从代码中理解。
void Main()
{
double C = Math.Log(5)/Math.Log(2);
int i = 0;
int j = 0;
int maxi = i;
int maxj = j;
List<int> outputList = new List<int>();
List<Transform> transforms = new List<Transform>();
outputList.Add(1);
while (outputList.Count<500)
{
Transform tr;
if (i==maxi)
{
//We haven't considered i this big before. Lets see if we can find an efficient transform by getting this many i and taking away some j.
maxi++;
tr = new Transform(maxi, (int)(-(maxi-maxi%C)/C), maxi%C);
AddIfWorthwhile(transforms, tr);
}
if (j==maxj)
{
//We haven't considered j this big before. Lets see if we can find an efficient transform by getting this many j and taking away some i.
maxj++;
tr = new Transform((int)(-(maxj*C)), maxj, (maxj*C)%1);
AddIfWorthwhile(transforms, tr);
}
//We have a set of transforms. We first find ones that are valid then order them by score and take the first (smallest) one.
Transform bestTransform = transforms.Where(x=>x.I>=-i && x.J >=-j).OrderBy(x=>x.Score).First();
//Apply transform
i+=bestTransform.I;
j+=bestTransform.J;
//output the next number in out list.
int value = GetValue(i,j);
//This line just gets it to stop when it overflows. I would have expected an exception but maybe LinqPad does magic with them?
if (value<0) break;
outputList.Add(value);
}
outputList.Dump();
}
public int GetValue(int i, int j)
{
return (int)(Math.Pow(2,i)*Math.Pow(5,j));
}
public void AddIfWorthwhile(List<Transform> list, Transform tr)
{
if (list.Where(x=>(x.Score<tr.Score && x.IncreaseI == tr.IncreaseI)).Count()==0)
{
list.Add(tr);
}
}
// Define other methods and classes here
public class Transform
{
public int I;
public int J;
public double Score;
public bool IncreaseI
{
get {return I>0;}
}
public Transform(int i, int j, double score)
{
I=i;
J=j;
Score=score;
}
}
我没有费心去看这个效率,但我强烈怀疑它比其他一些解决方案更好,因为在每个阶段,我需要做的就是检查我的变换集 - 计算出与“n”相比有多少变换是非平凡的。 它显然是相关的,因为你越往前就会有更多的变换,但是新变换的数量在更高的数字时变得越来越小,所以也许它只是O(1)。 这个O东西总是让我困惑。 ;-)
与其他解决方案相比,一个优点是它允许您计算i,j而无需计算产品,从而可以计算出序列的内容,而无需计算实际数字本身。
为了它在前230个nunmbers之后的价值(当int用完空间时)我每次都要进行9次变换检查。 并且考虑到它只有我的总数溢出,我跑了,如果为第一百万个结果,并得到i = 5191和j = 354。 变换的数量是23.该列表中该数字的大小约为10 ^ 1810。 达到这个水平的运行时间约为5秒。
PS如果你喜欢这个答案,请随时告诉你的朋友,因为我花了很多年的时间和几个+ 1s将是很好的补偿。 或者实际上只是评论告诉我你的想法。 :)
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.