Added tasks 233, 234.

Author: javadev

src/main/java/g0001_0100/s0052_n_queens_ii/Solution.java

@@ -9,7 +9,7 @@ public int totalNQueens(int n) {
         return totalNQueens(n, 0, row, col, diagonal, antiDiagonal);
     }
 
-    private static int totalNQueens(
+    private int totalNQueens(
             int n,
             int r,
             boolean[] row,

src/main/java/g0201_0300/s0233_number_of_digit_one/Solution.java

@@ -0,0 +1,24 @@
+package g0201_0300.s0233_number_of_digit_one;
+
+@SuppressWarnings("java:S127")
+public class Solution {
+    public int countDigitOne(int n) {
+        int ans = 0;
+        // count total number of 1s appearing in every digit, starting from the last digit
+        for (int k = n, cum = 0, curr10 = 1; k > 0; curr10 *= 10) {
+            int rem = k % 10;
+            int q = k / 10;
+            if (rem == 0) {
+                ans += q * curr10;
+            } else if (rem == 1) {
+                ans += q * curr10 + cum + 1;
+            } else {
+                ans += (q + 1) * curr10;
+            }
+            k = q;
+            // if loop is at 3rd last digit and n = 54321, cum is now = 321
+            cum += rem * curr10;
+        }
+        return ans;
+    }
+}

src/main/java/g0201_0300/s0233_number_of_digit_one/readme.md

@@ -0,0 +1,21 @@
+233\. Number of Digit One
+
+Hard
+
+Given an integer `n`, count _the total number of digit_ `1` _appearing in all non-negative integers less than or equal to_ `n`.
+
+**Example 1:**
+
+**Input:** n = 13
+
+**Output:** 6 
+
+**Example 2:**
+
+**Input:** n = 0
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>9</sup></code>

src/main/java/g0201_0300/s0234_palindrome_linked_list/Solution.java

@@ -0,0 +1,38 @@
+package g0201_0300.s0234_palindrome_linked_list;
+
+import com_github_leetcode.ListNode;
+
+public class Solution {
+    public boolean isPalindrome(ListNode head) {
+        int len = 0;
+        ListNode right = head;
+        // Culculate the length
+        while (right != null) {
+            right = right.next;
+            len++;
+        }
+        // Reverse the right half of the list
+        len = len / 2;
+        right = head;
+        for (int i = 0; i < len; i++) {
+            right = right.next;
+        }
+        ListNode prev = null;
+        while (right != null) {
+            ListNode next = right.next;
+            right.next = prev;
+            prev = right;
+            right = next;
+        }
+        // Compare left half and right half
+        for (int i = 0; i < len; i++) {
+            if (prev != null && head.val == prev.val) {
+                head = head.next;
+                prev = prev.next;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g0201_0300/s0234_palindrome_linked_list/readme.md

@@ -0,0 +1,28 @@
+234\. Palindrome Linked List
+
+Easy
+
+Given the `head` of a singly linked list, return `true` if it is a palindrome.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg)
+
+**Input:** head = \[1,2,2,1\]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg)
+
+**Input:** head = \[1,2\]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   `0 <= Node.val <= 9`
+
+**Follow up:** Could you do it in `O(n)` time and `O(1)` space?

src/test/java/g0201_0300/s0233_number_of_digit_one/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0201_0300.s0233_number_of_digit_one;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void countDigitOne() {
+        assertThat(new Solution().countDigitOne(13), equalTo(6));
+    }
+
+    @Test
+    public void countDigitOne2() {
+        assertThat(new Solution().countDigitOne(0), equalTo(0));
+    }
+}

src/test/java/g0201_0300/s0234_palindrome_linked_list/SolutionTest.java

@@ -0,0 +1,25 @@
+package g0201_0300.s0234_palindrome_linked_list;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.ListNode;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void isPalindrome() {
+        ListNode headActual = new ListNode(1);
+        headActual.next = new ListNode(2);
+        headActual.next.next = new ListNode(2);
+        headActual.next.next.next = new ListNode(1);
+        assertThat(new Solution().isPalindrome(headActual), equalTo(true));
+    }
+
+    @Test
+    public void isPalindrome2() {
+        ListNode headActual = new ListNode(1);
+        headActual.next = new ListNode(2);
+        assertThat(new Solution().isPalindrome(headActual), equalTo(false));
+    }
+}