post_href
stringlengths 57
213
| python_solutions
stringlengths 71
22.3k
| slug
stringlengths 3
77
| post_title
stringlengths 1
100
| user
stringlengths 3
29
| upvotes
int64 -20
1.2k
| views
int64 0
60.9k
| problem_title
stringlengths 3
77
| number
int64 1
2.48k
| acceptance
float64 0.14
0.91
| difficulty
stringclasses 3
values | __index_level_0__
int64 0
34k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
https://leetcode.com/problems/hamming-distance/discuss/2827624/python3 | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
def dec_to_char(num):
s = ''
while num > 0:
s = str(num % 2) + s
num = num // 2
return s.rjust(40, "0")
count = 0
for i in range(len(dec_to_char(x))):
if dec_to_char(x)[i] != dec_to_char(y)[i]:
count += 1
return count | hamming-distance | python3 | Geniuss87 | 0 | 1 | hamming distance | 461 | 0.749 | Easy | 8,200 |
https://leetcode.com/problems/hamming-distance/discuss/2816875/Python-one-liner | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return bin(x^y).count('1') | hamming-distance | Python one liner | mohammadhussain | 0 | 1 | hamming distance | 461 | 0.749 | Easy | 8,201 |
https://leetcode.com/problems/hamming-distance/discuss/2801471/Python-brute-force-solution-implementing-32-bits | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
x=f'{x:0>32b}'
y=f'{y:0>32b}'
return sum(x[z]!=y[z]for z in range(32)) | hamming-distance | Python brute force solution implementing 32 bits | alex41542 | 0 | 2 | hamming distance | 461 | 0.749 | Easy | 8,202 |
https://leetcode.com/problems/hamming-distance/discuss/2784861/Python-one-liner-using-XOR-beats-100 | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return str(bin(x^y)).count('1') | hamming-distance | Python one-liner using XOR beats 100% | rama_krishna044 | 0 | 1 | hamming distance | 461 | 0.749 | Easy | 8,203 |
https://leetcode.com/problems/hamming-distance/discuss/2784541/The-simplest-solution-in-Python | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return format(x^y, "b").count('1') | hamming-distance | The simplest solution in Python | aaronhaddad | 0 | 1 | hamming distance | 461 | 0.749 | Easy | 8,204 |
https://leetcode.com/problems/hamming-distance/discuss/2727112/Simple-python-code-with-explanation | class Solution:
def hammingDistance(self, x, y):
#create a variable count and assign value 0 to it
count = 0
#untill both values becomes 0 this while loop works
while x != 0 or y != 0 :
#a stores the value of last bit in x
a =( x&1)
#b stores the value of last bit in y
b = (y & 1)
#if the bits(a,b) are different
if a != b:
#then increase the count value by 1
count +=1
#right shift the bits in x by 1
x>>=1
#right shift the bits in y by 1
y>>=1
#after x and y becoming 0
#return the value of count
return count | hamming-distance | Simple python code with explanation | thomanani | 0 | 5 | hamming distance | 461 | 0.749 | Easy | 8,205 |
https://leetcode.com/problems/hamming-distance/discuss/2634143/Hamming-Distance-Python3-fast-and-easy-96-faster | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
if x == y: return 0
if x == 0: return sum([1 for b in "{0:b}".format(y) if b == '1'])
if y == 0: return sum([1 for b in "{0:b}".format(x) if b == '1'])
from math import log2
from math import floor
l = str(max(floor(log2(x))+1, floor(log2(y))+1))
f = "{0:0"+str(l)+"b}"
return sum([1 for a, b in zip(f.format(x), f.format(y)) if a != b]) | hamming-distance | Hamming Distance Python3, fast and easy, 96 % faster | th3lias | 0 | 5 | hamming distance | 461 | 0.749 | Easy | 8,206 |
https://leetcode.com/problems/hamming-distance/discuss/1899859/Python-easy-solution-using-strings-faster-than-89 | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
bin_x = str(bin(x))[2:]
bin_y = str(bin(y))[2:]
ham_dist = 0
if len(bin_x) < len(bin_y):
bin_x = ("0" * (len(bin_y) - len(bin_x))) + bin_x
elif len(bin_y) < len(bin_x):
bin_y = ("0" * (len(bin_x) - len(bin_y))) + bin_y
for i in range(len(bin_x)):
if bin_x[i] != bin_y[i]:
ham_dist += 1
return ham_dist | hamming-distance | Python easy solution using strings, faster than 89% | alishak1999 | 0 | 82 | hamming distance | 461 | 0.749 | Easy | 8,207 |
https://leetcode.com/problems/hamming-distance/discuss/1854719/1-Line-Python-Solution-oror-90-Faster-oror-Memory-less-than-98 | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return bin(x^y).count('1') | hamming-distance | 1-Line Python Solution || 90% Faster || Memory less than 98% | Taha-C | 0 | 59 | hamming distance | 461 | 0.749 | Easy | 8,208 |
https://leetcode.com/problems/hamming-distance/discuss/1760916/Simple-solution | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
z = bin(x ^ y)
return z.count('1') | hamming-distance | Simple solution | DavidVinicius | 0 | 26 | hamming distance | 461 | 0.749 | Easy | 8,209 |
https://leetcode.com/problems/hamming-distance/discuss/1735205/Python-solution%3A-13.9-MB-Beats-98.55-32ms-Beats-73.48 | class Solution:
def hammingDistance(self, l: int, s: int) -> int:
l,s = ''.join(bin(max(l,s)).split('0b')), ''.join(bin(min(l,s)).split('0b'))
len_l=len(l)
len_s = len(s)
if len_l < len_s:
for i in range(len_s-len_l):
l = '0' + l
elif len_l > len_s:
for i in range(len_l-len_s):
s = '0'+ s
output = 0
while True:
if l == '' or s == '':
break
if l[0] != s[0]:
output += 1
l,s = l[1:],s[1:]
return output | hamming-distance | Python solution: 13.9 MB Beats 98.55%, 32ms Beats 73.48% | alanlix | 0 | 64 | hamming distance | 461 | 0.749 | Easy | 8,210 |
https://leetcode.com/problems/hamming-distance/discuss/1651670/python3-one-liner-XOR | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return bin(x^y)[2:].count('1') | hamming-distance | python3 one-liner XOR | 752937603 | 0 | 41 | hamming distance | 461 | 0.749 | Easy | 8,211 |
https://leetcode.com/problems/hamming-distance/discuss/1622060/Python-Solution-or-Bit-Manipulation-or-O(log-n) | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
diff, xor = 0, x^y
while xor > 0:
diff += 1
xor = xor & (xor-1)
return diff | hamming-distance | Python Solution | Bit Manipulation | O(log n) | avi-arora | 0 | 87 | hamming distance | 461 | 0.749 | Easy | 8,212 |
https://leetcode.com/problems/hamming-distance/discuss/1586378/Python-or-O(N) | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
counter = 0
x = format(x, '08b')
y = format(y, '08b')
#Below code would be helpful incase the binary number has more than 8 bits
if len(x) != len(y):
if len(x) > len(y):
a = len(x) - len(y)
y = ("0" * a) + y
elif len(y) > len(x):
a = len(y) - len(x)
x = ("0" * a) + x
for n in range(len(x)):
if x[n] != y[n]:
counter += 1
return counter | hamming-distance | Python | O(N) | Shreya19595 | 0 | 44 | hamming distance | 461 | 0.749 | Easy | 8,213 |
https://leetcode.com/problems/hamming-distance/discuss/1586018/Simple-python-XOR-and-and-solution | class Solution:
def hammingDistance(self, x,y):
z = x ^ y
count = 0
for i in range(0,32):
if (1<<i) & z:
count += 1
return count | hamming-distance | Simple python XOR and & solution | sandeep623 | 0 | 9 | hamming distance | 461 | 0.749 | Easy | 8,214 |
https://leetcode.com/problems/hamming-distance/discuss/1585492/python3-intuitive-1-line-solution | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return bin(x^y).count('1') | hamming-distance | python3 intuitive 1 line solution | yingziqing123 | 0 | 35 | hamming distance | 461 | 0.749 | Easy | 8,215 |
https://leetcode.com/problems/hamming-distance/discuss/1554424/Python-Easy-Solution-or-Faster-than-90 | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
res = x ^ y
count = 0
while res:
if res & 1:
count += 1
res = res >> 1
return count | hamming-distance | Python Easy Solution | Faster than 90% | leet_satyam | 0 | 42 | hamming distance | 461 | 0.749 | Easy | 8,216 |
https://leetcode.com/problems/hamming-distance/discuss/1279193/Python3-dollarolution | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
c = 0
x = bin(x)[2:]
y = bin(y)[2:]
if len(x) < len(y):
x = '0'*(len(y)-len(x)) + x
elif len(x) > len(y):
y = '0'*(len(x)-len(y)) + y
for i in range(len(x)):
if x[i] != y[i]:
c += 1
else:
continue
return c | hamming-distance | Python3 $olution | AakRay | 0 | 138 | hamming distance | 461 | 0.749 | Easy | 8,217 |
https://leetcode.com/problems/hamming-distance/discuss/1062116/Python-1-Liner-Easy-XOR | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return sum(int(i) for i in format(x^y, "b")) | hamming-distance | Python 1 Liner Easy XOR | Onlycst | 0 | 76 | hamming distance | 461 | 0.749 | Easy | 8,218 |
https://leetcode.com/problems/hamming-distance/discuss/721218/Python3-count-set-bits-of-xor | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
x ^= y
ans = 0
while x:
x, d = divmod(x, 2)
ans += d
return ans | hamming-distance | [Python3] count set bits of xor | ye15 | 0 | 35 | hamming distance | 461 | 0.749 | Easy | 8,219 |
https://leetcode.com/problems/hamming-distance/discuss/721218/Python3-count-set-bits-of-xor | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
return bin(x^y).count("1") | hamming-distance | [Python3] count set bits of xor | ye15 | 0 | 35 | hamming distance | 461 | 0.749 | Easy | 8,220 |
https://leetcode.com/problems/hamming-distance/discuss/721218/Python3-count-set-bits-of-xor | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
ans = 0
diff = x^y
while diff:
ans += 1
diff &= diff - 1
return ans | hamming-distance | [Python3] count set bits of xor | ye15 | 0 | 35 | hamming distance | 461 | 0.749 | Easy | 8,221 |
https://leetcode.com/problems/hamming-distance/discuss/343587/Solution-in-Python-3-(two-lines) | class Solution:
def hammingDistance(self, x: int, y: int) -> int:
xb, yb = bin(min(x,y))[2:], bin(max(x,y))[2:]
return list(yb[:(len(yb)-len(xb))]).count('1') + sum([1 for i in range(len(xb)) if xb[-1-i] != yb[-1-i]])
- Junaid Mansuri | hamming-distance | Solution in Python 3 (two lines) | junaidmansuri | 0 | 230 | hamming distance | 461 | 0.749 | Easy | 8,222 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2218363/Python3-simple-solution%3A-Get-the-mid-element-from-the-sorted-array | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
mid = nums[len(nums)//2]
result = 0
for i in nums:
result+=abs(mid-i)
return result | minimum-moves-to-equal-array-elements-ii | 📌 Python3 simple solution: Get the mid element from the sorted array | Dark_wolf_jss | 6 | 68 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,223 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1219317/Python3-or-Easy-Explanation-or-O(nlogn)-or-Sorting-or-Median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
n = len(nums)
return sum(abs(nums[i] - nums[n//2]) for i in range(n)) | minimum-moves-to-equal-array-elements-ii | Python3 | Easy Explanation | O(nlogn) | Sorting | Median | codemonk1307 | 4 | 135 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,224 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1219317/Python3-or-Easy-Explanation-or-O(nlogn)-or-Sorting-or-Median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
n = len(nums)
minMoves = 0
for i in range(n):
minMoves += abs(nums[i] - nums[n//2])
return minMoves | minimum-moves-to-equal-array-elements-ii | Python3 | Easy Explanation | O(nlogn) | Sorting | Median | codemonk1307 | 4 | 135 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,225 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1090585/PythonPython3-Minimum-Moves-to-Equal-Array-Element-ll | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums_two = sorted(nums)
if len(nums_two) % 2 == 0:
median = (nums_two[len(nums_two)//2] + nums_two[(len(nums_two)//2) - 1]) // 2
else:
median = nums_two[len(nums_two)//2]
steps = 0
for x in nums_two:
if x != median:
steps += abs(x-median)
return steps | minimum-moves-to-equal-array-elements-ii | [Python/Python3] Minimum Moves to Equal Array Element ll | newborncoder | 3 | 264 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,226 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/849789/Python3-find-%22median%22 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
m = sorted(nums)[len(nums)//2] # median
return sum(abs(x-m) for x in nums) | minimum-moves-to-equal-array-elements-ii | [Python3] find "median" | ye15 | 3 | 238 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,227 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/849789/Python3-find-%22median%22 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
def part(lo, hi):
"""Partition array via a random pivot."""
i, j = lo+1, hi-1
while i <= j:
if nums[i] < nums[lo]: i += 1
elif nums[lo] < nums[j]: j -= 1
else:
nums[i], nums[j] = nums[j], nums[i]
i += 1
j -= 1
nums[lo], nums[j] = nums[j], nums[lo]
return j
shuffle(nums) # statistical guarantee of O(NlogN)
lo, hi = 0, len(nums)
while lo < hi:
mid = part(lo, hi)
if mid == len(nums)//2: break
if mid < len(nums)//2: lo = mid+1
else: hi = mid
return sum(abs(x-nums[mid]) for x in nums) | minimum-moves-to-equal-array-elements-ii | [Python3] find "median" | ye15 | 3 | 238 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,228 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2218860/Python-easy-approach-oror-Beats-92.72 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
res = 0
nums.sort()
med = nums[len(nums)//2]
for i in nums:
res += abs(med-i)
return res | minimum-moves-to-equal-array-elements-ii | Python easy approach || ✅Beats 92.72% | Shivam_Raj_Sharma | 2 | 81 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,229 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2216612/Python-oror-fastest-oror-explanation | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
middle_index= len(nums)//2
mv= nums[middle_index] #median value
ans=0
for i in nums:
ans+=abs(i-mv)
return ans | minimum-moves-to-equal-array-elements-ii | Python || fastest || explanation | palashbajpai214 | 2 | 11 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,230 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1218293/RustPython3-Sort-and-make-all-values-equal-with-center-value. | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
if len(nums) % 2 == 0:
rc = len(nums)//2
lc = rc-1
avg_median = (nums[rc]+nums[lc])/2
else:
avg_median = nums[len(nums)//2]
return int(sum([abs(i-avg_median) for i in nums])) | minimum-moves-to-equal-array-elements-ii | [Rust][Python3] Sort and make all values equal with center value. | vadhri_venkat | 2 | 97 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,231 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217876/Python-oror-Easy-explanation-oror-Time-Complexity-explained-oror-Faster-than-94 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
#brute force
# minCount = float("inf")
# for n in nums:
# count = 0
# for n1 in nums:
# if n1 == n:
# continue
# count += abs(n1 - n)
# minCount = min(minCount, count)
# return minCount
#optimized
nums.sort()
median = nums[len(nums)//2]
count = 0
for n in nums:
if n == median:
continue
count += abs(n - median)
return count | minimum-moves-to-equal-array-elements-ii | Python || Easy explanation || Time Complexity explained || Faster than 94% | kashyapshirodkar | 1 | 19 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,232 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215963/python3-or-2-approaches-or-Explained-or-Easy-to-understand-or-Median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
n = len(nums)
nums.sort()
# with median
# md = nums[n//2] # median
# return sum([abs(e-md) for e in nums]) # return sum of abs of diff
# with sum of diff of last and first element
return sum([nums[-(i+1)] - nums[i] for i in range(n//2)]) | minimum-moves-to-equal-array-elements-ii | python3 | 2 approaches | Explained | Easy to understand | Median | H-R-S | 1 | 43 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,233 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1587879/Python-Two-Easy-Solutions-or-Faster-than-99 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
# 1st Approach - Time: O(nlogn), Space: O(1)
nums.sort()
sum = 0
strt = 0
end = len(nums)-1
while strt <= end:
sum += nums[end]-nums[strt]
end -= 1
strt += 1
return sum
# 2nd Approach - Time : O(n)+O(nlogn), Space: O(1)
nums.sort()
med = nums[len(nums)//2]
sum = 0
for num in nums:
sum += abs(med-num)
return sum | minimum-moves-to-equal-array-elements-ii | Python Two Easy Solutions | Faster than 99% | leet_satyam | 1 | 186 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,234 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1218180/Python-solution-using-maths | class Solution:
def minMoves2(self, nums: List[int]) -> int:
median = sorted(nums)[len(nums)//2]
return sum(abs(i-median) for i in nums) | minimum-moves-to-equal-array-elements-ii | Python solution using maths | anurag2011 | 1 | 125 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,235 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1217512/O(nlogn)-solution-using-prefix-sum | class Solution:
def minMoves2(self, nums: List[int]) -> int:
N = len(nums)
nums.sort()
prefix = [0] + list(accumulate(nums))
# print(prefix)
def prefix_diff(left,right):
return prefix[right] - prefix[left]
ans = float("inf")
for i in range(N):
left_sum = prefix_diff(0,i)
right_sum = prefix_diff(i+1,N)
l = abs(left_sum - (nums[i])*(i))
r = abs(right_sum - (nums[i])*(N-i-1))
ans = min(ans,l+r)
# print(l,r,nums[i],left_sum,right_sum)
return ans | minimum-moves-to-equal-array-elements-ii | O(nlogn) solution using prefix sum | bismeet | 1 | 135 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,236 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/526810/Python3-simple-5-lines-solution-time-O(nlogn)-space-O(1) | class Solution:
def minMoves2(self, nums: List[int]) -> int:
"""
Time O(nlogn)
Space O(1)
"""
nums.sort()
sums=0
for num in nums:
sums+=abs(nums[len(nums)//2]-num)
return sums | minimum-moves-to-equal-array-elements-ii | Python3 simple 5-lines solution, time O(nlogn) space O(1) | jb07 | 1 | 157 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,237 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2800983/Easy-Python-solution | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
idx = int(len(nums)/2)
median = nums[idx]
output = 0
for num in nums:
diff = abs(median-num)
output += diff
return output | minimum-moves-to-equal-array-elements-ii | Easy Python solution | gorge_t88 | 0 | 2 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,238 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2757129/Simple-Python-Solution | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort() // sorting the array
ans = 0 // storing ans
if len(nums) == 1:
return 0
if len(nums) == 2:
return (nums[1]-nums[0])
mid = nums[len(nums)//2] // finding the middle element
for ele in nums:
ans += abs(ele-mid) // incrementing or decrementing the value to make it equal to the middle element
return ans | minimum-moves-to-equal-array-elements-ii | Simple Python Solution | imkprakash | 0 | 2 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,239 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2220187/Python3-or-O(nlogn)-or-Median-Approach | class Solution:
def minMoves2(self, nums: List[int]) -> int:
# sort numbers
nums.sort()
# find median
n = len(nums)
median = (nums[n//2] + nums[n//2 -1])//2 if n%2==0 else nums[n//2]
# calculate total steps
steps = 0
for num in nums:
steps+=abs(num-median)
return steps | minimum-moves-to-equal-array-elements-ii | Python3 | O(nlogn) | Median Approach | theKshah | 0 | 3 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,240 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2219451/Python-solution-or-Minimum-Moves-to-Equal-Array-Elements-II | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
step,left,right = 0,0,len(nums)-1
while left < right:
step += nums[right] - nums[left]
left += 1
right -= 1
return step | minimum-moves-to-equal-array-elements-ii | Python solution | Minimum Moves to Equal Array Elements II | nishanrahman1994 | 0 | 8 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,241 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2219207/Python-oror-Straight-Forward | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums = sorted(nums)
n = len(nums)
if n%2 != 0:
count = 0
median = nums[n//2]
for i in range(n):
if i == n//2: continue
count += max( median-nums[i], nums[i]-median)
return count
median1, median2 = nums[n//2-1], nums[n//2]
count1, count2 = 0,0
for i in range(n):
if i == n//2: continue
count1 += max( median2-nums[i], nums[i]-median2)
for i in range(n):
if i == n//2-1: continue
count2 += max( median1-nums[i], nums[i]-median1)
return min(count1,count2) | minimum-moves-to-equal-array-elements-ii | Python || Straight Forward | morpheusdurden | 0 | 13 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,242 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2219089/Python-simple-solution | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums = sorted(nums)
mid = nums[len(nums)//2]
ans = 0
for i in range(len(nums)):
if nums[i] != mid:
ans += abs(nums[i]-mid)
return ans | minimum-moves-to-equal-array-elements-ii | Python simple solution | StikS32 | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,243 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2218701/Python3-Solution-with-using-sorting | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
median = nums[len(nums) // 2]
res = 0
for num in nums:
res += abs(num - median)
return res | minimum-moves-to-equal-array-elements-ii | [Python3] Solution with using sorting | maosipov11 | 0 | 5 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,244 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2218471/Python-or-Easy-and-Understanding-Solutionor-Using-Median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
n=len(nums)
nums.sort()
ans,median=0,nums[n//2]
for i in range(n):
ans+=abs(median-nums[i])
return ans
# Please upvote if you like the solution | minimum-moves-to-equal-array-elements-ii | Python | Easy & Understanding Solution| Using Median | backpropagator | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,245 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2218177/Python3-oror-Very-Easy-oror-99-Faster-and-Easier-oror-Explained. | class Solution:
def minMoves2(self, nums: List[int]) -> int:
n = len(nums)
if n == 1: return 0
if n == 2: return abs(nums[0] - nums[1])
nums.sort()
mid = n >> 1 #Faster than n // 2 for dividing in half.
res = 0
for ele in nums:
res += abs(ele - nums[mid])
return res | minimum-moves-to-equal-array-elements-ii | Python3 || Very Easy || 99% Faster and Easier || Explained. | Dewang_Patil | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,246 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217772/C-C%2B%2B-Python-Kotlin-oror-Easy-Explained-Solution-oror-O(n) | class Solution(object):
def minMoves2(self, nums):
nums.sort()
left = 0
right = len(nums)-1
mid = len(nums)/2
count = 0
while (left != mid or right != mid):
if left != mid :
count += nums[mid]-nums[left]
left += 1
if right != mid :
count += nums[right]-nums[mid]
right -= 1
return count | minimum-moves-to-equal-array-elements-ii | C, C++, Python, Kotlin || Easy Explained Solution || O(n) | r_o_xx_ | 0 | 12 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,247 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217772/C-C%2B%2B-Python-Kotlin-oror-Easy-Explained-Solution-oror-O(n) | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
left = 0
right = len(nums)-1
mid = floor(len(nums)/2)
count = 0
while (left != mid or right != mid):
if left != mid:
count += nums[mid]-nums[left]
left += 1
if right != mid:
count += nums[right]-nums[mid]
right -= 1
return count | minimum-moves-to-equal-array-elements-ii | C, C++, Python, Kotlin || Easy Explained Solution || O(n) | r_o_xx_ | 0 | 12 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,248 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217559/Python-Sol-oror-beats-98-oror-6-lines-code | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
ans, median = 0, nums[len(nums) // 2]
for num in nums: ans += abs(median - num)
return ans | minimum-moves-to-equal-array-elements-ii | Python Sol || beats 98% || 6 lines code | anirudh_22 | 0 | 2 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,249 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217248/Median-Approach-oror-Easy-to-Understand | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums = sorted(nums)
mid = len(nums)//2
median = nums[mid]
minMoves = 0
for num in nums:
minMoves += abs(median - num)
return minMoves | minimum-moves-to-equal-array-elements-ii | Median Approach || Easy to Understand | Vaibhav7860 | 0 | 7 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,250 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217165/Python-Solution-2-Solutions | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
n=(len(nums)-1)//2
avg=nums[n]
count=0
for i in nums:
if i<=avg:
count+=(avg-i)
else:
count+=(i-avg)
return count | minimum-moves-to-equal-array-elements-ii | Python Solution - 2 Solutions | SakshiMore22 | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,251 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2217165/Python-Solution-2-Solutions | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
avg=nums[(len(nums)-1)//2]
return sum(abs(avg-i) for i in nums) | minimum-moves-to-equal-array-elements-ii | Python Solution - 2 Solutions | SakshiMore22 | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,252 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2216537/Median-oror-Python-or-Maths | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
n=len(nums)
if n&1==0:
a=(nums[(n-1)//2]+nums[n//2])//2
else:
a=nums[(n-1)//2]
sum=0
for i in nums:
sum+=abs(i-a)
return sum | minimum-moves-to-equal-array-elements-ii | Median || Python | Maths | chaurasiya_g | 0 | 2 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,253 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2216259/Approach-with-Explanation-or-Python3-and-C%2B%2B-Code-or | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
mid = len(nums) // 2
ans = 0
for i in range(mid):
ans += (nums[mid] - nums[i])
for i in range(mid+1, len(nums)):
ans += (nums[i] - nums[mid])
return ans | minimum-moves-to-equal-array-elements-ii | Approach with Explanation | Python3 & C++ Code | | omkulkarni22 | 0 | 6 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,254 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215853/PythonC%2B%2BJava-Solution-with-EXPLANATION!!! | class Solution:
def minMoves2(self, nums: List[int]) -> int:
snums = sorted(nums)
med = snums[int(len(snums) / 2)]
minMoveCount = 0
for n in snums: minMoveCount += abs(n-med)
return minMoveCount | minimum-moves-to-equal-array-elements-ii | [Python/C++/Java] Solution with EXPLANATION!!! | fahad_adnan | 0 | 11 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,255 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215806/Simple-Python-Solutions-Brute-Force-median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
n = len(nums)
l = []
for i in range(n):
count = 0
for j in range(n):
s = abs(nums[i]-nums[j])
count += s
l.append(count)
return min(l) | minimum-moves-to-equal-array-elements-ii | Simple Python Solutions - Brute Force/ median | sudoberlin | 0 | 12 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,256 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215806/Simple-Python-Solutions-Brute-Force-median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
n = len(nums)
nums.sort()
mid = n //2
count = 0
for i in range(n):
s = abs(nums[i] - nums[mid])
count += s
return count | minimum-moves-to-equal-array-elements-ii | Simple Python Solutions - Brute Force/ median | sudoberlin | 0 | 12 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,257 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215785/Python-3-using-sorting | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
index = (0 + len(nums) )//2
number = nums[index]
count = 0
for i in nums:
count+=abs(number-i)
return count | minimum-moves-to-equal-array-elements-ii | Python 3 - using sorting | gurucharandandyala | 0 | 22 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,258 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215729/Python-or-Commented-or-Sort-or-O(nlogn)-Top-99 | # Sort and Difference of Median Solution
# Time: O(nlogn + n), Sorting nums + iterating through nums.
# Space: O(1), Constant space used.
class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort() # Sort nums to get median number.
median = nums[len(nums) // 2] # Median number is in the middle of list after sorting.
steps = 0 # Variable to hold number of steps to equalize the list.
for number in nums: # Iterate through nums.
steps += abs(median - number) # Add difference of current number to median number.
return steps # Return the number of steps needed to equalize the list. | minimum-moves-to-equal-array-elements-ii | Python | Commented | Sort | O(nlogn) [Top 99%] | bensmith0 | 0 | 18 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,259 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/2215725/Python-binary-search | class Solution:
def minMoves2(self, nums: List[int]) -> int:
def moves(m):
return sum(abs(m-n) for n in nums)
left = min(nums)
right = max(nums)
while left <= right:
mid = (left + right) // 2
if moves(mid) < moves(mid-1):
left = mid + 1
else:
right = mid - 1
return moves(left - 1) | minimum-moves-to-equal-array-elements-ii | Python, binary search | blue_sky5 | 0 | 16 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,260 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1919167/Python-solution-faster-than-86 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
median = sorted(nums)[len(nums) // 2]
moves = 0
for i in nums:
moves += abs(i - median)
return moves | minimum-moves-to-equal-array-elements-ii | Python solution faster than 86% | alishak1999 | 0 | 65 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,261 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1886445/Python-2-methods-%3A | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
ans=0
median=nums[len(nums)//2]
for i in nums:
dist=abs(i-median)
ans+=dist
return ans | minimum-moves-to-equal-array-elements-ii | Python 2 methods : | goxy_coder | 0 | 46 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,262 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1886445/Python-2-methods-%3A | class Solution:
def minMoves2(self, nums: List[int]) -> int:
ans=0
nums.sort()
low=0
high=len(nums)-1
while low<=high:
ans+=nums[high]-nums[low]
high-=1
low+=1
return ans | minimum-moves-to-equal-array-elements-ii | Python 2 methods : | goxy_coder | 0 | 46 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,263 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1853584/Python-Solution-(Sorting) | class Solution:
def minMoves2(self, nums: List[int]) -> int:
# goal of all the elements is to be like the mid element
# Elements from start to mid have to add x in order to be equal as mid
# Elements from mid to end has to decrement by x to be made same as mid
# sort input
change = 0
nums = sorted(nums)
mid = (len(nums)-1) // 2
mide = nums[mid]
for i in range(mid+1):
change += mide-nums[i]
for i in range(mid+1, len(nums)):
change += nums[i] - mide
return change | minimum-moves-to-equal-array-elements-ii | Python Solution (Sorting) | DietCoke777 | 0 | 41 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,264 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1835058/python-3-oror-median-oror-O(nlogn)-oror-O(n) | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
median = nums[len(nums) // 2]
return sum(abs(num - median) for num in nums) | minimum-moves-to-equal-array-elements-ii | python 3 || median || O(nlogn) || O(n) | dereky4 | 0 | 65 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,265 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1798024/Python-Solution-Runtime-beats-94 | class Solution:
def minMoves2(self, nums: List[int]) -> int:
from statistics import median
tmp = int(median(nums))
count = 0
for i in nums:
if i != tmp:
count+=abs(i-tmp)
else:
continue
return count | minimum-moves-to-equal-array-elements-ii | Python Solution Runtime beats 94% | blazers08 | 0 | 84 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,266 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1235296/Python3-or-Two_Pointer-or-Easy_Understanding | class Solution:
def minMoves2(self, nums: List[int]) -> int:
res=0
i=0
j=len(nums)-1
nums.sort()
while i<j:
res+=(nums[j]-nums[i])
i+=1
j-=1
return res
``` | minimum-moves-to-equal-array-elements-ii | Python3 | Two_Pointer | Easy_Understanding | bug_buster | 0 | 120 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,267 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/1218373/PythonPython3-simple-solution | class Solution:
def minMoves2(self, nums: List[int]) -> int:
steps = 0 #To store the minimum moves or steps
nums.sort() # important step to be made else output will correct only for the sorted elements
for i in range(len(nums)//2): #since we are subtract kth largest and kth smallest element simultaneously half a traversal is enough
steps += (nums[-(i+1)]-nums[i]) #add the steps by subtracting kth largest element with kth smallest element
return steps | minimum-moves-to-equal-array-elements-ii | Python/Python3 simple solution | prasanthksp1009 | 0 | 42 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,268 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/476205/Python3-98.97-(68-ms)100.00-(13.9-MB)-O(n-*-log(n))-time-O(1)-space-median | class Solution:
def minMoves2(self, nums: List[int]) -> int:
nums.sort()
half = len(nums) // 2
median = nums[half] if len(nums) % 2 else \
(nums[half - 1] + nums[half]) // 2
moves = 0
for number in nums:
moves += abs(number - median)
return moves | minimum-moves-to-equal-array-elements-ii | Python3 98.97% (68 ms)/100.00% (13.9 MB) -- O(n * log(n)) time / O(1) space -- median | numiek_p | 0 | 147 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,269 |
https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/discuss/380107/Solution-in-Python-3-(beats-~93)-(one-line) | class Solution:
def minMoves2(self, n: List[int]) -> int:
return (lambda x,y: sum(abs(i-x[y]) for i in x))(sorted(n), len(n)//2)
- Junaid Mansuri
(LeetCode ID)@hotmail.com | minimum-moves-to-equal-array-elements-ii | Solution in Python 3 (beats ~93%) (one line) | junaidmansuri | -1 | 175 | minimum moves to equal array elements ii | 462 | 0.602 | Medium | 8,270 |
https://leetcode.com/problems/island-perimeter/discuss/343154/Solution-in-Python-3 | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
M, N, p = len(grid), len(grid[0]), 0
for m in range(M):
for n in range(N):
if grid[m][n] == 1:
if m == 0 or grid[m-1][n] == 0: p += 1
if n == 0 or grid[m][n-1] == 0: p += 1
if n == N-1 or grid[m][n+1] == 0: p += 1
if m == M-1 or grid[m+1][n] == 0: p += 1
return p
- Junaid Mansuri
- Chicago, IL | island-perimeter | Solution in Python 3 | junaidmansuri | 36 | 3,200 | island perimeter | 463 | 0.695 | Easy | 8,271 |
https://leetcode.com/problems/island-perimeter/discuss/1145167/WEEB-DOES-PYTHON-BFS | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
row, col, queue = len(grid), len(grid[0]), deque()
for x in range(row):
for y in range(col):
if grid[x][y] == 1:
queue.append((x,y))
return self.bfs(grid, row, col, queue)
def bfs(self,grid, row, col, queue):
visited = set()
perimeter = 0
while queue:
x,y = queue.popleft()
if (x,y) in visited: continue
visited.add((x,y))
for nx,ny in [[x+1,y],[x-1,y],[x,y+1],[x,y-1]]:
if 0<=nx<row and 0<=ny<col:
if grid[nx][ny] == 0:
perimeter+=1
if grid[nx][ny] == 1:
queue.append((nx,ny))
else: # if out of grid
perimeter+=1
return perimeter | island-perimeter | WEEB DOES PYTHON BFS | Skywalker5423 | 5 | 394 | island perimeter | 463 | 0.695 | Easy | 8,272 |
https://leetcode.com/problems/island-perimeter/discuss/953660/Very-simple-Python-solution | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
op = 0
m = len(grid)
n = len(grid[0])
for i in range(m):
for j in range(n):
if grid[i][j] == 1:
for x,y in [(0,1),(1,0),(-1,0),(0,-1)]:
dx = i + x
dy = j + y
# print(dx,dy)
if dx >= m or dy >= n or dx < 0 or dy < 0 or grid[dx][dy] == 0:
op += 1
return op | island-perimeter | Very simple Python solution | av4432 | 4 | 489 | island perimeter | 463 | 0.695 | Easy | 8,273 |
https://leetcode.com/problems/island-perimeter/discuss/1655746/Python-Simple-recursive-DFS-explained | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
row = len(grid)
col = len(grid[0])
visited = [[0 for x in range(col)] for y in range(row)]
def dfs(i, j):
# we're at a boundary node or a 0 node but we reached here
# from a 1 node, so this "unwanted node" is a adjacent to one
# of the wanted nodes and hence sharing the boundary (part perimeter)
# add 1 to the perimeter here
if i < 0 or i > row-1 or j < 0 or j > col-1 or grid[i][j] == 0:
return 1
# return if the current node is visited, we don't need
# to count that as part of our permieter calculation
# if not visited, mark the current node as visited,
# this is a legit node
if visited[i][j]:
return 0
visited[i][j] = 1
# now recursively check all the neighbours of the current node
return dfs(i-1, j) + dfs(i+1, j) + dfs(i, j+1) + dfs(i, j-1)
# loop over all elements in the
# matrix and as soon as you find
# a piece of land(1); begin graph
# traversal and we can safely return
# here since it's going to traverse
# the whole island and there's just 1
for x in range(row):
for y in range(col):
if grid[x][y] == 1:
return dfs(x, y) | island-perimeter | [Python] Simple recursive DFS explained | buccatini | 3 | 308 | island perimeter | 463 | 0.695 | Easy | 8,274 |
https://leetcode.com/problems/island-perimeter/discuss/1117735/Python-95-Expand-grid-greater-Easy-solve | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
rows, cols = len(grid), len(grid[0])
bal = 0
# Expand grid
grid.insert(0, [0]*cols)
grid.append([0]*cols)
for i in range(rows+2):
grid[i].append(0)
grid[i].insert(0, 0)
for i in range(1,rows+1):
for j in range(1,cols+1):
val = grid[i][j]
# By symmetry, look down and right:
if val: bal += 4*val-2*grid[i+1][j]-2*grid[i][j+1]
return bal | island-perimeter | [Python] 95% - Expand grid --> Easy solve | larskl | 2 | 224 | island perimeter | 463 | 0.695 | Easy | 8,275 |
https://leetcode.com/problems/island-perimeter/discuss/1117735/Python-95-Expand-grid-greater-Easy-solve | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
rows, cols = len(grid), len(grid[0])
grid.insert(0, [0]*cols)
grid.append([0]*cols)
for i in range(rows+2):
grid[i].append(0)
grid[i].insert(0, 0)
bal = 0
for i in range(1,rows+1):
for j in range(1,cols+1):
val = grid[i][j]
if val: bal += 4*val-grid[i+1][j]-grid[i][j+1]-grid[i-1][j]-grid[i][j-1]
return bal | island-perimeter | [Python] 95% - Expand grid --> Easy solve | larskl | 2 | 224 | island perimeter | 463 | 0.695 | Easy | 8,276 |
https://leetcode.com/problems/island-perimeter/discuss/724361/Python3-two-strategies | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
ans = 0
for i in range(m):
for j in range(n):
if grid[i][j]:
if i == 0 or not grid[i-1][j]: ans += 1
if j == 0 or not grid[i][j-1]: ans += 1
if i == m-1 or not grid[i+1][j]: ans += 1
if j == n-1 or not grid[i][j+1]: ans += 1
return ans | island-perimeter | [Python3] two strategies | ye15 | 2 | 92 | island perimeter | 463 | 0.695 | Easy | 8,277 |
https://leetcode.com/problems/island-perimeter/discuss/724361/Python3-two-strategies | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
ans = 0
for i in range(m):
for j in range(n):
if grid[i][j]:
ans += 4
if i and grid[i-1][j]: ans -= 2
if j and grid[i][j-1]: ans -= 2
return ans | island-perimeter | [Python3] two strategies | ye15 | 2 | 92 | island perimeter | 463 | 0.695 | Easy | 8,278 |
https://leetcode.com/problems/island-perimeter/discuss/501828/Python%3A-Simple-and-fast-solution | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
count = 0
for i in range(len(grid)):
for j in range(len(grid[i])):
if grid[i][j]:
count += 4
if j > 0 and grid[i][j - 1]:
count -= 2
if i > 0 and grid[i - 1][j]:
count -= 2
return count | island-perimeter | Python: Simple and fast solution | andnik | 2 | 427 | island perimeter | 463 | 0.695 | Easy | 8,279 |
https://leetcode.com/problems/island-perimeter/discuss/459718/Python-One-pass-100efficient-algorithm | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
count = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
if not grid[i][j]: continue
if i <= 0 or not grid[i-1][j]: count += 1
if i >= len(grid)-1 or not grid[i+1][j]: count += 1
if j <= 0 or not grid[i][j-1]: count += 1
if j >= len(grid[0])-1 or not grid[i][j+1]: count += 1
return count | island-perimeter | Python One pass 100%efficient algorithm | fallenranger | 2 | 377 | island perimeter | 463 | 0.695 | Easy | 8,280 |
https://leetcode.com/problems/island-perimeter/discuss/2562954/Python-DFS-easy | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
### dfs in grid
perimeter = 0
visited = set()
def dfs(grid,i,j,visited):
nonlocal perimeter
row = len(grid)
col = len(grid[0])
if (i,j) in visited:
return
if i<0 or i>=row or j<0 or j>=col or grid[i][j] == 0:
perimeter+=1
return
visited.add((i,j))
# call in 4 directions
directions = [[0,1],[1,0],[0,-1],[-1,0]]
for u,v in directions:
dfs(grid,i+u,j+v,visited)
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == 1 and (i,j) not in visited:
dfs(grid, i,j, visited)
return perimeter | island-perimeter | Python DFS easy | Abhi_009 | 1 | 81 | island perimeter | 463 | 0.695 | Easy | 8,281 |
https://leetcode.com/problems/island-perimeter/discuss/2329049/Python-DFS-w-Time-and-Space-O(n-*-m) | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
rows, cols = len(grid), len(grid[0])
def dfs(r, c):
# If already visited return 0
if (r, c) in visited:
return 0
# If out of bound or encountered water return 1
if r < 0 or c < 0 or r == rows or c == cols or grid[r][c] == 0:
return 1
visited.add((r, c))
return dfs(r + 1, c) + dfs(r - 1, c) + dfs(r, c + 1) + dfs(r, c - 1)
visited = set()
for r in range(rows):
for c in range(cols):
if grid[r][c] == 1:
return dfs(r, c) | island-perimeter | [Python] DFS w/ Time and Space - O(n * m) | tejeshreddy111 | 1 | 93 | island perimeter | 463 | 0.695 | Easy | 8,282 |
https://leetcode.com/problems/island-perimeter/discuss/2165398/DFS-Approach-oror-Fastest-Optimal-Solution-oror-Easy-Explanation | class Solution:
def __init__(self):
self.perimeter = 0
# checks if the given coordinate is in bound or not.
def isSafe(self,i,j,grid):
n = len(grid)
m = len(grid[0])
if 0 <= i < n and 0 <= j < m:
return True
else:
return False
def dfs(self, i,j,grid):
if not self.isSafe(i,j,grid) or grid[i][j] != 1:
if not self.isSafe(i,j,grid):
self.perimeter += 1
else:
if grid[i][j] == 0:
self.perimeter += 1
else:
grid[i][j] = 2
self.dfs(i-1,j,grid)
self.dfs(i,j-1,grid)
self.dfs(i+1,j,grid)
self.dfs(i,j+1,grid)
return self.perimeter
def islandPerimeter(self, grid: List[List[int]]) -> int:
n = len(grid)
m = len(grid[0])
for i in range(n):
for j in range(m):
if grid[i][j] == 1:
perimeter = self.dfs(i,j,grid)
return perimeter | island-perimeter | DFS Approach || Fastest Optimal Solution || Easy Explanation | Vaibhav7860 | 1 | 124 | island perimeter | 463 | 0.695 | Easy | 8,283 |
https://leetcode.com/problems/island-perimeter/discuss/2009088/Python-IterativeRecursive-with-explanation | class Solution:
# O(n * m) Time ( it's actually (n * m * 4), but we drop the constant)
# O(1) Space
def islandPerimeter(self, grid: List[List[int]]) -> int:
p = 0
# I'm using a 2D array (deltas) for the directions, so I do not have to keep repeating code
deltas = [[1, 0], [-1, 0], [0, 1], [0, -1]]
# iterate through every cell in the array
for r in range(len(grid)):
for c in range(len(grid[0])):
# We found land
if grid[r][c] == 1:
for dr, dc in deltas:
# We get the positions of the land's neighbors
nR = dr + r
nC = dc + c
rowBounds = 0 <= nR < len(grid)
colBounds = 0 <= nC < len(grid[0])
# Check if neighbor row/col are out of bounds or we found water
if not rowBounds or not colBounds or grid[nR][nC] == 0
p += 1
return p | island-perimeter | Python Iterative/Recursive with explanation | GeassAye | 1 | 96 | island perimeter | 463 | 0.695 | Easy | 8,284 |
https://leetcode.com/problems/island-perimeter/discuss/2009088/Python-IterativeRecursive-with-explanation | class Solution:
# O(n * m) Time
# O(n * m) Space
def islandPerimeter(self, grid: List[List[int]]) -> int:
# visited set so we do not call function again if we have already been to that land's position
visited = set()
def dfs(r, c):
# Check if our row/col are out of bounds or it is water
rowBounds = 0 <= r < len(grid)
colBounds = 0 <= c < len(grid[0])
if not rowBounds or not colBounds or grid[r][c] == 0:
return 1
# We found land, now we check if we have been there before
if (r, c) in visited:
return 0
# We have not been there before, so we add it to our set
visited.add((r,c))
#Here we check the neighbors of the land, if we find more land, we call dfs on that land as well, if we find water, we return 1 for each
p = dfs(r + 1, c)
p += dfs(r - 1, c)
p += dfs(r, c + 1)
p += dfs(r, c -1)
return p
for r in range(len(grid)):
for c in range(len(grid[0])):
if grid[r][c]:
return dfs(r, c) | island-perimeter | Python Iterative/Recursive with explanation | GeassAye | 1 | 96 | island perimeter | 463 | 0.695 | Easy | 8,285 |
https://leetcode.com/problems/island-perimeter/discuss/1800917/Python-Intuitive-DFS-Solution | class Solution:
def __init__(self):
self.directions = [[-1, 0], [0, 1], [1, 0], [0, -1]];
self.parimeterCount = 0;
def islandPerimeter(self, grid: List[List[int]]) -> int:
visited = set();
for row in range(len(grid)):
for col in range(len(grid[0])):
if grid[row][col] == 1 and grid[row][col] not in visited:
self.dfs(grid, row, col, visited);
return self.parimeterCount;
return self.parimeterCount;
def dfs(self, grid, curRow, curCol, visited):
if self.isOutbound(grid, curRow, curCol):
self.parimeterCount += 1;
return;
if (curRow, curCol) in visited:
return;
visited.add((curRow, curCol));
for direction in self.directions:
nextRow = curRow + direction[0];
nextCol = curCol + direction[1];
self.dfs(grid, nextRow, nextCol, visited);
def isOutbound(self, grid, row, col):
if row < 0 or col < 0 or row >= len(grid) or col >= len(grid[0]):
return True;
if grid[row][col] == 0:
return True;
return False; | island-perimeter | Python Intuitive DFS Solution | Symbolistic | 1 | 116 | island perimeter | 463 | 0.695 | Easy | 8,286 |
https://leetcode.com/problems/island-perimeter/discuss/1602531/Python-Find-neighbors | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
# 1 neighbors = 4 - 1
ans = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j]:
count = 0
if 0 <= i + 1 <= len(grid) - 1:
if grid[i + 1][j]:
count += 1
if 0 <= i - 1 <= len(grid) - 1:
if grid[i - 1][j]:
count += 1
if 0 <= j + 1 <= len(grid[0]) - 1:
if grid[i][j + 1]:
count += 1
if 0 <= j - 1 <= len(grid[0]) - 1:
if grid[i][j - 1]:
count += 1
ans += (4 - count)
return ans | island-perimeter | [Python] Find neighbors | Sai-Adarsh | 1 | 92 | island perimeter | 463 | 0.695 | Easy | 8,287 |
https://leetcode.com/problems/island-perimeter/discuss/1362968/Python-or-Iterate-Over-All-Grid-Cells | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
num_rows = len(grid)
num_cols = len(grid[0])
total = 0
# Iterate through all grid cells, automatically adding 4 edges
# for every 'island' cell. Subtract touching edges (mulitplied by 2)
# for any 'island' cells above and to the left. We multiply by 2 since
# we are double counting by automatically adding 4 for each 'island'
# cell encountered.
for i in range(num_rows):
for j in range(num_cols):
if grid[i][j] == 1:
total += 4
if i > 0:
total -= grid[i-1][j] * 2
if j > 0:
total -= grid[i][j-1] * 2
return total | island-perimeter | Python | Iterate Over All Grid Cells | jgroszew | 1 | 252 | island perimeter | 463 | 0.695 | Easy | 8,288 |
https://leetcode.com/problems/island-perimeter/discuss/725028/Very-Simple-Solution | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
res = 0
def check(grid,i,j):
ans = 0
if i-1 < 0 or grid[i-1][j] == 0: ans += 1
if j-1 < 0 or grid[i][j-1] == 0: ans += 1
if i+1 >= len(grid) or grid[i+1][j] == 0: ans += 1
if j+1 >= len(grid[0]) or grid[i][j+1] == 0: ans +=1
return ans
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == 1:
res += check(grid,i,j)
return res | island-perimeter | Very Simple Solution | theflash007 | 1 | 72 | island perimeter | 463 | 0.695 | Easy | 8,289 |
https://leetcode.com/problems/island-perimeter/discuss/2751756/Python-Solution | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
row = len(grid)
col = len(grid[0])
perimeter = 0
def has_neighbor(r: int, c: int) -> bool:
if r < 0 or r >= row:
return False
if c < 0 or c >= col:
return False
if grid[r][c] == 1:
return True
return False
for r in range(row):
for c in range(col):
if grid[r][c] == 1:
perimeter += 4
if has_neighbor(r + 1, c):
perimeter -= 1
if has_neighbor(r - 1, c):
perimeter -= 1
if has_neighbor(r, c + 1):
perimeter -= 1
if has_neighbor(r, c - 1):
perimeter -= 1
return perimeter | island-perimeter | Python Solution | mansoorafzal | 0 | 14 | island perimeter | 463 | 0.695 | Easy | 8,290 |
https://leetcode.com/problems/island-perimeter/discuss/2670159/Python-count-island-edges. | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
perimeter = 0
dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for x in range(len(grid)):
for y in range(len(grid[0])):
if grid[x][y] == 1:
for d in dirs:
#First four statements checks if tile plus direction is out of bounds, last or checks to see if tile plus dir is water.
if(
x+d[0] >= len(grid)
or y+d[1] >= len(grid[0])
or x+d[0] < 0
or y+d[1] < 0
or grid[x+d[0]][y+d[1]]==0
):
perimeter +=1
return perimeter | island-perimeter | Python count island edges. | mephiticfire | 0 | 7 | island perimeter | 463 | 0.695 | Easy | 8,291 |
https://leetcode.com/problems/island-perimeter/discuss/2522506/Python-with-analysis. | class Solution:
def islandPerimeter(self, grid):
def explore(row, col): # O(4) -> O(1)
directions = [[1,0], [-1, 0], [0, 1], [0, -1]]
counter = 0
for dr, dc in directions:
r, c = row+dr, col+dc
if (r < 0 or r >= len(grid)) or (c < 0 or c >= len(grid[0])):
counter += 1
continue
elif grid[r][c] == 0:
counter += 1
return counter
finalCounter = 0
for r in range(len(grid)): # O(rc)
for c in range(len(grid[0])):
if grid[r][c] != 0:
finalCounter += explore(r, c) # O(4) -> O(1)
return finalCounter | island-perimeter | Python with analysis. | OsamaRakanAlMraikhat | 0 | 77 | island perimeter | 463 | 0.695 | Easy | 8,292 |
https://leetcode.com/problems/island-perimeter/discuss/2469713/Easy-to-understand-Python-3-solution | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
count = 0
row, col = len(grid), len(grid[0])
for i in range(row):
for j in range(col):
if grid[i][j] == 1:
count += 4
if 0<=i-1<=row-1:
count -= 2*grid[i-1][j]
if 0<=j-1<=col-1:
count -= 2*grid[i][j-1]
return count
``` | island-perimeter | Easy to understand Python 3 solution | yhc22593 | 0 | 55 | island perimeter | 463 | 0.695 | Easy | 8,293 |
https://leetcode.com/problems/island-perimeter/discuss/2380993/96-faster-%2B-explanation | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
rows = len(grid)
cols=len(grid[0])
grid = [[0]*cols] + grid + [[0]*cols] #add rows of only zeros at top and bottom of grid
for i in range(rows+2):
grid[i] = [0]+grid[i]+[0] #add cols of only zeros at left and right of grid
perimeter=0
#for each cell that is 1(land) check if its surrounded by 1s or 0s. Add up the number of edges with 0s.
for row in range(1,rows+1):
for col in range(1,cols+1):
if grid[row][col]==1:
if grid[row-1][col]==0:
perimeter+=1
if grid[row+1][col]==0:
perimeter+=1
if grid[row][col-1]==0:
perimeter+=1
if grid[row][col+1]==0:
perimeter+=1
return perimeter | island-perimeter | 96% faster + explanation | sunakshi132 | 0 | 122 | island perimeter | 463 | 0.695 | Easy | 8,294 |
https://leetcode.com/problems/island-perimeter/discuss/2361438/Python3-or-Solved-Using-BFS-%2B-Queue-%2B-Hashset-of-Visited | class Solution:
#Time-Complexity: O(rows*cols + rows*cols) -> O(rows*cols)
#Space-Complexity: O(rows*cols)
def islandPerimeter(self, grid: List[List[int]]) -> int:
#i am going to perform bfs starting from first land cell I come across!
visited = set()
rows, cols = len(grid), len(grid[0])
#implement bfs helper
def bfs(sr, sc):
nonlocal rows, cols, visited
q = collections.deque()
q.append([sr, sc])
visited.add((sr, sc))
four_directions = [[1,0], [-1,0], [0,1], [0, -1]]
ans = 0
while q:
cr, cc = q.popleft()
#for current land cell, check each of its four neighboring cell
#to see if it's either out of bounds or in-bounds water cell!
#either of those cases would contribute additional 1 to the
#overall perimeter of the island!
for direction in four_directions:
r_change, c_change = direction
#check out of bounds neighbor!
if(cr + r_change not in range(rows) or
cc + c_change not in range(cols)):
ans += 1
continue
elif(grid[cr+r_change][cc+c_change] == 0):
ans += 1
continue
#otherewise, if the neighboring cell is both in-bounds
#and a land cell! All we got to check is that it's not
#already visited!
else:
if((cr+r_change, cc+ c_change) not in visited):
visited.add((cr+r_change, cc + c_change))
q.append([cr+r_change, cc+c_change])
#return the perimeter of single island in our grid input!
return ans
#run nested for loop and initiate bfs on grid entry that is a land and
#not already visited!
#our input is gauranteed to have at least one island so None value
#will be overwritten in ans variable!
ans = None
for i in range(rows):
for j in range(cols):
if(grid[i][j] == 1 and (i, j) not in visited):
ans = bfs(i, j)
#only one island
break
return ans | island-perimeter | Python3 | Solved Using BFS + Queue + Hashset of Visited | JOON1234 | 0 | 38 | island perimeter | 463 | 0.695 | Easy | 8,295 |
https://leetcode.com/problems/island-perimeter/discuss/2287195/Python-or-5-lines | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
n,m,ans = len(grid),len(grid[0]),0
for i in range(n):
for j in range(m):
if grid[i][j]==1:
ans+=(i==0 or grid[i-1][j]==0)+(i==n-1 or grid[i+1][j]==0)+(j==0 or grid[i][j-1]==0)+(j==m-1 or grid[i][j+1]==0)
return ans | island-perimeter | Python | 5 lines | ana_2kacer | 0 | 124 | island perimeter | 463 | 0.695 | Easy | 8,296 |
https://leetcode.com/problems/island-perimeter/discuss/2287156/dfs-or-python-or-faster-than-92-or-simple-few-lines | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
n = len(grid)
m = len(grid[0])
def dfs(i,j):
if i<0 or j<0 or i>=n or j>=m or grid[i][j]==0:
return 0
#for every time you encounter a 1
#check the sides -- if its an edge or 0 add--
return (i==0 or grid[i-1][j]==0)+(i==n-1 or grid[i+1][j]==0)+(j==0 or grid[i][j-1]==0)+(j==m-1 or grid[i][j+1]==0)
ans = 0
for i in range(n):
for j in range(m):
if grid[i][j]==1:
ans+=dfs(i,j)
return ans | island-perimeter | dfs | python | faster than 92% | simple few lines | ana_2kacer | 0 | 94 | island perimeter | 463 | 0.695 | Easy | 8,297 |
https://leetcode.com/problems/island-perimeter/discuss/2256733/DFS-using-python | class Solution:
def islandPerimeter(self, grid):
visited=set()
def dfs(r,c):
if r<0 or r>=len(grid) or c<0 or c>=len(grid[0]) or (r,c) in visited:
return 0
if grid[r][c]==1:
total=0
visited.add((r,c))
if r-1<0 or grid[r-1][c]==0:
total+=1
if c-1<0 or grid[r][c-1]==0:
total+=1
if c+1>=len(grid[0]) or grid[r][c+1]==0:
total+=1
if r+1>=len(grid) or grid[r+1][c]==0:
total+=1
else:
return 0
return total+dfs(r-1,c)+dfs(r,c+1)+dfs(r,c-1)+dfs(r+1,c)
for r in range(len(grid)):
for c in range(len(grid[0])):
if grid[r][c]==1:
return dfs(r,c)
return 0
``` | island-perimeter | DFS using python | pathakrohit08 | 0 | 28 | island perimeter | 463 | 0.695 | Easy | 8,298 |
https://leetcode.com/problems/island-perimeter/discuss/2155411/Python-solution-optimized | class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
count = 0
for i in range(len(grid)):
corner = 0
for j in range(len(grid[i])):
if i==0:
if grid[i][j]==1:
count += 4
if corner == 1:
count -=2
corner = 1
else:
corner = 0
else:
if grid[i][j]==1:
count += 4
if corner == 1:
count -= 2
if grid[i-1][j]==1:
count -= 2
corner = 1
else:
corner = 0
return count | island-perimeter | Python solution optimized | monish-jain | 0 | 54 | island perimeter | 463 | 0.695 | Easy | 8,299 |
Subsets and Splits