您的位置:首页 > 编程语言 > Python开发

leetcode简单题81-100(python)

2018-10-11 15:45 615 查看

387. First Unique Character in a String(e-81)-----------

Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.

389. Find the Difference(e-82)

Given two strings s and t which consist of only lowercase letters.

String t is generated by random shuffling string s and then add one more letter at a random position.

Find the letter that was added in t.

[code]class Solution(object):
def findTheDifference(self, s, t):
"""
:type s: str
:type t: str
:rtype: str
"""
sum1 = sum(map(ord, [c for c in s]))
sum2 = sum(map(ord, [c for c in t]))
return chr(sum2 - sum1)

400. Nth Digit(e-83)

Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...

[code]class Solution(object):
def findNthDigit(self, n):
"""
:type n: int
:rtype: int
"""
"""
个位数:1-9,一共9个,共计9个数字
2位数:10-99,一共90个,共计180个数字
3位数:100-999,一共900个,共计270个数字
4位数,1000-9999,一共9000个,共计36000个数字  36000=4*9*10**(4-1)
......
"""
#第一步确定n是在几位数里,第二步是确定在几位数的第几位数字的第几位
#第一步
digit=1#位数
while n>digit*9*10**(digit-1):
n-=digit*9*10**(digit-1)
digit+=1
#第二步
a=int((n-1)/digit)#得到几位数的第几位数字
b=int((n-1)%digit)#得到几位数的第几位数字的第几位
num=10**(digit-1)+a#得到第几位数字是多少
res=list(str(num))[b:b+1]#数字转字符再转列表把第几位数的第几位切出来
return int(''.join(res))#列表转字符再转数字

401. Binary Watch(e-84)

A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes(0-59).

Each LED represents a zero or one, with the least significant bit on the right

[code]class Solution(object):
def readBinaryWatch(self, num):
"""
:type num: int
:rtype: List[str]
"""
ans=[]
for i in range(0,12):
for j in range(0,60):
if (bin(i)+bin(j)).count("1") == num:
ans.append("%d:%0.2d"%(i, j))

return ans

404. Sum of Left Leaves(e-85)

Find the sum of all left leaves in a given binary tree.

[code]class Solution(object):
def sumOfLeftLeaves(self, root):
"""
:type root: TreeNode
:rtype: int
"""
if not root:
return 0
if root.left and not root.left.left and not root.left.right:
return root.left.val + self.sumOfLeftLeaves(root.right)
return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)

405. Convert a Number to Hexadecimal(e-86)

Given an integer, write an algorithm to convert it to hexadecimal. For negative integer, two’s complement method is used.

[code]class Solution(object):
def toHex(self, num):
"""
:type num: int
:rtype: str
"""
d = {0: "0", 1: "1", 2: "2", 3: "3", 4: "4", 5: "5", 6: "6", 7: "7", 8: "8", 9: "9", 10: "a", 11: "b", 12: "c", 13: "d", 14: "e", 15: "f"}
ans = ""
mask = 0xf0000000
flag = False
for i in xrange(0, 8):
halfb = (num & mask) >> 28
if halfb != 0:
flag = True
if flag:
ans = ans + d[(num & mask) >> 28]
num = num << 4
if ans == "":
return "0"
return ans

409. Longest Palindrome(e-87)

Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.

This is case sensitive, for example 

"Aa"
 is not considered a palindrome here.

[code]class Solution(object):
def longestPalindrome(self, s):
ss = set(s)
#print ss
res = 0
for i in ss:
tmp = s.count(i)
if tmp % 2 == 0:
res += tmp
else:
if tmp > 1:
res += (tmp - 1)
tmp = 1
if res%2 == 0:
res += 1
return res

412. Fizz Buzz(e-88)

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

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

[code]class Solution(object):
def fizzBuzz(self, n):
"""
:type n: int
:rtype: List[str]
"""
res=[]
for i in range(1,n+1):
if i%3 == 0 and i%5 == 0:
res.append("FizzBuzz")
elif i%3==0 and i%5!=0:
res.append("Fizz")
elif i%3!=0 and i%5==0:
res.append("Buzz")
else:
res.append("{}".format(i))
return res

414. Third Maximum Number(e-89)

Given a non-empty array of integers, return the third maximum number in this array. If it does not exist, return the maximum number. The time complexity must be in O(n).

[code]class Solution(object):
def thirdMax(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
a=set(nums)
if len(a)<3:
return max(a)
else:
a.remove(max(a))
a.remove(max(a))
return max(a)

415. Add Strings(e-90)--------

Given two non-negative integers 

num1
 and 
num2
 represented as string, return the sum of 
num1
 and 
num2
.

Note:

  1. The length of both 
    num1
     and 
    num2
     is < 5100.
  2. Both 
    num1
     and 
    num2
     contains only digits 
    0-9
    .
  3. Both 
    num1
     and 
    num2
     does not contain any leading zero.
  4. You must not use any built-in BigInteger library or convert the inputs to integer directly.

427. Construct Quad Tree(e-91)-------

We want to use quad trees to store an 

N x N
 boolean grid. Each cell in the grid can only be true or false. The root node represents the whole grid. For each node, it will be subdivided into four children nodes until the values in the region it represents are all the same.

Each node has another two boolean attributes : 

isLeaf
 and 
val
isLeaf
 is true if and only if the node is a leaf node. The 
val
attribute for a leaf node contains the value of the region it represents.

Your task is to use a quad tree to represent a given grid. The following example may help you understand the problem better:

Given the 

8 x 8
 grid below, we want to construct the corresponding quad tree:

429. N-ary Tree Level Order Traversal(e-92)-------

Given an n-ary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example, given a 

3-ary
 tree:

 

 

We should return its level order traversal:

434. Number of Segments in a String(e-93)

Count the number of segments in a string, where a segment is defined to be a contiguous sequence of non-space characters.

Please note that the string does not contain any non-printable characters.

[code]class Solution(object):
def countSegments(self, s):
"""
:type s: str
:rtype: int
"""
return (len(s.split()))

437. Path Sum III(e-94)--------

You are given a binary tree in which each node contains an integer value.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

438. Find All Anagrams in a String(e-95)

Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.

Strings consists of lowercase English letters only and the length of both strings s and p will not be larger than 20,100.

The order of output does not matter.

[code]from collections import Counter
class Solution(object):
def findAnagrams(self, s, p):
"""
:type s: str
:type p: str
:rtype: List[int]
"""
sCount = Counter(s[:len(p) - 1])
pCount = Counter(p)
ans = []

for i in range(len(p) - 1, len(s)):
sCount[s[i]] += 1
if sCount == pCount:
ans.append(i - len(p) + 1)
sCount[s[i - len(p) + 1]] -= 1
if sCount[s[i - len(p) + 1]] == 0:
del sCount[s[i - len(p) + 1]]
return ans

441. Arranging Coins(e-96)

You have a total of n coins that you want to form in a staircase shape, where every k-th row must have exactly k coins.

Given n, find the total number of full staircase rows that can be formed.

n is a non-negative integer and fits within the range of a 32-bit signed integer.

[code]class Solution(object):
def arrangeCoins(self, n):
return int(((8*n + 1)**0.5 - 1)/2)

443. String Compression(e-97)

Given an array of characters, compress it in-place.

The length after compression must always be smaller than or equal to the original array.

Every element of the array should be a character (not int) of length 1.

After you are done modifying the input array in-place, return the new length of the array.

[code]class Solution(object):
def compress(self, chars):
"""
:type chars: List[str]
:rtype: int
"""
n = len(chars)
cur = 0 # 当前字符的索引,用以压缩原字符串
i = 0
while i < n:
j = i
while j < n - 1 and chars[j] == chars[j+1]:# 找字符连续出现的次数
j += 1
chars[cur] = chars[i] # 记录当前处理的字符
cur += 1
if i != j:
times = str(j-i+1) # 将字符的次数写入原串中
tLen = len(times)
for k in range(tLen):
chars[cur+k] = times[k]
cur += tLen
i = j + 1 # 处理下一个字符
return cur

447. Number of Boomerangs(e-98)

Given n points in the plane that are all pairwise distinct, a "boomerang" is a tuple of points 

(i, j, k)
 such that the distance between 
i
 and 
j
 equals the distance between 
i
 and 
k
 (the order of the tuple matters).

Find the number of boomerangs. You may assume that n will be at most 500 and coordinates of points are all in the range [-10000, 10000] (inclusive).

[code]class Solution(object):
def numberOfBoomerangs(self, points):
"""
:type points: List[List[int]]
:rtype: int
"""
ans=0
for p1 in points:
d={}
for p2 in points:
if p1!=p2:
dist=(p1[0] - p2[0]) ** 2 + (p1[1] - p2[1])**2
d[dist] = d.get(dist, 0) + 1
for k in d:
ans+=d[k]*(d[k]-1)
return ans

448. Find All Numbers Disappeared in an Array(e-99)

Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements of [1, n] inclusive that do not appear in this array.

Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

[code]class Solution(object):
def findDisappearedNumbers(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
news=range(1,len(nums)+1)
return list(set(news) - set(nums))

453. Minimum Moves to Equal Array Elements(e-100)

Given a non-empty integer array of size n, find the minimum number of moves required to make all array elements equal, where a move is incrementing n - 1 elements by 1.

[code]class Solution(object):
def minMoves(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
return (sum(nums) - len(nums)*min(nums))

 

阅读更多
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: