Added task 3374

Author: javadev

README.md

@@ -1816,6 +1816,7 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3374 |[First Letter Capitalization II](src/main/java/g3301_3400/s3374_first_letter_capitalization_ii)| Hard | Database | 261 | 84.21
 | 3373 |[Maximize the Number of Target Nodes After Connecting Trees II](src/main/java/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii)| Hard | Depth_First_Search, Breadth_First_Search, Tree | 26 | 98.75
 | 3372 |[Maximize the Number of Target Nodes After Connecting Trees I](src/main/java/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i)| Medium | Depth_First_Search, Breadth_First_Search, Tree | 50 | 99.49
 | 3371 |[Identify the Largest Outlier in an Array](src/main/java/g3301_3400/s3371_identify_the_largest_outlier_in_an_array)| Medium | Array, Hash_Table, Counting, Enumeration | 5 | 100.00

src/main/java/g0001_0100/s0014_longest_common_prefix/readme.md

@@ -43,7 +43,7 @@ public class Solution {
         String temp = strs[0];
         int i = 1;
         String cur;
-        while (temp.length() > 0 && i < strs.length) {
+        while (!temp.isEmpty() && i < strs.length) {
             if (temp.length() > strs[i].length()) {
                 temp = temp.substring(0, strs[i].length());
             }

src/main/java/g0001_0100/s0065_valid_number/readme.md

@@ -61,7 +61,7 @@ Given a string `s`, return `true` _if_ `s` _is a **valid number**_.
 ```java
 public class Solution {
     public boolean isNumber(String s) {
-        if (s == null || s.length() == 0) {
+        if (s == null || s.isEmpty()) {
             return false;
         }
         boolean eSeen = false;

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

@@ -71,7 +71,7 @@ import java.util.List;
 public class Solution {
     public List<String> addOperators(String num, int target) {
         List<String> res = new ArrayList<>();
-        if (num.length() == 0 || Long.parseLong(num) > Integer.MAX_VALUE) {
+        if (num.isEmpty() || Long.parseLong(num) > Integer.MAX_VALUE) {
             return res;
         }
         char[] list = num.toCharArray();

src/main/java/g0401_0500/s0434_number_of_segments_in_a_string/readme.md

@@ -35,13 +35,13 @@ A **segment** is defined to be a contiguous sequence of **non-space characters**
 public class Solution {
     public int countSegments(String s) {
         s = s.trim();
-        if (s.length() == 0) {
+        if (s.isEmpty()) {
             return 0;
         }
         String[] splitted = s.split(" ");
         int result = 0;
         for (String value : splitted) {
-            if (value.length() > 0) {
+            if (!value.isEmpty()) {
                 result++;
             }
         }

src/main/java/g0401_0500/s0468_validate_ip_address/readme.md

@@ -52,7 +52,7 @@ public class Solution {
     private static final String NEITHER = "Neither";
 
     public String validIPAddress(String ip) {
-        if (ip.length() == 0) {
+        if (ip.isEmpty()) {
             return NEITHER;
         }
         String[] arr = ip.split("\\.", -1);
@@ -70,7 +70,7 @@ public class Solution {
             return "IPv4";
         } else if (arr1.length == 8) {
             for (String num : arr1) {
-                if (num.length() < 1 || num.length() > 4) {
+                if (num.isEmpty() || num.length() > 4) {
                     return NEITHER;
                 }
                 for (int j = 0; j < num.length(); j++) {

src/main/java/g0401_0500/s0488_zuma_game/readme.md

@@ -84,10 +84,10 @@ public class Solution {
     }
 
     private int findMinStepDp(String board, String hand, Map<String, Map<String, Integer>> dp) {
-        if (board.length() == 0) {
+        if (board.isEmpty()) {
             return 0;
         }
-        if (hand.length() == 0) {
+        if (hand.isEmpty()) {
             return -1;
         }
         if (dp.get(board) != null && dp.get(board).get(hand) != null) {

src/main/java/g0501_0600/s0520_detect_capital/readme.md

@@ -35,7 +35,7 @@ Given a string `word`, return `true` if the usage of capitals in it is right.
 ```java
 public class Solution {
     public boolean detectCapitalUse(String word) {
-        if (word == null || word.length() == 0) {
+        if (word == null || word.isEmpty()) {
             return false;
         }
         int upper = 0;

src/main/java/g0601_0700/s0664_strange_printer/readme.md

@@ -38,7 +38,7 @@ Given a string `s`, return _the minimum number of turns the printer needed to pr
 ```java
 public class Solution {
     public int strangePrinter(String s) {
-        if (s.length() == 0) {
+        if (s.isEmpty()) {
             return 0;
         }
         int[][] dp = new int[s.length()][s.length()];

src/main/java/g0701_0800/s0761_special_binary_string/readme.md

@@ -46,7 +46,7 @@ import java.util.PriorityQueue;
 
 public class Solution {
     public String makeLargestSpecial(String s) {
-        if (s == null || s.length() == 0 || s.length() == 2) {
+        if (s == null || s.isEmpty() || s.length() == 2) {
             return s;
         }
         PriorityQueue<String> pq = new PriorityQueue<>((a, b) -> b.compareTo(a));
@@ -72,7 +72,7 @@ public class Solution {
         while (!pq.isEmpty()) {
             ans.append(pq.poll());
         }
-        if (ans.length() == 0) {
+        if (ans.isEmpty()) {
             ans.append('1');
             ans.append(makeLargestSpecial(s.substring(1, s.length() - 1)));
             ans.append('0');

src/main/java/g1001_1100/s1002_find_common_characters/readme.md

@@ -52,7 +52,7 @@ public class Solution {
     }
 
     private String getCommon(String s1, String s2) {
-        if (s1.length() == 0 || s2.length() == 0) {
+        if (s1.isEmpty() || s2.isEmpty()) {
             return "";
         }
         int[] c1c = countChars(s1);

src/main/java/g1101_1200/s1138_alphabet_board_path/readme.md

@@ -45,7 +45,7 @@ Return a sequence of moves that makes our answer equal to `target` in the minimu
 ```java
 public class Solution {
     public String alphabetBoardPath(String target) {
-        if (target.length() == 0) {
+        if (target.isEmpty()) {
             return "";
         }
         int sourceRow = 0;

src/main/java/g1701_1800/s1704_determine_if_string_halves_are_alike/readme.md

@@ -38,7 +38,7 @@ Return `true` _if_ `a` _and_ `b` _are **alike**_. Otherwise, return `false`.
 ```java
 public class Solution {
     public boolean halvesAreAlike(String s) {
-        if (s.length() < 1) {
+        if (s.isEmpty()) {
             return false;
         }
         return countVowel(0, s.length() / 2, s) == countVowel(s.length() / 2, s.length(), s);

src/main/java/g1801_1900/s1898_maximum_number_of_removable_characters/readme.md

@@ -59,7 +59,7 @@ Hence, the maximum k is 2.
 ```java
 public class Solution {
     public int maximumRemovals(String s, String p, int[] removable) {
-        if (s == null || s.length() == 0) {
+        if (s == null || s.isEmpty()) {
             return 0;
         }
         // binary search for the k which need to be removed

src/main/java/g1901_2000/s1948_delete_duplicate_folders_in_system/readme.md

@@ -132,14 +132,14 @@ public class Solution {
                 folder.calculateHash();
                 builder.append('#');
                 builder.append(foldername);
-                if (folder.folderHash.length() > 0) {
+                if (!folder.folderHash.isEmpty()) {
                     builder.append('(');
                     builder.append(folder.folderHash);
                     builder.append(')');
                 }
             }
             folderHash = builder.toString();
-            if (folderHash.length() > 0) {
+            if (!folderHash.isEmpty()) {
                 ArrayList<Folder> duplicateFolders =
                         duplicates.computeIfAbsent(folderHash, k -> new ArrayList<>());
                 duplicateFolders.add(this);

src/main/java/g3301_3400/s3374_first_letter_capitalization_ii/readme.md

@@ -0,0 +1,79 @@
+[![](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)
+
+## 3374\. First Letter Capitalization II
+
+Hard
+
+SQL Schema
+
+Table: `user_content`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | content_id  | int     |
+    | content_text| varchar |
+    +-------------+---------+
+content_id is the unique key for this table. Each row contains a unique ID and the corresponding text content. 
+
+Write a solution to transform the text in the `content_text` column by applying the following rules:
+
+*   Convert the **first letter** of each word to **uppercase** and the **remaining** letters to **lowercase**
+*   Special handling for words containing special characters:
+    *   For words connected with a hyphen `-`, **both parts** should be **capitalized** (**e.g.**, top-rated → Top-Rated)
+*   All other **formatting** and **spacing** should remain **unchanged**
+
+Return _the result table that includes both the original `content_text` and the modified text following the above rules_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+user\_content table:
+
+    +------------+---------------------------------+
+    | content_id | content_text                    |
+    +------------+---------------------------------+
+    | 1          | hello world of SQL              |
+    | 2          | the QUICK-brown fox             |
+    | 3          | modern-day DATA science         |
+    | 4          | web-based FRONT-end development |
+    +------------+---------------------------------+ 
+
+**Output:**
+
+    +------------+---------------------------------+---------------------------------+
+    | content_id | original_text                   | converted_text                  |
+    +------------+---------------------------------+---------------------------------+
+    | 1          | hello world of SQL              | Hello World Of Sql              |
+    | 2          | the QUICK-brown fox             | The Quick-Brown Fox             |
+    | 3          | modern-day DATA science         | Modern-Day Data Science         |
+    | 4          | web-based FRONT-end development | Web-Based Front-End Development |
+    +------------+---------------------------------+---------------------------------+ 
+
+**Explanation:**
+
+*   For content\_id = 1:
+    *   Each word's first letter is capitalized: "Hello World Of Sql"
+*   For content\_id = 2:
+    *   Contains the hyphenated word "QUICK-brown" which becomes "Quick-Brown"
+    *   Other words follow normal capitalization rules
+*   For content\_id = 3:
+    *   Hyphenated word "modern-day" becomes "Modern-Day"
+    *   "DATA" is converted to "Data"
+*   For content\_id = 4:
+    *   Contains two hyphenated words: "web-based" → "Web-Based"
+    *   And "FRONT-end" → "Front-End"
+
+## Solution
+
+```python
+import pandas as pd
+
+def capitalize_content(user_content):
+    user_content['converted_text'] = (user_content.content_text.apply(lambda x: x.title()))
+    return user_content.rename(columns={'content_text': 'original_text'})
+```