Added tasks 3232-3245

Author: javadev

README.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3232\. Find if Digit Game Can Be Won
+
+Easy
+
+You are given an array of **positive** integers `nums`.
+
+Alice and Bob are playing a game. In the game, Alice can choose **either** all single-digit numbers or all double-digit numbers from `nums`, and the rest of the numbers are given to Bob. Alice wins if the sum of her numbers is **strictly greater** than the sum of Bob's numbers.
+
+Return `true` if Alice can win this game, otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,10]
+
+**Output:** false
+
+**Explanation:**
+
+Alice cannot win by choosing either single-digit or double-digit numbers.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4,5,14]
+
+**Output:** true
+
+**Explanation:**
+
+Alice can win by choosing single-digit numbers which have a sum equal to 15.
+
+**Example 3:**
+
+**Input:** nums = [5,5,5,25]
+
+**Output:** true
+
+**Explanation:**
+
+Alice can win by choosing double-digit numbers which have a sum equal to 25.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 99`
+
+## Solution
+
+```java
+public class Solution {
+    public boolean canAliceWin(int[] nums) {
+        int sdSum = 0;
+        int ddSum = 0;
+        for (int num : nums) {
+            if (num / 10 == 0) {
+                sdSum += num;
+            } else {
+                ddSum += num;
+            }
+        }
+        return sdSum != ddSum;
+    }
+}
+```

src/main/java/g3201_3300/s3232_find_if_digit_game_can_be_won/readme.md

@@ -0,0 +1,86 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3233\. Find the Count of Numbers Which Are Not Special
+
+Medium
+
+You are given 2 **positive** integers `l` and `r`. For any number `x`, all positive divisors of `x` _except_ `x` are called the **proper divisors** of `x`.
+
+A number is called **special** if it has exactly 2 **proper divisors**. For example:
+
+*   The number 4 is _special_ because it has proper divisors 1 and 2.
+*   The number 6 is _not special_ because it has proper divisors 1, 2, and 3.
+
+Return the count of numbers in the range `[l, r]` that are **not** **special**.
+
+**Example 1:**
+
+**Input:** l = 5, r = 7
+
+**Output:** 3
+
+**Explanation:**
+
+There are no special numbers in the range `[5, 7]`.
+
+**Example 2:**
+
+**Input:** l = 4, r = 16
+
+**Output:** 11
+
+**Explanation:**
+
+The special numbers in the range `[4, 16]` are 4 and 9.
+
+**Constraints:**
+
+*   <code>1 <= l <= r <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int nonSpecialCount(int l, int r) {
+        List<Integer> primes = sieveOfEratosthenes((int) Math.sqrt(r));
+        int specialCount = 0;
+
+        for (Integer prime : primes) {
+            long primeSquare = (long) prime * prime;
+            if (primeSquare >= l && primeSquare <= r) {
+                specialCount++;
+            }
+        }
+
+        int totalNumbersInRange = r - l + 1;
+        return totalNumbersInRange - specialCount;
+    }
+
+    private List<Integer> sieveOfEratosthenes(int n) {
+        boolean[] isPrime = new boolean[n + 1];
+        for (int i = 2; i <= n; i++) {
+            isPrime[i] = true;
+        }
+
+        for (int p = 2; p * p <= n; p++) {
+            if (isPrime[p]) {
+                for (int i = p * p; i <= n; i += p) {
+                    isPrime[i] = false;
+                }
+            }
+        }
+
+        List<Integer> primes = new ArrayList<>();
+        for (int i = 2; i <= n; i++) {
+            if (isPrime[i]) {
+                primes.add(i);
+            }
+        }
+        return primes;
+    }
+}
+```

src/main/java/g3201_3300/s3233_find_the_count_of_numbers_which_are_not_special/readme.md

@@ -0,0 +1,89 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3234\. Count the Number of Substrings With Dominant Ones
+
+Medium
+
+You are given a binary string `s`.
+
+Return the number of substrings with **dominant** ones.
+
+A string has **dominant** ones if the number of ones in the string is **greater than or equal to** the **square** of the number of zeros in the string.
+
+**Example 1:**
+
+**Input:** s = "00011"
+
+**Output:** 5
+
+**Explanation:**
+
+The substrings with dominant ones are shown in the table below.
+
+| i | j | s[i..j] | Number of Zeros | Number of Ones |
+|---|---|---------|-----------------|----------------|
+| 3 | 3 | 1       | 0               | 1              |
+| 4 | 4 | 1       | 0               | 1              |
+| 2 | 3 | 01      | 1               | 1              |
+| 3 | 4 | 11      | 0               | 2              |
+| 2 | 4 | 011     | 1               | 2              |
+
+**Example 2:**
+
+**Input:** s = "101101"
+
+**Output:** 16
+
+**Explanation:**
+
+The substrings with **non-dominant** ones are shown in the table below.
+
+Since there are 21 substrings total and 5 of them have non-dominant ones, it follows that there are 16 substrings with dominant ones.
+
+| i | j | s[i..j] | Number of Zeros | Number of Ones |
+|---|---|---------|-----------------|----------------|
+| 1 | 1 | 0       | 1               | 0              |
+| 4 | 4 | 0       | 1               | 0              |
+| 1 | 4 | 0110    | 2               | 2              |
+| 0 | 4 | 10110   | 2               | 3              |
+| 1 | 5 | 01101   | 2               | 3              |
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 4 * 10<sup>4</sup></code>
+*   `s` consists only of characters `'0'` and `'1'`.
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int numberOfSubstrings(String s) {
+        List<Integer> zero = new ArrayList<>();
+        zero.add(-1);
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '0') {
+                zero.add(i);
+            } else {
+                result += i - zero.get(zero.size() - 1);
+            }
+            for (int j = 1; j < zero.size(); j++) {
+                int len = j * (j + 1);
+                if (len > i + 1) {
+                    break;
+                }
+                int prev = zero.get(zero.size() - j - 1);
+                int from = Math.min(i - len + 1, zero.get(zero.size() - j));
+                if (from > prev) {
+                    result += from - prev;
+                }
+            }
+        }
+        return result;
+    }
+}
+```