Jonatas Blog

A Good (and Fun) Use Case for AI

2025-12-04T00:00:00Z

A Good (and Fun) Use Case for AI

One thing I learned is that AI is good it to write unit tests for enterprise level applications. Another good use is to convert programs between different languages. It works well with modern languages like Python, JavaScript, C/C++, but what about the BASIC language for 8-bit computers?

The Past

My first contact with computers was in the 80's when I learned how to program using BASIC in the 8 bit computers such as the Sinclair ZX81 clone model CP-200 and then later an Apple II clone called TK-3000 IIe.

If you never saw a BASIC program, it looks like this:

05 HOME : TEXT : REM Fibonacci numbers
10 LET MAX = 5000
20 LET X = 1 : LET Y = 1
30 IF (X > MAX) GOTO 100
40 PRINT X
50 X = X + Y
60 IF (Y > MAX) GOTO 100
70 PRINT Y
80 Y = X + Y
90 GOTO 30
100 END

The lines are numbered and the computer executes them in order. They usually increase by 10 (10, 20, 30, 40, 50) and not by 1 and the reason is to facilitate the inclusion of new lines in between without having to renumber the whole program. For example I can add a new line 15 PRINT MAX and it will work. The only rule is for them to be sequential.

We also have the dreadful "GOTO" statements. Some BASIC implementations or versions may have a "GOSUB" and "RETURN" which is similar to a modern function structure (kind of). This is where the term "spaghetti code" was coined.

For a simple program like this it is easy to see and follow the jumps but for programs with thousands of lines this becomes a big problem...

To learn more about the BASIC language check this Wikipedia link.

The Future

One of the things I like to do for fun is to play with those old BASIC programs. And since the only way to run them today is to use an emulator - which can be cumbersome sometimes - I try to convert them to new, more modern languages like JavaScript or Python.

My brain is not wired to create new things out of thin air, so I prefer to take something, break it apart, learn how it works, modify it, improve it, make it run faster and so on.

However, converting these programs can be fun, but sometimes can be very hard to untangle the nested "GOTO" jumps. Here is where AI comes into play. I am using AI tools for my job and I think there are some interesting use cases for it and this is one of them.

I started with this game that can be found in this page: Applesoft BASIC in JavaScript called "ARTILLERY" - select Artillery (Michael "Moose" O'Malley) in the dropdown and click "Run"

I copied the code and asked Copilot to convert it to JavaScript and HTML5 using canvas so it can be played in the browser. And it worked - kind of - here is the result:

The UI needs improvement and there was a bug: the trajectory was wrong and not plotting the lines.

It took me some time to debug the jumps and I found out that one of the GOSUB-RETURN was mistakenly replaced by a "break" statement in one of the JavaScript loops.

But then I thought: can AI help me to understand this? So I asked it to generate a flowchart diagram of the code and present it in an HTML page. Here is the result:

Nice, but the lines overlap and some boxes are not in a good position. I tried to organize it but each box is made of a couple of html elements, not really easy to move.

<!-- SUB 1160: Draw Explosion -->
<rect x="660" y="60" width="140" height="80" class="block-subroutine" rx="5"/>
<text x="730" y="75" text-anchor="middle" class="line-num">1160-1280</text>
<text x="730" y="90" text-anchor="middle" class="label" style="font-size:12px;font-weight:bold;">SUB 1160</text>
<text x="730" y="105" text-anchor="middle" class="label">Draw Explosion</text>
<text x="730" y="120" text-anchor="middle" class="label">FOR Z=1 TO 5</text>
<text x="730" y="133" text-anchor="middle" class="label" style="font-size:10px;fill:#7b1fa2;">RETURN</text>

I guess that is my fault since I was not specific enough (remember Aladdin's request: "make me a prince" to the Genie in the movie)...

So I asked Copilot to generate the diagram again, but this time using the Mermaid.js diagramming and charting tool.

And so I got this:

Which is much better than the previous one! But there was a bug. Copilot broke the diagram in 3 tabs, I assume because the content is too long and only the first tab was showing correctly:

And the second tab:

At first I thought the error could be in one of the texts that it used from the basic program to create the Mermaid diagram. I did some Google digging but there was nothing interesting there, just some suggestions to update the Mermaid version.

My next step was to copy the diagrams to Mermaid's online editor here and check if it worked there. Surprisingly it did, so a quick look a the documentation followed. Nothing suspicious...

That's when something came to my mind. The tabs were grouping multiple containers (one for each diagram) and the CSS was:

.diagram-container {
            display: none;
        }
.diagram-container.active {
            display: block;
        }

And the solution was to make display: block for both. Hiding part of the diagram was not working well with Mermaid's rendering system, maybe because it was treated as one piece only. Either way, the problem was solved!

Next steps

I still want to double check the game logic and probably make some improvements in the UI, but an improved (still in progress) version can be found here.

Conclusion

AI tools can help in many ways:

converting code
explaining it
generating unit tests
creating diagrams and flowcharts

but it is not perfect - such as the box positioning or the bugs due to hiding elements.

The more specific you are when writing your prompts the better, but that does not guarantee 100% correct behavior - always check and evaluate the output.

Codility Lesson 03 - Time Complexity - PermMissingElem

2025-11-06T00:00:00Z

Difficulty: [easy] Practice it here

PermMissingElem

Find the missing element in a given permutation.

An array A consisting of N different integers is given. The array contains integers in the range [1..(N + 1)], which means that exactly one element is missing.

Your goal is to find that missing element.

Write a function:

function solution(A);

that, given an array A, returns the value of the missing element.

For example, given array A such that:

A[0] = 2 A[1] = 3 A[2] = 1 A[3] = 5

the function should return 4, as it is the missing element.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [0..100,000]; the elements of A are all distinct; each element of array A is an integer within the range [1..(N + 1)].

Problem Analysis

The first thing that comes to mind for this problem is to sort the array then check each number and its successor to check for missing ones.

Another idea that comes to my mind is something that I read in the book Programming Pearls (2nd Edition by Jon Louis Bentley) where the problem statement is similar to this:

Column 1: Cracking the Oyster

Input:

A file containing at most n positive integers, each less than n, where n = 10^7. It is a fatal error if any integer occurs twice in the input. No other data is associated with the integer.

Output:

A sorted list in increasing order of the input integers.

Constraints:

At most (roughly) a megabyte of storage is available in main memory; ample disk storage is available. The run time can be at most several minutes; a run time of ten seconds need not be decreased.

It is better to read the full chapter to understand the process, but the main idea is to use a bitmap or bit vector representation to solve this problem.

For example A = [1, 2, 3, 5, 8, 13] can be represented in a bitmap:

                            1 1 1 1 1 1 1 1 1 1
index:  0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
number: 0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0
          ^ ^ ^   ^     ^         ^
A = [1, 2, 3, 5, 8, 13]

Every number's position (index) is set to "1" if the number is in the array "A", or set to "0" if not. If memory/space was a constraint it could be done with bits, but for now I will use another array to make things easier.

A = [1, 2, 3, 5, 8, 13]
B = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

From the problem description:

A[2, 3, 1, 5] A.length = N = 4

A[0] = 2 A[1] = 3 A[2] = 1 A[3] = 5

The new array is: (index 0 is ignored)

idx= 0  1  2  3  4  5
B = [0, 1, 1, 1, 0, 1]

so the first missing integer is idx = 4.

Solution:

create a new array B[N+1] and initialize it with 0's;
loop through A, (for i=0; i < A.length; i++)
set B[A[i]-1] = 1 (true);
after that, loop through B again and return the first i where B[i] == 0;

Alternate Approach

Solution approach:

Uses the mathematical sum method for O(N) time complexity and O(1) space complexity Expected sum of 1 to (N+1) = (N+1) × (N+2) / 2 Missing element = Expected sum - Actual sum

Codility Lesson 03 - Time Complexity - FrogJmp

2025-11-05T00:00:00Z

Difficulty: [easy] Practice it here

FrogJmp

Count minimal number of jumps from position X to Y.

A small frog wants to get to the other side of the road. The frog is currently located at position X and wants to get to a position greater than or equal to Y. The small frog always jumps a fixed distance, D.

Count the minimal number of jumps that the small frog must perform to reach its target.

Write a function:

function solution(X, Y, D);

that, given three integers X, Y and D, returns the minimal number of jumps from position X to a position equal to or greater than Y.

For example, given:

X = 10 Y = 85 D = 30

the function should return 3, because the frog will be positioned as follows:

after the first jump, at position 10 + 30 = 40 after the second jump, at position 10 + 30 + 30 = 70 after the third jump, at position 10 + 30 + 30 + 30 = 100

Write an efficient algorithm for the following assumptions:

X, Y and D are integers within the range [1..1,000,000,000]; X ≤ Y.

Problem Analysis

A frog starts at position X and needs to reach position Y (or beyond) by jumping a fixed distance D each time. Find the minimum number of jumps needed.

X = start position Y = final position D = jump distance

Distance to cover: Y - X

If X = 10 and Y = 85, the frog needs to cover 75 units.

Jumps needed: Divide distance by jump size and round up

With D = 30: 75 / 30 = 2.5 Round up to 3 jumps (since we can't make partial jumps)

Time Complexity: O(1) - constant time, just one calculation

Example Walkthrough Given X = 10, Y = 85, D = 30:

Distance = 85 - 10 = 75 Jumps = 75 / 30 = 2.5 = 3 After 3 jumps: 10 + (3 × 30) = 100 >= 85

function solution(X, Y, D) {
    // Calculate the distance to cover
    const distance = Y - X;
    // Calculate number of jumps needed (round up)
    return Math.ceil(distance / D);
}
// or
function solutionInt(X, Y, D) {
    const distance = Y - X;
    return Math.floor((distance + D - 1) / D);
    // or: return Math.floor(distance / D) + (distance % D > 0 ? 1 : 0);
}

Codility Lesson 02 - Arrays - OddOccurrencesInArray

2025-11-04T00:00:00Z

Difficulty: [easy] Practice it here

OddOccurrencesInArray

Find value that occurs in odd number of elements.

A non-empty array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.

For example, in array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9

the elements at indexes 0 and 2 have value 9, the elements at indexes 1 and 3 have value 3, the elements at indexes 4 and 6 have value 9, the element at index 5 has value 7 and is unpaired.

Write a function:

function solution(A);

that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.

For example, given array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9

the function should return 7, as explained in the example above.

Write an efficient algorithm for the following assumptions:

N is an odd integer within the range [1..1,000,000]; each element of array A is an integer within the range [1..1,000,000,000]; all but one of the values in A occur an even number of times.

Problem Analysis

I will start with the validations:

// 02-Arrays/odd-occurrences-in-array.test.js

  // each element of array A is an integer within the range [1..1,000,000,000].
  test('each element of array A is an integer within the range [1..1,000,000,000].', () => {
    // arrange
    const A = [0, -1, 10, 5000000000, 1000000001]; // invalid values
    // act & assert
    expect(() => {
      solution(A)
    }).toThrow();
  });

This time I will add the input array and the expected output result since the problem description only shows one example. I also used the AAA structure:

// 02-Arrays/odd-occurrences-in-array.test.js

// test case to rotate A[1,2,3,4,5] K=2 return should be A[4,5,1,2,3]
  test('given A[9, 3, 9, 3, 9, 7, 9] should return 7.', () => {
    // arrange
    const A = [9, 3, 9, 3, 9, 7, 9];
    const expected = 7;
    // act
    const result = solution(A);
    // assert
    expect(result).toEqual(expected);
  });

Run the tests:

 FAIL  02-Arrays/odd-occurrences-in-array.test.js
  OddOccurrencesInArray Tests
    × each element of array A is an integer within the range [1..1,000,000,000]. (3 ms)
    × given A[9, 3, 9, 3, 9, 7, 9] should return 7. (3 ms)

It is time to start working on the solution. Validations first.

// 02-Arrays/odd-occurrences-in-array.js
'use strict';

// Find value that occurs in odd number of elements.

module.exports = function solution(A) { // A array

	// each element of array A is an integer within the range [1..1,000,000,000];
	for (let i = 0; i < A.length; i++) {
		if (A[i] < 1 || A[i] > 1000000000) {
			throw new Error("Element A[" + i + "] is invalid!");
		}
	}
}

The problem says that there are pair of elements, except for one element that is left unpaired. One way to find the odd element would be loop through the array and count the elements, adding them to a table and then look at the rows that have odd numbers.

For example: array A = [9, 3, 9, 3, 9, 7, 9]

element	count
9	4
3	2
7	1

And "7" is the odd element since there is only 1 element in the array.

I learned to program in BASIC (8 bit) then used C later in college and one of the things I always have in mind is how to solve problem using common/simple structures: for/while loops, arrays and so on. Modern languages offer different constructs and data structures and it makes the job a lot easier for sure. Most languages today share the same features: hashes, maps sets and so on.

One way that I can think of solving this problem without using fancy structures is to have 2 arrays (or maybe a bidimensional 2 cols x N rows). This would look like this:

// 2 arrays, one hold the element and another the count
element[0] = 9 , count[0] = 4
element[1] = 3 , count[1] = 2
element[2] = 7 , count[2] = 1

// or using a multidimensional array:
let matrix = [
  [9, 4],
  [3, 2],
  [7, 1]
];

matrix[0][0] = 9; // the first  value of the first inner array
matrix[0][1] = 4; // the second value of the first inner array

Both will work and I can simply iterate over it using a for or while loop.

There are may other way to store our data, but since I am working with JavaScript I can think of 2 other options: Map and Set.

Map

A Map is a collection of key-value pairs where keys can be of any data type (including objects or functions), unlike plain JavaScript objects where keys must be strings or Symbols.

Set

A Set is a collection of unique values. It does not store key-value pairs; instead, it simply stores a list of distinct elements.

Since a "Set" can only store unique values I think "Map" is a better option because it can store key-value pairs and I need "element-count" pair.

Looking at the documentation I can see that Map methods and properties are:

new Map() – creates the map. map.set(key, value) – stores the value by the key. map.get(key) – returns the value by the key, undefined if key doesn’t exist in map. map.has(key) – returns true if the key exists, false otherwise. map.delete(key) – removes the element (the key/value pair) by the key. map.clear() – removes everything from the map. map.size – returns the current element count.

I can use this to:

loop through the A array;
check if that element exists in the Map;
if not exists, then add it to the set with count = 1;
if exists, then update count = count + 1;

	// using map to count occurrences
	let map = new Map();
	for (let i = 0; i < A.length; i++) {
        let element = A[i];
		let exists = map.get(element);
		if (exists) {
			map.set(element, exists + 1);
		} else {
			map.set(element, 1);
		}
	}
	//debug:
	console.log(map);

At this point, I have this table stored in a Map data structure:

key	value
9	4
3	2
7	1

The last step is to find the odd count (value) and to do that it will be necessary to iterate over the Map.

For looping over a map, there are 3 methods:

map.keys() – returns an iterable for keys, map.values() – returns an iterable for values, map.entries() – returns an iterable for entries [key, value], it's used by default in for..of.

    // find the element with odd occurrences
	for (let [key, value] of map) {
		if (value % 2 !== 0) {
			return key;
		}
	}

The problem description says that only one element is left unpaired (all but one of the values in A occur an even number of times) so if that element is found, it can be returned as the solution. Having more than one odd element in the array means that the input is invalid.

Codility Lesson 02 - Arrays - CyclicRotation

2025-11-03T00:00:00Z

Difficulty: [easy] Practice it here

CyclicRotation

Given the problem description:

Rotate an array to the right by a given number of steps.

An array A consisting of N integers is given. Rotation of the array means that each element is shifted right by one index, and the last element of the array is moved to the first place.

For example, the rotation of array A = [3, 8, 9, 7, 6] is [6, 3, 8, 9, 7] (elements are shifted right by one index and 6 is moved to the first place).

The goal is to rotate array A K times; that is, each element of A will be shifted to the right K times.

Write a function:

function solution(A, K);

that, given an array A consisting of N integers and an integer K, returns the array A rotated K times.

For example, given:

A = [3, 8, 9, 7, 6] K = 3 the function should return [9, 7, 6, 3, 8].

Three rotations were made:

[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7] [6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9] [7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

For another example, given:

A = [0, 0, 0] K = 1 the function should return [0, 0, 0]

Given

A = [1, 2, 3, 4] K = 4 the function should return [1, 2, 3, 4]

Assume that:

N and K are integers within the range [0..100]; each element of array A is an integer within the range [−1,000..1,000].

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

Problem Analysis

I will start with the boundaries test, from the problem description:

N and K are integers within the range [0..100]; each element of array A is an integer within the range [-1,000..1,000].

I will start a new test case and test K (number or rotations) first. K should be between 0 and 100. Next test is N (number of elements in the array) and because an array cannot have a negative number of elements, I can skip this test. So I will test an array with more than 100 elements.

The following test is to check if each element of the array is within the range -1k..1k. In order to do that, I will follow a standard practice in Unit Test: the Arrange, Act and Assert (AAA) Pattern. This means that the unit test contain 3 parts:

Arrange: setup and prepare things needed by the test. Create objects, assign values or set expectations.
Act: invoke the method being tested.
Assert: verify the results and check if the expectations were met.

// cyclic-rotation.js

  // N and K are integers within the range [0..100];
  test('N and K are integers within the range [0..100];', () => {

    // K: rotations = less than 0 or greater than 100
    expect(() => {
      solution(new Array(1), -1)
    }).toThrow("Parameter K is invalid!");

    expect(() => {
      solution(new Array(1), 101)
    }).toThrow("Parameter K is invalid!");

    // N: number of elements in A[] = less than 0 or greater than 100
    // an array cannot have less than 0 elements, so we skip that test
    expect(() => {
      solution(new Array(150), 5)
    }).toThrow();
  });

  // each element of array A is an integer within the range [−1,000..1,000].
  test('each element of array A is an integer within the range [-1,000..1,000].', () => {
    // arrange
    const N = 5;
    const K = 3;
    const A = [];
    // values added are A[0, 500, 1000, 1500, 2000]
    for (let i = 0; i < N; i++) {
      A.push(i * 500);
    }

    // act & assert
    expect(() => {
      solution(A, K)
    }).toThrow();

  });

With the validations and boundaries in place, I can add more unit tests using the requirements in the problem description.

The next test will be to test one valid input array and the correct result expected.

I can start with a basic rotation:

input: A = [1, 2, 3] rotation: K = 1 output: A = [2, 3, 1]

But I like to use the same from the problem description:

"Given an array A consisting of N integers and an integer K, returns the array A rotated K times."

input: A = [3, 8, 9, 7, 6] rotation: K = 3 output: A = [9, 7, 6, 3, 8]

In this test, I will need to provide the input Array, the number of rotations K and the expected result Array to compare.

The good thing here is that the Jest framework offers this method from it's matchers.

toEqual(): This matcher performs a deep comparison, checking if both arrays have the same elements in the same order. It works for arrays of primitives and objects.

Since my arrays only contain integers, this should work. I could chain the calls to make the code more short, but for now I will keep it separated so I can console.log the results to make sure it is working. If I didn't have a method to compare the arrays, I would need to loop/iterate to both and compare the values.

Here is the Unit Test:

  // test case to rotate A[1,2,3,4,5] K=2 return should be A[4,5,1,2,3]
  test('rotate A[1,2,3,4,5] with K=2 should return A[4,5,1,2,3]', () => {
    // arrange
    const A = [1, 2, 3, 4, 5];
    const K = 2;
    const expected = [4, 5, 1, 2, 3];

    // act
    const result = solution(A, K);

    // assert
    expect(result).toEqual(expected);
  });

I can add more tests. One nice feature of the Jest test framework is the possibility to send a list (or table, or array) of different test data to the same test function - this is useful when we want to use the same Unit Test to check different sets of data.

In the example bellow I am using test.each to keep duplicating the same unit test with different data sets. I also merged the test and expect in the same statement: expect(solution(A, K)).toEqual(expected);.

  test.each([
    [[1, 2, 3, 4, 5], 2, [4, 5, 1, 2, 3]],
    [[1, 2, 3, 4, 5], 1, [5, 1, 2, 3, 4]],
    [[1, 2, 3, 4, 5], 3, [3, 4, 5, 1, 2]],
  ])('array: %s and K: %i => %s', (A, K, expected) => {
    // each parameter goes into the test function: A, K, expected
    expect(solution(A, K)).toEqual(expected);
  });

and run the tests

 FAIL  02-Arrays/cyclic-rotation.test.js
  CyclicRotation Tests
    × N and K are integers within the range [0..100]; (6 ms)
    × each element of array A is an integer within the range [-1,000..1,000]. (1 ms)
    × rotate A[1,2,3,4,5] with K=2 should return A[4,5,1,2,3] (3 ms)
    × array: [ 1, 2, 3, 4, 5 ] and K: 2 => [ 4, 5, 1, 2, 3 ]
    × array: [ 1, 2, 3, 4, 5 ] and K: 1 => [ 5, 1, 2, 3, 4 ] (1 ms)
    × array: [ 1, 2, 3, 4, 5 ] and K: 3 => [ 3, 4, 5, 1, 2 ] (1 ms)

Test Suites: 1 failed, 1 total
Tests:       6 failed, 6 total
Snapshots:   0 total
Time:    0.938 s, estimated 1 s

So the next step is to implement the validations.

    // k: integer representing number of rotations;
    if (K < 1 || K > 100) {
    throw new Error("Parameter K is invalid!");
    }

    // N: number of elements in A[];
    let N = A.length;
    if (N < 0 || N > 100) {
    throw new Error("Parameter N is invalid!");
    }

    // each element of array A is an integer within the range [-1,000..1,000].
    for (let i = 0; i < N; i++) {
    if (A[i] < -1000 || A[i] > 1000) {
        throw new Error("Element A[" + i + "] is invalid!");
    }
    }

and run the tests again

 FAIL  02-Arrays/cyclic-rotation.test.js
  CyclicRotation Tests
    √ N and K are integers within the range [0..100]; (11 ms)
    √ each element of array A is an integer within the range [-1,000..1,000]. (1 ms)
    × rotate A[1,2,3,4,5] with K=2 should return A[4,5,1,2,3] (6 ms)
    × array: [ 1, 2, 3, 4, 5 ] and K: 2 => [ 4, 5, 1, 2, 3 ] (1 ms)
    × array: [ 1, 2, 3, 4, 5 ] and K: 1 => [ 5, 1, 2, 3, 4 ] (1 ms)
    × array: [ 1, 2, 3, 4, 5 ] and K: 3 => [ 3, 4, 5, 1, 2 ]

Test Suites: 1 failed, 1 total
Tests:       4 failed, 2 passed, 6 total
Snapshots:   0 total
Time:    0.901 s, estimated 1 s

the failing tests now are for the actual solution array - which I have not implemented anything yet.

Solution 1

I have to start thinking about the problem and how to find a solution. The problem description says:

Rotate an array to the right by a given number of steps. Rotation of the array means that each element is shifted right by one index, and the last element of the array is moved to the first place.

So if I rotate the array by 1 step, the last element is removed and added to the beginning of the array. To do that in JavaScript I looked at the Array methods and saw that I can use pop() and unshift():

The pop() method of Array instances removes the last element from an array and returns that element. This method changes the length of the array.
The unshift() method of Array instances adds the specified elements to the beginning of an array and returns the new length of the array.

OK, so if I want to do it K times, here is the code I added to my cyclic-rotation.js file:

// cyclic-rotation.js

    for (let i = 0; i < K; i++) {
    let item = A.pop();
    A.unshift(item);
    }

and run the tests again:

 PASS  02-Arrays/cyclic-rotation.test.js
  CyclicRotation Tests
    √ N and K are integers within the range [0..100]; (12 ms)
    √ each element of array A is an integer within the range [-1,000..1,000]. (1 ms)
    √ rotate A[1,2,3,4,5] with K=2 should return A[4,5,1,2,3] (1 ms)
    √ array: [ 1, 2, 3, 4, 5 ] and K: 2 => [ 4, 5, 1, 2, 3 ] (1 ms)
    √ array: [ 1, 2, 3, 4, 5 ] and K: 1 => [ 5, 1, 2, 3, 4 ]
    √ array: [ 1, 2, 3, 4, 5 ] and K: 3 => [ 3, 4, 5, 1, 2 ]

Test Suites: 1 passed, 1 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:    0.746 s, estimated 1 s

Nice! all my tests are passing now.

Note: this is a solution that match the criteria in the problem description but it is not an optimized solution yet and this is fine. First I solve the problem, then I iterate over it trying to find ways to optimize it (use less memory, space or computing time). Sometimes this is not necessary - for example when the code is not used very often or something needs to be deployed fast to fix a bug. And sometimes there are spots where memory and processing time are really important.

In order to find a better solution, lets look at what happens in each iteration and draw some conclusions.

Problem Exploration

For example, given:

A = [3, 8, 9, 7, 6] K = 3 the function should return [9, 7, 6, 3, 8]

Step by step:

Rotation 1 => [3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]
Rotation 2 => [6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]
Rotation 3 => [7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

or

K = 3 rotations
Initial Arr=> [3, 8, 9, 7, 6]
Rotation 1 => [6, 3, 8, 9, 7]
Rotation 2 => [7, 6, 3, 8, 9]
Rotation 3 => [9, 7, 6, 3, 8]

idx  0  1  2  3  4
A = [3, 8, 9, 7, 6]
O = [9, 7, 6, 3, 8]
K=3  |________^

I can draw some conclusions: given K (rotation), if K <= A.length, then K is the new index of the first element. Item 3 was at position 0, after 3 rotations it was moved to position 3 (remember indexes in JavaScript arrays start with 0)

K = 3
idx  0  1  2  3  4
A = [3, 8, 9, 7, 6]
O = [9, 7, 6, 3, 8]
     |________^

This will be true only when K <= A.length. But what happens if K > A.length?

Looks like it goes back to 0 index and start again...

----------------------------------------
K: 1 A: [ 3, 8, 9, 7, 6 ] A.length: 5 (K % A.length): 1
i: 1 A: [ 6, 3, 8, 9, 7 ]
----------------------------------------
K: 6 A: [ 3, 8, 9, 7, 6 ] A.length: 5 (K % A.length): 1
i: 1 A: [ 6, 3, 8, 9, 7 ]
i: 2 A: [ 7, 6, 3, 8, 9 ]
i: 3 A: [ 9, 7, 6, 3, 8 ]
i: 4 A: [ 8, 9, 7, 6, 3 ]
i: 5 A: [ 3, 8, 9, 7, 6 ]
i: 6 A: [ 6, 3, 8, 9, 7 ]

If A.length = 5, both K=1 and K=6 produce the same result. This tells me that I can use the remainder of a division to reduce the number or rotations - why do 6 rotations if I can do just 1 and get the same result?

So if K > A.length, then use (K MOD A.length)

MOD: is the "modulus" (the remainder of a division)

The first improvement I can do is:

    let N = A.length;
    // if K > N, we can reduce the number of rotations
    if (K > N) {
    K = K % N;
    }
    for (let i = 0; i < K; i++) {
    let item = A.pop();
    A.unshift(item);
    }

And run the tests again. Tests pass! This is the beauty of TDD and Unit Tests - I can make changes to my code and see it still returns the correct results. If I made a breaking change or introduced any bugs, the tests will show me. If you understand this then my job is done!

I could stop here because my requirement says: "N and K are integers within the range [0..100];" which means the biggest array I may have will contain 100 items. If the requirements were different and I could have thousands or millions or items, improving this would be a must.

Another thing to consider is memory usage. In some languages array sizes are fixed (immutable) which means that an operation to resize (remove or add elements) will return a new array in memory and the old one must be released of freed by the garbage collector. For example if I have an array with 100 integers and each integer use 8 bytes of memory, my array takes 800 bytes of memory. This is not much, but if I do that operation 100x twice (one for pop and another for unshift) that is 800 x 200 = 160,000 bytes or 160k (ish). Now if my array has 10,000 integers: x8 bytes each = 80,000 bytes x200 = 16,000,000 or 16 Mbytes of space (even if temporary). Many times this type of optimization is not relevant, but there are times when the application is slow or the site is down and you have no clue why. Or when working with limited resources such as IoT devices where every byte counts!

Further Exploration

What if instead of modifying the array every step we could calculate the final state and then split the array in a way that matches the expected result?

Let's take a look in this particular case:

A = [1, 2, 3, 4, 5] K = 3 the function should return [3, 4, 5, 1, 2]

For K = 3 rotations, the array can be split into: [1, 2] and [3, 4, 5]

And then merged again as: [3, 4, 5] + [1, 2]

K: 3
A: [ 1, 2, 3, 4, 5 ]
A.length: 5
R = K % A.length: 3  => split point
result [3, 4, 5, 1, 2]

     0  1  2  3  4  = index (start at 0)
A: [ 1, 2, 3, 4, 5 ]

split at 2 (R - 1)
   [1, 2] + [3, 4, 5]
flip
   [3, 4, 5] + [1, 2]

if K=3 then split the array at position (K-1) = 2 (remember that array index start at 0)

Split point R is A[2] : [1, 2] + [3, 4, 5]

Flip and join: [3, 4, 5] + [1, 2]

R is the "rotation point".

// if K is bigger than the array size, the use the remainder
if (K > A.length) {
    K = K % A.length;
}

// calculate where to split
let R = A.length - K; // from end the until the split point

// split the array:
let arrLeft = A.slice(0, R); // from start to R
let arrRight = A.slice(R, A.length); // from R to end

// merge new array: R .. L
let result = arrRight.concat(arrLeft);
return result;

Document about Arrays from the MDN documentation site:

The slice() method of Array instances returns a shallow copy of a portion of an array into a new array object selected from start to end (end not included) where start and end represent the index of items in that array. The original array will not be modified.

const animals = ["ant", "bison", "camel", "duck", "elephant"];
console.log(animals.slice(2, 4));
// Expected output: Array ["camel", "duck"]

The concat() method of Array instances is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.

const array1 = ["a", "b", "c"];
const array2 = ["d", "e", "f"];
const array3 = array1.concat(array2);
// Expected output: Array ["a", "b", "c", "d", "e", "f"]

Time complexity: O(N) Where n is the number of elements in the input array nums. This is because we are iterating through the array twice, once to copy the elements to a new array and once to update the original array with the rotated elements.

Space complexity: O(N) We are creating a copy of the input array nums with the same size, which requires additional space.

Extras

One thing to keep in mind is that there is always a different way to solve the same problem, so here it is.

Since the array rotation does not change the array size, another approach is to just reorganize the items to their new location in a new array of the same size. This is much more efficient in terms of space and processing.

The idea is to iterate over the array and set each item in the new array and position, calculating the new index of that element.

The new position is the current position (i) + the number of rotations (K), but it is necessary to use the MOD because if it passes the number of elements, it need to start at 0 again.

It is easy to see bellow

K = 3
N = A.length = 5
========================================
i = 0 mod 5 =  0
i = 1 mod 5 =  1
i = 2 mod 5 =  2
i = 3 mod 5 =  3
i = 4 mod 5 =  4
i = 5 mod 5 =  0
i = 6 mod 5 =  1
i = 7 mod 5 =  2
i = 8 mod 5 =  3
i = 9 mod 5 =  4
i = 10 mod 5 =  0
========================================
(i = 0 + K = 3) mod 5 =>  3
(i = 1 + K = 3) mod 5 =>  4
(i = 2 + K = 3) mod 5 =>  0
(i = 3 + K = 3) mod 5 =>  1
(i = 4 + K = 3) mod 5 =>  2
(i = 5 + K = 3) mod 5 =>  3
(i = 6 + K = 3) mod 5 =>  4
(i = 7 + K = 3) mod 5 =>  0
(i = 8 + K = 3) mod 5 =>  1
(i = 9 + K = 3) mod 5 =>  2
(i = 10 + K = 3) mod 5 =>  3
========================================

Here is the code:

    // rotate the array
    let N = A.length;
    for (let i = 0; i < N; i++) {
    let newIndex = (i + K) % N;
    result[newIndex] = A[i];
    }
    return result;

run the tests again

 PASS  02-Arrays/cyclic-rotation.test.js
  CyclicRotation Tests
    √ N and K are integers within the range [0..100]; (16 ms)
    √ each element of array A is an integer within the range [-1,000..1,000]. (2 ms)
    √ rotate A[1,2,3,4,5] with K=2 should return A[4,5,1,2,3] (2 ms)
    √ array: [ 1, 2, 3, 4, 5 ] and K: 2 => [ 4, 5, 1, 2, 3 ] (1 ms)
    √ array: [ 1, 2, 3, 4, 5 ] and K: 1 => [ 5, 1, 2, 3, 4 ]
    √ array: [ 1, 2, 3, 4, 5 ] and K: 3 => [ 3, 4, 5, 1, 2 ] (1 ms)

Test Suites: 1 passed, 1 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:    0.713 s, estimated 1 s

Codility Lesson 01 - Iterations - BinaryGap

2025-11-02T00:00:00Z

Difficulty: [easy] Practice it here

BinaryGap

Find longest sequence of zeros in binary representation of an integer.

A binary gap within a positive integer N is any maximal sequence of consecutive zeros that is surrounded by ones at both ends in the binary representation of N.

For example,

number 9 has binary representation 1001 and contains a binary gap of length 2.
The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3.
The number 20 has binary representation 10100 and contains one binary gap of length 1.
The number 15 has binary representation 1111 and has no binary gaps.
The number 32 has binary representation 100000 and has no binary gaps.

Write a function:

function solution(N);

that, given a positive integer N, returns the length of its longest binary gap.

The function should return 0 if N doesn't contain a binary gap.

For example,

given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5.
Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..2,147,483,647].

Solution

BinaryGap

Find longest sequence of zeros in binary representation of an integer.

A binary gap within a positive integer N is any maximal sequence of consecutive zeros that is surrounded by ones at both ends in the binary representation of N.

For example,

number 9 has binary representation 1001 and contains a binary gap of length 2.
The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3.
The number 20 has binary representation 10100 and contains one binary gap of length 1.
The number 15 has binary representation 1111 and has no binary gaps.
The number 32 has binary representation 100000 and has no binary gaps.

Write a function:

function solution(N);

that, given a positive integer N, returns the length of its longest binary gap.

The function should return 0 if N doesn't contain a binary gap.

For example,

given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5.
Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..2,147,483,647].

Logical Thinking in Programming

Before starting to write a solution for any problem it is necessary to better understand it first. Many junior developers or people new to code fail in this step. The urge to start writing code is strong. I found the quotes below (don't ask me about the historical accuracy, focus on the idea instead):

"If I had an hour to solve a problem I’d spend 55 minutes thinking about the problem and 5 minutes thinking about solutions" - Albert Einstein

"Give me six hours to chop down a tree and I will spend the first four sharpening the axe" - Abraham Lincoln

"A problem well defined is a problem half solved" - Dan Martell

Logical thinking involves using systematic reasoning to solve problems efficiently. In programming, this means applying clear, structured thought processes to debugging, algorithm optimization, and feature design tasks. The primary methods include deductive reasoning, inductive reasoning, and problem decomposition.

Deductive Reasoning: Deductive reasoning involves drawing specific conclusions from general premises.
Inductive Reasoning: Inductive reasoning is the process of forming general conclusions from specific instances or observations.
Problem Decomposition: Problem decomposition breaks down complex problems into smaller, more manageable parts, making it easier to solve them.

With that in mind, let's take a look at our first problem.

The Problem/Solution Thinking

Based on the problem description: I will assume the input is "positive integer N", and that the parameter N passed to the solution(N) is decimal. Then in order to find a binary gap in a given number, I need to convert it from decimal to binary.

To understand it and make things more clear, I created the table below. I like to visualize and look for patterns before writing the code.

Each decimal number has its binary representation and now I can see the '0' gaps. Some numbers have more than one gap and some have none.

+--------+-----------------------+------------+--------+
| Number | Binary Representation | Binary Gap | Result |
+--------+-----------------------+------------+--------+
|      9 |                  1001 | 2          |      2 |
|    529 |            1000010001 | 4 & 3      |      4 |
|     20 |                 10100 | 1          |      1 |
|     15 |                  1111 | 0          |      0 |
|     32 |                100000 | 0          |      0 |
|   1041 |           10000010001 | 5 & 3      |      5 |
+--------+-----------------------+------------+--------+

Write Some Code

Before jumping into the solution, I need to create my code and test files. So I copied the template files solution-template.js and solution-template.test.js in the "01-Iterations" folder.

The first file is the code (solution) itself and it was renamed from solution-template.js to binary-gap.js:

// binary-gap.js
'use strict';

module.exports = function solution(N) {
  var maxGap = -1;

  return maxGap;
}

I will return -1 as an invalid value for now.

The other file is the unit test suite for this problem, which was renamed from solution-template.test.js to binary-gap.test.js:

// binary-gap.test.js
'use strict';

const solution = require("./binary-gap");

describe('BinaryGap Tests', () => {

  test('given 1 should return 1.', () => {
    expect(solution(1)).toBe(1);
  });

});

Now I can start writing unit tests and solution code.

Adding Unit Tests First

TDD is called Test Driven Development, which means the development is driven by tests.

The process follows a cycle called "Red-Green-Refactor": write a failing test (Red), write just enough code for the test to pass (Green), and then clean up the code while ensuring tests remain green (Refactor). This iterative approach helps create higher-quality, more maintainable code by ensuring every new piece of functionality is built upon a passing test.

Based on the instructions provided in the problem description, I can start adding the test cases.

Feel free to add more, start simple and add more as you go and look for edge cases or potential issues. It is good to also add test cases to check conditions outside the scope or boundaries too.

Start with the requirements from the problem description:

The number 9 has binary representation 1001 and contains a binary gap of length 2.
The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3.
The number 20 has binary representation 10100 and contains one binary gap of length 1.
The number 15 has binary representation 1111 and has no binary gaps.
The number 32 has binary representation 100000 and has no binary gaps.
Given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5.
Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.

The test syntax is pretty straightforward, but in doubt check the Jest documentation.

The problem description does not say anything about errors, so I will assume that an invalid parameter will throw an error.

The first tests will cover boundaries and invalid numbers from this statement in the problem description:

N is an integer within the range [1 .. 2,147,483,647].

// binary-gap.test.js
'use strict';

const solution = require("./binary-gap");

describe('BinaryGap Tests', () => {

  // valid input: negative number
  test('Given -1 should throw an error.', () => {
    expect(() => {
      solution(-1);
    }).toThrow();
  });

  // valid input: zero
  test('Given 0 should throw an error.', () => {
    expect(() => {
      solution(0);
    }).toThrow();
  });

  // valid input: big number
  test('Given 2,147,483,648 should throw an error.', () => {
    expect(() => {
      solution(2147483648);
    }).toThrow();
  });

  // valid input boundary: 1
  test('Given 1 [0001] should return 0.', () => {
    expect(solution(1)).toBe(0);
  });

  // valid input boundary: 2,147,483,647
  test('Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.', () => {
    expect(solution(2147483647)).toBe(0);
  });

After adding the test cases to binary-gap.test.js, run the tests with:

npm test

or using the "watch mode" so the tests will run automatically and also using "verbose" to display more information about the test cases being executed:

npm run test -- --watch --verbose

And the test result is:

 PASS  00-template/solution-template.test.js
  Template Tests
    √ given -1 should throw an error (9 ms)
    √ given 1 should return 1. (1 ms)

 FAIL  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    × Given -1 should throw an error. (4 ms)
    × Given 0 should throw an error.
    × Given 2,147,483,648 should throw an error.
    × Given 1 [0001] should return 0. (1 ms)
    × Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.

Test Suites: 1 failed, 1 passed, 2 total
Tests:       5 failed, 2 passed, 7 total
Snapshots:   0 total
Time:    0.732 s, estimated 1 s

The solution-template.tests.js has 1 test suite and 2 unit tests - all passing.

The binary-gap.tests.js has 1 test suite and 5 unit tests - all failing.

A total of 2 test suites and 7 unit tests.

With the validations and boundaries in place, I can add more tests using the requirements in the problem description. Lets check some other numbers. These will be valid input numbers that should return valid output results. For example: 9, 529, 20, 15, 32, 1041.

In the test name, I added the converted binary number inside the backets to make it easier to understand: 9 decimal = [1001] binary.

Like this: 'Given 9 [1001] should return 2.'

Here are the unit tests:

  // valid input boundary: 1
  test('Given 1 [0001] should return 0.', () => {
    expect(solution(1)).toBe(0);
  });

  // valid input boundary: 2,147,483,647
  test('Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.', () => {
    expect(solution(2147483647)).toBe(0);
  });

  // test numbers from the problem description:
  test('Given 9 [1001] should return 2.', () => {
    expect(solution(9)).toBe(2);
  });
  test('Given 529 [0010.0001.0001] should return 4.', () => {
    expect(solution(529)).toBe(4);
  });
  test('Given 20 [0001.0100] should return 1.', () => {
    expect(solution(20)).toBe(1);
  });
  test('Given 15 [1111] should return 0.', () => {
    expect(solution(15)).toBe(0);
  });
  test('Given 32 [0010.0000] should return 0.', () => {
    expect(solution(32)).toBe(0);
  });
  test('Given 1041 [0100.0001.0001] should return 5.', () => {
    expect(solution(1041)).toBe(5);
  });

Run the tests again, and some of the tests will fail. This is expected.

I removed part of the results because they are very similar and I will focus on fixing one error at a time. Here is the test output:

 PASS  00-template/solution-template.test.js
  Template Tests
    √ given -1 should throw an error (10 ms)
    √ given 1 should return 1.

 FAIL  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    × Given -1 should throw an error. (5 ms)
    × Given 0 should throw an error. (1 ms)
    × Given 2,147,483,648 should throw an error. (1 ms)
    × Given 1 [0001] should return 0. (2 ms)
    × Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0. (1 ms)
    × Given 9 [1001] should return 2.
    × Given 529 [0010.0001.0001] should return 4. (1 ms)
    × Given 20 [0001.0100] should return 1.
    × Given 15 [1111] should return 0.
    × Given 32 [0010.0000] should return 0.
    × Given 1041 [0100.0001.0001] should return 5. (1 ms)

... more errors ...

Test Suites: 1 failed, 1 passed, 2 total
Tests:       11 failed, 2 passed, 13 total
Snapshots:   0 total
Time:    0.725 s, estimated 1 s

Write Some Code

Now it is time to start writing some functional code.

Note that I don't have a "main" or "index" as an application entry point calling the solution(N) function. This is intended and if I run npm start I will get an error. I want to test my function in isolation, provide multiple inputs and evaluate the results. This would be more difficult and time consuming to do without a test framework.

With the tests in place, I can now start writing the code to solve the problem. I may even go back and add more tests for other uses cases, but this is enough for now. TDD is an incremental approach.

The first thing I usually do is to add some validations to test the input parameters in the solution(N) function inside the binary-gap.js file.

First, for this statement in the problem description:

N is an integer within the range [1 .. 2,147,483,647].

I already have the unit tests, now it is time to write the functional code to address that.

// `binary-gap.js`
'use strict';

module.exports = function solution(N) {
  var maxGap = -1;

  // validations
  if (N < 1 || N > 2147483647) {
    throw new Error("Parameter is invalid!");
  }

  return maxGap;
}

Then run the tests again with:

npm test

And he result is:

 FAIL  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    √ Given -1 should throw an error. (11 ms)
    √ Given 0 should throw an error. (1 ms)
    √ Given 2,147,483,648 should throw an error. (1 ms)
    × Given 1 [0001] should return 0. (2 ms)
    × Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.
    × Given 9 [1001] should return 2.
    × Given 529 [0010.0001.0001] should return 4. (1 ms)
    × Given 20 [0001.0100] should return 1. (1 ms)
    × Given 15 [1111] should return 0. (1 ms)
    × Given 32 [0010.0000] should return 0. (1 ms)
    × Given 1041 [0100.0001.0001] should return 5. (1 ms)

Now I have some progress and the first 3 tests as passing! They check for numbers outside the scope (invalid inputs).

Next, I will start the problem/solution logic.

The first thing to consider is that my input number is a decimal number. I need to convert it to its binary representation.

In JavaScript, the simplest and most common method to convert a decimal number to its binary representation is by using the built-in toString() method with a radix of 2.

See Javascript Number.prototype.toString() reference at MDN.

// `binary-gap.js`
'use strict';

module.exports = function solution(N) {
  var maxGap = -1;

  // validations
  if (N < 1 || N > 2147483647) {
    throw new Error("Parameter is invalid!");
  }

  // first, convert the number to binary
  bin = N.toString(2);
  console.log(bin);

  return maxGap;
}

And run the tests again.

Looking at the test results again, I can plan the next steps.

 FAIL  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    √ Given -1 should throw an error. (11 ms)
    √ Given 0 should throw an error. (1 ms)
    √ Given 2,147,483,648 should throw an error. (1 ms)
    × Given 1 [0001] should return 0. (2 ms)
    × Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.
    × Given 9 [1001] should return 2.
    × Given 529 [0010.0001.0001] should return 4. (1 ms)
    × Given 20 [0001.0100] should return 1. (1 ms)
    × Given 15 [1111] should return 0. (1 ms)
    × Given 32 [0010.0000] should return 0. (1 ms)
    × Given 1041 [0100.0001.0001] should return 5. (1 ms)

  ● BinaryGap Tests › Given 1 [0001] should return 0.

    expect(received).toBe(expected) // Object.is equality

    Expected: 0
    Received: -1

      28 |   // valid input boundary: 1
      29 |   test('Given 1 [0001] should return 0.', () => {
    > 30 |     expect(solution(1)).toBe(0);
     |             ^
      31 |   });
      32 |
      33 |   // valid input boundary: 2,147,483,647

      at Object.toBe (01-Iterations/binary-gap.test.js:30:25)

The test results show which tests failed and some other important information:

BinaryGap Tests › Given 1 [0001] should return 0.

This tells me that:

Test Suite: 'BinaryGap Tests'
Unit Test: 'Given 1 [0001] should return 0.'
Expected: 0
Received: -1
test code: expect(solution(1)).toBe(0);

In summary: the test received the input parameter "1" and expected the result to be "0" but received "-1" instead.

The output will show where the unit test failed, not the functional code (there is no code yet!). So the first thing to do is look at this condition and write the functional code to fix this test.

Problem Logic

Note that I added the console.log(bin); after the conversion. The reason for that is to see what the result of the decimal to binary conversion is. This is important because depending on the language or the result returned from the binary conversion function, I may need to remove the trailing zeros (they can be discarded).

dec	bin	bytes
1	1	0001
5	101	0101
7	111	0111
9	1001	1001
32	100000	0010.0000

Note:

Here is one situation where it is OK to do a Google search. I usually work with multiple languages and environments (C#, C, C++, Python, JavaScript, PowerShell, T-SQL, TypeScript just to name a few) and there is no way to know all the syntaxes and parameters for all languages and functions.

But there is a difference between asking "how to convert decimal to binary in JavaScript" to "give me the solution to this problem so I can copy it". Sometimes in a real work situation it is necessary to just get one solution and apply it, instead of reinventing the wheel and creating your own solution. Viewer discretion is advised.

I will remove the console.log(bin); now, because it affects performance. It is OK to have it while developing/debugging, but it is ideal to remove before shipping the code (when the work is done).

Assuming there are no trailing 0's so that all binary numbers will start with 1 (see table above, column 'bin') and the converted binary number can be accessed as an array, I can use the index/array syntax:

  N = 5 (decimal)
  bin = 101 (binary)
then
  bin[0] = 1
  bin[1] = 0
  bin[2] = 1

Algorithm:

convert the decimal number to binary
iterate over the binary digits counting the 0's

Next, I will iterate over the binary digits and count the 0's. I added a new variable zeros = 0 to hold the count of 0's. After the loop, I need to assign maxGap = zeros; because I return maxGap.

    let maxGap = -1;
    let zeros = 0;
    // now iterate over the 0's and 1's and count
    for (var x = 0; x < bin.length; x++) {
    if (bin[x] == 0) {
        zeros++;
    }
    }
    maxGap = zeros;
    return maxGap;

Run the tests again:

 FAIL  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    √ Given -1 should throw an error. (10 ms)
    √ Given 0 should throw an error.
    √ Given 2,147,483,648 should throw an error.
    √ Given 1 [0001] should return 0. (1 ms)
    √ Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.
    √ Given 9 [1001] should return 2.
    × Given 529 [0010.0001.0001] should return 4. (4 ms)
    × Given 20 [0001.0100] should return 1. (1 ms)
    √ Given 15 [1111] should return 0. (1 ms)
    × Given 32 [0010.0000] should return 0. (2 ms)
    × Given 1041 [0100.0001.0001] should return 5. (1 ms)

  ● BinaryGap Tests › Given 529 [0010.0001.0001] should return 4.

This is interesting, the failed tests tell me that the returned value is wrong when I have more than one gap: 529 [0010.0001.0001] and 20 [0001.0100] or when there is no 1 closing the last gap [100000].

To fix that I will need to modify my main loop and add some more checks. I need to check for 1's too (closing gap).

    // now iterate over the 0's and 1's and count
    for (var x = 0; x < bin.length; x++) {
    if (bin[x] == 0) { // means that there is gap
        zeros++;
    }
    if (bin[x] == 1) { // means that the gap ended
        // if the gap ended, check if this is biggest found
        if (zeros > maxGap) {
        maxGap = zeros;
        }
        // reset the zero counter
        zeros = 0;
    }
    }
    return maxGap;

Run the tests again:

 PASS  00-template/solution-template.test.js
  Template Tests
    √ given -1 should throw an error (10 ms)
    √ given 1 should return 1.

 PASS  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    √ Given -1 should throw an error. (11 ms)
    √ Given 0 should throw an error. (1 ms)
    √ Given 2,147,483,648 should throw an error.
    √ Given 1 [0001] should return 0. (1 ms)
    √ Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.
    √ Given 9 [1001] should return 2. (1 ms)
    √ Given 529 [0010.0001.0001] should return 4.
    √ Given 20 [0001.0100] should return 1. (1 ms)
    √ Given 15 [1111] should return 0.
    √ Given 32 [0010.0000] should return 0. (1 ms)
    √ Given 1041 [0100.0001.0001] should return 5.

Test Suites: 2 passed, 2 total
Tests:       13 passed, 13 total
Snapshots:   0 total
Time:    0.854 s, estimated 1 s

And we have a solution!

Now I can start improving the solution, cleaning up the code, adding more tests.

Just to be sure, I went back to the Codility site and tested my solution there. The site also show some other unit tests, so I added them to my test suite too.

And ran the tests again.

 PASS  00-template/solution-template.test.js
  Template Tests
    √ given -1 should throw an error (10 ms)
    √ given 1 should return 1. (1 ms)

 PASS  01-Iterations/binary-gap.test.js
  BinaryGap Tests
    √ Given -1 should throw an error. (13 ms)
    √ Given 0 should throw an error. (1 ms)
    √ Given 2,147,483,648 should throw an error. (1 ms)
    √ Given 1 [0001] should return 0.
    √ Given 2147483647 [0111.1111.1111.1111.1111.1111.1111.1111] should return 0.
    √ Given 9 [1001] should return 2.
    √ Given 529 [0010.0001.0001] should return 4. (1 ms)
    √ Given 20 [0001.0100] should return 1.
    √ Given 15 [1111] should return 0.
    √ Given 32 [0010.0000] should return 0.
    √ Given 1041 [0100.0001.0001] should return 5.
    √ Given 64 [0100.0000] should return 0. (1 ms)
    √ Given 132 [1000.0100] should return 4.
    √ Given 133 [1000.0101] should return 4.
    √ Given 5 [0101] should return 1.
    √ Given 6 [0110] should return 0.
    √ Given 9 [1001] should return 2.
    √ Given 11 [1011] should return 1. (1 ms)
    √ Given 16 [0001.0000] should return 0.
    √ Given 19 [0001.0011] should return 2. (1 ms)
    √ Given 42 [0010.1010] should return 1.
    √ Given 328 [0001.0100.1000] should return 2. (1 ms)
    √ Given 1024 [0100.0000.0000] should return 0.
    √ Given 1162 [0100.1000.1010] should return 3.
    √ Given 51712 [0110.0101.0000.0000] should return 2. (1 ms)
    √ Given 561892 [1000.1001.0010.1110.0100] should return 3.
    √ Given 66561 [0001.0000.0100.0000.0001] should return 9.
    √ Given 6291457 [0110.0000.0000.0000.0000.0001] should return 20. (1 ms)
    √ Given 74901729 [0100.0111.0110.1110.1000.1110.0001] should return 4.
    √ Given 805306373 [0011.0000.0000.0000.0000.0000.0000.0101] should return 25.
    √ Given 1376796946 [0101.0010.0001.0000.0100.0001.0001.0010] should return 5.
    √ Given 1073741825 [0100.0000.0000.0000.0000.0000.0000.0001] should return 29. (1 ms)
    √ Given 1610612737 [0110.0000.0000.0000.0000.0000.0000.0001] should return 28.

Test Suites: 2 passed, 2 total
Tests:       35 passed, 35 total
Snapshots:   0 total
Time:    0.882 s, estimated 1 s
Ran all test suites related to changed files

Suggestions

Sometimes, when working on a problem it is better to use Pseudocode to think about the algorithm logic, this way I don't have to worry about the syntax or language construction rules.

Something like this:

  let maxGap = 0; // max gap found
  let zeros = 0; // zero counter

  // convert input N to bin
  let n = ConvertToBinary(N);

  // example:
  // N = 5 (decimal) => n = 101 (binary)
  // so
  // n[0] = 1
  // n[1] = 0
  // n[2] = 1

  // loop through all binary digits
  for x = 0 to n.length:
    if x == 0 then
      // n[0] = 1 first digit
      skip // do nothing
    end if
    if x > 0 then
      // second digit and on
      // check if is 0
      if n[x] == 0 then // it is a 0 gap
    // increase out counter
    zeros++
      end if
      // save the maxGap number
      maxGap = zeros
    end if
  next x
  return maxGap

Then it is easier later to find the correct syntax for the language I am using.

Codility Lessons Using TDD

2025-11-01T00:00:00Z

Codility Lessons

The goal of this project is to show how to solve coding problems using TDD - Test Driven Development.

In the process of learning or during a coding interview, the process (how) is much more important than the result itself. If I only needed a solution I could simply Google it or use AI. Your final solution may not even be complete, but through multiple iterations it can always be improved. There are many ways to solve a problem as you will see if you look for solutions on the Internet. In a real world scenario, the solution may not be easily available, and some exploration, thinking and refactoring may be necessary.

I will take a step-by-step approach showing the steps that any interviewer would like to see, providing explanations along the way. In order to solve any problem, you need to understand it first. Then take gradual iterations, sometimes by trial and error, until a solution is achieved. This is how things work in a company or the real world.

For the purpose of this exercise, I will use JavaScript since it is one of the most popular languages and requires less setup and tools. Maybe later I will expand it to other languages like C# or Python. I like to do this exercise to learn other languages or understand how it works.

I will use the Test Driven Development (TDD) approach, writing the tests first then the code. This allows for more experimentation and helps with correctness. The Codility tool will generate a suite of tests to validate the solution, but I can start with the information provided in the problem description. Codility also has a timer, which I don't like - so running it locally can be less stressful.

Lessons

For this I will use the Codility Developer Training site lessons. Please go ahead visit the site, create an account there and start exploring the lessons.

Each problem description will be copied here to make it easier to follow.

Setup

I assume you have a computer and access to the Internet. A Windows, Linux or MacOS machine and some familiarity with the console (command line or terminal).

Tools

First, install the development tools. If you don't have it, please install:

Node.JS (any LTS version is good).
Visual Studio Code (or any other IDE that you like, even Notepad++ will do).

I decided to use Node.JS and JavaScript so it can run on Mac, Windows or Linux. Also, it can run on "watch mode" re-running tests automatically after any file changed.

Project

Next, I create a new project and install Jest to run the tests (you can use Mocha or Jasmine if you like). Open the console or terminal, create a new folder for the project and then type (inside the project folder):

npm init --yes

npm install --save-dev jest

Then modify the package.json file to run the tests:

"scripts": {
    "test": "jest"
  },

Then you can run the tests with:

npm test

To run in "watch mode":

npm run test -- --watch

Or to show more information:

npm run test -- --verbose

Next, create sub-folders, one for each lesson (to make it easy to find and keep it organized):

mkdir 01-Iterations
mkdir 02-Arrays
mkdir 03-Time-Complexity
mkdir 04-Counting-Elements
mkdir 05-Prefix-Sums
mkdir 06-Sorting
mkdir 07-Stacks-and-Queues
mkdir 08-Leader
mkdir 09-Maximum-Slice-Problem
mkdir 10-Prime-and-Composite-Numbers
mkdir 11-Sieve-of-Eratosthenes
mkdir 12-Euclidean-Algorithm
mkdir 13-Fibonacci-Nnumbers
mkdir 14-Binary-Search-Algorithm
mkdir 15-Caterpillar-Method
mkdir 16-Greedy-Algorithms
mkdir 17-Dynamic-Programming

Now I am ready to starting solving some problems using TDD. Here I will start with the first lesson (warm-up), but the setup process will be the same for all.

Template

Since I will be working on multiple problems and they all start the same way, I will create a template so I can duplicate it for each new problem and start from there.

The first file is the solution code and it is called "solution-template.js":

// solution-template.js
'use strict';

module.exports = function solution(N) {
  // your code here
  return 1;
}

The other file is the test suite for this problem called "solution-template.test.js":

// solution-template.test.js
'use strict';

const solution = require("./solution-template");

describe('solution-template tests', () => {

  test('given 1 should return 1.', () => {
    expect(solution(X)).toBe(Y);
  });

});

And with that I can just run npm test and see the results:

PS > npm test

> codility-javascript@1.0.0 test
> jest

 PASS  00-template/solution-template.test.js
  Template Tests
    √ given 1 should return 1. (2 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:    0.492 s, estimated 1 s
Ran all test suites.

Here I have

one Test Suite defined with "describe()" and
one Unit Test defined with "test()".

The Problems

The problems were copied from the Codility web site. I recommend you go there create an account and try to solve the problems there too.

For detailed step-by-step approach, analysis and solution to each problem, check the links bellow:

Solutions

Lesson-01 - Iterations
- BinaryGap
Lesson-02 - Arrays
- CyclicRotation
- OddOccurrencesInArray
Lesson-03 - Time Complexity
Lesson-04 - Counting Elements
Lesson-05 - Prefix Sums
Lesson-06 - Sorting
Lesson-07 - Stacks and Queues
- Brackets
- Fish
- Nesting
- StoneWall
Lesson-08 - Leader
- Dominator
- EquiLeader
Lesson-09 - Maximum slice problem
Lesson-10 - Prime and composite numbers
Lesson-11 - Sieve of Eratosthenes
- CountNonDivisible
- CountSemiprimes
Lesson-12 - Euclidean algorithm
- ChocolatesByNumbers
- CommonPrimeDivisors
Lesson-13 - Fibonacci numbers
- FibFrog
- Ladder
Lesson-14 - Binary search algorithm
- MinMaxDivision
- NailingPlanks
Lesson-15 - Caterpillar method
Lesson-16 - Greedy algorithms
- MaxNonoverlappingSegments
- TieRopes
Lesson-17 - Dynamic programming
- NumberSolitaire
- MinAbsSum

SOLID Principles

2019-10-06T00:00:00Z

SOLID Principles

Single Responsibility Principle (S.R.P)

A class should have one, and only one, reason to change.

A Class should be responsible for a single task.

A Class should have only a single responsibility.

Open-Closed Principle

You should be able to extend a class’s behavior, without modifying it.

Open for extension but closed for modification.

A Class should be open to extension and close to modification.

Software entities … should be open for extension, but closed for modification.

Liskov Substitution Principle

Derived classes must be substitutable for their base classes.

A derived Class can be substituted at places where base Class is used.

Objects in a program should be replaceable with instances of their sub-types without altering the correctness of that program.

Interface Segregation Principle

Make fine grained interfaces that are client specific.

Clients should not be forced to implement interfaces they do not use.

Don’t make FAT Interfaces. i.e. Classes don’t have to override extra agreements that are not needed for that Class simply because it is there in interface.

Many client-specific interfaces are better than one general-purpose interface.

Dependency Inversion Principle

Depend on abstractions, not on concretions. Not only high level Classes but low level Classes also depend on the abstractions in order to decouple the code.

A. High level modules should not depend upon low level modules. Both should depend upon abstractions.
B. Abstractions should not depend upon details. Details should depend upon abstractions.

But don't get confused with the terms:

Dependency Injection,
Dependency Inversion,
Inversion of Control,
IoC Container.

One should “depend upon abstractions, [not] concretions.”

Examples

Single Responsibility Principle

If one class does more than one thing, it should be split into multiple classes. For example, an User class:

class User {
	public bool validateUser(user){
	...
	}
	public user formatUser(user){
	...
	}
	public user getUserFromDb(id){
	...
	}
}

Open-Close Principle

For example, an authentication module which requires username and password to login. You code a login module and perform login for that user.

class LoginModule
{
	public bool loginUser(user)
	{
		if(normalUser) {
			authenticateNormalUser(user);
		}
		else if (thirdPartyUser) {
			authenticateGoogleUser(user);
		}
	}
}

In this case to add a new type of authentication, the original class has to change.

What to do?

Separate the login behaviour behind an interface and create separate Classes for normal login and third party login to flip the dependencies.

Any new person who wants to write a whole different login module functionality for a different set of users will create their own login module’s Class and implement the login interface (the functions that Login interface has as agreements).

interface LoginInterface
{
	public AuthenticateUser(user);
}

class NormalLogin : LoginInterface
{
	public bool AuthenticateUser(user)
	{ ... }
}
class ThirdpartyLogin : LoginInterface
{
	public bool AuthenticateUser(user)
	{ ... }
}

class LoginModule
{
	public bool login(user)
	{
		user.AuthenticateUser(user);
	}
}

Liskov Substitution

For example, a child class return a different type than its parent class.

Interface Segregation Principle

It states that a client must not be forced to implement an interface that it doesn’t use. The result is fined grained interfaces

Dependency Inversion Principle

It states that High level modules should never depend on Low level modules, instead the High level module can depend upon an abstraction and the Low level module depends on that same abstraction.

WebService vs WebApi

2018-10-21T00:00:00Z

Web Service vs Web API

What are the differences between a WebService and Web API?

Both are means of communication between consumers and providers over a network.

Web Service

Definition from W3C:

A Web service is a software system designed to support interoperable machine-to-machine interaction over a network. It has an interface described in a machine-processable format (specifically WSDL). Other systems interact with the Web service in a manner prescribed by its description using SOAP-messages, typically conveyed using HTTP with an XML serialization in conjunction with other Web-related standards.

Main points:

Web Service communicate using XML.
A client invokes a web service by sending a XML request message
The service sends back an XML response
SOA (service oriented architecture), rely on XML-RPC and SOAP (Simple Object Access Protocol)
Highly coupled - the client calls a remote procedure

w3schools

dne

Web Api

The term "API" stands for Application Programming Interface.

In practice, an API is "a set of functions and procedures" that allow you to access and build upon the data and functionality of an existing application.

Web APIs expose an application’s data and functionality over the internet. Web APIs usually send data back and forth using HTTP requests. These requests often return textual data in the form of a JSON or XML response.

Main points:

Uses HTTP protocol
The client doesn't need to know what procedure to call on the server
HTTP verbs (GET, PUT, POST, DELETE)
Loosely coupled
RESTful APIs
Data payloads can be of multiple types such as JSON or XML

Example of endpoints:

http://api.plos.org/search?q=title:DNA

http://api.plos.org/search?q=title:Drosophila&fl=id,abstract

WebAPI does not expose it's methods, I used Swagger (https://swagger.io) to generate my API documentation

Unfortunately, most of these APIs do not come with any specification that developers (and machines) can rely on to automatically understand and integrate them. Instead, most of the time we have to rely on reading its ad-hoc documentation web pages, despite the existence of languages to model Web APIs like Swagger or, more recently, OpenAPI that developers could use to formally describe their APIs.

Calling a WebService in C#

Using Visual Studio, you add a Service Reference to the WebService URL:

http://www.dneonline.com/calculator.asmx

This will add references to .csproj file and web.config or app.config. It will also create a file in the project:

"\Service References\CalculatorSvc\Reference.cs"

describing all the methods no inside the code we instanciate the object and call the method:

using WebTest.CalculatorSvc;
namespace WebTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var calc = new CalculatorSoapClient();
            var res1 = calc.Add(10,20);
            Console.WriteLine("Result: "+ res);
        }
    }
}

Here we have to call the method

"Add(int intA, int intB)"

Calling a Web API in C#

To call a web API from a .NET application, there are several ways using:

HttpWebRequest/Response Class
WebClient Class
HttpClient Class
RestSharp NuGet Package
ServiceStack Http Utils
Flurl

example

Using System.Net.Http.HttpClient, endpoint:

https://reqres.in/api/users

namespace WebTest
{
    public class TestApi
    {
        private static readonly HttpClient client = new HttpClient();

        public string GetUsers()
        {
            string Url = "https://reqres.in/api/users/2";
            var result = "";

            // Add an Accept header for JSON format.
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            var response = client.GetStringAsync(Url).Result; //blocking, I know...
            return response;
        }
    }
}

Aditional Information

Url: https://www.xtm-cloud.com/project-manager-gui/services/v2/customer/XTMWebService?wsdl

Notice the "?wsdl" at the end:

WSDL stands for Web Services Description Language.

An WSDL document describes a web service. It specifies the location of the service, and the methods of the service, using these major elements:

<types> Defines the (XML Schema) data types used by the web service
<message> Defines the data elements for each operation
<portType> Describes the operations that can be performed and the messages involved.
<binding> Defines the protocol and data format for each port type

W3Schools

Wikipedia

WSDL

WSDL is an XML format for describing network services as a set of endpoints operating on messages containing either document-oriented or procedure-oriented information. The operations and messages are described abstractly, and then bound to a concrete network protocol and message format to define an endpoint. Related concrete endpoints are combined into abstract endpoints (services). WSDL is extensible to allow description of endpoints and their messages regardless of what message formats or network protocols are used to communicate, however, the only bindings described in this document describe how to use WSDL in conjunction with SOAP 1.1, HTTP GET/POST, and MIME.

SOAP

https://en.wikipedia.org/wiki/SOAP

SOAP (originally Simple Object Access Protocol) is a messaging protocol specification for exchanging structured information in the implementation of web services in computer networks. Its purpose is to induce extensibility, neutrality and independence. It uses XML Information Set for its message format, and relies on application layer protocols, most often Hypertext Transfer Protocol (HTTP) or Simple Mail Transfer Protocol (SMTP), for message negotiation and transmission.

SOAP allows processes running on disparate operating systems (such as Windows and Linux) to communicate using Extensible Markup Language (XML). Since Web protocols like HTTP are installed and running on all operating systems, SOAP allows clients to invoke web services and receive responses independent of language and platforms.

REST

https://en.wikipedia.org/wiki/Representational_state_transfer

Representational State Transfer (REST) is an architectural style that defines a set of constraints to be used for creating web services. Web services that conform to the REST architectural style, or RESTful web services, provide interoperability between computer systems on the Internet. REST-compliant web services allow the requesting systems to access and manipulate textual representations of web resources by using a uniform and predefined set of stateless operations. Other kinds of web services, such as SOAP web services, expose their own arbitrary sets of operations.[1]

https://api.example.com/resources/
	GET 	List the URIs and perhaps other details of the collection's members.
	PUT		Replace the entire collection with another collection.
	PATCH	Not generally used
	POST	Create a new entry in the collection. The new entry's URI is assigned automatically and is usually returned by the operation.[17]
	DELETE	Delete the entire collection.

https://api.example.com/resources/item17
	GET 		Retrieve a representation of the addressed member of the collection, expressed in an appropriate Internet media type.
	PUT			Replace the addressed member of the collection, or if it does not exist, create it.
	PATCH		Update the addressed member of the collection.
	POST		Not generally used. Treat the addressed member as a collection in its own right and create a new entry within it.[17]
	DELETE		Delete the addressed member of the collection.

XML-RPC

https://en.wikipedia.org/wiki/XML-RPC

XML-RPC is a remote procedure call (RPC) protocol which uses XML to encode its calls and HTTP as a transport mechanism.[1] "XML-RPC" also refers generically to the use of XML for remote procedure call, independently of the specific protocol. This article is about the protocol named "XML-RPC".

RSDL

http://www.balisage.net/Proceedings/vol10/html/Robie01/BalisageVol10-Robie01.html

RESTful Service Description Language (RSDL) provides a description of the structure and elements in the the REST API in one whole XML specification. Invoke the RSDL using the following request.

GET /api?rsdl HTTP/1.1
Accept: application/xml

Links

https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Virtualization/3.1/html/Developer_Guide/sect-Developer_Guide.entry_Point-RSDL.html

https://modeling-languages.com/automatic-discovery-web-api-specifications/

https://swagger.io/resources/articles/best-practices-in-api-documentation/ https://modeling-languages.com/modeling-web-api-comparing/

References

https://blogs.mulesoft.com/dev/api-dev/apis-versus-web-services/

https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/calling-a-web-api-from-a-net-client

Learn a New Skill

2016-01-08T00:00:00Z

Learn a New Skill

Here are some steps to help you learn a new skill:

Deconstruct the skill
Learn enough to self-correct
Remove practice barriers
Practice at least 20 hours

So, before you pick a skill to focus on this month, your first step should be identifying those that will be most important for your future. Ask yourself:

What gaps in knowledge do I have for my job (or the job I want)?
What skills do those around me (and above me) have that I don't?
What gaps in knowledge are there on my team that I could fill?
What characteristics does my boss value most?

Ref: link