Find the highest power of 2 that divides N.
Sign up for our newsletter:
Information about upcoming challenges, solutions and lessons directly in your inbox.
Social:
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
int solution(int N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
int solution(int N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
int solution(int N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
class Solution { public int solution(int N); }
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
int solution(int N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
func Solution(N int) int
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
class Solution { public int solution(int N); }
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
class Solution { public int solution(int N); }
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
function solution(N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
fun solution(N: Int): Int
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
function solution(N)
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
int solution(int N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
function solution(N: longint): longint;
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
function solution($N);
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
sub solution { my ($N) = @_; ... }
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
def solution(N)
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
def solution(n)
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
object Solution { def solution(n: Int): Int }
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
public func solution(_ N : Int) -> Int
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
function solution(N: number): number;
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
A positive integer N is given. The goal is to find the highest power of 2 that divides N. In other words, we have to find the maximum K for which N modulo 2^K is 0.
For example, given integer N = 24 the answer is 3, because 2^3 = 8 is the highest power of 2 that divides N.
Write a function:
Private Function solution(N As Integer) As Integer
that, given a positive integer N, returns the highest power of 2 that divides N.
For example, given integer N = 24, the function should return 3, as explained above.
Assume that:
- N is an integer within the range [1..1,000,000,000].
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
Information about upcoming challenges, solutions and lessons directly in your inbox.