Happy Number

Write an algorithm to determine if a number n is happy.

A happy number is a number defined by the following process:

 Starting with any positive integer, replace the number by the sum
of the squares of its digits.
 Repeat the process until the number equals 1 (where it will stay),
or it loops endlessly in a cycle which does not include 1.
 Those numbers for which this process ends in 1 are happy.

Return true if n is a happy number, and false if not.

Example 1:

Input: n = 19
Output: true
Explanation:
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

Example 2:

Input: n = 2
Output: false

Constraints:

 1 <= n <= 231 - 1

Bulb Switcher
There are n bulbs that are initially off. You first turn on all the bulbs,
then you turn off every second bulb.
On the third round, you toggle every third bulb (turning on if it's off or
turning off if it's on). For the i round, you toggle every i bulb. For
th

the n round, you only toggle the last bulb.

th

Return the number of bulbs that are on after n rounds.

Example 1:

Input: n = 3
Output: 1
Explanation: At first, the three bulbs are [off, off, off].
After the first round, the three bulbs are [on, on, on].
After the second round, the three bulbs are [on, off, on].
After the third round, the three bulbs are [on, off, off].
So you should return 1 because there is only one bulb is on.

Example 2:

Input: n = 0
Output: 0

Example 3:

Input: n = 1
Output: 1
Constraints:

 0 <= n <= 109

Two Sum
Given an array of integers nums and an integer target, return indices of
the two numbers such that they add up to target.

You may assume that each input would have exactly one solution,
and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9

Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6

Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6

Output: [0,1]

Constraints:

 2 <= nums.length <= 104

 -109 <= nums[i] <= 109
 -109 <= target <= 109
 Only one valid answer exists.

Climbing Stairs
You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways
can you climb to the top?

Example 1:

Input: n = 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

Input: n = 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

Constraints:

 1 <= n <= 45

Palindrome Number
Given an integer x, return true if x is a palindrome, and false otherwise.

Example 1:

Input: x = 121
Output: true
Explanation: 121 reads as 121 from left to right and from right to left.

Example 2:

Input: x = -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a
palindrome.

Example 3:

Input: x = 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

Constraints:

 -231 <= x <= 231 - 1

Rotate Array
Given an integer array nums, rotate the array to the right by k steps,
where k is non-negative.

Example 1:

Input: nums = [1,2,3,4,5,6,7], k = 3

Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

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

Output: [3,99,-1,-100]
Explanation:
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

Constraints:

 1 <= nums.length <= 105

 -231 <= nums[i] <= 231 - 1
 0 <= k <= 105
 Roman to Integer
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 ones 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:

 Ican 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 a roman numeral, convert it to an integer.

Example 1:

Input: s = "III"
Output: 3
Explanation: III = 3.

Example 2:

Input: s = "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.
Example 3:

Input: s = "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Constraints:

 1 <= s.length <= 15

 s contains onlythe characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
 It is guaranteed that s is a valid roman numeral in the range [1,
3999].

Maximum Subarray
Given an integer array nums, find the subarray with the largest sum, and
return its sum.

Example 1:

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]

Output: 6
Explanation: The subarray [4,-1,2,1] has the largest sum 6.

Example 2:

Input: nums = [1]

Output: 1
Explanation: The subarray [1] has the largest sum 1.

Example 3:

Input: nums = [5,4,-1,7,8]

Output: 23
Explanation: The subarray [5,4,-1,7,8] has the largest sum 23.

Constraints:

 1 <= nums.length <= 105

 -104 <= nums[i] <= 104
Delete and Earn
You are given an integer array nums. You want to maximize the number
of points you get by performing the following operation any number of
times:

 Pick any nums[i] and delete it to earn nums[i] points. Afterwards, you
must delete every element equal to nums[i] - 1 and every element
equal to nums[i] + 1.

Return the maximum number of points you can earn by applying

the above operation some number of times.

Example 1:

Input: nums = [3,4,2]

Output: 6
Explanation: You can perform the following operations:
- Delete 4 to earn 4 points. Consequently, 3 is also deleted. nums = [2].
- Delete 2 to earn 2 points. nums = [].
You earn a total of 6 points.

Example 2:

Input: nums = [2,2,3,3,3,4]

Output: 9
Explanation: You can perform the following operations:
- Delete a 3 to earn 3 points. All 2's and 4's are also deleted. nums = [3,3].
- Delete a 3 again to earn 3 points. nums = [3].
- Delete a 3 once more to earn 3 points. nums = [].
You earn a total of 9 points.

Edit Distance
Given two strings word1 and word2, return the minimum number of
operations required to convert word1 to word2.

You have the following three operations permitted on a word:

 Insert a character
 Delete a character
 Replace a character
Example 1:

Input: word1 = "horse", word2 = "ros"

Output: 3
Explanation:
horse -> rorse (replace 'h' with 'r')
rorse -> rose (remove 'r')
rose -> ros (remove 'e')

Example 2:

Input: word1 = "intention", word2 = "execution"

Output: 5
Explanation:
intention -> inention (remove 't')
inention -> enention (replace 'i' with 'e')
enention -> exention (replace 'n' with 'x')
exention -> exection (replace 'n' with 'c')
exection -> execution (insert 'u')

Constraints:

 0 <= word1.length, word2.length <= 500

 word1 and word2 consist of lowercase English letters.

Constraints:

 1 <= nums.length <= 2 * 104

 1 <= nums[i] <= 104

Koko Eating Bananas

Koko loves to eat bananas. There are n piles of bananas, the i pile th

has piles[i] bananas. The guards have gone and will come back
in h hours.

Koko can decide her bananas-per-hour eating speed of k. Each hour,

she chooses some pile of bananas and eats k bananas from that pile. If
the pile has less than k bananas, she eats all of them instead and will
not eat any more bananas during this hour.
Koko likes to eat slowly but still wants to finish eating all the bananas
before the guards return.

Return the minimum integer k such that she can eat all the bananas
within h hours.

Example 1:

Input: piles = [3,6,7,11], h = 8

Output: 4

Example 2:

Input: piles = [30,11,23,4,20], h = 5

Output: 30

Example 3:

Input: piles = [30,11,23,4,20], h = 6

Output: 23

Constraints:

 1 <= piles.length <= 104

 piles.length <= h <= 109
 1 <= piles[i] <= 109

Integer to English Words

Convert a non-negative integer num to its English words representation.

Example 1:

Input: num = 123

Output: "One Hundred Twenty Three"

Example 2:

Input: num = 12345

Output: "Twelve Thousand Three Hundred Forty Five"

Example 3:

Input: num = 1234567

Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

Constraints:

 0 <= num <= 231 - 1