标签：p3 面试题 return 工程师 ## 示例 next 测试 10

经典测试工程师面试题(三)

 

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:
输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

 1 ## python
 2 class Solution(object):
 3     def twoSum(self, numbers, target):
 4         l=0
 5         r=len(numbers)-1
 6         while(l<r):
 7             if(numbers[l]+numbers[r]== target):
 8                 return [l+1,r+1]
 9             if(numbers[l]+numbers[r] <target):
10                 l += 1
11             else:
12                 r -= 1

## 测试用例：
def test_towSum1(self):
    assert towSum([0,1, 1, 2, 3, 6,8], 2) == [1, 4]

def test_towSum2(self):
    assert towSum([1,2,5,6,12], 13) == [1, 5]

def test_towSum3(self):
    assert towSum([2, 7, 11, 15], 9) == [1, 2]

## Java
public int[] twoSum(int[] numbers, int target) {
        int left = 0;
        int right = numbers.length - 1;
        while (left < right) {
            if (numbers[left] + numbers[right] == target) {
                return new int[]{left + 1, right + 1};
            }
            if (numbers[left] + numbers[right] < target) {
                left += 1;
            } else {
                right -= 1;
            }
        }
        return null;
    }

 

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。

 1 示例 1：
 2 
 3 输入： 2
 4 输出： 2
 5 解释： 有两种方法可以爬到楼顶。
 6 1.  1 阶 + 1 阶
 7 2.  2 阶
 8 示例 2：
 9 
10 输入： 3
11 输出： 3
12 解释： 有三种方法可以爬到楼顶。
13 1.  1 阶 + 1 阶 + 1 阶
14 2.  1 阶 + 2 阶
15 3.  2 阶 + 1 阶

Python
## 不推荐 效率极低 ##
def setpMethod(num):
   if(n == 1 or n == 2):
            return n
    else:
        return self.setpMethod(num-1)+self.setpMethod(num-2)

 1 ## 推荐写法 ##
 2     def climbStairs(self, n):
 3         if(n == 1 or n == 2):
 4             return n
 5         num1=1
 6         num2=2
 7         while(n >= 3):
 8             result = num1 + num2
 9             num1 = num2
10             num2 = result
11             n -=1
12         return result

 1 ## Java ##
 2 public int setpMethod(int n){
 3         if(n ==1 || n ==2){
 4         return n;
 5         }
 6         int result = 0,n1 = 1,n2 = 2;
 7         while (n>=3){
 8             result = n1 + n2;
 9             n1 = n2;
10             n2 = result;
11             n--;
12         }
13         return result;
14     }

 

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
示例 2:

输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

 1 ## python ##
 2 class Solution(object):
 3     def canJump(self, nums):
 4         need = 1
 5         if(len(nums) ==1):
 6             return True
 7         if(nums[0] == 0):
 8             return False
 9         for i in range(len(nums)-2,-1,-1):
10             if(nums[i] == 0 or nums[i] < need):
11                 need += 1
12             else:
13                 need = 1
14         if(need == 1) :
15             return True
16         else:
17             return False

## java ##
public boolean canJump(int[] nums) {
        int n = 1;
        if(nums.length ==1){
        return true;
        }
        if(nums[0] == 0){
        return false;
        }
        for(int i=nums.length-2; i>=0; i--){
            if(nums[i] >= n){
                n=1;
            }else{
                n++;
            }
        }
        if(n == 1){
            return true;
        }else{
            return false;
        }
    }

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

 1 示例 1：
 2 
 3 输入："/home/"
 4 输出："/home"
 5 解释：注意，最后一个目录名后面没有斜杠。
 6 示例 2：
 7 
 8 输入："/../"
 9 输出："/"
10 解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。
11 示例 3：
12 
13 输入："/home//foo/"
14 输出："/home/foo"
15 解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
16 示例 4：
17 
18 输入："/a/./b/../../c/"
19 输出："/c"
20 示例 5：
21 
22 输入："/a/../../b/../c//.//"
23 输出："/c"
24 示例 6：
25 
26 输入："/a//b////c/d//././/.."
27 输出："/a/b/c"

 

##python##
def simplifyPath(self, path):
        """
        :type path: str
        :rtype: str
        """
        paths = path.split('/')
        str = ''
        pathlist = [i for i in paths if I]
        result = []
        for j in range(len(pathlist)):
            print(j)
            if(pathlist[j] == ".."):
                if(result):
                    result.pop()
            elif(pathlist[j] == "."):
                continue
            else :
                result.append(pathlist[j])
        if not result:
            return '/'
        for k in range(len(result)):
            str = str + '/' + result[k]
        return str

 

给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '' 的通配符匹配。'?' 可以匹配任何单个字符。'' 可以匹配任意字符串（包括空字符串）。两个字符串完全匹配才算匹配成功。

说明:
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。
示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:

输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
示例 3:

输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
示例 4:

输入:
s = "adceb"
p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
示例 5:

输入:
s = "acdcb"
p = "a*c?b"
输入: false

 1 ##python##
 2 def isMatch(self, s, p):
 3         si, pi, pj, sj = 0, 0, -1, -1
 4         while si < len(s):
 5             if pi < len(p) and p[pi] == '*':
 6                 pi += 1
 7                 pj = pi
 8                 sj = si
 9             elif pi < len(p) and (p[pi] == '?' or p[pi] == s[si]):
10                 pi += 1
11                 si += 1
12             elif pj != -1:
13                 pi = pj
14                 sj += 1
15                 si = sj
16             else:
17                 return False
18         while (pi < len(p) and p[pi] == '*'):
19             pi += 1
20         return pi == len(p)

  执行结果.png

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

 1 ## python ##
 2 class Solution(object):
 3     def addTwoNumbers(self, l1, l2):
 4         n =l1.val + l2.val
 5         l3 = ListNode(n%10)
 6         l3.next = ListNode(n//10)
 7         p1 = l1.next
 8         p2 = l2.next
 9         p3 = l3
10         while True:
11             if p1 and p2:
12                 sum = p1.val+ p2.val + p3.next.val
13                 p3.next.val = sum % 10
14                 p3.next.next = ListNode(sum//10)
15                 p1 = p1.next
16                 p2 = p2.next
17                 p3 = p3.next
18             elif p1 and not p2:
19                 sum = p1.val + p3.next.val
20                 p3.next.val = sum %10
21                 p3.next.next = ListNode(sum // 10)
22                 p1 = p1.next
23                 p3 = p3.next
24             elif not p1 and p2:
25                 sum = p2.val +p3.next.val
26                 p3.next.val = sum % 10
27                 p3.next.next = ListNode(sum // 10)
28                 p2 = p2.next
29                 p3 = p3.next
30             else :
31                 if p3.next.val == 0:
32                     p3.next = None
33                 break
34         return l3

  执行结果.png

【转】龚十一

标签：p3,面试题,return,工程师,##,示例,next,测试,10
来源： https://www.cnblogs.com/vickyx/p/13813166.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。