DEV Community: Dwiki

Leetcode75 - Reverse vowels in a string #5

Dwiki — Mon, 04 Aug 2025 12:21:35 +0000

This is the 5th problem in Leetcode75 ( Array&Hashing ).

Problem Statement

Given a string s, reverse only all the vowels in the string and return it.

The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in both lower and upper cases, more than once.

Solution Strategy

we're gonna create a variable that holds an array of strings of vowels
also create a variable that holds a list of given string, since string in python is immutable, we need to do it on a list
create 2 variables for pointer, left and right, left starts at first index of given string, and right starts at the last index of given string
then we will do a while-loop while left < right
we check if the character in left and right index are vowels ( by checking if its in the array that contains vowel that we crated), if yes then swap it , if no then ->
check if the character in left index is vowel then, we decrease the value of right
otherwise we increase the value of left, ( moving the pointer ) until the 5th conditions are met

code:


class Solution:
    def reverseVowels(self, s: str) -> str:
        vowels = ['a','i','u','e','o']

        s_list = list(s)

        left = 0
        right = len(s) - 1

        while left < right:
            if s_list[left].lower() in vowels and s_list[right].lower() in vowels:
                temp = s_list[left]
                s_list[left] = s_list[right]
                s_list[right] = temp
                left += 1
                right -= 1

            elif s_list[left].lower() in vowels:
                right -= 1 
            else:
                left += 1 


        return ''.join(s_list)```

Leetcode75 - Can Place Flowers #4

Dwiki — Wed, 05 Mar 2025 12:45:45 +0000

This is the 4th problem in Leetcode75 ( Array&Hashing ).

Problem Statement

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule and false otherwise

Solution Strategy

we're going to modify the array of flowers, by adding 0 at first index and at the last index.
then we're going to iterate through the modified array with pointer, starting from 1 ( since the first element is definitely 0, cuz we just inserted that ).
on each iteration we're gonna check if the current element in the array is 0, and we're also checking the previous element of current index and the next element also 0, if so, then we're going to place the flower there by changing the current element to 1, and and we move the pointer by 2 steps, then substracting the n numbers of flower that will be placed
then if no such conditions met, we're just going to increase the pointer value to iterate to the next indices
then after the while loop, we're going to return if the placed flowers equal to zero, since we have to return a boolean.

code:

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        var modifiedArray = flowerbed
        var pointer = 1
        var totalFlowers = n

        modifiedArray.insert(0, at: modifiedArray.startIndex)
        modifiedArray.insert(0, at: modifiedArray.endIndex)

        while pointer < modifiedArray.count - 1 && totalFlowers > 0 {
            if modifiedArray[pointer] == 0 && modifiedArray[pointer-1] == 0 && modifiedArray[pointer+1] == 0 {
                modifiedArray[pointer] = 1
                pointer += 2
                totalFlowers -= 1
            } else {
              pointer += 1
            }

        }

        return totalFlowers == 0 

    }
}

Leetcode75 - Kids with the Greatest Number of Candies #3

Dwiki — Fri, 24 Jan 2025 08:29:44 +0000

This is the 3rd problem in Leetcode75 ( Array&Hashing ).

Problem Statement

There are n kids with candies. You are given an integer array candies, where each candies[i] represents the number of candies the ith kid has, and an integer extraCandies, denoting the number of extra candies that you have.

Return a boolean array result of length n, where result[i] is true if, after giving the ith kid all the extraCandies, they will have the greatest number of candies among all the kids, or false otherwise.

Note that multiple kids can have the greatest number of candies.

Solution Strategy

Create an array of boolean, we're going to store the result here
Find the current maximum number of candies
Iterate through the array of candies. For each candy, add the extra candies and check if this addition makes it the greatest. If so, append true to the results array; otherwise, append false

class Solution {
    func kidsWithCandies(_ candies: [Int], _ extraCandies: Int) -> [Bool] {
       var result = [Bool]()
       let greatestCandies = candies.max()

       guard let greatestCandies = greatestCandies else {
        fatalError("error")
       }

       for candy in candies {
        if candy + extraCandies >= greatestCandies {
            result.append(true)
        } else {
            result.append(false)
        }
       }

       return result
    } 
}

## SOLUTION 2 ##

if you are familiar with .map() function, you could do it like this

func kidsWithCandies(_ candies: [Int], _ extraCandies: Int) -> [Bool] {
    guard let maxCandies = candies.max() else { return [] }
    return candies.map { candy in
        candy + extraCandies >= maxCandies
    }
}

LeetCode75 - Greatest Common Divisor of Strings #2

Dwiki — Thu, 23 Jan 2025 02:21:23 +0000

Hi there!

So this is the 2nd challenge in leetcode 75, we're still tackling with array&hashing problem, so let's jump right into it.

Problem Statement

Given two strings str1 and str2, find the largest string x that divides both strings. If no such string exists, return an empty string.
Example Scenarios

str1 = "ABCABC", str2 = "ABC"

Output: "ABC"
Explanation: "ABC" divides both input strings perfectly

str1 = "ABABAB", str2 = "ABAB"

Output: "AB"
Explanation: "AB" divides both input strings perfectly

Solution Strategy

Start from the length of the shorter string
Decrease length in each iteration
Validate if current length produces a valid divisor

Key Validation Conditions

Divisor length must evenly divide both string lengths
Repeating the divisor should reconstruct original strings

func gcdOfStrings(_ str1: String, _ str2: String) -> String {
   func isDivisor(_ factor: Int) -> Bool {
       if str1.count % factor != 0 || str2.count % factor != 0 {
           return false
       }

       let stringDivisor = String(str1.prefix(factor))

       return String(repeating: stringDivisor, count: str1.count / factor) == str1 && 
              String(repeating: stringDivisor, count: str2.count / factor) == str2
   }

   for i in stride(from: min(str1.count, str2.count), to: 0, by: -1) {
       if isDivisor(i) {
           return String(str1.prefix(i))
       }
   }

   return ""
}

LeetCode75 - Merge Strings Alternately #1

Dwiki — Tue, 21 Jan 2025 06:58:19 +0000

Hi there !

This is going to be my first post on this platform. I decided to write down everything I find useful so I don't forget it easily. I'm starting with this LeetCode series because I'm studying Data Structures and Algorithms (DSA).

The first challenge is called Merge Strings Alternately. In this problem, we are given 2 strings as parameters, and we need to merge them by adding letters in alternating order.

For example:
word1: abc
word2: pqr
output: apbqcr
Example 2:
word1: ab
word2: pqrs
output: apbqrs

Solution
We'll start by creating a variable 'word' and initializing it as an empty string, along with 'left' and 'right' variables starting at 0. We'll use the left and right variables as indices for word1 and word2 respectively as we iterate through them using a while loop.

The while loop condition will check if either the left or right pointer is still within the index range. If both pointers are within range, we'll append each character from word1 and word2 to our previously created variable 'word', and then increment the left and right values to move to the next indices.

Then we'll check for the case where one of the pointers goes out of range. In this situation, we just need to append the remaining characters from the other string and break out of the while loop.
Finally, we return the 'word' variable that contains our merged result.

func mergeAlternately(_ word1: String, _ word2: String) -> String {
    var word = String()
    var (left, right) = (0, 0)

    while left < word1.count || right < word2.count {
        if left < word1.count && right < word2.count {
            word.append(word1[word1.index(word1.startIndex, offsetBy: left)])
            word.append(word2[word2.index(word2.startIndex, offsetBy: right)])
            left += 1
            right += 1
        } else if left < word1.count {
            word.append(contentsOf: word1[word1.index(word1.startIndex, offsetBy: left)...])
            break
        } else {
            word.append(contentsOf: word2[word2.index(word2.startIndex, offsetBy: right)...])
            break
        }
    }

    return word
}