Merge branch 'neetcode-gh:main' into main

Author: drxlx

README.md

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
+        struct ListNode *currA = headA;
+        struct ListNode *currB = headB;
+
+        while (currA && currB){
+            if (currA == currB){
+                return currA;
+            }
+            currA = currA->next;
+            currB = currB->next;
+
+            if (!currA && currB){
+                currA = headB;
+            }
+            if (!currB && currA){
+                currB = headA;
+            }
+        }
+    return NULL;
+}

c/0160-intersection-of-two-linked-lists.c

@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+bool isPalindrome(struct ListNode* head){
+
+    // find middle of linked list
+    struct ListNode *slow = head, *fast = head;
+    while (fast && fast->next){
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    // reverse second half
+    struct ListNode* prev = NULL;
+    while (slow){
+        struct ListNode* nxt = slow->next;
+        slow->next = prev;
+        prev = slow;
+        slow = nxt;
+    }
+
+    // compare left and right
+    struct ListNode *left=head, *right=prev;
+    while (right){
+        if (left->val != right->val){
+            return false;
+        }
+        left = left->next;
+        right = right->next;
+    }
+    return true;
+    
+}

c/0234-palindrome-linked-list.c

@@ -2,7 +2,7 @@
     Given the head of a singly linked list, reverse list & return
     Ex. head = [1,2,3,4,5] -> [5,4,3,2,1], head = [1,2] -> [2,1]
 
-    Maintain prev, curr, & next pointers, iterate thru & reverse
+    Maintain prev, curr pointers, iterate thru & reverse
 
     Time: O(n)
     Space: O(1)
@@ -18,24 +18,24 @@
  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
  * };
  */
-class Solution {
+class Solution
+{
 public:
-    ListNode* reverseList(ListNode* head) {
-        if (head == NULL || head->next == NULL) {
+    ListNode *reverseList(ListNode *head)
+    {
+        if (head == NULL || head->next == NULL)
             return head;
-        }
-        
-        ListNode* prev = NULL;
-        ListNode* curr = head;
-        ListNode* next = curr->next;
-        
-        while (curr != NULL) {
-            next = curr->next;
+
+        ListNode *prev = NULL;
+        ListNode *curr = head;
+
+        while (curr != NULL)
+        {
+            ListNode *temp = curr->next;
             curr->next = prev;
             prev = curr;
-            curr = next;
+            curr = temp;
         }
-        
         return prev;
     }
 };

cpp/0206-reverse-linked-list.cpp

@@ -0,0 +1,25 @@
+typedef unsigned long long ll;
+class Solution {
+public:
+    bool solve(string & s , ll last , int index,int cnt){
+
+        if(index >= s.size()) return cnt > 1;
+
+        ll num = 0;
+        bool ret = false;
+
+        for(int i = index ; i < s.size() ; i++){
+            num = num * 10;
+            num += (s[i] - '0');
+
+            if(last == -1 || last == num + 1){
+                ret |= solve(s , num , i + 1 , cnt + 1);
+            }else if(last != -1 && num >= last)break;
+        }
+
+        return ret;
+    }
+    bool splitString(string s) {
+        return solve(s,-1,0,0);
+    }
+};

cpp/1849-splitting-a-string-into-descending-consecutive-values.cpp

@@ -0,0 +1,12 @@
+public class Solution {
+    public string LargestNumber(int[] nums) 
+    {
+        if(nums.All(_ => _ == 0)) return "0";
+
+        var s = nums.Select(_ => _.ToString()).ToList();
+
+        s.Sort((a, b) => (b+a).CompareTo(a+b));
+
+        return string.Concat(s);
+    }
+}

csharp/0179-largest-number.cs

@@ -0,0 +1,50 @@
+public class Solution {
+    public int MaxProduct(string s) {
+        if(s == null || s.Length < 2)
+            return 0;
+        if(s.Length == 2)
+            return 1;
+
+        int n = s.Length;
+        int total = 1 << n;
+
+        List<(int, int)> possible = new List<(int, int)>();
+
+        for(int i = 0; i < total; i++) {
+            StringBuilder sb = new StringBuilder();
+
+            for(int j = 0; j < n; j++) {
+                if((i & (1 << j)) != 0) {
+                    sb.Append(s[j]);
+                }
+            }
+
+            if(IsPalindrome(sb.ToString())) {
+                possible.Add((i, sb.Length));
+            }
+        }
+
+        int ans = 0;
+        for(int i = 0; i < possible.Count; i++) {
+            int bitmask = possible[i].Item1;
+            int count = possible[i].Item2;
+            for(int j = i + 1; j < possible.Count; j++) {
+                int bitmask2 = possible[j].Item1;
+                int count2 = possible[j].Item2;
+                if((bitmask & bitmask2) == 0)
+                    ans = Math.Max(ans, count * count2);
+            }
+        }
+        return ans;
+    }
+
+    private bool IsPalindrome(string s){
+        int i = 0;
+        int j = s.Length - 1;
+        while(i < j) {
+            if(s[i++] != s[j--])
+                return false;
+        }
+        return true;
+    }
+}

csharp/2002-maximum-product-of-the-length of-2-palindromic-subsequences.cs

@@ -0,0 +1,8 @@
+func largestNumber(nums []int) string {
+    ans, s := "", make([]string, len(nums))
+    for i, num := range nums { s[i] = strconv.Itoa(num) }
+    sort.Slice(s, func(a, b int) bool { return s[a] + s[b] > s[b] + s[a] })
+    if s[0] == "0" { return "0" }
+    for _, v := range s { ans += v }
+    return ans
+}

go/0179-largest-number.go

@@ -0,0 +1,46 @@
+func maxProduct(s string) (res int) {
+	dp := make([]int, 1<<len(s))
+	mask := (1 << len(s)) - 1
+	palindromeSize := func(s string, mask int) (res int) {
+		i, j := 0, len(s)
+		for i <= j {
+			if mask&(1<<i) == 0 {
+				i++
+			} else if mask&(1<<j) == 0 {
+				j--
+			} else if s[i] != s[j] {
+				return 0
+			} else {
+				if i == j {
+					res++
+				} else {
+					res += 2
+				}
+				i++
+				j--
+			}
+		}
+		return res
+	}
+
+	max := func(a, b int) int {
+		if a > b {
+			return a
+		}
+		return b
+	}
+
+	for m := 1; m <= mask; m++ {
+		dp[m] = palindromeSize(s, m)
+	}
+
+	for m1 := mask; m1 > 0; m1-- {
+		if dp[m1]*(len(s)-dp[m1]) <= res {
+			continue
+		}
+		for m2 := mask ^ m1; m2 > 0; m2 = (m2 - 1) & (mask ^ m1) {
+			res = max(res, dp[m1]*dp[m2])
+		}
+	}
+	return
+}

go/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.go

@@ -28,15 +28,16 @@ public boolean isValid(String s) {
 class Solution {
     public boolean isValid(String s) {
         Stack<Character> brackets = new Stack<>();
-        Map<Character, Character> bracketLookup = new HashMap<>();
+        Map<Character, Character> bracketLookup = new HashMap<>(3);
 
         bracketLookup.put(')', '(');
         bracketLookup.put('}', '{');
         bracketLookup.put(']', '[');
 
-        for (char c : s.toCharArray()) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
             if (bracketLookup.containsKey(c)) {
-                if (brackets.size() != 0 && brackets.peek() == bracketLookup.get(c)) {
+                if (!brackets.isEmpty() && bracketLookup.get(c).equals(brackets.peek())) {
                     brackets.pop();
                 } else {
                     return false;
@@ -46,7 +47,6 @@ public boolean isValid(String s) {
             }
         }
 
-        if (brackets.size() == 0) return true;
-        return false;
+        return brackets.isEmpty();
     }
 }