2 つのソートされた配列をマージする#
非減少順 に並べられた 2 つの整数配列 nums1 と nums2 が与えられ、m と n という 2 つの整数があり、それぞれ nums1 と nums2 の要素数を表します。
nums2 を nums1 に マージ して、マージ後の配列も 非減少順 に並べる必要があります。
注意：最終的に、マージ後の配列は関数から返すのではなく、配列 nums1 に格納されるべきです。このため、nums1 の初期長さは m + n であり、最初の m 個の要素はマージすべき要素を表し、後の n 個の要素は 0 であり、無視されるべきです。nums2 の長さは n です。
例 1：
入力：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
出力：[1,2,2,3,5,6]
説明： [1,2,3] と [2,5,6] をマージする必要があります。
マージ結果は [1,2,2,3,5,6] であり、斜体太字で示されたのは nums1 の要素です。
例 2：
入力：nums1 = [1], m = 1, nums2 = [], n = 0
出力：[1]
説明： [1] と [] をマージする必要があります。
マージ結果は [1] です。
例 3：
入力：nums1 = [0], m = 0, nums2 = [1], n = 1
出力：[1]
説明：マージする配列は [] と [1] です。
マージ結果は [1] です。
注意：m = 0 のため、nums1 には要素がありません。nums1 に残っている 0 は、マージ結果が nums1 に正常に格納できるようにするためだけのものです。
class Solution:
def merge(self, nums1: list[int], m: int, nums2: list[int], n: int) -> None:
"""
何も返さず、nums1 をその場で変更します。
"""
i, j = m - 1, n - 1
k = len(nums1) - 1
while (i >= 0 and j >= 0):
if (nums1[i] > nums2[j]):
nums1[k] = nums1[i]
i -= 1
else:
nums1[k] = nums2[j]
j -= 1
k -= 1
if (i == -1):
for i in range(0, j+1):
nums1[i] = nums2[i]
要素を削除する#
配列 nums と値 val が与えられます。すべての値が val に等しい要素を 原地 で削除し、削除後の配列の新しい長さを返す必要があります。
追加の配列スペースを使用せず、O(1) の追加スペースのみを使用し、原地 で入力配列を変更する必要があります。
要素の順序は変更可能です。新しい長さを超える配列の要素については考慮する必要はありません。
例 1：
入力：nums = [3,2,2,3], val = 3
出力：2, nums = [2,2]
説明：関数は新しい長さ 2 を返すべきであり、nums の最初の2つの要素はすべて 2 です。配列の新しい長さを超える要素については考慮する必要はありません。たとえば、関数が返す新しい長さが 2 であっても、nums = [2,2,3,3] または nums = [2,2,0,0] も正しい答えと見なされます。
例 2：
入力：nums = [0,1,2,2,3,0,4,2], val = 2
出力：5, nums = [0,1,4,0,3]
説明：関数は新しい長さ 5 を返すべきであり、nums の最初の5つの要素は 0, 1, 3, 0, 4 です。これらの5つの要素は任意の順序で構いません。配列の新しい長さを超える要素については考慮する必要はありません。
class Solution:
def removeElement(self, nums: list[int], val: int) -> int:
i, j = 0, len(nums)
while (i < j):
if (nums[i] == val):
j -= 1
nums[i] = nums[j]
else:
i += 1
return j
ソートされた配列から重複を削除する#
昇順 に並べられた配列 nums が与えられます。重複する要素を 原地 で削除し、各要素が 1 回だけ 出現するようにし、削除後の配列の新しい長さを返す必要があります。要素の 相対的な順序 は 一貫性 を保つ必要があります。nums 中のユニークな要素の数を k とした場合、以下のことを行う必要があります：
- 配列
numsを変更し、numsの最初のk個の要素にユニークな要素を含め、元のnumsに出現した順序で並べます。numsの残りの要素はnumsのサイズに関して重要ではありません。 kを返します。
例 1：
入力：nums = [1,1,2]
出力：2, nums = [1,2,_]
説明：関数は新しい長さ 2 を返すべきであり、元の配列 nums の最初の2つの要素は 1, 2 に変更されます。配列の新しい長さを超える要素については考慮する必要はありません。
例 2：
入力：nums = [0,0,1,1,1,2,2,3,3,4]
出力：5, nums = [0,1,2,3,4]
説明：関数は新しい長さ 5 を返すべきであり、元の配列 nums の最初の5つの要素は 0, 1, 2, 3, 4 に変更されます。配列の新しい長さを超える要素については考慮する必要はありません。
class Solution:
def removeDuplicates(self, nums: list[int]) -> int:
j = 0
for i in range(1, len(nums)):
if (nums[i] != nums[j]):
nums[j + 1] = nums[i]
j += 1
return j + 1
ソートされた配列から重複を削除する II#
ソートされた配列 nums が与えられます。重複する要素を 原地 で削除し、出現回数が 2 回を超える要素が 2 回だけ 出現するようにし、削除後の配列の新しい長さを返す必要があります。
追加の配列スペースを使用せず、原地 で入力配列を変更し、O(1) の追加スペースで完了する必要があります。
例 1：
入力：nums = [1,1,1,2,2,3]
出力：5, nums = [1,1,2,2,3]
説明：関数は新しい長さ length = 5 を返すべきであり、元の配列の最初の5つの要素は 1, 1, 2, 2, 3 に変更されます。配列の新しい長さを超える要素については考慮する必要はありません。
例 2：
入力：nums = [0,0,1,1,1,1,2,3,3]
出力：7, nums = [0,0,1,1,2,3,3]
説明：関数は新しい長さ length = 7 を返すべきであり、元の配列の最初の7つの要素は 0, 0, 1, 1, 2, 3, 3 に変更されます。配列の新しい長さを超える要素については考慮する必要はありません。
class Solution:
def removeDuplicates(self, nums: list[int]) -> int:
if (len(nums) <= 2):
return len(nums)
i = 1
for j in range(2, len(nums)):
if (nums[j] != nums[i] or nums[j] == nums[i] and nums[j] != nums[i-1]):
nums[i + 1] = nums[j]
i += 1
return i + 1
多数の要素#
サイズ n の配列 nums が与えられ、その中の多数の要素を返します。多数の要素とは、配列中に出現回数が ⌊ n/2 ⌋ よりも多い要素を指します。
配列は空でないと仮定でき、与えられた配列には常に多数の要素が存在します。
例 1：
入力：nums = [3,2,3]
出力：3
例 2：
入力：nums = [2,2,1,1,1,2,2]
出力：2
class Solution:
def majorityElement(self, nums: list[int]) -> int:
count = 0
res = nums[0]
for num in nums:
if (count == 0 or res == num):
res = num
count += 1
else:
count -= 1
return res
回転配列#
整数配列 nums が与えられ、配列の要素を右に k 個位置回転させます。ここで、k は非負の数です。
例 1:
入力: nums = [1,2,3,4,5,6,7], k = 3
出力: [5,6,7,1,2,3,4]
説明:
1ステップ右に回転: [7,1,2,3,4,5,6]
2ステップ右に回転: [6,7,1,2,3,4,5]
3ステップ右に回転: [5,6,7,1,2,3,4]
例 2:
入力：nums = [-1,-100,3,99], k = 2
出力：[3,99,-1,-100]
説明:
1ステップ右に回転: [99,-1,-100,3]
2ステップ右に回転: [3,99,-1,-100]
class Solution:
def rotate(self, nums: list[int], k: int) -> None:
"""
何も返さず、nums をその場で変更します。
"""
def reverse(nums, start, end):
while (start < end):
nums[start], nums[end] = nums[end], nums[start]
start += 1
end -= 1
k = k % len(nums)
reverse(nums, 0, len(nums) - k - 1)
reverse(nums, len(nums) - k, len(nums)-1)
reverse(nums, 0, len(nums)-1)
株式の売買の最適なタイミング#
配列 prices が与えられ、その第 i 個目の要素 prices[i] は、特定の株の第 i 日の価格を表します。
ある日 にこの株を購入し、将来の別の日 にその株を売却することができます。最大の利益を計算するアルゴリズムを設計してください。
この取引から得られる最大の利益を返します。利益を得られない場合は 0 を返します。
例 1：
入力：[7,1,5,3,6,4]
出力：5
説明：第2日目（株価 = 1）に購入し、第5日目（株価 = 6）に売却すると、最大の利益は 6-1 = 5 です。
注意：利益は 7-1 = 6 ではなく、売却価格は購入価格よりも大きくなければなりません。また、購入前に株を売却することはできません。
例 2：
入力：prices = [7,6,4,3,1]
出力：0
説明：この場合、取引は完了しないため、最大の利益は 0 です。
class Solution:
def maxProfit(self, prices: list[int]) -> int:
minprice = int(1e9)
maxprofit = 0
for price in prices:
maxprofit = max(price - minprice, maxprofit)
minprice = min(price, minprice)
return maxprofit
ジャンプゲーム#
非負整数配列 nums が与えられ、最初に配列の 最初のインデックス に位置します。
配列の各要素は、その位置でジャンプできる最大の長さを表します。
最後のインデックスに到達できるかどうかを判断してください。
例 1：
入力：nums = [2,3,1,1,4]
出力：true
説明：最初に1ステップジャンプしてインデックス0からインデックス1に到達し、その後インデックス1から3ステップジャンプして最後のインデックスに到達できます。
例 2：
入力：nums = [3,2,1,0,4]
出力：false
説明：どのようにしても、インデックス3に到達することになります。しかし、そのインデックスの最大ジャンプ長は0であり、最後のインデックスに到達することはできません。
class Solution:
def canJump(self, nums: list[int]) -> bool:
n, rightmost = len(nums), 0
for i in range(n):
if (i <= rightmost):
rightmost = max(rightmost, i + nums[i])
if (rightmost >= n-1):
return True
return False
ジャンプゲーム II#
長さ n の 0 インデックス 整数配列 nums が与えられます。初期位置は nums[0] です。
各要素 nums[i] は、インデックス i から前方にジャンプできる最大の長さを表します。言い換えれば、nums[i] にいる場合、任意の nums[i + j] にジャンプできます：
0 <= j <= nums[i]i + j < n
nums[n - 1] に到達するための最小ジャンプ数を返してください。生成されるテストケースは nums[n - 1] に到達可能です。
例 1:
入力: nums = [2,3,1,1,4]
出力: 2
説明: 最後の位置に到達するための最小ジャンプ数は 2 です。
インデックス0からインデックス1にジャンプし、次に3ステップジャンプして配列の最後の位置に到達します。
例 2:
入力: nums = [2,3,0,1,4]
出力: 2
class Solution:
def jump(self, nums: list[int]) -> int:
n = len(nums)
rightmost, end, step = 0, 0, 0
for i in range(n-1):
if (rightmost >= i):
rightmost = max(rightmost, i + nums[i])
if (i == end):
end = rightmost
step += 1
return step
自身以外の配列の積#
整数配列 nums が与えられ、配列 answer を返します。ここで、answer[i] は nums の中で nums[i] を除く他のすべての要素の積を表します。
問題のデータは、配列 nums の任意の要素のすべての前の要素と後の要素の積が 32 ビット 整数の範囲内にあることを 保証 します。
除算を使用せず、 O(*n*) の時間計算量でこの問題を解決してください。
例 1:
入力: nums = [1,2,3,4]
出力: [24,12,8,6]
例 2:
入力: nums = [-1,1,0,-3,3]
出力: [0,0,9,0,0]
class Solution:
def productExceptSelf(self, nums: list[int]) -> list[int]:
left = [1 for _ in nums]
right = [1 for _ in nums]
for i in range(1, len(nums)):
left[i] = nums[i-1] * left[i-1]
for i in range(len(nums)-2, -1, -1):
right[i] = nums[i+1] * right[i+1]
return [left[i] * right[i] for i in range(len(nums))]
雨水を捕まえる#
n 個の非負整数が与えられ、各幅が 1 の柱の高さを表す配列を与えられます。この配置の柱の間に雨が降ったとき、どれだけの雨水を捕まえることができるかを計算します。
例 1：
入力：height = [0,1,0,2,1,0,1,3,2,1,2,1]
出力：6
説明：上記は配列 [0,1,0,2,1,0,1,3,2,1,2,1] によって表される高さの図であり、この場合、6 単位の雨水を捕まえることができます（青色部分が雨水を示します）。
例 2：
入力：height = [4,2,0,3,2,5]
出力：9
class Solution:
def trap(self, height: list[int]) -> int:
if (len(height) <= 2):
return 0
lmax = [0 for _ in height]
rmax = [0 for _ in height]
for i in range(1, len(height)-1):
lmax[i] = max(lmax[i-1], height[i-1])
for i in range(len(height)-2, 0, -1):
rmax[i] = max(rmax[i+1], height[i+1])
res = 0
for i in range(1, len(height) - 1):
if (min(lmax[i], rmax[i]) - height[i] > 0):
res += (min(lmax[i], rmax[i]) - height[i])
return res
ローマ数字を整数に変換する#
ローマ数字には以下の 7 つの文字が含まれます： I， V， X， L，C，D および M。
文字 数値
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
たとえば、ローマ数字 2 は II と書かれ、1 が 2 つ並んでいます。12 は XII と書かれ、X + II です。 27 は XXVII と書かれ、XX + V + II です。
通常、ローマ数字では小さい数字が大きい数字の右側にあります。しかし、特例も存在します。たとえば、4 は IIII ではなく IV と書かれます。数字 1 は数字 5 の左側にあり、表される数は大きな数 5 から小さな数 1 を引いた数値 4 です。同様に、数字 9 は IX と表されます。この特別なルールは以下の 6 つのケースにのみ適用されます：
IはV(5) およびX(10) の左側に置くことができ、4 および 9 を表します。XはL(50) およびC(100) の左側に置くことができ、40 および 90 を表します。CはD(500) およびM(1000) の左側に置くことができ、400 および 900 を表します。
ローマ数字が与えられた場合、それを整数に変換してください。
例 1:
入力: s = "III"
出力: 3
例 2:
入力: s = "IV"
出力: 4
例 3:
入力: s = "IX"
出力: 9
例 4:
入力: s = "LVIII"
出力: 58
説明: L = 50, V= 5, III = 3.
例 5:
入力: s = "MCMXCIV"
出力: 1994
説明: M = 1000, CM = 900, XC = 90, IV = 4.
class Solution:
SYMBOL_VALUES = {
'I': 1,
'V': 5,
'X': 10,
'L': 50,
'C': 100,
'D': 500,
'M': 1000,
}
def romanToInt(self, s: str) -> int:
ans = 0
n = len(s)
for i, ch in enumerate(s):
val = Solution.SYMBOL_VALUES[ch]
if ((i < n-1) and val < Solution.SYMBOL_VALUES[s[i+1]]):
ans -= val
else:
ans += val
return ans
整数をローマ数字に変換する#
ローマ数字には以下の 7 つの文字が含まれます： I， V， X， L，C，D および M。
文字 数値
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
たとえば、ローマ数字 2 は II と書かれ、1 が 2 つ並んでいます。12 は XII と書かれ、X + II です。 27 は XXVII と書かれ、XX + V + II です。
通常、ローマ数字では小さい数字が大きい数字の右側にあります。しかし、特例も存在します。たとえば、4 は IIII ではなく IV と書かれます。数字 1 は数字 5 の左側にあり、表される数は大きな数 5 から小さな数 1 を引いた数値 4 です。同様に、数字 9 は IX と表されます。この特別なルールは以下の 6 つのケースにのみ適用されます：
IはV(5) およびX(10) の左側に置くことができ、4 および 9 を表します。XはL(50) およびC(100) の左側に置くことができ、40 および 90 を表します。CはD(500) およびM(1000) の左側に置くことができ、400 および 900 を表します。
整数が与えられた場合、それをローマ数字に変換してください。
例 1:
入力: num = 3
出力: "III"
例 2:
入力: num = 4
出力: "IV"
例 3:
入力: num = 9
出力: "IX"
例 4:
入力: num = 58
出力: "LVIII"
説明: L = 50, V = 5, III = 3.
例 5:
入力: num = 1994
出力: "MCMXCIV"
説明: M = 1000, CM = 900, XC = 90, IV = 4.
class Solution:
VALUE_SYMBOLS = [
(1000, "M"),
(900, "CM"),
(500, "D"),
(400, "CD"),
(100, "C"),
(90, "XC"),
(50, "L"),
(40, "XL"),
(10, "X"),
(9, "IX"),
(5, "V"),
(4, "IV"),
(1, "I"),
]
def intToRoman(self, num: int) -> str:
res = []
for val, symbol in Solution.VALUE_SYMBOLS:
while (num >= val):
res.append(symbol)
num -= val
if (num == 0):
break
return ''.join(res)
最後の単語の長さ#
文字列 s が与えられ、いくつかの単語で構成されており、単語は空白文字で区切られています。文字列中の 最後の 単語の長さを返す必要があります。
単語 とは、文字のみで構成され、空白文字を含まない最大の部分文字列を指します。
例 1：
入力：s = "Hello World"
出力：5
説明：最後の単語は「World」で、長さは5です。
例 2：
入力：s = " fly me to the moon "
出力：4
説明：最後の単語は「moon」で、長さは4です。
例 3：
入力：s = "luffy is still joyboy"
出力：6
説明：最後の単語は長さ6の「joyboy」です。
class Solution:
def lengthOfLastWord(self, s: str) -> int:
r = len(s)-1
while (s[r] == ' '):
r -= 1
i = r
while (i >= 0 and s[i] != ' '):
i -= 1
return r-i
最長共通接頭辞#
文字列配列の中で最長の共通接頭辞を見つける関数を作成してください。
共通接頭辞が存在しない場合は、空の文字列 "" を返します。
例 1：
入力：strs = ["flower","flow","flight"]
出力："fl"
例 2：
入力：strs = ["dog","racecar","car"]
出力：""
説明：入力には共通接頭辞が存在しません。
class Solution:
def longestCommonPrefix(self, strs: list[str]) -> str:
if (len(strs) == 1):
return "".join(strs)
ans = ""
minLength = 300
for s in strs:
minLength = min(minLength, len(s))
for i in range(minLength):
c = strs[0][i]
print(c)
for j in range(len(strs)):
if (strs[j][i] != c):
return ans
ans += c
return ans
文字列の単語を反転する#
文字列 s が与えられ、文字列中の 単語 の順序を反転させてください。
単語 とは、空白以外の文字で構成された文字列です。s では、少なくとも 1 つの空白を使用して文字列中の 単語 を区切ります。
単語 の順序を反転させ、単語 の間を単一の空白で接続した結果の文字列を返してください。
注意：入力文字列 s には前導空白、尾随空白、または単語間の複数の空白が存在する可能性があります。返される結果の文字列には、単語間の空白は単一の空白のみを使用し、余分な空白は含まれないようにしてください。
例 1：
入力：s = "the sky is blue"
出力："blue is sky the"
例 2：
入力：s = " hello world "
出力："world hello"
説明：反転された文字列には前導空白や尾随空白が存在してはなりません。
例 3：
入力：s = "a good example"
出力："example good a"
説明：2つの単語の間に余分な空白がある場合、反転された文字列では単語間の空白を1つに減らす必要があります。
class Solution:
def reverseWords(self, s: str) -> str:
ans = []
end, start = 0, 0
i = len(s) - 1
while (i >= 0):
if (s[i] == " "):
i -= 1
continue
end = i + 1
while (s[i] != " " and i >= 0):
i -= 1
start = i + 1
ans.append(s[start: end])
return ' '.join(ans)
N 字形変換#
与えられた文字列 s を指定された行数 numRows に従って、上から下、左から右に Z 字形に配置します。
たとえば、入力文字列が "PAYPALISHIRING" で、行数が 3 の場合、配置は次のようになります：
P A H N
A P L S I I G
Y I R
その後、左から右に行ごとに読み取って、新しい文字列を生成します。たとえば："PAHNAPLSIIGYIR"。
この関数を実装してください：
string convert(string s, int numRows);
例 1：
入力：s = "PAYPALISHIRING", numRows = 3
出力："PAHNAPLSIIGYIR"
例 2：
入力：s = "PAYPALISHIRING", numRows = 4
出力："PINALSIGYAHRPI"
説明：
P I N
A L S I G
Y A H R
P I
例 3：
入力：s = "A", numRows = 1
出力："A"
class Solution:
def convert(self, s: str, numRows: int) -> str:
if (numRows == 1):
return s
res = ["" for _ in range(numRows)]
step = -1
i, j = 0, 0
while (i < len(s)):
if (j == 0 or j == numRows-1):
step = 0 - step
res[j] += s[i]
j += step
i += 1
return ''.join(res)
文字列中の最初の一致のインデックスを見つける#
2 つの文字列 haystack と needle が与えられます。haystack 文字列の中で needle 文字列の最初の一致のインデックス（インデックスは 0 から始まります）を見つけてください。needle が haystack の一部でない場合は、-1 を返します。
例 1：
入力：haystack = "sadbutsad", needle = "sad"
出力：0
説明："sad" はインデックス 0 と 6 で一致します。
最初の一致のインデックスは 0 なので、0 を返します。
例 2：
入力：haystack = "leetcode", needle = "leeto"
出力：-1
説明："leeto" は "leetcode" に存在しないため、-1 を返します。
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
l1, l2 = len(haystack), len(needle)
if (l2 > l1):
return -1
for i in range(0, l1 - l2 + 1):
if (haystack[i] != needle[0]):
continue
j = 0
while (j < l2 and haystack[i + j] == needle[j]):
j += 1
if (j == l2):
return i
return -1
部分列かどうかを判断する#
文字列 s と t が与えられ、s が t の部分列であるかどうかを判断してください。
文字列の部分列とは、元の文字列からいくつかの（削除してもよい）文字を削除し、残りの文字の相対的な位置を変更せずに形成された新しい文字列を指します。（たとえば、"ace" は abcde の部分列ですが、"aec" ではありません）。
進化：
大量の入力 S、S1, S2, ... , Sk があり、k >= 10 億の場合、これらが T の部分列であるかどうかを順次確認する場合、コードをどのように変更しますか？
例 1：
入力：s = "abc", t = "ahbgdc"
出力：true
例 2：
入力：s = "axc", t = "ahbgdc"
出力：false
class Solution:
def isSubsequence(self, s: str, t: str) -> bool:
print(s,t)
if(len(s) == 0 or s == t):
return True
for i in range(0,len(t)):
if(t[i] == s[0]):
return self.isSubsequence(s[1:],t[i+1:])
return False
2 つの数の和 II - 入力がソートされた配列#
1 から始まる整数配列 numbers が与えられ、この配列は 非減少順 に並べられています。配列から、合計が目標数 target に等しい 2 つの数を見つけてください。これらの 2 つの数をそれぞれ numbers[index1] と numbers[index2] とすると、1 <= index1 < index2 <= numbers.length となります。
長さ 2 の整数配列 [index1, index2] の形式で、これらの整数のインデックス index1 と index2 を返してください。
各入力には 一意の答え があると仮定でき、同じ要素を再利用することはできません。
設計した解決策は、定数級の追加スペースのみを使用する必要があります。
例 1：
入力：numbers = [2,7,11,15], target = 9
出力：[1,2]
説明：2 と 7 の合計は目標数 9 に等しいです。したがって index1 = 1, index2 = 2 です。返すのは [1, 2] です。
例 2：
入力：numbers = [2,3,4], target = 6
出力：[1,3]
説明：2 と 4 の合計は目標数 6 に等しいです。したがって index1 = 1, index2 = 3 です。返すのは [1, 3] です。
例 3：
入力：numbers = [-1,0], target = -1
出力：[1,2]
説明：-1 と 0 の合計は目標数 -1 に等しいです。したがって index1 = 1, index2 = 2 です。返すのは [1, 2] です。
class Solution:
def twoSum(self, numbers: list[int], target: int) -> list[int]:
start = 0
end = len(numbers) - 1
while(start < end):
if(numbers[start] + numbers[end] == target):
return [start+1,end+1]
elif(numbers[start] + numbers[end] > target):
end -= 1
else:
start += 1
最も水を貯める容器#
長さ n の整数配列 height が与えられます。n 本の垂直線があり、i 本の線の 2 つの端点は (i, 0) と (i, height[i]) です。
その中から 2 本の線を見つけ、x 軸と共に容器を形成し、最大の水を貯めることができるようにします。
容器が貯めることができる最大の水量を返してください。
説明：容器を傾けることはできません。
例 1：
入力：[1,8,6,2,5,4,8,3,7]
出力：49
説明：図中の垂直線は入力配列 [1,8,6,2,5,4,8,3,7] を表します。この場合、容器が水を貯める最大値は 49 です。
例 2：
入力：height = [1,1]
出力：1
class Solution:
def maxArea(self, height: list[int]) -> int:
start,end = 0,len(height)-1
res = (end-start) * min(height[start],height[end])
while(start < end):
if(height[start] < height[end]):
start += 1
else:
end -= 1
res = max(res,(end-start) * min(height[start],height[end]))
return res