Merge pull request neetcode-gh#2209 from Mohammed785/main

Create: 0021-merge-two-sorted-lists.rs, 0682-baseball-game, 1930-unique-length-3-palindromic-subsequences

Author: tahsintunan

Diff for: csharp/0682-baseball-game.cs

@@ -0,0 +1,26 @@
+public class Solution {
+    public int CalPoints(string[] operations) {
+        List<int> stack = new();
+
+        foreach(var operation in operations)
+        {
+            switch(operation)
+            {
+                case "D":
+                    stack.Add(stack[stack.Count()-1]*2);
+                    break;
+                case "+":
+                    stack.Add(stack[stack.Count()-1] + stack[stack.Count()-2]);
+                    break;
+                case "C":
+                    stack.RemoveAt(stack.Count()-1);
+                    break;
+                default:
+                    stack.Add(int.Parse(operation));
+                    break;
+            }
+        }
+        
+        return stack.Sum();
+    }
+}

Diff for: javascript/0682-baseball-game.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string[]} operations
+ * @return {number}
+ */
+var calPoints = function (operations) {
+    const stack = [];
+    for(const op of operations){
+        if(op==="+"){
+            stack.push(stack[stack.length - 1] + stack[stack.length - 2]);
+        }else if(op==="C"){
+            stack.pop()
+        }else if(op==="D"){
+            stack.push(stack[stack.length - 1] * 2);
+        }else{
+            stack.push(parseInt(op))
+        }
+    }
+    return stack.reduce((prev,curr)=>prev+curr,0)
+};

Diff for: javascript/1930-unique-length-3-palindromic-subsequences.js

@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var countPalindromicSubsequence = function (s) {
+    let count = 0;
+    let chars = new Set(s);
+    for(const char of chars){
+        let first = s.indexOf(char),last = s.lastIndexOf(char);
+        count += new Set(s.slice(first + 1, last)).size;
+    }
+    return count;
+};

Diff for: python/1930-unique-length-3-palindromic-subsequences.py

@@ -0,0 +1,8 @@
+class Solution:
+    def countPalindromicSubsequence(self, s: str) -> int:
+        count = 0
+        chars = set(s)
+        for char in chars:
+            first,last = s.find(char),s.rfind(char)
+            count += len(set(s[first+1:last]))
+        return count

Diff for: rust/0021-merge-two-sorted-lists.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn merge_two_lists(list1: Option<Box<ListNode>>, list2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        match (list1,list2) {
+            (Some(list1),None)=> Some(list1),
+            (None,Some(list2))=>Some(list2),
+            (None,None)=>None,
+            (Some(l1),Some(l2))=>{
+                if l1.val<l2.val {
+                  return Some(Box::new(ListNode{val:l1.val,next:Solution::merge_two_lists(l1.next,Some(l2))}));
+                }else {
+                  return Some(Box::new(ListNode { val: l2.val, next: Solution::merge_two_lists(Some(l1),l2.next) }))
+                }
+            }
+        }
+    }
+}

Diff for: rust/1930-unique-length-3-palindromic-subsequences.rs

@@ -0,0 +1,34 @@
+use std::iter::FromIterator;
+
+impl Solution {
+    pub fn count_palindromic_subsequence(s: String) -> i32 {
+        let mut result = 0;
+        let mut ranges: [(i32, i32); 26] = [(-1, -1); 26];
+
+        for (i, c) in s.chars().enumerate() {
+            let ix = Solution::char_to_index(c) as usize;
+            if ranges[ix].0 == -1 {
+                ranges[ix].0 = i as i32;
+            }
+            if i as i32 > ranges[ix].1 {
+                ranges[ix].1 = i as i32;
+            }
+        }
+
+        for range in ranges {
+            if range.1 > range.0 {
+                let mut set: u32 = 0;
+                for c in s[range.0 as usize + 1..range.1 as usize].chars() {
+                    set |= 1 << Solution::char_to_index(c);
+                }
+                result += set.count_ones() as i32;
+            }
+        }
+
+        result
+    }
+
+    pub fn char_to_index(c: char) -> u32 {
+        c as u32 - 'a' as u32
+    }
+}

Diff for: swift/0682-baseball-game.swift

@@ -0,0 +1,17 @@
+class Solution {
+    func calPoints(_ operations: [String]) -> Int {
+        var scoreArray = [Int]()
+		for i in 0..<operations.count {
+			if operations[i] == "C" {
+				scoreArray.removeLast()
+			} else if operations[i] == "D" {
+				scoreArray.append(scoreArray.last! * 2)
+			} else if operations[i] == "+" {
+				scoreArray.append(scoreArray[scoreArray.count - 2] + scoreArray[scoreArray.count - 1])
+			} else {
+				scoreArray.append(Int(operations[i])!)
+			}
+		}
+		return scoreArray.isEmpty ? 0 : scoreArray.reduce(0, +)
+    }
+}

Diff for: typescript/1930-unique-length-3-palindromic-subsequences.ts

@@ -0,0 +1,20 @@
+function countPalindromicSubsequence(s: string): number {
+    const alphabets = 'abcdefghijklmnopqrstuvwxyz';
+
+    const N = alphabets.length;
+    let count = 0;
+
+    for (let i = 0; i < N; i += 1) {
+        const ch = alphabets[i];
+        const left = s.indexOf(ch);
+        const right = s.lastIndexOf(ch);
+        if (left < right) {
+            for (const alpha of alphabets) {
+                const mid = s.indexOf(alpha, left + 1);
+                if (mid !== -1 && mid < right) count += 1;
+            }
+        }
+    }
+
+    return count;
+}