codility | Various Codility excercises

I'm trying to understand how the XOR operation managed to solve the problem PermMissingElem

I know one of the properties of XOR is that:

I am trying to use recursion to solve the OddOccurrencesInArray Problem in Codility, in which

• we are given an array with N elements, N is always odd
• all of the elements of the array except for one has a total even number of occurrences
• we need to write code that returns the one unpaired value

For example, if the array given is [9, 3, 9, 3, 7, 9, 9], the code must return 7, because that is the only element in the array which is unpaired.

My solution pseudocode/thought process was:

• sort the array
• if the first two elements are equal to each other, remove them and run the solution algorithm again recursively on the array minus the first two elements (after sorting) i.e. if the unpaired element is not found, we keep reducing the size of the array
• if the first two elements are NOT equal to each other, the first element of the array must be the unpaired item

My implementation was:

I'm solving the MinPerimeterRectangle problem from Codility:

An integer N is given, representing the area of some rectangle.

The area of a rectangle whose sides are of length A and B is A * B, and the perimeter is 2 * (A + B).

The goal is to find the minimal perimeter of any rectangle whose area equals N. The sides of this rectangle should be only integers.

For example, given integer N = 30, rectangles of area 30 are:

(1, 30), with a perimeter of 62, (2, 15), with a perimeter of 34, (3, 10), with a perimeter of 26, (5, 6), with a perimeter of 22. Write a function:

def solution(N)

that, given an integer N, returns the minimal perimeter of any rectangle whose area is exactly equal to N.

For example, given an integer N = 30, the function should return 22, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..1,000,000,000].

I initially used this code:

''' import math

I have already read through the answers on this question - Codility NailingPlanks. This is not a duplicate, as I'm trying to solve this problem using a different approach - instead of running a binary search on the planks that a given nail can cover, I'm trying to run it on the total number of nails required to cover all the planks.

This is my code:

I'm trying to solve the Codility FibFrog problem and I came up with the following solution:

I'm trying to solve the FibFrog Codility problem and I came up with the following approach:

1. If len(A) is 0 we know we can reach the other side in one jump.
2. If len(A) + 1 is a fibonacci number, we can also reach it in one jump.
3. Else, we loop through A, and for the positions we can reach, we check if we can either reach them directly from -1 using a fibonacci number (idx + 1 in fibonaccis) or if we can reach them by first jumping to another position (reachables) and then jumping to the current position. In either case, we also check if we can go from the current position to the end of the river - if we can, then we can return because we found the minimum number of steps required.
4. Finally, if unreachable is True once this loop completes, this means we can't reach any position using a Fibonacci number, so we return -1.

I'm getting 83% correctness and 0% performance with this approach.

I understand the solution is O(n^2), assuming the array consists of only 1, the nested loop for v in reachables: would run n times - however I'm not sure how else I can compute this, since for each of the positions I need to check whether we can reach it from the start of the array, or from any previous positions using a fibonacci number.

Recently, I'm practicing code exercises in Codility. Here you can find the problem, it is in the Exercises 6 - SQL section. Just start a test to see the problem description! SqlEventsDelta

Problem Define:

I wrote this solution to the SqlEventDelta Question in SQLite. It works fine in local tool But, It was not working in web tool.

Can anyone give any advice on how can I solve this problem?

※ I searched this problem in Stackoverflow and I know a better code then my own way. But, If possible, I wanna use my own SQLite code logic and function.

I've written the below algorithm as a solution to Codility Flags. This passes the correctness checks, however it times out on most of the performance checks.

The complexity of this should be O(m**2) where m is the number of peaks in A and n is the length of A. However, the while potentialK > maxFlags loop should only execute until a suitable number of flags is found which satisfies the criteria. I'm not sure how to further optimise this for time complexity.

I'm practicing on Codility. There is an Easy Level question, yet I'm stuck on performance. The test result analysis marks this code as O(N**2), but obviously there are not any nested loops. Can anyone tell me why my code is O(N**2)?