DEV Community: Ben Pereira

LeetCode — 1791. Find Center of Star Graph

Ben Pereira — Mon, 14 Jul 2025 14:58:57 +0000

It’s an easy problem with the description being:

There is an undirected star graph consisting of n nodes labeled from 1 to n. A star graph is a graph where there is one center node and exactly n - 1 edges that connect the center node with every other node.

You are given a 2D integer array edges where each edges[i] = [ui, vi] indicates that there is an edge between the nodes ui and vi. Return the center of the given star graph.

The first thing before starting to solve this issue is to understand a star graph, best way to get into it is looking into different types:

As you can see in this image, the idea of the star graph is that there is multiple points and a center piece. With that in mind we can always assume that the second array in the edges will be the one related to the center, but the exact number is still something that we need to identify based on validations.

With that in mind then is just about comparing the numbers and giving the right one:

class Solution {
    public int findCenter(int[][] edges) {
        return edges[0][1] == edges[1][0] || edges[0][1] == edges[1][1] ? edges[0][1] : edges[0][0];
    }
}

Runtime: 0ms, faster than 100.00% of Java online submissions.

Memory Usage: 72.20 MB, less than 61.83% of Java online submissions.

If for some reason the items were mixed then would be a bit more trouble to look for the center piece and compare with the respective one (meaning we would have to iterate it further), but that’s not the case here.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 3264. Final Array State After K Multiplication Operations I

Ben Pereira — Mon, 07 Jul 2025 15:07:28 +0000

It’s an easy problem with the description being:

You are given an integer array nums, an integer k, and an integer multiplier.

You need to perform k operations on nums. In each operation:

Find the minimum value x in nums. If there are multiple occurrences of the minimum value, select the one that appears first.

Replace the selected minimum value x with x * multiplier.

Return an integer array denoting the final state of nums after performing all k operations.

Example 1:

Input: nums = [2,1,3,5,6], k = 5, multiplier = 2

Output: [8,4,6,5,6]

Explanation:

OperationResultAfter operation 1[2, 2, 3, 5, 6]After operation 2[4, 2, 3, 5, 6]After operation 3[4, 4, 3, 5, 6]After operation 4[4, 4, 6, 5, 6]After operation 5[8, 4, 6, 5, 6]

Example 2:

Input: nums = [1,2], k = 3, multiplier = 4

Output: [16,8]

Explanation:

OperationResultAfter operation 1[4, 2]After operation 2[4, 8]After operation 3[16, 8]

Constraints:

1 <= nums.length <= 100

1 <= nums[i] <= 100

1 <= k <= 10

1 <= multiplier <= 5]

Well, for this problem we can separate into three parts:

Iterate k times
Find the smallest number in the list
Update smallest number with multiplier

Let’s also separate each into a method so it’s easier to understand:

class Solution {
    public int[] getFinalState(int[] nums, int k, int multiplier) {
        for(int i=0;i<k;i++) { // iterate k operations
            final int smallestIndex = smallestNumberIndex(nums);
            nums[smallestIndex] = applyMultiplier(nums[smallestIndex], multiplier);
        }

        return nums;
    }

    public int smallestNumberIndex(final int[] nums) {
        int index = 0;
        int x = nums[index];
        for(int i=1;i<nums.length;i++) {
            if(x > nums[i]) {
                index = i;
                x = nums[i];
            }
        }
        return index;
    }

    public int applyMultiplier(final int x, final int multiplier) {
        return x * multiplier;
    }
}

Runtime: 1ms, faster than 66.48% of Java online submissions.

Memory Usage: 44.84 MB, less than 72.37% of Java online submissions.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 2373. Largest Local Values in a Matrix

Ben Pereira — Fri, 06 Jun 2025 12:30:04 +0000

This is an easy problem with the description being:

You are given an n x n integer matrix grid.

Generate an integer matrix maxLocal of size (n - 2) x (n - 2) such that:

maxLocal[i][j] is equal to the largest value of the 3 x 3 matrix in grid centered around row i + 1 and column j + 1.

In other words, we want to find the largest value in every contiguous 3 x 3 matrix in grid.

Return the generated matrix.

As the problem states, the result needs to be a smaller matrix where each item should be the largest among it’s neighbors. With that in mind, there isn’t much to do besides following the conditions, which is traverse the grid, on each variable check it’s neighbors and get the largest.

The result would be:

class Solution {
    public int[][] largestLocal(int[][] grid) {
        final int [][] response = new int[grid.length - 2][grid[0].length - 2];

        for(int i=1 ; i < (grid.length-1) ; i++) {
            for(int j=1; j < (grid[i].length-1) ; j++) {
                response[i-1][j-1] = findLargestAmontNeighbors(grid, i, j);
            }
        }

        return response;
    }

    public int findLargestAmontNeighbors(final int[][] grid, final int i, final int j) {
        int largest = 0;
        for(int a=-1 ; a < 2 ; a++) {
            for(int b=-1 ; b < 2 ; b++) {
                if (largest < grid[i+a][j+b]) {
                    largest = grid[i+a][j+b];
                }
            }   
        }
        return largest;
    }

Runtime: 3ms, faster than 66.48% of Java online submissions.

Memory Usage: 45.72 MB, less than 38.80% of Java online submissions.

A simple improvement here that can be done would be when defining a and b use the indexes already instead of calculate later, but that’s a very small one.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 2824. Count Pairs Whose Sum is Less than Target

Ben Pereira — Fri, 30 May 2025 13:51:14 +0000

It’s an easy problem with the description being:

Given a 0-indexed integer array nums of length n and an integer target, return the number of pairs (i, j) where 0 <= i < j < n and nums[i] + nums[j] < target.

It’s a easy problem so we shouldn’t go deep on it. First we read and understand the conditions, and with that we see that we may need to iterate twice nums (it’s possible to not, but add much more pain than purpose), and the condition that the sums needs to be smaller than the target. With that in mind, let’s jump straight to the code:

class Solution {
    public int countPairs(List<Integer> nums, int target) {
        int pairs = 0;

        for(int i=0;i<nums.size();i++) {
            for(int j=(i+1);j<nums.size();j++) {
                if((nums.get(i) + nums.get(j)) < target) {
                    pairs++;
                }
            }
        }

        return pairs;
    }
}

Runtime: 2ms, faster than 96.64% of Java online submissions.

Memory Usage:42.23 MB, less than 83.37% of Java online submissions.

As you can see, is as simple as it gets. That’s the code translated from the problem as solution.

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 2798. Number of Employees Who Met the Target

Ben Pereira — Thu, 29 May 2025 12:57:09 +0000

It’s an easy problem with description being:

There are n employees in a company, numbered from 0 to n - 1. Each employee i has worked for hours[i] hours in the company.

The company requires each employee to work for at least target hours.

You are given a 0-indexed array of non-negative integers hours of length n and a non-negative integer target.

Return the integer denoting the number of employees who worked at least target hours.

This problem is simple and straight forward, you basicaly iterate the array of hours, the ones that are equal or bigger than the target you add into a sum, and then return the sum:

class Solution {
    public int numberOfEmployeesWhoMetTarget(int[] hours, int target) {
        int employeesWhoMetTarget = 0;

        for(int i=0;i<hours.length;i++){
            if(hours[i] >= target) {
                employeesWhoMetTarget++;
            }
        }

        return employeesWhoMetTarget;
    }
}

Runtime: 0ms, faster than 100.00% of Java online submissions.

Memory Usage: 43.08 MB, less than 9.90% of Java online submissions.

if you want to do a bit more fancy you can do like:

class Solution {
    public int numberOfEmployeesWhoMetTarget(int[] hours, int target) {
       return (int) Arrays.stream(hours)
                         .filter(employeeHours -> employeeHours >= target)
                         .count();
    }
}

Runtime: 5ms, faster than 1.24% of Java online submissions.

Memory Usage: 42.53 MB, less than 35.86% of Java online submissions.

Looks nice, but not as good as the first one, if you need performance go for the one that doesn’t use stream.

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 3467. Transform Array by Parity

Ben Pereira — Wed, 28 May 2025 18:17:16 +0000

This is an easy problem with the description being:

You are given an integer array nums. Transform nums by performing the following operations in the exact order specified:

Replace each even number with 0.

Replace each odd numbers with 1.

Sort the modified array in non-decreasing order.

Return the resulting array after performing these operations.

There is two ways of getting it solved. First and as simple as can be, you iterate, identify and replace the numbers with 0 and 1 if even or odd and then you sort your array before returning it:

class Solution {
    public int[] transformArray(int[] nums) {
        final int[] response = replaceEvenWithZeroOddWithOne(nums);
        Arrays.sort(response);
        return response;
    }

    public boolean isEven(final int num) {
        return num % 2 == 0; // & can be used as well
    }

    public int[] replaceEvenWithZeroOddWithOne(final int[] nums) {
        final int[] response = new int[nums.length];
        for(int i=0;i<nums.length;i++){
            response[i] = isEven(nums[i]) ? 0 : 1;
        }
        return response;
    }
}

Runtime: 2ms, faster than 59.68% of Java online submissions.

Memory Usage: 44.70 MB, less than 95.92% of Java online submissions.

is not bad, and you can reuse the methods there, but there is a way to do everything inside a for loop, that would be using two pointers for the even and the odd:

class Solution {
    public int[] transformArray(int[] nums) {

        int even = 0;
        int odd = nums.length - 1;
        final int[] response = new int[nums.length];

        for(int i=0;i<nums.length;i++){
            if(isEven(nums[i])) {
                response[even] = 0;
                even++;
            } else {
                response[odd] = 1;
                odd--;
            }
        }

        return response;
    }

    public boolean isEven(final int num) {
        return num % 2 == 0; // & can be used as well
    }
}

Runtime: 1ms, faster than 100.00% of Java online submissions.

Memory Usage: 45.03 MB, less than 39.26% of Java online submissions.

This is much faster than the previous one, not as clean, but better in performance as you can see on the runtime numbers if you compare with previous solution.

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 2161. Partition Array According to Given Pivot

Ben Pereira — Mon, 26 May 2025 14:37:00 +0000

This is a medium problem with the description being:

You are given a 0-indexed integer array nums and an integer pivot. Rearrange nums such that the following conditions are satisfied:

Every element less than pivot appears before every element greater than pivot.

Every element equal to pivot appears in between the elements less than and greater than pivot.

The relative order of the elements less than pivot and the elements greater than pivot is maintained.

More formally, consider every pi, pj where pi is the new position of the ith element and pj is the new position of the jth element. If i < j and both elements are smaller (or larger) than pivot, then pi < pj.

Return nums after the rearrangement.

Ok, so for the first and most simple thing that you would imagine, would be to separate in different arrays the small ones, biggest ones and fill up the rest. With that in mind the code would be:

class Solution {
    public int[] pivotArray(int[] nums, int pivot) {

        final List<Integer> beforePivot = new ArrayList<>();
        final List<Integer> afterPivot = new ArrayList<>();
        int amountThatsEqual = 0;

        for(int i=0 ; i < nums.length ; i++) {
            if(nums[i] < pivot) {
                beforePivot.add(nums[i]);
            } else if(nums[i] > pivot) {
                afterPivot.add(nums[i]);
            } else {
                amountThatsEqual++;
            }
        }

        final List<Integer> response = new ArrayList<>();

        response.addAll(beforePivot);

        IntStream.range(0, amountThatsEqual).forEach(i -> response.add(pivot));

        response.addAll(afterPivot);

        return response.stream().mapToInt(Integer::intValue).toArray();
    }
}

Runtime: 25ms, faster than 5.30% of Java online submissions.

Memory Usage: 66.20 MB, less than 63.43% of Java online submissions.

It feels like a good memory usage, but the runtime is really bad. In this first try we use a lot of things that are not needed, and we could go into usage of arrays only. Let’s try to go for just one array and see how it goes:

class Solution {
    public int[] pivotArray(int[] nums, int pivot) {
        final int[] response = new int[nums.length];
        int left = 0;

        for(int i=0 ; i<response.length ; i++) {
            if(nums[i] < pivot) {
                response[left] = nums[i];
                left++;
            }
        }

        for(int i=0 ; i<response.length ; i++) {
        if(nums[i] == pivot) {
                response[left] = pivot;
                left++;
            }
        }

        for(int i=0 ; i<response.length ; i++) {
            if(nums[i] > pivot) {
                response[left] = nums[i];
                left++;
            } 
        }

        return response;
    }
}

Runtime: 5ms, faster than 75.98% of Java online submissions.

Memory Usage: 68.17 MB, less than 33.65% of Java online submissions.

Not bad, runtime much faster, five times faster and we are using only one array, but the bad things is that we are making an iteration three times, and that could be reduced to only one if we used a thing called two pointers technique, which consists into having two markers, usually one at the beginning and the other at the end.

With those you can make your checks and change as needed regarding the question in place.

With that in mind let’s try out:

class Solution {
    public int[] pivotArray(int[] nums, int pivot) {
        final int[] response = new int[nums.length];
        int left = 0;
        int right = nums.length - 1;

        // two pointes one from begining and the other from the end
        for(int i=0,j = nums.length-1 ; i<response.length ; i++, j--) {
            if(nums[i] < pivot) {
                response[left] = nums[i];
                left++;
            }
            if(nums[j] > pivot) {
                response[right] = nums[j];
                right--;
            } 
        }

        // fill the zeros
        while (left <= right) {
            response[left] = pivot;
            left++;
        }

        return response;
    }
}

Runtime: 5ms, faster than 75.98% of Java online submissions.

Memory Usage: 67.28 MB, less than 52.84% of Java online submissions.

Very good, with that we keep good runtime speed, decrease a bit of memory usage and have it more clear and simple.

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

Singleton

Ben Pereira — Sun, 13 Apr 2025 22:03:10 +0000

At first glance, on the software world, singleton its’ a design pattern that means one unique instance only.

By refactoring guru the word intent is to be:

A creational design pattern that lets you ensure that a class has only one instance, while providing a global access point to this instance.

The word singleton comes from math, which from wikipedia states:

A singleton (also known as a unit set[1] or one-point set) is a set with exactly one element.

Singleton word, it’s a mix of two smaller ones, single and ton. Single word is pretty explanatory and -ton is used in surnames that come from place names, such as Newton, Hilton, Dayton, and Clinton.

But why would you use a singleton in your project?

First advantage of using it is the fact that you can have it as a place for your global variables or any type of global access. Instead of having to re-instantiate or look for properties or any other types of data source every time you want to reach for it (degrading I/O performance), if you load into a singleton object instance, that object will always be available for the whole application, as a single source of truth.
Second advantage is that you don’t need / can’t have multiple objects for the same end if just one is enough for it, having more than one you just cause you to increase memory for no big reason and breaks the idea of singleton (unique instance).

What problems comes with singleton?

It makes harder to test your code since uses static (but this can be solved with dependency injection or usage of power mock).
It brakes single responsibility principles (solves 2 items — the advantages).
Since it’s easy to share data/functionalities global, users tend to abuse it breaking it’s purpose (e.g. having multiple functionalities that are not made for the same end), so the team needs to be aware of it and use with caution.

One extra tip is to be aware of multi thread usage/access and how this can affect your singleton and related arguments if you make changes on attributes that are shared between the threads.

How can you create a singleton in Java?

You want a unique reference of your object, to do that you use static keyword.
You don’t want to have anyone to instance it, so you add a private constructor and make the instance in the class itself.
One last thing to be aware is that you can have the instance created in a static way (as soon as the application get’s started) or once someone requests a instance of it.

With those two ideas in place the result in a lazy instance is:

// Lazy instance
public class SingletonExample {

    public static SingletonExample instance;

    private SingletonExample() {
      // private constructor
    }

    public SingletonExample getInstance() {
        if (instance == null) {
            instance = new SingletonExample();
        }
        return instance;
    }
}

If you want an eager approach would be:

// Eager instance
public class SingletonExample {

    public static SingletonExample instance = new SingletonExample();

    private SingletonExample() {
      // private constructor
    }

    public SingletonExample getInstance() {
        return instance;
    }
}

Today singleton is the most used design pattern in the software industry I would say, it’s well adopted and used everywhere.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

LeetCode — 2807. Insert Greatest Common Divisors in Linked List

Ben Pereira — Mon, 24 Feb 2025 13:46:14 +0000

It’s a medium problem with the description being:

Given the head of a linked list head, in which each node contains an integer value.

Between every pair of adjacent nodes, insert a new node with a value equal to the greatest common divisor of them.

Return the linked list after insertion.

The greatest common divisor of two numbers is the largest positive integer that evenly divides both numbers.

Example 1:

Input: head = [18,6,10,3]
Output: [18,6,6,2,10,1,3]

Explanation: The 1st diagram denotes the initial linked list and the 2nd diagram denotes the linked list after inserting the new nodes (nodes in blue are the inserted nodes).

We insert the greatest common divisor of 18 and 6 = 6 between the 1st and the 2nd nodes.

We insert the greatest common divisor of 6 and 10 = 2 between the 2nd and the 3rd nodes.

We insert the greatest common divisor of 10 and 3 = 1 between the 3rd and the 4th nodes.

There are no more adjacent nodes, so we return the linked list.

Constraints:

The number of nodes in the list is in the range [1, 5000].

1 <= Node.val <= 1000

For this problem first thing to understand is that you need to know how to get the greatest common divisor.

An easy way to do would be use what’s already written through BigInteger gcd method:

public BigInteger gcd(BigInteger val)

Returns a BigInteger whose value is the greatest common divisor of abs(this) and abs(val). Returns 0 if this == 0 && val == 0.

With that in hand, as the problem states you need to add new node in between the two nodes being calculated.

Also since we don’t know how many nodes we have, we will have to loop indefinitely and once there is no next node we assume the loop is over.

Wrapping up those ideas in mind, the solution proposed would be:

class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode pivot = head;
        while(true) {
            if(Objects.isNull(pivot.next)){
                return head;
            }
            ListNode next = pivot.next;
            int gcd = getGreatestCommonDivisor(pivot.val, next.val);
            ListNode newNode = new ListNode(gcd, next);
            pivot.next = newNode;
            pivot = next;
        }
    }

    // Greatest Common Divisor from BigInteger class
    private int getGreatestCommonDivisor(int a, int b) {
        return BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).intValue();
    }
}

Runtime: 16ms, faster than 19.39% of Java online submissions.

Memory Usage: 45.45 MB, less than 19.34% of Java online submissions.

That’s a good solution, but still takes a lot of time to get it sorted out.

In this case we could remove some instances references and also use a more primitive way of calculating the greatest common divisor, and with that achieve a 1ms runtime:

class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode pivot = head;
        while(true) {
            if(pivot.next==null){
                return head;
            }
            ListNode next = pivot.next;
            pivot.next = new ListNode(getGreatestCommonDivisor(pivot.val, next.val), next);
            pivot = next;
        }
    }

    // Greatest Common Divisor from BigInteger class
    private int getGreatestCommonDivisor(int a, int b) {
         while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
}

Runtime: 1ms, faster than 100.00% of Java online submissions.

Memory Usage: 45.16 MB, less than 54.56% of Java online submissions.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

Leetcode — 1486. XOR Operation in an Array

Ben Pereira — Fri, 31 Jan 2025 13:22:44 +0000

It’s an easy problem with description being:

You are given an integer n and an integer start.

Define an array nums where nums[i] = start + 2 * i (0-indexed) and n == nums.length.

Return the bitwise XOR of all elements of nums.

Example 1:

Input: n = 5, start = 0
Output: 8
Explanation: Array nums is equal to [0, 2, 4, 6, 8] where (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8.
Where "^" corresponds to bitwise XOR operator.

Example 2:

Input: n = 4, start = 3
Output: 8
Explanation: Array nums is equal to [3, 5, 7, 9] where (3 ^ 5 ^ 7 ^ 9) = 8.

Constraints:

1 <= n <= 1000

0 <= start <= 1000

n == nums.length

First, to get this sorted out, you need to understand what XOR operator means.

This operator means exclusivity, meaning if both have same values, they will not get counted, if not then they will.

In this case with numbers it goes bitwise (binary numeral), so you update numbers from let’s say 9 to 1001 and use the binaries, on each, to determine if they are exclusive from one number to the other.

One example would be:

9 being 1001
8 being 1000

It shows just one exclusive number there, the first one (1 for 9 and 0 for 8), and due to that 8 ^ 9 = 1

So getting back into your problem, for us to return the bitwise XOR of all elements of nums you basically have to iterate based on n and use XOR on a sum, for each iteration, with the code being:

class Solution {
    public int xorOperation(int n, int start) {
        int bitwiseXor = 0;
        for(int i=0 ; i < n ; i++) {
            bitwiseXor = bitwiseXor ^ (start + 2 * i);
        }
        return bitwiseXor;
    }
}

Runtime: 1ms, faster than 100.00% of Java online submissions.

Memory Usage: 40.04 MB, less than 95.84% of Java online submissions.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

Leetcode — 3146. Permutation Difference between Two Strings

Ben Pereira — Fri, 17 Jan 2025 13:56:55 +0000

It’s an easy problem with description being:

You are given two strings s and t such that every character occurs at most once in s and t is a permutation of s.

The permutation difference between s and t is defined as the sum of the absolute difference between the index of the occurrence of each character in s and the index of the occurrence of the same character in t.

Return the permutation difference between s and t.

Example 1:

Input: s = “abc”, t = “bac”

Output: 2

Explanation:

For s = "abc" and t = "bac", the permutation difference of s and t is equal to the sum of:

The absolute difference between the index of the occurrence of "a" in s and the index of the occurrence of "a" in t.

The absolute difference between the index of the occurrence of "b" in s and the index of the occurrence of "b" in t.

The absolute difference between the index of the occurrence of "c" in s and the index of the occurrence of "c" in t.

That is, the permutation difference between s and t is equal to |0 - 1| + |1 - 0| + |2 - 2| = 2.

Example 2:

Input: s = “abcde”, t = “edbac”

Output: 12

Explanation: The permutation difference between s and t is equal to |0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12.

Constraints:

1 <= s.length <= 26

Each character occurs at most once in s.

t is a permutation of s.

s consists only of lowercase English letters.

There is a lot of pretty words to describe what needs to be done, but once you see one example it makes it easier to understand what is that the problem is trying to accomplish.

Following the permutation difference calculation there is an understatement that needs to be done is:

Iterate the String;
Retrieve the character based on the index;
Find this character index on the second String;
Subtract first index with second one;
Get the absolute value from that subtraction and collect all into one output.

Now let’s translate that thought into java code:

class Solution {
    public int findPermutationDifference(String s, String t) {

        int output = 0;

        for(int i=0; i <s.length(); i++) {
            final char c = s.charAt(i);
            final int j = t.indexOf(c);
            output += Math.abs(i - j);
        }

        return output;
    }
}

Runtime: 1ms, faster than 100% of Java online submissions.

Memory Usage: 42.67 MB, less than 57.64% of Java online submissions.

That’s a good solution that’s also very good performance wise. If we want to be more elegant and follow the solution with a Stream the solution would be:

class Solution {
    public int findPermutationDifference(String s, String t) {
        return IntStream.range(0, s.length())
                   .map(i -> findCharPermutationDifference(s,t,i))
                   .sum();
    }

    public int findCharPermutationDifference(final String s, final String t, final int i) {
        final char c = s.charAt(i);
        final int j = t.indexOf(c);
        return Math.abs(i - j);
    }
}

Runtime: 5ms, faster than 2.31% of Java online submissions.

Memory Usage: 43.02 MB, less than 23.05% of Java online submissions.

Not as good performance and memory wise, but ellegant nonetheless.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)

Leetcode — 2942. Find Words Containing Character

Ben Pereira — Tue, 07 Jan 2025 14:32:14 +0000

It’s an easy problem with description being:

You are given a 0-indexed array of strings words and a character x.

Return an array of indices representing the words that contain the character x.

Note that the returned array may be in any order.

Example 1:

Input: words = ["leet","code"], x = "e"
Output: [0,1]
Explanation: "e" occurs in both words: "leet", and "code". Hence, we return indices 0 and 1.

Example 2:

Input: words = ["abc","bcd","aaaa","cbc"], x = "a"
Output: [0,2]
Explanation: "a" occurs in "abc", and "aaaa". Hence, we return indices 0 and 2.

Example 3:

Input: words = ["abc","bcd","aaaa","cbc"], x = "z"
Output: []
Explanation: "z" does not occur in any of the words. Hence, we return an empty array.

Constraints:

1 <= words.length <= 50

1 <= words[i].length <= 50

x is a lowercase English letter.

words[i] consists only of lowercase English letters.

To solve this problem you will need to iterate the words list, on each word check if contains the char, if so you store it’s index into a response list:

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        // create response
        final List<Integer> indexes = new ArrayList<>();

        // iterate words string array
        for(int i=0;i<words.length;i++){
            // check if char exists into the word
            if(words[i].indexOf(x) != -1){
                indexes.add(i); // if yes add index into the response
            }
        }

        // return searched indexes
        return indexes;
    }
}

Runtime: 1ms, faster than 100.00% of Java online submissions.

Memory Usage: 44.95 MB, less than 49.76% of Java online submissions.

—

If you want to go into a lambda/function approach, which usually is cleaner but takes more toll on performance, it would look like this:

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        return IntStream.range(0, words.length)
                .boxed() // convert primitive into Class related (int -> Integer)
                .map(i -> getIndexIfCharExistsInWord(words[i], i, x))
                .filter(Objects::nonNull) // to remove null ones from mapping
                .collect(Collectors.toList());
    }

    public Integer getIndexIfCharExistsInWord(final String word, final int i, final char x) {
        return word.indexOf(x) != -1 ? i : null;
    }
}

Runtime: 9ms, faster than 2.72% of Java online submissions.

Memory Usage: 44.90 MB, less than 66.32% of Java online submissions.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)