##### Problem Statement
There is a new alien language which uses the English alphabet. However, the order among letters are unknown to you. You are given a list of words from the dictionary, where words are sorted lexicographically by the rules of this new language. Derive the order of letters in this language.

##### Example
```plaintext
Input: words = ["wrt", "wrf", "er", "ett", "rftt"]
Output: "wertf"

Input: words = ["z", "x", "z"]
Output: "" (Invalid order, as there's a cycle)
```

##### Constraints
- `1 <= words.length <= 1000`
- `1 <= words[i].length <= 100`
- `words[i]` consists of only lowercase English letters.

#### Expected Challenge Output
When the function `alienOrder` is called with the given example input, the expected output is the correct order of letters in the alien language, or an empty string if no valid order exists.

JavaScript

JavaScript is a high-level, dynamic, and interpreted programming language that is widely used for web development and beyond. It was created in the mid-1990s and has since become one of the most popular and widely used programming languages in the world. JavaScript allows developers to create interactive and dynamic websites, as well as build complex web applications and server-side programs. It is a versatile language that can run on any modern web browser, as well as server environments like Node.js, making it an essential tool for any full-stack web developer.

learn-javascript

Python

Python is a high-level, interpreted, general-purpose programming language. It was created in the late 1980s by Guido van Rossum and has since become one of the most popular programming languages in the world. Python is known for its simple and easy-to-read syntax, making it a great language for beginners to learn, and for experienced developers to write complex applications.

Python is used in a variety of applications, including web development, scientific computing, data analysis, artificial intelligence, and more. It has a large and active community of users and developers who have created many libraries and frameworks that make it easier to build complex applications quickly. Python is also known for its strong support for object-oriented programming and its dynamic typing, which makes it flexible and easy to use.

Overall, Python is a versatile and powerful language that can be used for a wide range of applications, making it a great choice for developers looking to build anything from simple scripts to complex applications.

learn-python

C++ Programming

C++ is a high-level, general-purpose programming language that was created as an extension of the C programming language. It is widely used for developing systems software, game development, and desktop and mobile applications. C++ is known for its performance, efficiency, and versatility, making it a popular choice for developing resource-intensive applications. It is also used in the development of other programming languages, as well as in various scientific and engineering applications. C++ is considered a mid-level language, as it contains both high-level and low-level programming concepts, and provides control over system resources through its use of pointers and manual memory management.

learn-cpp-programming

C Programming

This C fundamentals learning module is designed to teach individuals the basics of programming using the C programming language. The module typically covers the fundamentals of C programming, including topics such as data types, variables, control structures, functions, pointers, and memory management. The module may also cover more advanced topics, such as file handling, dynamic memory allocation, and multithreading.

learn-c-programming

Alien Dictionary Order

alien-dictionary-order

##### Problem Statement
Given an array of integers and a number `k`, rotate the array to the right by `k` steps.

##### Example
```plaintext
Input: nums = [1, 2, 3, 4, 5, 6, 7], k = 3
Output: [5, 6, 7, 1, 2, 3, 4]

Input: nums = [-1, -100, 3, 99], k = 2
Output: [3, 99, -1, -100]
```

##### Constraints
- `1 <= nums.length <= 10^5`
- `-2^31 <= nums[i] <= 2^31 - 1`
- `0 <= k <= 10^5`

#### Expected Challenge Output
When the function `rotateArray` is called with the given example inputs, the expected output is the rotated array.

Array Rotation

array-rotation

##### Problem Statement
Given an integer `n`, determine if it is a prime number. A prime number is a number greater than 1 with no positive divisors other than 1 and itself.

##### Example
```plaintext
Input: n = 5
Output: True
Explanation: 5 is a prime number.

Input: n = 4
Output: False
Explanation: 4 is not a prime number.
```

##### Constraints
- `1 <= n <= 10^9`

#### Expected Challenge Output
When the function `isPrime` is called with the given example inputs, the expected outputs are:
- For the input `5`, the output is `True`.
- For the input `4`, the output is `False`.

Check if Number is Prime

check-if-number-is-prime

##### Problem Statement
Given n non-negative integers `height` where each represents a point at coordinate `(i, height[i])`. n vertical lines are drawn such that the two endpoints of the line `i` is at `(i, height[i])` and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.

Notice that you may not slant the container.

##### Example
```plaintext
Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49
Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
```

```plaintext
Input: height = [1,1]
Output: 1
```

```plaintext
Input: height = [4,3,2,1,4]
Output: 16
```

##### Constraints
- `n == height.size()`
- `2 <= n <= 10^5`
- `0 <= height[i] <= 10^4`


#### Expected Challenge Output
When the function `maxArea` is called with the given example inputs, the expected outputs are:
- For the input `[1,8,6,2,5,4,8,3,7]`, the output is `49`.
- For the input `[1,1]`, the output is `1`.
- For the input `[4,3,2,1,4]`, the output is `16`.

##### Problem Statement
Given n non-negative integers `height` where each represents a point at coordinate `(i, height[i])`. n vertical lines are drawn such that the two endpoints of the line `i` is at `(i, height[i])` and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.

Notice that you may not slant the container.

##### Example
```plaintext
Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49
Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
```

```plaintext
Input: height = [1,1]
Output: 1
```

```plaintext
Input: height = [4,3,2,1,4]
Output: 16
```

##### Constraints
- `n == height.length`
- `2 <= n <= 10^5`
- `0 <= height[i] <= 10^4`


#### Expected Challenge Output
When the function `maxArea` is called with the given example inputs, the expected outputs are:
- For the input `[1,8,6,2,5,4,8,3,7]`, the output is `49`.
- For the input `[1,1]`, the output is `1`.
- For the input `[4,3,2,1,4]`, the output is `16`.

Container With Most Water

container-with-most-water

##### Problem Statement
Given a time in 12-hour AM/PM format, convert it to military (24-hour) time.

##### Example
```plaintext
Input: 07:05:45PM
Output: 19:05:45
```

```plaintext
Input: 12:00:00AM
Output: 00:00:00
```

##### Constraints
- The input string will always be in the format `hh:mm:ssAM` or `hh:mm:ssPM`.


#### Expected Challenge Output
When the function `convertTimeFormat` is called with the given example inputs, the expected outputs are:
- For the input `"07:05:45PM"`, the output is `"19:05:45"`.
- For the input `"12:00:00AM"`, the output is `"00:00:00"`.

These outputs represent the time in military format.

##### Problem Statement
Given a time in 12-hour AM/PM format, convert it to military (24-hour) time.

##### Example
```plaintext
Input: 07:05:45PM
Output: 19:05:45
```

```plaintext
Input: 12:00:00AM
Output: 00:00:00
```

##### Constraints
- The input string will always be in the format `hh:mm:ssAM` or `hh:mm:ssPM`.


#### Expected Challenge Output
When the function `convert_time_format` is called with the given example inputs, the expected outputs are:
- For the input `"07:05:45PM"`, the output is `"19:05:45"`.
- For the input `"12:00:00AM"`, the output is `"00:00:00"`.

These outputs represent the time in military format.

Convert Time Format

convert-time-format

##### Problem Statement
Write a function to validate an email address. The function should check if the given email address is in the correct format. The correct format for an email address is as follows:

- It must have the format `local@domain`.
- The `local` part can contain alphanumeric characters and special characters `._%+-`.
- The `domain` part can contain alphanumeric characters and hyphens `-`.
- The `domain` part must contain at least one dot `.` with at least one character before and after it.
- The overall length of the email should be no more than 254 characters.

##### Example
```plaintext
Input: email = "test.email+alex@leetcode.com"
Output: True

Input: email = "test.email.leetcode.com"
Output: False
```

##### Constraints
- The email address string will be a non-empty string.

#### Expected Challenge Output
When the function `isValidEmail` is called with the given example input, the expected output is a boolean indicating whether the email is valid or not.

##### Problem Statement
Write a function to validate an email address. The function should check if the given email address is in the correct format. The correct format for an email address is as follows:

- It must have the format `local@domain`.
- The `local` part can contain alphanumeric characters and special characters `._%+-`.
- The `domain` part can contain alphanumeric characters and hyphens `-`.
- The `domain` part must contain at least one dot `.` with at least one character before and after it.
- The overall length of the email should be no more than 254 characters.

##### Example
```plaintext
Input: email = "test.email+alex@leetcode.com"
Output: true

Input: email = "test.email.leetcode.com"
Output: false
```

##### Constraints
- The email address string will be a non-empty string.

#### Expected Challenge Output
When the function `isValidEmail` is called with the given example input, the expected output is a boolean indicating whether the email is valid or not.

Email Address Validator

email-address-validator

##### Problem Statement
Given a string `s` and a non-empty string `p`, find all the start indices of `p`'s anagrams in `s`. The order of output does not matter.

##### Example
```plaintext
Input: s = 'cbaebabacd', p = 'abc'
Output: [0, 6]
Explanation: The substring 'cba' starting at index 0 and 'bac' starting at index 6 are anagrams of 'abc'.
```

```plaintext
Input: s = 'abab', p = 'ab'
Output: [0, 1, 2]
Explanation: The substring 'ab' starting at index 0, 'ba' starting at index 1, and 'ab' starting at index 2 are anagrams of 'ab'.
```

##### Constraints
- The input strings only contain lowercase English letters.
- The length of both strings will not be larger than `20,100`.


#### Expected Challenge Output
When the function `findAnagrams` is called with the given example inputs, the expected outputs are:
- For the input `s = 'cbaebabacd', p = 'abc'`, the output is `[0, 6]`.
- For the input `s = 'abab', p = 'ab'`, the output is `[0, 1, 2]`.

Find All Anagrams in a String

find-all-anagrams-in-a-string

##### Problem Statement
Given an integer `n`, return the `n`th number in the Fibonacci sequence. The Fibonacci sequence is defined as follows:
- `F(0) = 0, F(1) = 1`
- `F(n) = F(n-1) + F(n-2)` for `n > 1`

##### Example
```plaintext
Input: n = 5
Output: 5
Explanation: The 5th Fibonacci number is 5.

Input: n = 10
Output: 55
Explanation: The 10th Fibonacci number is 55.
```

##### Constraints
- `0 <= n <= 30`

#### Expected Challenge Output
When the function `fibonacci` is called with the given example inputs, the expected outputs are:
- For the input `5`, the output is `5`.
- For the input `10`, the output is `55`.

Find Fibonacci Number at Nth Position

find-fibonacci-number-at-nth-position

##### Problem Statement
Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. The LCA is defined as the lowest node that has both nodes as descendants.

##### Example
```plaintext
Input: root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 8
Output: 6

Input: root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 4
Output: 2
```

##### Constraints
- All values in the tree are unique.
- p and q are different and both values exist in the BST.

#### Expected Challenge Output
When the function `lowestCommonAncestor` is called with the given example inputs, the expected outputs are:
- For the input `root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 8`, the output is `6`.
- For the input `root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 4`, the output is `2`.

Find Lowest Common Ancestor in BST

find-lowest-common-ancestor-in-bst

##### Problem Statement
Given an array `nums` containing `n` distinct numbers in the range `[0, n]`, return the only number in the range that is missing from the array.

##### Example
```plaintext
Input: nums = [3, 0, 1]
Output: 2

Input: nums = [0, 1]
Output: 2

Input: nums = [9,6,4,2,3,5,7,0,1]
Output: 8
```

##### Constraints
- `n == nums.length`
- `1 <= n <= 10^4`
- `0 <= nums[i] <= n`
- All the numbers of `nums` are unique.

#### Expected Challenge Output
When the function `findMissingNumber` is called with the given example inputs, the expected output is the missing number in the array.

Find Missing Number

find-missing-number

##### Problem Statement
You are given an integer array `nums`, where `nums[i]` is the value of the array at index `i`. A peak element is an element that is strictly greater than its neighbors.

Return the index of any peak element if there is one. If there are multiple peaks, return the index to any one of them.

You may imagine that `nums[-1] = nums[n] = -∞`, where `n` is the length of `nums`.

##### Example
```plaintext
Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and it is at index 2.
```

```plaintext
Input: nums = [1,2,1,3,5,6,4]
Output: 5
Explanation: 6 is a peak element and it is at index 5.
```

##### Constraints
- `1 <= nums.size() <= 1000`
- `-2^31 <= nums[i] <= 2^31 - 1`
- `nums[i] != nums[i + 1]` for all valid `i`


#### Expected Challenge Output
When the function `findPeakElement` is called with the given example inputs, the expected outputs are:
- For the input `[1,2,3,1]`, the output is `2`.
- For the input `[1,2,1,3,5,6,4]`, the output is `5`.

##### Problem Statement
You are given an integer array `nums`, where `nums[i]` is the value of the array at index `i`. A peak element is an element that is strictly greater than its neighbors.

Return the index of any peak element if there is one. If there are multiple peaks, return the index to any one of them.

You may imagine that `nums[-1] = nums[n] = -∞`, where `n` is the length of `nums`.

##### Example
```plaintext
Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and it is at index 2.
```

```plaintext
Input: nums = [1,2,1,3,5,6,4]
Output: 5
Explanation: 6 is a peak element and it is at index 5.
```

##### Constraints
- `1 <= nums.length <= 1000`
- `-2^31 <= nums[i] <= 2^31 - 1`
- `nums[i] != nums[i + 1]` for all valid `i`


#### Expected Challenge Output
When the function `findPeakElement` is called with the given example inputs, the expected outputs are:
- For the input `[1,2,3,1]`, the output is `2`.
- For the input `[1,2,1,3,5,6,4]`, the output is `5`.

Find Peak Element

find-peak-element

##### Problem Statement
Given a 2D grid of characters where 'S' represents the start position, 'T' represents the target, 'O' represents open spaces, and 'X' represents walls, find the shortest path from 'S' to 'T'. You can move up, down, left, or right.

##### Example
```plaintext
Input: grid = [
  ['S', 'O', 'X', 'O'],
  ['O', 'O', 'X', 'O'],
  ['X', 'O', 'O', 'T'],
  ['O', 'X', 'X', 'O']
]
Output: 5
Explanation: The shortest path is 5 steps.
```

##### Constraints
- The grid will have at most 1000 rows and columns.


#### Expected Challenge Output
When the function `findShortestPath` is called with the given example input, the expected output is:
- For the input grid, the output is `5`.

Find Target in a Maze

find-target-in-a-maze

##### Problem Statement
Write a program that outputs the string representation of numbers from 1 to n.

But for multiples of three, it should output 'Fizz' instead of the number and for the multiples of five output 'Buzz'. For numbers which are multiples of both three and five output 'FizzBuzz'.

##### Example
```plaintext
Input: n = 15
Output: ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"]
```

##### Constraints
- `1 <= n <= 10^4`


#### Expected Challenge Output
When the function `fizzBuzz` is called with the given example input, the expected output is:
- For the input `15`, the output is `["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"]`.

FizzBuzz

fizz-buzz

##### Problem Statement
Given the root of a binary search tree and a node `p` in it, write a function to find the in-order successor of that node in the BST. The in-order successor of a node `p` is the node with the smallest key greater than `p.val`.

##### Example
```plaintext
Input: root = [2,1,3], p = 1
Output: 2

Input: root = [5,3,6,2,4,null,null,1], p = 6
Output: None
```

##### Constraints
- The number of nodes in the tree is in the range `[1, 10^4]`.
- `-10^5 <= Node.val <= 10^5`
- All `Node.val` are unique.

#### Expected Challenge Output
When the function `inOrderSuccessor` is called with the given example input, the expected output is the value of the in-order successor of the given node `p`, or `None` if no successor exists.

In-Order Successor in Binary Search Tree

in-order-successor-bst

##### Problem Statement
Given an integer, convert it to a Roman numeral. Roman numerals are represented by seven different symbols: I, V, X, L, C, D, and M.

| Symbol | Value |
|--------|-------|
| I      | 1     |
| V      | 5     |
| X      | 10    |
| L      | 50    |
| C      | 100   |
| D      | 500   |
| M      | 1000  |

For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

- I can be placed before V (5) and X (10) to make 4 and 9.
- X can be placed before L (50) and C (100) to make 40 and 90.
- C can be placed before D (500) and M (1000) to make 400 and 900.

Given an integer, convert it to a Roman numeral.

##### Example
```plaintext
Input: num = 1994
Output: "MCMXCIV"
```

##### Constraints
- `1 <= num <= 3999`

#### Expected Challenge Output
When the function `intToRoman` is called with the given example input, the expected output is the corresponding Roman numeral string.

Integer to Roman Numeral

integer-to-roman

##### Problem Statement
Given a string `s`, return the longest palindromic substring in `s`.

##### Example
```plaintext
Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.
```

```plaintext
Input: s = "cbbd"
Output: "bb"
```

##### Constraints
- `1 <= s.length <= 1000`
- `s` consist of only digits and English letters (lower-case and/or upper-case).


#### Expected Challenge Output
When the function `longestPalindromicSubstring` is called with the given example inputs, the expected outputs are:
- For the input `"babad"`, the output is `"bab"` or `"aba"`.
- For the input `"cbbd"`, the output is `"bb"`.

These outputs represent the longest palindromic substrings in the provided strings.

##### Problem Statement
Given a string `s`, return the longest palindromic substring in `s`.

##### Example
```plaintext
Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.
```

```plaintext
Input: s = "cbbd"
Output: "bb"
```

##### Constraints
- `1 <= s.length <= 1000`
- `s` consist of only digits and English letters (lower-case and/or upper-case).


#### Expected Challenge Output
When the function `longest_palindromic_substring` is called with the given example inputs, the expected outputs are:
- For the input `"babad"`, the output is `"bab"` or `"aba"`.
- For the input `"cbbd"`, the output is `"bb"`.

These outputs represent the longest palindromic substrings in the provided strings.

Longest Palindromic Substring

longest-palindromic-substring

##### Problem Statement
Given a string `s`, find the length of the longest substring without repeating characters.

##### Example
```plaintext
Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.
```

```plaintext
Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.
```

```plaintext
Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
```

##### Constraints
- `0 <= s.length <= 5 * 10^4`
- `s` consists of English letters, digits, symbols and spaces.


#### Expected Challenge Output
When the function `lengthOfLongestSubstring` is called with the given example inputs, the expected outputs are:
- For the input `"abcabcbb"`, the output is `3`.
- For the input `"bbbbb"`, the output is `1`.
- For the input `"pwwkew"`, the output is `3`.

These outputs represent the length of the longest substrings without repeating characters in the provided strings.

##### Problem Statement
Given a string `s`, find the length of the longest substring without repeating characters.

##### Example
```plaintext
Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.
```

```plaintext
Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.
```

```plaintext
Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
```

##### Constraints
- `0 <= s.length <= 5 * 10^4`
- `s` consists of English letters, digits, symbols and spaces.


#### Expected Challenge Output
When the function `length_of_longest_substring` is called with the given example inputs, the expected outputs are:
- For the input `"abcabcbb"`, the output is `3`.
- For the input `"bbbbb"`, the output is `1`.
- For the input `"pwwkew"`, the output is `3`.

These outputs represent the length of the longest substrings without repeating characters in the provided strings.

Longest Substring Without Repeating Characters

longest-substring-without-repeating-characters

##### Problem Statement
Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow a node to be a descendant of itself).”

##### Example
```plaintext
Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
```

##### Constraints
- The number of nodes in the tree is in the range `[2, 10^5]`.
- `-10^9 <= Node.val <= 10^9`
- All `Node.val` are unique.
- `p != q`
- `p` and `q` will exist in the tree.

#### Expected Challenge Output
When the function `lowestCommonAncestor` is called with the given example inputs, the expected output is the value of the lowest common ancestor of the two nodes.

Lowest Common Ancestor in Binary Tree

lowest-common-ancestor-binary-tree

##### Problem Statement
Given an `m x n` matrix, return all elements of the matrix in spiral order.

##### Example
```plaintext
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,3,6,9,8,7,4,5]
```

```plaintext
Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]
```

##### Constraints
- `m == matrix.length`
- `n == matrix[i].length`
- `1 <= m, n <= 10`
- `-100 <= matrix[i][j] <= 100`


#### Expected Challenge Output
When the function `spiralOrder` is called with the given example inputs, the expected outputs are:
- For the input `[[1,2,3],[4,5,6],[7,8,9]]`, the output is `[1,2,3,6,9,8,7,4,5]`.
- For the input `[[1,2,3,4],[5,6,7,8],[9,10,11,12]]`, the output is `[1,2,3,4,8,12,11,10,9,5,6,7]`.

Matrix Spiral Order

matrix-spiral-order

##### Problem Statement
Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

##### Example
```plaintext
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.
```

```plaintext
Input: nums = [1]
Output: 1
```

```plaintext
Input: nums = [5,4,-1,7,8]
Output: 23
```

##### Constraints
- `1 <= nums.size() <= 10^5`
- `-10^4 <= nums[i] <= 10^4`


#### Expected Challenge Output
When the function `maxSubArray` is called with the given example inputs, the expected outputs are:
- For the input `[-2,1,-3,4,-1,2,1,-5,4]`, the output is `6`.
- For the input `[1]`, the output is `1`.
- For the input `[5,4,-1,7,8]`, the output is `23`.

##### Problem Statement
Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

##### Example
```plaintext
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.
```

```plaintext
Input: nums = [1]
Output: 1
```

```plaintext
Input: nums = [5,4,-1,7,8]
Output: 23
```

##### Constraints
- `1 <= nums.length <= 10^5`
- `-10^4 <= nums[i] <= 10^4`


#### Expected Challenge Output
When the function `maxSubArray` is called with the given example inputs, the expected outputs are:
- For the input `[-2,1,-3,4,-1,2,1,-5,4]`, the output is `6`.
- For the input `[1]`, the output is `1`.
- For the input `[5,4,-1,7,8]`, the output is `23`.

Code Challenge