DEV Community: Bukunmi Odugbesan

Coding Challenge Practice - Question 120

Bukunmi Odugbesan — Tue, 17 Feb 2026 21:35:40 +0000

The task is to write a function to remove duplicate characters in a string

function smallestUniqueSubstr(str) {
  // your code here
}

Count the remaining occurrences of each character. This stores how many times each character appears

const remaining = {};
for(const ch of str) {
remaining[ch] = (remaining[ch] || 0) + 1;
}

Create data structures to build the final result and ensure uniqueness

const stack = []
const inStack = new Set()

Iterate through the string. Decrease the count as the character is being processed

for(const ch of str) {
remaining[ch]--

Skip the character if it has already been added to the result

if(inStack.has(ch)) return;

Remove characters from the stack if the stack is not empty, the current character is smaller top character, and the top character is greater than zero

while(
  stack.length > 0 &&
  stack[stack.length - 1] > ch &&
  remaining[stack[stack.length -1]] > 0
) {
  inStack.delete(stack.pop());
}

Add the current character to the result if all conditions are not met

stack.push(ch);
inStack.add(ch);

Return the final result

return stack.join('')

The final solution

function smallestUniqueSubstr(str) {
  // your code here
  const remaining = {};
  for(const ch of str) {
    remaining[ch] = (remaining[ch] || 0) + 1
  }

  const inStack = new Set();
  const stack = [];

  for(const ch of str) {
    remaining[ch]--;

    if(inStack.has(ch)) continue;

    while(stack.length > 0 && stack[stack.length - 1] > ch && 
    remaining[stack[stack.length -1]] > 0) {
      inStack.delete(stack.pop());
    }
    stack.push(ch);
    inStack.add(ch);
  }
  return stack.join('')
}

That's all folks!

Coding Challenge Practice - Question 119

Bukunmi Odugbesan — Thu, 12 Feb 2026 22:34:51 +0000

The task is to implement a function that validates IPv4 and IPv6 IP addresses.

The boilerplate code

function isValidIP(str) {
  // your code here
}

A valid IPv4 address should be in 4 parts, separated by ".", and should contain digits between 0 and 255, with no number having a leading zero. Create a function to validate those parameters

function isValidIPv4(ip) {
}

Each part should be separated by "."

const parts = ip.split(".");

There must be exactly 4 parts

if(parts.length !== 4) return false;

If the number is less than zero or greater than 255, it is not a valid IPv4 address. The number should also not have a leading 0.

for (const part of parts) {
    if (!/^\d+$/.test(part)) return false;
    if (part.length > 1 && part[0] === '0') return false;

    const num = Number(part);
    if (num < 0 || num > 255) return false;
  }
  return true;
}

The complete function to validate an IPv4 address

function isValidIPv4(ip) {
  const parts = ip.split('.');
  if (parts.length !== 4) return false;

  for (const part of parts) {
    if (!/^\d+$/.test(part)) return false;
    if (part.length > 1 && part[0] === '0') return false;

    const num = Number(part);
    if (num < 0 || num > 255) return false;
  }
  return true;
}

A valid IPv6 address is exactly 8 parts, separated by ":". Each part contains 1 to 4 characters in hex digits. Create a function to validate these parameters.

function isValidIPv6(ip) {
}

Each part must be separated by ":"

const parts = ip.split(":");

There must be exactly 8 parts

if(parts.length !== 8) return false;

If the part has fewer than 1 or more than 4 characters, it is invalid. The characters should also follow the hex code

for (const part of parts) {
    if (part.length < 1 || part.length > 4) return false;
    if (!/^[0-9a-fA-F]+$/.test(part)) return false;
  }

The complete function to validate an IPv6 address.

function isValidIPv6(ip) {
  const parts = ip.split(':');
  if (parts.length !== 8) return false;

  for (const part of parts) {
    if (part.length < 1 || part.length > 4) return false;
    if (!/^[0-9a-fA-F]+$/.test(part)) return false;
  }
  return true;
}

The address could either be an IPv4 or IPv6 address. If it is an IPv4 address, it would contain "."

if(str.includes('.')) {
    return isValidIPv4(str) ? true : false;
  }

If it is an IPv6 address, it would contain ":"

if(str.includes(':')) {
    return isValidIPv6(str) ? true : false;
  }

"." and ":" are the first differentiators, before the address are further validated with either function. The final code

function isValidIP(str) {
  // your code here
  if(str.includes('.')) {
    return isValidIPv4(str) ? true : false;
  }

  if(str.includes(':')) {
    return isValidIPv6(str) ? true : false;
  }
  return false;
}

function isValidIPv4(ip) {
  const parts = ip.split('.');
  if(parts.length !== 4) return false;

  for(const part of parts) {
    if(!/^\d+$/.test(part)) return false;
    if(part.length > 1 && part[0] === '0') return false;

    const num = Number(part);
    if(num < 0 || num > 255) return false;
  }
  return true;
}

function isValidIPv6(ip) {
  const parts = ip.split(':');
  if(parts.length !== 8) return false;

  for(const part of parts) {
    if(part.length < 1 || part.length > 4) return false;
    if(!/^[0-9a-fA-F]+$/.test(part)) return false;
  }
  return true;
}

That's all folks!

Coding Challenge Practice - Question 118

Bukunmi Odugbesan — Tue, 10 Feb 2026 22:34:27 +0000

The task is to implement a function to add class names.

The boilerplate code

function classNames(...args) {
  // your code here
}

The function should combine different kinds of input into one space-separated string.

Create a variable to store the result

const result = []

If the argument is not a string, number, array, or object, skip it.

const process = (arg) => {
    if (!arg) return;

If the argument is a string or a number, push is immediately

if (typeof arg === 'string' || typeof arg === 'number') {
      result.push(arg);
      return;
    }

If the argument is an array, loop through it again (recursion)

if (Array.isArray(arg)) {
      arg.forEach(process);
      return;
    }

If the argument is an object, check each key's value


    if (typeof arg === 'object') {
      for (const key in arg) {
        if (arg[key]) {
          result.push(key);
        }
      }
    }

The final code

function classNames(...args) {
  // your code here
  const result = [];

  const process = (arg) => {
    if(!arg) return;

    if(typeof arg === 'string' || typeof arg === "number") {
      result.push(arg);
      return;
    }
    if(Array.isArray(arg)) {
      arg.forEach(process);
      return;
    }
    if(typeof arg === 'object') {
      for(const key in arg) {
        if(arg[key]) {
          result.push(key);
        }
      }
    }
  }
  args.forEach(process);

  return result.join(' ');
}

That's all folks!

Coding Challenge Practice - Question 117

Bukunmi Odugbesan — Mon, 09 Feb 2026 14:25:37 +0000

The task is to implement an enhanced debounce which has an option to invoke right away or after a delay.

The boilerplate code

function debounce(func, wait, option = {leading: false, trailing: true}) {
  // your code here
}

Keep track of the delay required and the latest call data

let timer = null;
let lastArgs;
let lastThis;

When the function is called, clear any existing timer and start a new one

return function(...args) {
lastArgs = args;
lastThis = this;

if(timer) clearTimeout(timer);

If there is no active timer, the function executes immediately on first call.

const shouldCallNow = option.leading && !timer

if(shouldCallNow) {
func.apply(lastThis, lastArgs)
lastArgs = lastThis = null;
}

If there is a timer, the function executes after a waiting period expires

timer = setTimeout(() => {
timer = null;
if(option.trailing && lastArgs) {
func.apply(lastThis, lastArgs)
lastArgs = lastThis = null;
}
}, wait)

The final code

function debounce(func, wait, option = {leading: false, trailing: true}) {
  // your code here
  let timer = null;
  let lastArgs;
  let lastThis;

  return function(...args) {
    lastArgs = args;
    lastThis = this;

    const shouldCallNow = option.leading && !timer;

    if(timer) clearTimeout(timer);

    timer = setTimeout(() => {
      timer = null;

      if(option.trailing && lastArgs) {
        func.apply(lastThis, lastArgs)
        lastArgs = lastThis = null;
      }
    }, wait)
    if(shouldCallNow) {
      func.apply(lastThis, lastArgs);
      lastArgs = lastThis = null;
    }
  }
}

That's all folks!

Coding Challenge Practice - Question 116

Bukunmi Odugbesan — Sat, 07 Feb 2026 17:30:22 +0000

The task is to implement Promise.prototype.finally()

The boilerplate code

function myFinally(promise, onFinally) {
  // your code here
}

Promise.prototype.finally() could be used to return a callback when a promise is settled (fulfilled or rejected).

Attach .then to resolve the promise

return promise.then(

If the promise was fulfilled

(value) => {
return Promise.resolve(onFinally && onFinally()).then(() => value)
}

Promise.resolve is used because it converts normal value to a resolved promise.

If the promise is rejected

(error) => {
return Promise.resolve(onFinally && onFinally()).then(() => {
throw error
}

The final code

function myFinally(promise, onFinally) {
  // your code here
  return promise.then(
    (value) => {
      return Promise.resolve(onFinally && onFinally()).then(() => value);
    },
    (error) => {
      return Promise.resolve(onFinally && onFinally()).then(() => {
        throw error
      })
    }
  )
}

That's all folks!

Coding Challenge Practice - Question 115

Bukunmi Odugbesan — Thu, 05 Feb 2026 22:35:08 +0000

The task is to implement memoizeOne().

The boilerplate code

function memoizeOne(func, isEqual) {
  // your code here
}

memoizeOneis a lightweight memoization function that caches only the most recent function call result.

Previous arguments, result and context have to be stored. And also need to track if it has been called (subsequent calls should return cached value)

lastArgs = undefined
lastResult = undefined;
lastThis = undefined;
hasBeenCalled = false;

On the first call, mark that the function has been called, store arguments and context, cache and return the result.

if(!hasBeenCalled) {
  hasBeenCalled = true;
  lastArgs = args;
  lastThis = this;
  lastResult = func.apply(this, args);
  return lastResult;
}

Check if the next function call is the same as the previous

const equalityCheck = isEqual || defaultIsEqual;

Also, ensure that the context of execution is the same

if(this === lastThis && equalityCheck(args, lastArgs)) {
  return lastResult;
}

The function to check each function call.

function defaultIsEqual(args1, args2) {

If the length of both arguments are not equal, the functions are not

 if(args1.length !== args2.length) {
    return false;
  }

Check each argument strictly

 for(let i = 0; i < args1.length; i++) {
    if(args1[i] !== args2[i]) {
      return false;
    }
  }

  return true;

The final code

function memoizeOne(func, isEqual) {
  // your code here
  let lastArgs = undefined;
  let lastResult = undefined;
  let hasBeenCalled = false;
  let lastThis = undefined;

  return function (...args) {
    if(!hasBeenCalled) {
      hasBeenCalled = true;
      lastArgs = args; 
      lastThis = this;
      lastResult = func.apply(this, args);
      return lastResult
    }

    const equalityCheck = isEqual || defaultIsEqual;

    if(this ===lastThis && equalityCheck(args, lastArgs)) {
      return lastResult;
    }

    lastArgs = args;
    lastThis = this;
    lastResult = func.apply(this, args);
    return lastResult;
  }
}

function defaultIsEqual(args1, args2) {
  if(args1.length !== args2.length) {
    return false;
  }

  for(let i = 0; i < args1.length; i++) {
    if(args1[i] !== args2[i]) {
      return false;
    }
  }
  return true;
}

That's all folks!

Coding Challenge Practice - Question 114

Bukunmi Odugbesan — Wed, 04 Feb 2026 13:26:28 +0000

The task is to find the n-th Fibonacci number.

The boilerplate code

function fib(n) {
  // your code here
}

Fibonacci numbers are the sum of the previous 2 numbers in the Fibonacci sequence. It starts from 0, 1,..., then the addition starts.

If the n-th Fibonacci number is less than or equal to 1, return the value of n

if(n <= 1) return n;

Create the variables of the numbers to be added

let prev = 0;
let curr = 1;

To find the n-th number, keep adding the previous and the current number till n is reached

for(let i = 2; i <= n; i++) {
 const next = prev + curr;
   prev = curr;
   curr = next;
}
return curr;

After addition, the current becomes the previous, and the next becomes the current, till n is reached.

The final code

function fib(n) {
  // your code here
  if(n <= 1) return n;

  let prev = 0;
  let curr = 1;

  for(let i = 2; i <= n; i++) {
    const next = prev + curr;
    prev = curr;
    curr = next;
  }

  return curr;
}

That's all folks!

Coding Challenge Practice - Question 113

Bukunmi Odugbesan — Tue, 03 Feb 2026 15:39:51 +0000

The task is to implement _.get().

The boilerplate code

function get(source, path, defaultValue = undefined) {
  // your code here
}

_.get() is a handy method for retrieving data from an arbitrary object.

source is the Object being read. path is where to look. defaultValue is where to return to if lookup fails.

If the source does not exist, return the value

if(source === null) return defaultValue;

If the path is empty or invalid, return the default value

if(path === null || (Array.isArray(path) && path.length === 0) || path === '') {
    return defaultValue;
  }

Normalise the path

const pathArray = Array.isArray(path)
  ? path
  : path
      .replace(/\[(\w+)\]/g, '.$1')
      .replace(/^\./, '')
      .split('.');

Traverse the object one key at a time

let result = source;

for (let key of pathArray) {

If the property cannot be read or the property does not exist, return the default value

if (result === null || !(key in result)) {
  return defaultValue;
}

Update the result to the next nested value

result = result[key];

Return the final value

return result

The final code

function get(source, path, defaultValue = undefined) {
  // your code here
  if(source === null) return defaultValue;

  if(path === null || (Array.isArray(path) && path.length === 0) || path === '') {
    return defaultValue;
  }

  const pathArray = Array.isArray(path) ? path 
  : path
        .replace(/\[(\w+)\]/g, '.$1')
        .replace(/^\./, '') 
        .split('.');

  let result = source;

  for(let key of pathArray) {
    if(result === null || !(key in result)) {
      return defaultValue;
    }
    result = result[key];
  }
  return result;
}

That's all folks!

Coding Challenge Practice - Question 112

Bukunmi Odugbesan — Mon, 02 Feb 2026 15:43:22 +0000

The task is to implement setInterval.

the boilerplate code

function mySetInterval(func, delay, period) {
  // your code here
}

/**
 * @param { number } id
 */
function myClearInterval(id) {

}

Create the global states

let nextId = 1;
const intervals = new Map()

nextId simulates browser-generated interval IDs and intervals keep track of active intervals.

Create a progressive interval

func mySetInterval(func, delay, period) {

Create an ID

const id = nextId++;

It ensures every interval has a unique identifier.

Create an interval state

const state = {
  active: true,
  count: 0,
  timeoutId: null
}

active stops future executions when cleared. count is the number of times the function has been run. timeoutId is the current setTimeout reference.

Each period after every time the function runs is determined by

const waitTime = delay + period * state.count;

Execute and reschedule

state.timeoutId = setTimeout(() => {
  if (!state.active) return;

  func();
  state.count++;
  schedule();
}, waitTime);

Start the first timer

schedule();
intervals.set(id, state);

Return ID

return id;

To clear the interval after it runs

function myClearInterval(id) {

If the interval doesn't exist, do nothing

const state = intervals.get(id);
if (!state) return;

Stop future executions

state.active = false;

Cancel pending timeout

clearTimeout(state.timeoutId);

Remove the interval from tracking

intervals.delete(id);

The final code

let nextId = 1;
const intervals = new Map();
function mySetInterval(func, delay, period) {
  // your code here
  const id = nextId++;

  const state = {
    active: true,
    count: 0,
    timeoutId: null
  }

  function schedule() {
    const waitTime = delay + period * state.count;

    state.timeoutId = setTimeout(() => {
      if(!state.active) return;

      func();
      state.count++;
      schedule();
    }, waitTime)
  }

  schedule();
  intervals.set(id, state);

  return id;
}


function myClearInterval(id) {
  const state = intervals.get(id);
  if(!state) return;

  state.active = false;
  clearTimeout(state.timeoutId);
  intervals.delete(id)
}

That's all folks!

Coding Challenge Practice - Question 111

Bukunmi Odugbesan — Sun, 01 Feb 2026 22:35:46 +0000

The task is to implement Math.sqrt().

The boilerplate code

function mySqrt(x) {
  // your code here   
}

Convert whatever is input to a number

const num = Number(x)

If the input is negative or invalid, return NaN

if(isNaN(num)) {
 return NaN
}

if(num < 0) {
return NaN
}

If the input is 0 or 1, the square root is itself

if(num < 2) return num;

Binary search will be used to find the square root between 1 and the input

let left = 1;
let right = Math.floor((left + right) / 2);
let ans = 0

For any number greater than or equal to 2, the square root is less than or equal to half the number. That's why the upper boundary for the search is at half of the number; the square root can't be bigger than that.

To implement binary search, find the middle point of the search range

while(left <= right) {
const mid = Math.floor((left + right) / 2);
const square = mid * mid

If the square is equal to the original value, the middle point is the square root

if (square === num) {
 return mid;
}

If the square is less than the original value, search the right half. Otherwise, search the left half.

else if(square < num) {
    ans = mid;    
    left = mid + 1; 
  } else {
    right = mid - 1;
  }

The final code

function mySqrt(x) {
  // your code here  
  const num = Number(x);

  if(isNaN(num)) {
    return NaN;
  }

  if(num < 0) {
    return NaN;
  }

  if(num < 2) return x;

  let left = 1;
  let right = Math.floor(num / 2);
  let ans = 0;

  while(left <= right) {
    const mid = Math.floor((left + right) / 2);
    const square =  mid * mid;

    if(square === num) {
      return mid;
    } else if(square < num) {
      ans = mid;
      left = mid + 1;
    } else {
      right = mid - 1;
    }
    }
  return ans;
}

That's all folks!

Coding Challenge Practice - Question 110

Bukunmi Odugbesan — Sat, 31 Jan 2026 22:47:02 +0000

The task is to implement String.prototype.trim().

The boilerplate code

function trim(str) {
  // your code here
}

Initialise pointers to move inwards till they hit a whitespace

let start = 0;
let end = str.length - 1;

Trim leading whitespace

while (start <= end && /\s/.test(str[start])) {
  start++;
}

\s matches all types of whitespace characters - spaces, tabs, newlines.

Trim ending whitespace

while (end >= start && /\s/.test(str[end])) {
  end--;
}

Extract the trimmed string

return str.slice(start, end + 1);

The final code

function trim(str) {
  // your code here
  let start = 0;
  let end = str.length - 1;

  while(start <= end && /\s/.test(str[start])) {
    start++;
  }

  while(end >= start && /\s/.test(str[end])) {
    end--;
  }
  return str.slice(start, end + 1) 
}

That's all folks!

Coding Challenge Practice - Question 109

Bukunmi Odugbesan — Fri, 30 Jan 2026 16:25:04 +0000

The task is to implement a function that converts snake case to camel case.

The boilerplate code

function snakeToCamel(str) {
  // your code here
}

To convert from snake_case to camelCase, it is required that the connecting underscore be removed and the next word has its first letter capitalised. Leading underscores, trailing underscores and double underscores should be kept.

Initialize variables to build the final string and a pointer to walk through the string

let result = '';
let i = 0;

Loop through the string manually

while (i < str.length)

Determine the conditions that ensure only underscores that connect words are removed

if (
  str[i] === '_' &&
  i > 0 &&
  i < str.length - 1 &&
  /[a-zA-Z]/.test(str[i + 1]) &&
  str[i - 1] !== '_'
)

Convert the next character correctly. If it is lowercase, convert to uppercase. If it is uppercase, leave it

const nextChar = str[i + 1];

result += nextChar >= 'a' && nextChar <= 'z'
  ? nextChar.toUpperCase()
  : nextChar;

Skip the underscore and the next character

i += 2;

Copy as-is if there is no underscore

else {
  result += str[i];
  i++;
}

Return the final string

return result;

The final code

function snakeToCamel(str) {
  // your code here
 let result = "";
 let i = 0;

 while(i < str.length) {
  if(str[i] === '_' && i > 0 && i < str.length - 1 &&  /[a-zA-Z]/.test(str[i + 1]) && str[i - 1] !== '_') {
   const nextChar = str[i + 1];
   result += nextChar >= 'a' && nextChar <= 'z' ? nextChar.toUpperCase() : nextChar;
   i += 2;
  } else {
    result += str[i];
    i++;
  }
 }
 return result;
}

That's all folks!