Forem: CLeeBenjamin

Codewars: Find the odd int

CLeeBenjamin — Tue, 26 Mar 2024 08:36:10 +0000

This problem on codewars asks the following:

Given an array, find the integer that appears an odd number of times. There will always be exactly one integer that appears an odd number of times.

Example: (Input --> Output)

findOdd([20, 1, 1, 2, 2]) = 20
findOdd([5, 4, 3, 2, 1, 5, 4, 3, 2, 10, 10]) = 1

How to approach it with the PEDAC method:

P: Understand the problem -
We need to identify which number in an array appears an odd number of times. Although each number can appear multiple times, only one will appear an odd number of times.

E: Give Example -
In an array like [8, 8, 7, 7, 7], 7 shows up 3 times (odd), making it our target.
For [1, 1, 2], 2 appears just once (odd), pinpointing it as the solution.

D: What data structure(s) would be needed -
An object seems perfect for mapping each number to its occurrence count within the array.

A: Steps to solve it without language specific information -

- Loop first through the array: This allows me to inspect each number individually.

- If I arrive at a number, add it to a data structure: object

- Check if the number has been encountered before. If not, initialize its count in the object. If the number is already in the object, increment its count

- Loop through the object to inspect counts and return the odd number of counts

C: Code the solution guided by the pseudocode-

- Loop first through the array

for (let i of A) {

- If I arrive at a number, add it to a data structure: object
- Check if the number has been encountered before. If not, initialize its count in the object. If the number is already in the object, increment its count

  if (!values[i]) {
    values[i] = 1;
  } else {
    values[i] += 1;
  }
}

- Loop through the object to inspect counts and return the odd number of counts

for (let k in values) {
  if (values[k] % 2 === 1) {
    return Number(k);
  }
}

Putting it all together in the function findOdd:

function findOdd(A) {
  let values = {};

  // Loop first through the array
  for (let i of A) {
    // Check if the number has been encountered before
    if (!values[i]) {
      values[i] = 1; // If not, initialize its count
    } else {
      values[i] += 1; // If it has, increment its count
    }
  }

  // Loop through the object to find and return the number with an odd count
  for (let k in values) {
    if (values[k] % 2 === 1) {
      return Number(k);
    }
  }
}

Codewars: Multiples of 3 or 5

CLeeBenjamin — Mon, 25 Mar 2024 10:41:35 +0000

This problem on codewars asks the following:

A function should return the sum of all the multiples of 3 or 5 below a given number. If the number is negative, return 0. For numbers that are multiples of both 3 and 5, count them only once.

Example: (Input --> Output)

solution(10) = 23
solution(-1) = 0
solution(15) = 45 (Not including 15)

How to approach it with the PEDAC method:

P: Understand the problem -
The task is to compute the sum of all numbers below a given number that are multiples of 3 or 5, treating negatives as a special case where the result is always 0.

E: Give Example -
For a number like 10, you’d get 3, 5, 6, and 9 as the multiples, summing up to 23.
For -1, since it's negative, the result should be 0.

D: What data structure(s) would be needed -
You can simply use a variable to accumulate the total sum; no complex data structure is required.

A: Steps to solve it without language specific information -

Initialize a sum variable at 0.
If the input number is negative, return 0 immediately.
Loop through numbers starting from 1 up to but not including the input number.
For each number, check if it's a multiple of 3 or 5.
If it is, add it to the sum.
Return the sum after the loop.

C: The final code using the pseudocode (A) to guide me -

- Initialize sum and handle negative input

function solution(number){
  let total = 0;  
  if(number < 0){ return 0}
}

- Loop through numbers and check for multiples of 3 or 5

function solution(number){
  let total = 0;  
  if(number < 0){ return 0}

  for(let i = 1; i < number; i++){
    if(i % 3 === 0 || i % 5 === 0){
      total += i;
    }
  }

  return total; 
}

- Final step: returning the total sum

function solution(number){
  let total = 0;  
  if(number < 0){ return 0}

  for(let i = 1; i < number; i++){
    if(i % 3 === 0 || i % 5 === 0){
      total += i;
    }
  }

  return total; // This is where the sum gets returned
}

Codewars: Isogram Problem

CLeeBenjamin — Thu, 21 Mar 2024 13:35:47 +0000

This problem on codewars ask the following:

An isogram is a word that has no repeating letters, consecutive or non-consecutive. Implement a function that determines whether a string that contains only letters is an isogram. Assume the empty string is an isogram. Ignore letter case.

Example: (Input --> Output)

isIsogram "Dermatoglyphics" = true
isIsogram "moose" = false
isIsogram "aba" = false

How to approach it with PEDAC method:

P: Understand the problem -
Understand that isogram is a string that has no letter that repeats.

E: Give Example -
Creating your own example would be:
"apple" = false
"ted" = true
As I check each letter, I will need to place characters that were visited in a data structure.

D: What data structure(s) would be need -
What will I use to hold data if necessary:
Object

A: Steps to solve it without language specific information -

make string lowercase
check if string is empty and return true if so
loop through string
place item in data structure when visited
check if the character appears more than once in visited data structure, if it has return false
if looping finishes without returning, return true

C: The final code using the psuedocode (A) to guid me -

- make string lowercase

function isIsogram(str){
  let newStr = str.toLowerCase(); /// here
}

- check if string is empty and return true if so

function isIsogram(str){
  let newStr = str.toLowerCase();

  if(newStr === ""){ /// here
    return true; /// here
  }  
}

- loop through string

function isIsogram(str){
  let newStr = str.toLowerCase();

  if(newStr === ""){
    return true;
  }  

  for(let char of newStr){ /// here
    /* loop through the string */
  }
}

- place item in data structure when visited

function isIsogram(str){
  let visited = {}; /// here
  let newStr = str.toLowerCase();

  if(newStr === ""){
    return true;
  }  

  for(let char of newStr){ 
    if(!visited[char]){ /// here
      visited[char] = 1 /// here
    }
}

- check if the character appears more than once in visited data structure, if it has return false

function isIsogram(str){
  let visited = {};
  let newStr = str.toLowerCase();

  if(newStr === ""){
    return true;
  }  

  for(let char of newStr){
    if(!visited[char]){
      visited[char] = 1
    }else { /// here
      return false /// here
    }
  }
}

- if looping finishes without terminating the function, return true


function isIsogram(str){
  let visited = {};
  let newStr = str.toLowerCase();

  if(newStr === ""){
    return true;
  }  

  for(let char of newStr){
    if(!visited[char]){
      visited[char] = 1
    }else {
      return false
    }
  }
  return true; /// here
}