abh - HTMLify profile

// @leet start
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
*

func valid(stack []rune) bool {
var _s []rune
for _, p := range stack {
if p == '(' {
_s = appen

class Solution {
bool isRobotBounded(String instructions) {
List<int> direction = [0, 1], cordinates = [0, 0];

class Solution:
def lastStoneWeight(self, stones: list[int]) -> int:
stones.sort()
print(stones)

func removeDuplicates(s string) string {
var stack []rune
for _, c := range s {
if len(stack) > 0 && stack[le

func defangIPaddr(address string) string {
var defanged string
for _, c := range address {
if c == '.' {

from time import sleep

class Foo:
def __init__(self):
self.last_print = 0


def first(self, printFirst:

from time import sleep

class FooBar:
def __init__(self, n):
self.n = n
self.next = "foo"

/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *Tree

SELECT DISTINCT author_id AS id FROM Views WHERE author_id = viewer_id ORDER BY author_id;

# @leet start
# @param {Integer[]} arr
# @param {Integer} a
# @param {Integer} b
# @param {Integer} c
# @return {Integer}

class Solution:
def lastSubstring(self, s: str) -> str:
alphas = "abcdefghijklmnopqrstuvwxyz"
i = 0

func contain(target int, array []int) bool {
for _, v := range array {
if v == target {
return true

class Solution:
def isPalindrome(self, s: str) -> bool:
fls = "".join([c for c in s.lower() if c in "pyfgcrlaoeuid

# @leet start
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):

class Solution:
def findSpecialInteger(self, arr: List[int]) -> int:
l = len(arr)
t = l / 4
freq

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func ge

func sumZero(n int) []int {
var ans []int
if n%2==1 {
ans = append(ans, 0)
}
for i:=1;len(ans)!=n;i

class Solution:
def checkIfExist(self, arr: List[int]) -> bool:
for i in range(len(arr)):
for j in ra

type Cashier struct {
customers_done int
n int
discount int
products []int
prices []int
}

class Solution:
def singleNumber(self, nums: List[int]) -> int:
return sorted(nums, key=lambda e:nums.count(e))[0]

class Solution:
def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
smallercount = []
sort

class Solution:
def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]:
target = []

class Solution:
def countLargestGroup(self, n: int) -> int:
groups = {}
l = 0
for i in range(1,

class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
p = ""
i = 0
while True:

class Solution:
def canConstruct(self, s: str, k: int) -> bool:
if len(s) < k: return False
m = {}

class Solution:
def stringMatching(self, words: List[str]) -> List[str]:
ans = []
for word in words:

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/

# Definition for singly-linked list.
# class ListNode
# attr_accessor :val, :next
# def initialize(val)
# @v

class Solution:
def maxScore(self, s: str) -> int:
maxscore = 0
for i in range(1, len(s)):
l

class Solution:
def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
return [c + extraC

https://leetcode.com/problems/binary-tree-preorder-traversal/submissions/1579203892/?envType=problem-list-v2&envId=stack

/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *Tree

class Solution:
def isPrefixOfWord(self, sentence: str, searchWord: str) -> int:
for word in sentence.split(" "):

class Solution:
def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
return sorted(target) == sorted(a

// @leet start

type BrowserHistoryNode struct {
Url string
Back *BrowserHistoryNode
Forward *BrowserHistoryNode
}

class Solution:
def finalPrices(self, prices: List[int]) -> List[int]:
for i in range(len(prices)-1):

func runningSum(nums []int) []int {
var sum int
var sumarray []int
for _, n := range nums {
sum += n

class Solution:
def reformatDate(self, date: str) -> str:
days = [
"1st", "2nd", "3rd", "4th", "5th",

impl Solution {
pub fn num_identical_pairs(nums: Vec<i32>) -> i32 {
let mut count = 0;
for i in 0..nums.l

# Write your MySQL query statement below
SELECT * FROM patients
WHERE conditions LIKE '% DIAB1%' or conditions LIKE 'DIAB1%' ;

class Solution:
def restoreString(self, s: str, indices: List[int]) -> str:
shuffeld = ""
for i in range(

func abs(n int) int {
if n < 0 {
return -n
}
return n
}
func makeGood(s string) string {
var stac

class Solution:
def diagonalSum(self, mat: List[List[int]]) -> int:
i = 0
s = 0
if len(mat)%2:

func minOperations(logs []string) int {
depth := 0
for _, o := range logs {
if o == "../" {
if d

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/

type ParkingSystem struct {
big int
medium int
small int
}


func Constructor(big int, medium int, small int) Parki

func maxDepth(s string) int {
var depth, max_depth int
for _, c := range s {
if c == '(' {
depth

class Solution:
def frequencySort(self, nums: List[int]) -> List[int]:
freq = []
for n in set(nums):

func getMaximumGenerated(n int) int {
if n == 0 {
return 0
}
arr := []int{0, 1}
for len(arr) < n + 1 {
l := len(ar

func twoSum(numbers []int, target int) []int {
var last_i int
for i:=0;i<len(numbers)-1;i++ {
if i!=0 && last

class Solution:
def twoSum(self, numbers: List[int], target: int) -> List[int]:
last_i = None
for i in ra

func maximumWealth(accounts [][]int) int {
var max_wealth int
for _, customer := range accounts {
var wealth

func convertToTitle(columnNumber int) string {
var bs []int
for ;columnNumber!=0; {
d := columnNumber%26

SELECT tweet_id FROM Tweets WHERE CHAR_LENGTH(content) > 15;

class Solution:
def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
return len(list(filter(la

class Solution:
def majorityElement(self, nums: List[int]) -> int:
f = int(len(nums)/2)
for n in set(nums

class Solution:
def letterCombinations(self, digits: str) -> List[str]:
pad = {
"2": "abc",

func all_same(arr []int) bool {
for _, v := range arr {
if v != arr[0] {
return false
}

func titleToNumber(columnTitle string) int {
p := 1
var n int
for i:=len(columnTitle)-1; i>=0; i++ {
c = columnTitle[i]

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/

SELECT user_id, count(follower_id) as followers_count FROM Followers GROUP BY user_id ORDER BY user_id;

func sumOfUnique(nums []int) int {
var sum int = 0;
for i := 0; i < len(nums); i++ {
var u bool = true

class Solution:
def check(self, nums: List[int]) -> bool:
if len(nums) == 1:
return True
s =

SELECT product_id FROM Products WHERE low_fats = 'Y' AND recyclable = 'Y';

func mergeAlternately(word1 string, word2 string) string {
var merged string
m := min(len(word1), len(word2))
for

class Solution:
def areAlmostEqual(self, s1: str, s2: str) -> bool:
if s1 == s2:
return True

class Solution:
def findCenter(self, edges: List[List[int]]) -> int:
flat = set()
for l in edges[:3]:

class Solution:truncateSentence=lambda _,s,k:" ".join(s.split()[:k])

class Solution:
def checkIfPangram(self, sentence: str) -> bool:
return len(set(sentence)) == 26

class Solution:
def sortSentence(self, s: str) -> str:
return " ".join([w[:-1] for w in sorted(s.split(), key=lamb

def remove_nth_from_end(head, n)
if not head or not head.next then
return nil
end

len = 0
th = head
while

func uint32_to_bin_s(n uint32) string {
var b string
for ;n!=0; {
if n%2==1 {
n--
b

func hammingWeight(n int) int {
var w int
for ;n!=0; {
if n%2==1 {
w++
n--

class Solution:
def removeOccurrences(self, s: str, part: str) -> str:
while part in s:
s = s.replace

class Solution:
def areOccurrencesEqual(self, s: str) -> bool:
fa = s.count(s[0])
for c in set(s):

class Solution:
def getLucky(self, s: str, k: int) -> int:
n = ""
for c in s:
n += str(ord(c

class Solution:
def makeFancyString(self, s: str) -> str:
for c in set(s):
while c*3 in s:

# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val

class Solution:
def isValid(self, s: str) -> bool:
stack = []
m = {
')': '(',
'

func reversePrefix(word string, ch byte) string {
var stack []rune
for _i, c := range word {
stack = append(s

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func re

func contain(nums []int, target int) bool {
for _, n := range nums {
if n == target {
return true

func atoi(s string) int {
var n int
for _, c := range s {
n = (n*10) + int(c-48)
}
return n
}
func is_number(s stri

import "fmt"
func split_words(sentence string) []string {
var words []string
l, i := 0, 0
for ; i<len(sentence); i++ {

class Solution:
def kthDistinct(self, arr: List[str], k: int) -> str:
distinct = []
for c in arr:

// @leet start
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
*

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/

# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val

/**
* @param {number} num
* @return {boolean}
*/
var isSameAfterReversals = function(num) {
if (num)
return

class Solution:
def isSameAfterReversals(self, num: int) -> bool:
if not num: return True
return num % 10

impl Solution {
pub fn is_same_after_reversals(num: i32) -> bool {
if (num != 0){
return num % 10 !=

public class Solution {
public int NumberOfBeams(string[] bank) {
int pre_lesers = 0;
int beams = 0;

class Solution:
def numberOfBeams(self, bank: List[str]) -> int:
beams = 0
pre_lesers = 0
for fl

class Solution:findKthLargest=lambda _,n,k:sorted(n)[-k]

func findFinalValue(nums []int, original int) int {
for ;true; {
f := false
for _, n := range nums {

class Solution:
def prefixCount(self, words: List[str], pref: str) -> int:
return len(list(filter(lambda e:e.start

func containsNearbyDuplicate(nums []int, k int) bool {
for i:=0; i<len(nums); i++ {
for j:=1; j<=k && i+j<len(nums

func divideArray(nums []int) bool {
pairs := make(map[int]int)
for _, n := range nums {
c, f := pairs[n]

func contain(target int, array []int) bool {
for _, item := range array {
if item == target {
return

class Solution:
def minBitFlips(self, start: int, goal: int) -> int:
bb = len(bin(max([start, goal]))) - 2

/**
* @param {number} num1
* @param {number} num2
* @return {number}
*/
var sum = function(num1, num2) {
return nu

class Solution:
def sum(self, num1: int, num2: int) -> int:
return num1 + num2

# @param {Integer} num1
# @param {Integer} num2
# @return {Integer}
def sum(num1, num2)
return num1 + num2
end

impl Solution {
pub fn sum(num1: i32, num2: i32) -> i32 {
return num1 + num2;
}
}

object Solution {
def sum(num1: Int, num2: Int): Int = {
return num1 + num2;
}
}

/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *Tree

type MyStack struct {
values []int
len int
}


func Constructor() MyStack {
var stack MyStack

class Solution:
def waysToSplitArray(self, nums: List[int]) -> int:
c = 0
ls = 0
rs = sum(nums)

type Char struct {
Value string
Prev *Char
Next *Char
}

type TextEditor struct {
Cursor *Char

# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val

// Stack implimentatin
type MyStack struct {
values []int
len int
}

func (this *MyStack) Push(x int) {
this.va

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/

class Solution:
def digit_sum(self, num) -> int:
s = 0
for d in str(num):
s += int(d)

/**
* @param {string} s
* @return {character}
*/
var repeatedCharacter = function(s) {
seen = [];
for (let i=0;

class Solution:
def repeatedCharacter(self, s: str) -> str:
seen = set()
for c in s:
if c in

// @leet start
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
*

func minimumRecolors(blocks string, k int) int {
m := len(blocks)
for i:=0; i<len(blocks)-k+1; i++ {
c := 0

class Solution:
def secondsToRemoveOccurrences(self, s: str) -> int:
secs = 0
while "01" in s:

func isStrictlyPalindromic(n int) bool {
return false
}

class Solution:
def checkDistances(self, s: str, distance: List[int]) -> bool:
for l in sorted(set(s)):

# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self

class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
return [names[heights.ind

class Solution:
def isAnagram(self, s: str, t: str) -> bool:
return sorted(s) == sorted(t)

func hg_sum(x int, y int, mat [][]int) int {
var sum int
sum += (mat[y-1][x-1] + mat[y-1][x] + mat[y+1][x-1])
sum

class Solution:
def findMaxK(self, nums: List[int]) -> int:
nums.sort()
l = -1
for n in nums:

class Solution:
def applyOperations(self, nums: List[int]) -> List[int]:
for i in range(len(nums)-1):

func unequalTriplets(nums []int) int {
l := len(nums)
var count int
for i:=0; i<l-2; i++ {
for j:=i+1; j<l-1; j++ {

class Solution:
def isCircularSentence(self, sentence: str) -> bool:
sentence = sentence.split(" ")
if se

func tpow(x int) int {
p := 1
for ;x>1; x-- {
p *= 10
}
return p
}
func maximumValue(strs []strin

class Solution:
def countDigits(self, num: int) -> int:
return len(list(filter(lambda n:not num%n,[int(n)for n in

func sortTheStudents(score [][]int, k int) [][]int {
for i:=0; i<len(score); i++ {
for j:=i; j<len(score); j++ {

class Solution:
def separateDigits(self, nums: List[int]) -> List[int]:
saprated = []
for num in nums:

class Solution:
def pickGifts(self, gifts: List[int], k: int) -> int:
for _ in range(k):
m = max(gift

class Solution:
def findTheArrayConcVal(self, nums: List[int]) -> int:
n = 0
while nums:
f =

func coloredCells(n int) int64 {
var ans int
for i:=1; i<=n; i++ {
if i == 1 {
ans += 1

class Solution:
def evenOddBit(self, n: int) -> List[int]:
ans = [0, 0]
for i, v in enumerate(bin(n)[2:][

func removeDuplicates(nums []int) int {
l := len(nums)
for i:=0; i<l-1; i++ {
if nums[i] == nums[i+1] {

class Solution:
def findMatrix(self, nums: List[int]) -> List[List[int]]:
mat = []
for n in nums:

/**
* @param {number} n
* @return {Function} counter
*/
var createCounter = function(n) {
let count = n;
return

/**
* @param {Function[]} functions
* @return {Function}
*/
var compose = function(functions) {

return functio

/**
* @param {integer} init
* @return { increment: Function, decrement: Function, reset: Function }
*/
var createCounter

/**
* @param {Function} fn
* @return {Function}
*/
var once = function(fn) {
let called = false;
return function(.

/**
* @return {Function}
*/
var createHelloWorld = function() {

return function(...args) {
return "Hell

/**
* @param {Array} arr
* @param {number} size
* @return {Array}
*/
var chunk = function(arr, size) {
const chunk

class Solution:
def countSeniors(self, details: List[str]) -> int:
return len(list(filter(lambda p: p>60, [int(p[1

class Solution:
def minLength(self, s: str) -> int:
while "AB" in s or "CD" in s:
s = s.replace("AB",

class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
while val in nums:
nums.re

/**
* @param {...(null|boolean|number|string|Array|Object)} args
* @return {number}
*/
var argumentsLength = function(...

/**
* @param {string} val
* @return {Object}
*/
var expect = function(val) {
return {"toBe":
function (v

func SliceFind(arr []int, target int) int {
for i, v := range arr {
if v == target {
return i
}
}
return -1
}

class Solution:
def theMaximumAchievableX(self, num: int, t: int) -> int:
return num + (t*2)

/**
* @return {Function}
*/
var createHelloWorld = function() {

return function(...args) {
return "Hello

class Solution:
def isGood(self, nums: List[int]) -> bool:
nums.sort()
good = list(range(1, len(nums))) +

func numberOfEmployeesWhoMetTarget(hours []int, target int) int {
var ans int
for _, hour := range hours {
if

class Solution:
def findKthNumber(self, n: int, k: int) -> int:
l = sorted(map(lambda e:str(e), range(1, n+1)))

func reverse(s string) string {
var rev string
for i:=len(s)-1; i>=0; i-- {
rev += string(s[i])
}
r

// @leet start
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
*

func isAcronym(words []string, s string) bool {
if len(words) != len(s) {
return false
}
for i, c := ran

func moveZeroes(nums []int) {
for i, j := 0, 0; i<len(nums); i++ {
for;j<len(nums)&&nums[j]==0;j++{}
if

func count_set_bit(n int) int {
var count int
for ;n>0; {
if n % 2 == 1 {
n--
count

class Solution:
def maximumOddBinaryNumber(self, s: str) -> str:
if s.count("1") == 1:
return ("0" *

import pandas as pd

def selectFirstRows(employees: pd.DataFrame) -> pd.DataFrame:
return employees[:3]

func wordPattern(pattern string, s string) bool {
var words []string
mapping := make(map[rune]string)
var lb int

class Solution:
def findChampion(self, grid: List[List[int]]) -> int:
n = len(grid)
strongerthancount = [

func abs(n int) int {
if n < 0 {
return n*-1
}
return n
}
func maximumStrongPairXor(nums []int) int {

func sort(list []int) []int {
for i:=0; i<len(list); i++ {
for j:=i; j<len(list); j++ {
if list[j] <

func contain_duplicate(s string) bool {
for _, c := range s {
var count int
for _, cc := range s {
if c == cc {

class Solution:
def maxFrequencyElements(self, nums: List[int]) -> int:
freq = {}
h = 0
for n in

class Solution:
def minimumCost(self, nums: List[int]) -> int:
c = nums[0]
nums = nums[1:]
s = m

class Solution:
def isPrefixAndSuffix(self, str1: str, str2: str):
return str2.startswith(str1) and str2.endswith(

func longestMonotonicSubarray(nums []int) int {
l := 0

le := 0
ci := 0
for _, v := range nums {
i

class Solution:
def scoreOfString(self, s: str) -> int:
values = []
for c in s:
values.appen

class Solution:
def isValid(self, w: str, vo="aoeuiAOEUI", co="pyfgcrldhtnsqjkxbmwvzPYFGCRLDHTNSQJKXBMWVZ", n="7531902468")

func isArraySpecial(nums []int) bool {
for i:=0; i<len(nums)-1; i++ {
f, s := nums[i]%2, nums[i+1]%2
if f

func numberOfPairs(nums1 []int, nums2 []int, k int) int {
var count int
for _, i := range nums1 {
for _, j :=

class Solution:
def clearDigits(self, s: str) -> str:
ns = "01234567890"
s = list(s[::-1])
tl =

class Solution:
def minimumAverage(self, nums: List[int]) -> float:
avgs = []
while nums:
s,

class Solution:
def getEncryptedString(self, s: str, k: int) -> str:
return "".join([s[(i+k)%len(s)] for i in rang

class Solution:
def getFinalState(self, nums: List[int], k: int, multiplier: int) -> List[int]:
for _ in range(k):

func stringHash(s string, k int) string {
var result string
var chunk string
for _, c := range s {
chunk

class Solution:
def convertDateToBinary(self, date: str) -> str:
return "-".join([bin(int(e))[2:] for e in date.sp

func one_count(n int) int {
var count int
for ;n!=0; {
if n%2==1 {
count++
}
n

class Solution:
def minimumOperations(self, nums: List[int]) -> int:
l = len(nums)
seen = set()

class Solution:
def reverseString(self, s: List[str]) -> None:
"""
Do not return anything, modify s in-pl

class Solution:
def reverseVowels(self, s: str) -> str:
rvs = ""
for c in s[::-1]:
if c in "

func sumOfGoodNumbers(nums []int, k int) int {
var sum int
for i, _ := range nums {
var good bool = true

func hasSameDigits(s string) bool {
for ;len(s)!=2; {
var t string
for i:=0; i<len(s)-1; i++ {

func transformArray(nums []int) []int {
o, e := 0, 0
for _, n := range nums {
if n%2==1 {
o++

func contain(target int, array []int) bool {
for _, v := range array {
if v == target {
return true

func contain(target int, arr []int) bool {
for _, v := range arr {
if v == target {
return true

func searchInsert(nums []int, target int) int {
for i, v := range nums {
if target <= v {
return i

func minsumpair(nums []int) int {
var min_sum int = (2000 * 50) + 1
var min_inexd int = -1
for i:=0; i<len(nums)-1; i++ {

func isPerfectSquare(num int) bool {
n := 1
for {
s := n * n
if s == num {
return true
}
if s > num {

/**
* Forward declaration of guess API.
* @param num your guess
* @return -1 if num is higher than the picked nu

from random import choice
class RandomizedSet:

def __init__(self):
self.values = []

def insert(self, val

from random import choice
class RandomizedCollection:

def __init__(self):
self.values = []

def insert(se

# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val

from random import shuffle

class Solution:

def __init__(self, nums: List[int]):
self.list = nums
sel

from random import choice

class Solution:

def __init__(self, nums: List[int]):
self.nums = nums

def pi

/**
* Definition for a Node.
* type Node struct {
* Val int
* Prev *Node
* Next *Node
* Child *Node

class Solution:
def countSegments(self, s: str) -> int:
n = 0
f = True
for c in s+" ":

// @leet start
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
*

class Solution:
def findContentChildren(self, g: List[int], s: List[int]) -> int:
g.sort()
s.sort()

class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
if len(nums) == 1: return [[nums[0]]]

func int_to_binary(n int) string {
var b string = ""
for ;n!=0; {
if n % 2 == 0 {
b = "0" + b

class Solution:
def validIPAddress(self, queryIP: str) -> str:
if "." in queryIP:
try:

class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
combs = []
if len(nums) == 1

class Solution:
def findComplement(self, num: int) -> int:
b = bin(num)[2:]
b = b.replace("0", "2")

class Solution:
def licenseKeyFormatting(self, s: str, k: int) -> str:
while "-" in s:
s = s.replace(

func findMaxConsecutiveOnes(nums []int) int {
m := 0
cc := 0
for _, n := range nums {
if n != 1 {

class Solution:
def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
m = 0
cc = 0
for n in

func nextGreaterElement(nums1 []int, nums2 []int) []int {
var ans []int
for _, n := range nums1 {
f := false
g := -

class Solution:
def findWords(self, words: List[str]) -> List[str]:
rows = [
"qwertyuiop",

/**
* @param {number} n
* @return {number}
*/
var fib = function(n) {
if (n == 0)
return 0;
if (n == 1

class Solution:
def fib(self, n: int) -> int:
if n == 0:
return 0
if n == 1:
re

impl Solution {
pub fn fib(n: i32) -> i32 {
if (n == 0){
return 0;
}
if (n == 1){

SELECT name FROM Customer WHERE referee_id != 2 OR referee_id IS NULL;

/**
* Definition for a Node.
* type Node struct {
* Val int
* Children []*Node
* }
*/

/**
* Definition for a Node.
* type Node struct {
* Val int
* Children []*Node
* }
*/

SELECT name, population, area FROM world WHERE area >= 3000000 or population >= 25000000;

class Solution:
def findRestaurant(self, list1: list[str], list2: list[str]) -> list[str]:
lis = len(list1+list2)+

class Solution:
def findDuplicate(self, paths: List[str]) -> List[List[str]]:
content_match = {}
for path

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func ro

func count(target int, arr []int) int {
var count int
for _, n := range arr {
if n == target {
c

import "fmt"
type Stack struct {
values []int
}
func (stack *Stack) push(n int) {
stack.values = append(stack.value

func mySqrt(x int) int {
for n := range x+1 {
if n*n >= x || (n+1)*(n+1) > x {
return n
}
}
return 0
}

func int_to_str(n int) string {
s := ""
if n < 0 {
s += "-"
n *= -1
}
for ;n!=0; {

class Solution:
def reverse(self, x):
if x < 0: n = -1; x = x * (-1)
else: n = 1
r = 0

class KthLargest:

def __init__(self, k: int, nums: List[int]):
self.values = sorted(nums)
self.k = k

// LinkedList //
import "fmt"
// type ListNode struct {
// Val int
// Next *ListNode
// }

type MyLinkedList struct {

func pivotIndex(nums []int) int {
var sum int
for _, n := range nums {
sum += n
}
var ls int = 0

class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
for row in matrix:

func numJewelsInStones(jewels string, stones string) int {
var count int
for _, j := range jewels {
for _, s := range sto

class Solution:
def rotateString(self, s: str, goal: str) -> bool:
for _ in range(len(s)):
s = s[1:]

func char_to_morse(char rune) string {
codes := []string{
".-","-...","-.-.","-..",".","..-.","--.",
"...

func numberOfLines(widths []int, s string) []int {
var line, lw int
line = 1
for _, c := range s {
w :=

/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode? next;
* ListNode([this.val =

class Solution:
def flipAndInvertImage(self, image: list[list[int]]) -> list[list[int]]:
for i in range(len(image)

class Solution:
def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
if len(hand) % groupSize != 0:

class Solution:
def lemonadeChange(self, bills: List[int]) -> bool:
galla = []
for bill in bills:

/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func mi

class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not r

class Solution:
def uncommonFromSentences(self, s1: str, s2: str) -> List[str]:
uncommon_words = []
s1 =

class Solution:
def reverseOnlyLetters(self, s: str) -> str:
s = list(s)
chars = "qwertyuiopasdfghjklzxcv

type RecentCounter struct {
pings []int
}


func Constructor() RecentCounter {
var rc RecentCounter
return rc

/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *Tree

class Solution:
def isLowerOrEqual(self, word1, word2, order) -> bool:
for i in range(min(len(word1), len(word2)))

class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
return list(sorted(map(lambda a:a*a, nums))