Arrays-LinkedList-hashtable-strings

Question 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.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?

Answer 1

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        unordered_map hash;
        vector result;
        for(int i =0;i

Question 2

https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/

Answer 2

https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/

Question 3

https://leetcode.com/problems/concatenation-of-array/

Answer 3

https://leetcode.com/problems/concatenation-of-array/

Question 4

https://leetcode.com/problems/running-sum-of-1d-array/

Answer 4

https://leetcode.com/problems/running-sum-of-1d-array/

Question 5

https://leetcode.com/problems/shuffle-the-array/

Answer 5

https://leetcode.com/problems/shuffle-the-array/

Question 6

https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/

Answer 6

https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/

Question 7

https://leetcode.com/problems/number-of-good-pairs/

Answer 7

https://leetcode.com/problems/number-of-good-pairs/

Question 8

https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/

Answer 8

https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/

Question 9

https://leetcode.com/problems/shuffle-string/

Answer 9

https://leetcode.com/problems/shuffle-string/

Question 10

https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/

Answer 10

https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/

Question 11

https://leetcode.com/problems/truncate-sentence/

Answer 11

https://leetcode.com/problems/truncate-sentence/

Question 12

https://leetcode.com/problems/number-of-students-doing-homework-at-a-given-time/

Answer 12

https://leetcode.com/problems/number-of-students-doing-homework-at-a-given-time/

Question 13

https://leetcode.com/problems/sort-array-by-parity/

Answer 13

https://leetcode.com/problems/sort-array-by-parity/

Question 14

https://leetcode.com/problems/n-repeated-element-in-size-2n-array/

Answer 14

https://leetcode.com/problems/n-repeated-element-in-size-2n-array/

Question 15

https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/

Answer 15

https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/

Question 16

https://leetcode.com/problems/unique-number-of-occurrences/

Answer 16

https://leetcode.com/problems/unique-number-of-occurrences/

Question 17

https://leetcode.com/problems/squares-of-a-sorted-array

Answer 17

https://leetcode.com/problems/squares-of-a-sorted-array

Question 18

https://leetcode.com/problems/intersection-of-two-arrays/

Answer 18

https://leetcode.com/problems/intersection-of-two-arrays/

Question 19

https://leetcode.com/problems/three-consecutive-odds/

Answer 19

https://leetcode.com/problems/three-consecutive-odds/

Question 20

https://leetcode.com/problems/check-if-all-1s-are-at-least-length-k-places-away/

Answer 20

https://leetcode.com/problems/check-if-all-1s-are-at-least-length-k-places-away/

Question 21

https://leetcode.com/problems/contains-duplicate/

Answer 21

https://leetcode.com/problems/contains-duplicate/

Question 22

https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/

Answer 22

https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/

Question 23

https://leetcode.com/problems/binary-search/

Answer 23

https://leetcode.com/problems/binary-search/

Question 24

https://leetcode.com/problems/max-consecutive-ones

Answer 24

https://leetcode.com/problems/max-consecutive-ones

Question 25

https://leetcode.com/problems/intersection-of-two-arrays-ii/

Answer 25

https://leetcode.com/problems/intersection-of-two-arrays-ii/

Question 26

https://leetcode.com/problems/remove-duplicates-from-sorted-array/

Answer 26

https://leetcode.com/problems/remove-duplicates-from-sorted-array/

Question 27

https://leetcode.com/problems/reverse-string/

Answer 27

https://leetcode.com/problems/reverse-string/

Question 28

https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/

Answer 28

https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/

Question 29

https://leetcode.com/problems/valid-parentheses/

Answer 29

https://leetcode.com/problems/valid-parentheses/

Question 30

https://leetcode.com/problems/remove-outermost-parentheses/

Answer 30

https://leetcode.com/problems/remove-outermost-parentheses/

Question 31

https://leetcode.com/problems/delete-node-in-a-linked-list/

Answer 31

https://leetcode.com/problems/delete-node-in-a-linked-list/

Question 32

https://leetcode.com/problems/reverse-linked-list/

Answer 32

https://leetcode.com/problems/reverse-linked-list/

Question 33

https://leetcode.com/problems/merge-two-sorted-lists/

Answer 33

https://leetcode.com/problems/merge-two-sorted-lists/

Question 34

https://leetcode.com/problems/remove-duplicates-from-sorted-list/

Answer 34

https://leetcode.com/problems/remove-duplicates-from-sorted-list/

Question 35

https://leetcode.com/problems/intersection-of-two-linked-lists/

Answer 35

https://leetcode.com/problems/intersection-of-two-linked-lists/

Question 36

https://leetcode.com/problems/linked-list-cycle/

Answer 36

https://leetcode.com/problems/linked-list-cycle/

Question 37

https://leetcode.com/problems/palindrome-linked-list/

Answer 37

https://leetcode.com/problems/palindrome-linked-list/

Question 38

https://leetcode.com/problems/remove-linked-list-elements/

Answer 38

https://leetcode.com/problems/remove-linked-list-elements/

Question 39

https://leetcode.com/problems/middle-of-the-linked-list/

Answer 39

https://leetcode.com/problems/middle-of-the-linked-list/

Question 40

https://leetcode.com/problems/merge-in-between-linked-lists/

Answer 40

https://leetcode.com/problems/merge-in-between-linked-lists/

Question 41

https://leetcode.com/problems/swapping-nodes-in-a-linked-list/

Answer 41

https://leetcode.com/problems/swapping-nodes-in-a-linked-list/

Question 42

https://leetcode.com/problems/odd-even-linked-list/

Answer 42

https://leetcode.com/problems/odd-even-linked-list/

Question 43

https://leetcode.com/problems/swap-nodes-in-pairs/

Answer 43

https://leetcode.com/problems/swap-nodes-in-pairs/

Question 44

https://leetcode.com/problems/partition-list/

Answer 44

https://leetcode.com/problems/partition-list/

Question 45

https://leetcode.com/problems/insertion-sort-list/

Answer 45

https://leetcode.com/problems/insertion-sort-list/

Question 46

https://leetcode.com/problems/reverse-linked-list-ii/

Answer 46

https://leetcode.com/problems/reverse-linked-list-ii/

Question 47

https://leetcode.com/problems/linked-list-cycle-ii/

Answer 47

https://leetcode.com/problems/linked-list-cycle-ii/

Question 48

https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/

Answer 48

https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/

Question 49

https://leetcode.com/problems/add-two-numbers/

Answer 49

https://leetcode.com/problems/add-two-numbers/

Question 50

https://leetcode.com/problems/remove-nth-node-from-end-of-list/

Answer 50

https://leetcode.com/problems/remove-nth-node-from-end-of-list/

Question 51

https://leetcode.com/problems/rotate-list/

Answer 51

https://leetcode.com/problems/rotate-list/

Question 52

You’re given strings jewels representing the types of stones that are jewels, and stones representing the stones you have. Each character in stones is a type of stone you have. You want to know how many of the stones you have are also jewels.

Letters are case sensitive, so “a” is considered a different type of stone from “A”.

Example 1:

Input: jewels = “aA”, stones = “aAAbbbb”
Output: 3

Example 2:

Input: jewels = “z”, stones = “ZZ”
Output: 0

Constraints:

1 <= jewels.length, stones.length <= 50
jewels and stones consist of only English letters.
All the characters of jewels are unique.

Answer 52

class Solution {
public:
    int numJewelsInStones(string jewels, string stones) {
        unordered_set hash(jewels.begin(),jewels.end());
        int count = 0;
        for(int i:stones){
            if(hash.count(i)){
                count++;
            }
        }
        return count;

} };

Question 53

1832. Check if the Sentence Is Pangram

A pangram is a sentence where every letter of the English alphabet appears at least once.

Given a string sentence containing only lowercase English letters, return true if sentence is a pangram, or false otherwise.

Example 1:

Input: sentence = “thequickbrownfoxjumpsoverthelazydog”
Output: true
Explanation: sentence contains at least one of every letter of the English alphabet.

Example 2:

Input: sentence = “leetcode”
Output: false

Constraints:

1 <= sentence.length <= 1000
sentence consists of lowercase English letters.

Answer 53

class Solution {
public:
    bool checkIfPangram(string sentence) {
        unordered_set hash(sentence.begin(),sentence.end());
        if(hash.size()==26) return true;
        return false;
    }
};

Question 54

Given head which is a reference node to a singly-linked list. The value of each node in the linked list is either 0 or 1. The linked list holds the binary representation of a number.

Return the decimal value of the number in the linked list.

Example 1:

Input: head = [1,0,1]
Output: 5
Explanation: (101) in base 2 = (5) in base 10

Example 2:

Input: head = [0]
Output: 0

Example 3:

Input: head = [1]
Output: 1

Example 4:

Input: head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
Output: 18880

Example 5:

Input: head = [0,0]
Output: 0

Constraints:

The Linked List is not empty.
Number of nodes will not exceed 30.
Each node's value is either 0 or 1.

Answer 54

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    int getDecimalValue(ListNode* head) {
        int sum = 0;
        while(head){
            sum =sum<<1; 
            sum |= head->val;
            head=head->next;
        }
        return sum;

} };

Question 55

278. First Bad Version
     Easy

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, …, n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which returns whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

Example 1:

Input: n = 5, bad = 4
Output: 4
Explanation:
call isBadVersion(3) -> false
call isBadVersion(5) -> true
call isBadVersion(4) -> true
Then 4 is the first bad version.

Example 2:

Input: n = 1, bad = 1
Output: 1

Answer 55

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int low=1,high=n,mid;
        while(low<=high){
            mid=low + (high - low) / 2;;
            if(isBadVersion(mid)){
                high=mid-1;

            }
            else{
                low=mid+1;
            }
        }
        return low;
    }
};

Question 56

35. Search Insert Position
    Easy

Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [1,3,5,6], target = 5
Output: 2

Example 2:

Input: nums = [1,3,5,6], target = 2
Output: 1

Example 3:

Input: nums = [1,3,5,6], target = 7
Output: 4

Example 4:

Input: nums = [1,3,5,6], target = 0
Output: 0

Example 5:

Input: nums = [1], target = 0
Output: 0

Constraints:

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums contains distinct values sorted in ascending order.
-104 <= target <= 104

Answer 56

class Solution {
public:
    int searchInsert(vector& nums, int target) {
       int low=0,high=nums.size()-1,mid;
        while(low<=high){
            mid=((low+high)/2);
            if(nums[mid]==target) return mid;
            else if(target