Solution For Problem no

Unfortunately, there is no problem titled “no problem” on leetcode. Can you please provide more information or a specific link to the problem?

Step by Step Implementation For Problem no

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.



class Solution {
    public int[] sortedSquares(int[] A) {
        for(int i = 0; i < A.length; i++){
            A[i] = A[i] * A[i]; // squaring each element in the array
        }
        Arrays.sort(A); // sorting the array in non-decreasing order
        return A;
    }
}

Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.

Examples:

s = "leetcode"
return 0.

s = "loveleetcode",
return 2.

def firstUniqChar(self, s: str) -> int:
        #initialize a dictionary 
        dic = {}
        
        #loop through the string
        for i in range(len(s)):
            #if the character is not in the dictionary, add it 
            if s[i] not in dic:
                dic[s[i]] = 1
            #if the character is already in the dictionary, increment the value 
            else:
                dic[s[i]] += 1
        
        #loop through the string again        
        for i in range(len(s)):
            #if the character has a value of 1, return the index 
            if dic[s[i]] == 1:
                return i
        #if no unique characters are found, return -1        
        return -1

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

// Solution: 

var twoSum = function(nums, target) {
    
    // create an empty object
    let hash = {};
    
    // loop through the array
    for(let i = 0; i < nums.length; i++) {
        
        // set the current number as a key in the object
        // with the value as the index
        hash[nums[i]] = i;
    }
    
    // loop through the array again
    for(let i = 0; i < nums.length; i++) {
        
        // set a variable equal to the difference between
        // the current number and the target
        let diff = target - nums[i];
        
        // check to see if the difference exists in the object
        // and that it's not the same index as the current number
        if(hash.hasOwnProperty(diff) && hash[diff] !== i) {
            
            // return the indices of the two numbers that add up to the target
            return [i, hash[diff]];
        }
    }
};

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        // Initialize an empty array to store the indices of the two numbers that add up to the target
        int[] indices = new int[2];
        
        // Use a for loop to iterate through the array
        for (int i = 0; i < nums.Length; i++) {
            // Initialize a variable to store the value of the current element
            int current = nums[i];
            
            // Use another for loop to iterate through the remaining elements in the array
            for (int j = i + 1; j < nums.Length; j++) {
                // Initialize a variable to store the value of the next element
                int next = nums[j];
                
                // If the sum of the current and next element equals the target, store the indices of the two elements in the array and return it
                if (current + next == target) {
                    indices[0] = i;
                    indices[1] = j;
                    return indices;
                }
            }
        }
        
        // If no two elements in the array add up to the target, return an empty array
        return new int[0];
    }
}