## Is the time complexity of this solution O(logn)?

o(n log n) explained
time complexity of log function
o(n log n) code example
o(log n) code example
time complexity calculator
time complexity of linear search
n log n complexity
log n value

I have written the following solution for a challenge but I am not sure about its time complexity:

```def ASCIIConversion(string):
newStr = ''

for chr in string:
if chr.isspace():
newStr = newStr + ' '
else:
newStr += str(ord(chr))

return newStr
```

Is the complexity of the program, O(logn), because of the else statement?

This solution is still O(n). I'm not entirely sure why the else statement would affect this, actually. You're performing one operation on every character in the string.

Even though for each character, you're performing multiple instructions (comparisons, etc.), you may think the complexity is something like O(3n), but of course you disregard the coefficient. I'm sure you know this, but for people viewing this question in the future, confused about the else statement, this might help.

What does O(log n) mean exactly?, ) means that the algorithm's maximum running time is proportional to the input size. One place where you might have heard about O(log n) time complexity the first time is Binary search algorithm. So there must be some type of behavior that algorithm is showing to be given a complexity of log n. Let us see how it works.

The time complexity in worst case is calculated as below(suppose string max length is n):

```newStr = ''  # will be done once so 1 time.

for chr in string: # is iterating on the input with max length of n so n times.
if chr.isspace(): # will be checked once it is in the loop so 1 time per each iteration.
newStr = newStr + ' ' # also once per iteration if the if condition is satisfied
else: # will be chehcked once per iteration
newStr += str(ord(chr)) # if else is satisfied

return newStr # will be done 1 time.
```

we will assumes that the constant times are c so:

`Time complexity = 1 + n(c*c + c*c) + 1 = 2+Cn => O(n)`

Difference between O(n) and O(log(n)), can be estimated in relation to N as N approaches infinity. O(logn) is known as logarithmic complexity. The logarithm in O(logn) has a base of 2. The best way to wrap your head around this is to remember the concept of halving: every time n increases by an

Irrespective of if-else condition, loop iterate through each character of string so time complexity is O(n).

How to find time complexity of an algorithm, This solution is still O(n). I'm not entirely sure why the else statement would affect this, actually. You're performing one operation on every  O(log n) — Logarithmic time: given an input of size n, the number of steps it takes to accomplish the task are decreased by some factor with each step. O(n) — Linear Time: Given an input of size n, the number of of steps required is directly related (1 to 1)

Is the time complexity of this solution O(logn)?, It's dependent on the problem you are trying to solve if there is an O(logn) solution. How to adapt a O(n2) or O(n) algorithm to be O(logn)? Many times you just  The time complexity for inserting an element into a binary search tree is O(logn). In an AVL tree, the element just inserted is always at the leaf. Every object has the hashCode() method. If two strings are equal, the two strings have the same hashCodes.

How would you make an algorithm's time complexity O(logn)?, O(log n). That's time complexity analysis or big-O notation! 3^x == 9. The question logarithms answer is: “What power do we raise 3 to to get 9? What if we could speed this up to O(log n)? Well, if the list is sorted, we can! We don’t measure the speed of an algorithm in seconds (or minutes!). Instead, we measure the number of operations it takes to complete. The O is short for “Order of”. So, if we’re discussing an algorithm with O (log N), we say its order of, or rate of growth, is “log n”, or logarithmic complexity.

A Gentle Explanation of Logarithmic Time Complexity, In computer science, the time complexity is the computational complexity that describes the An algorithm is said to take logarithmic time when T(n) = O(log n)​. algorithms are typically randomized, and provide only approximate solutions. Keep in mind this is in terms of the amount of recursive calls of this method. We conclude by understanding that a single invocation of the method itself is constant (O(1)) time, and it is invoked log(n) times, so the runtime complexity is O(logn)

• you iterate through the array of strings, that should be `O(n)`. all statements inside the loop are constant time, including if and else.