我知道这并不是最适合leetcode问题202“快乐号”的优化代码,但是我试图找出这个问题的“大O”是什么,因为有条件的what循环。如果n开始为0-4,则为O(1).
/**
* @param {number} n
* @return {boolean}
*/
var isHappy = function(n) {
/* pseudocode
- n is input
- while loop if num is greater than 1
- turn number to string
- split the string
- m
对于下面给出的python函数,我必须找到操作数和Big。
def no_odd_number(list_nums):
i = 0
while i < len(list_nums):
num = list_nums[i]
if num % 2 != 0:
return False
i += 1
return True
根据我的计算,操作的数量是4 + 3n,但我不确定,因为我不知道如何处理if...else语句。
我也有选择选择正确的大O,从我的计算,我认为应该是d. O(n),但我不确定。救
对于下面的伪码,最糟糕的时间复杂度大O表示法是什么?(假设函数调用是O(1)),我对大O表示法非常陌生,所以我不确定答案,但我认为O(log(n))是因为while循环参数每次乘以2,还是仅仅是O(loglog(n))?还是我在这两方面都错了?任何输入/帮助都是值得赞赏的,我正试图掌握最糟糕的时间复杂度的大O表示法的概念,我刚刚开始学习。谢谢!
i ← 1
while(i<n)
doSomething(...)
i ← i * 2
done
问题:对于下面与T一起给出的伪代码,作为运行第一行的或指令周期,以大O符号提供总执行时间。
// get a positive integer from input
if n > 10
print "this might take a while"
for k=1 to n
for j = 1 to k
print k*j
print "Done!"
实际上,我知道这段代码是做什么的,但是我不知道如何在大O符号中输入这个代码?
编辑:
另一个大O符号question...What是下面代码的大O:
for (int i = n; i > 0; i = i / 2){
for (int j = 0; j < n; j++){
for (int k = 0; k < n; k++){
count++;
}
}
}
我的想法是:分解一下,我认为外部循环是O(log2(n)),那么每个内部循环都是O(n),这会导致O(n^2 * log2(n))问题#1,对吗?
问题#2:当组合嵌套循环时,它
刚开始研究复杂性时,我正在努力解决这个问题:
void what(int n) {
int i;
for (i = 1; i <= n; i++) {
int x = n;
while (x > 0)
x -= i;
}
}
好的,第一个for循环显然是O(n)。第一次迭代是O(n),第二次迭代是O(n/2)。我猜,就像那个log(n)时代一样?这意味着O(n) * O(log(n)) = O(n * log(n)) complexity.我说对了吗?
编辑:(不是复制品)我知道大O是什么。我在一个特定
我正在学习Big-O,虽然我开始理解一些东西,但我仍然不能正确地衡量算法的Big-O。我有一个代码:
int n = 10;
int count = 0;
int k = 0;
for (int i = 1; i < n; i++)
{
for (int p = 200; p > 2*i; p--)
{
int j = i;
while (j < n)
{
do
{
count++;
k = count * j;
} while (k > j);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
for (int k = 0; k < 5; k++) {
for (int l = 0; l < 5; l++) {
look up in a perfect constant time hash table
}
}
}
}
这在大θ中的运行时间是多少?
我最好的猜测是:我总是看到嵌套的for循环是O(n^k),其中k是循环
// Assume n is some random integer
int q = 1;
while (q <= Math.Sqrt(n))
{
q++;
int k = 1;
while (k <= Math.Log(n, 2))
{
k++;
if (q^k == n){
return true;
}
}
return false;
在上面的代码中,我发现很难决定最坏情况下的大O是什么。由于循环运行N次,其中嵌套循环运行log2(N)次,我知道它应该是O(sqrt(n)*log2(n))次。然而,我
while (num > 1)
{
cout << "num is now " << num << endl;
cout << "hello // \n";
num /= 2;
}
我正试图给出打印报表的大O值。
用户可以输入num。我尝试了一些输入,并开始看到一个模式。
1表示0的打印。
2-3给出1个打印。
4-7给出2个指纹。
8-15分出3个指纹。
16-31给出4张指纹。
让p = the number of prints。我看到给你一定数量的指纹
我试图在不使用任何助手排序函数和嵌套循环的情况下,查找给定的字符串是否为字谜。
因此,我尝试使用while循环;但是,我不确定这段代码的大O符号是什么。你能帮忙吗?
def anagrams(string1, string2):
if len(string1) != len(string2):
return False
string3 = ""
x = 0
y = 0
while x < len(string1) and y < len(string2):
element = string1[x
import java.util.Scanner;
/**
Prints all prime numbers less than a given value
*/
public class PrimeNumberMethod {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter a value for n: ");
int n = input.nextInt();
System.o
你好,我使用大O符号已经有一段时间了,所以我有点生疏了。
我知道有一个循环,循环n次是O(n),在另一个循环n次的循环中有一个循环n次是O(n^2)。
但是在下面的代码片段中,我有一个循环n次,在这个循环中,n-i次循环。
对于这段代码,最坏的和最好的O符号是什么?
最糟糕的是它在没有找到碰撞的情况下运行,而最好的情况是前两个矩形之间有拼接。
class TestClass
{
bool Run(List<Rectangle> R)
{
var b = false;
var i = 0;
var n = R.Count
我只是在学习大O符号,我对嵌套循环感到困惑:
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++)
for (int z = 0; z < y; z++)
anything();
据我所知,上面的内部循环执行n(n+1)/2次,第二个循环执行n次,第一个循环执行n次。这不是意味着大O是n x n x n(n+1)/2 = O(n^4)吗?为什么第二个循环没有包含在大O公式中?
如果我需要用给定函数设置的成本来确定一个过程的算法复杂度,这只是一个给出O(n^2logn)的问题-或者无论大O是什么?
另外,大O不就是多项式中任何项的最高阶吗?如果我被要求给出一个派生,我不确定要提供什么,因为它看起来有点琐碎。
最后一个问题,如果我需要给一个算法的操作计数,并且它真的很简单-大致像这样
array1, array2, array3 of size n
for i in n:
array2[i] = sqrt(array1[i])
array3[i] = array1[i]^2
对于“操作计数”,我只是计算我所有的算术操作,并找出哪些算术操作(如sqrt)
所以我正在准备一场考试,25%的考试都是大O,我有点迷失在如何从算法中获得复杂性和大O。下面是有答案的例子,我只需要解释一下答案是如何产生的,以及为什么会做一些事情的推理,这是我能给出的最好的解释,因为如上所述,我不是很清楚这一点:
int i =n; //this is 1 because it is an assignment (=)
while (i>0){ //this is log10(10)*(1 or 2) because while
i/=10; //2 bc / and = // loops are l
不知道这是不是适合这类问题的地方,但现在开始了。根据下面的代码,有多少个基本操作,每个操作执行多少次。这个运行时间的大O符号是什么?这是MATLAB中的,如果有关系的话。
total = 0;
for i = 1:n
for j = 1:n
total = total + j;
end
end
我的想法是,对于每个n,j= 1:n循环运行一次。在j= 1:n循环中有n个计算。对于j= 1:n循环,它的n^2。在i= 1:n循环内运行n次,所以计算的总数是n^3,大的O值是O(N^3)。这是正确的吗?
我得到了以下代码,并被告知func函数的Big O是Big O (n^ 2)。我相信它是大O( n),因为它应该是大O(n +n),我错了吗?
what is Big O of following func?
nums = list(range(1, 11))
K = 4
def func(nums: list, K:int):
i, end = 0, len(nums)
res = []
x = []
while i < end:
res.a
这段代码的大O是什么?,我认为它是O(logn),因为每个递归,num得到/= 10,否则,它必须是O(n)。对此有什么想法吗?
不是家庭作业问题,只是面试的复习。所以答案是受欢迎的。
public class Solution {
public int addDigits(int num) {
int sum = 0;
while (num > 0){
sum += num % 10;
num /= 10;
}
if (sum < 10){
这个函数的大O表示法是什么(作为n=len(Lst)的函数):
def foo(lst):
jump = 1
total = 0
while jump < len(lst):
for i in range(0, len(lst), jump):
total += i
jump = jump * 2
return total
我以为是O(n*log(n)),但它不是,试图理解为什么它实际上是O(N).我在这方面有点新,所以如果你也能解释你是如何得到答案的,这将是最好的!谢谢
我正在学习Charles Dierbach的书“使用Python的计算机科学导论”。
我在第五章,我试着在自动游戏上做这个练习。
我在为pc创建一个选择空框([])的函数时遇到了困难。
这是我的密码
import re
import random
def template():
mylst = list()
for i in range(0, 3):
my_temp = []
for j in range(0, 3):
my_temp.append([])
mylst.append(my_temp)