初、中、高級測試工程師面試題匯總（附答案）

【熱身題】

1.為什么選擇測試這行？

因為其具有挑戰性和成就感，找一些系統隱藏的邏輯漏洞的時候，自己就非常的開心。並且測試需要細心和耐心，自己可以很快的分析bug的來源。

2.請描述下你公司的測試流程？

需求分析討論-確定測試策略-設計測試用例-測試用例評審-beta測試-uat測試-測試報告

【基礎題】

1.軟件測試項目從什么時候開始為什么？

需求確認開始，因為在需求階段，測試可以評審需求並進行靜態測試，減少開發過程中的bug。

2.軟件的評審一般由哪些人員參加？其目的是什么？

參加人員：需求業務人員、產品經理、項目經理、開發人員、測試人員;
目的：查看軟件在未正式投入運行前是否還存在問題。對於不同軟硬件平台能否正常運行，是否有與客戶理解不一致的地方，同時可以對一些可以改進的地方再多加改進。

3.如何設計測試用例？什么樣子的測試用例是好用例？

掌握邊界值分析、等價類划分、錯誤推測等方法來設計測試用例。
好用例是一個完備的集合，它能夠覆蓋所有等價類以及各種邊界值；需要從軟件功能需求出發，全面地，無遺漏地識別出測試需求；最好是代碼覆蓋測試也全面的測試。

4.不能發現BUG的測試用例不是好的測試用例嗎？

不一定，要看情況，如果測試用例質量高，沒有發現bug，說明開發質量高。但一般程序都會有bug，如果沒有發現BUG，就要思索測試場景是否有遺漏，需求是否理解沒到位。

5.測試用例需要哪些人來評審？

產品經理，開發人員，測試人員，業務需求人員。

6.什么是bug？

沒有實現需求說明書列出的功能，出現了沒有需求說明書提到不該出現的事情；實現了多的功能；沒有實現應該實現的邏輯。

7.簡單概述缺陷報告，並說明包括哪些項？

缺陷描述，缺陷的優先級，缺陷的標題，缺陷所屬版本號，缺陷所屬的功能模塊，操作步驟，預期效果，缺陷原因，缺陷所屬的開發人員。

8.開發人員修復缺陷后，如何保證不影響其他功能？

重新執行測試用例，並且針對這個缺陷影響的相關點寫新的測試用例。

9.開發人員說不是bug時，你如何應付？

首先把自己的理由，並以需求說明書為自己的站點，如果開發人員還是不認同，可以把自己的觀點和理由，提交給產品經理，由其去決定是否為一個bug。

10.當測試過程發生錯誤時，有哪幾種解決辦法？

　　a.跳轉其他的測試流程；
　　b.調用某個程序能繞過這個錯誤，繼續后面的流程。

11.所有的軟件缺陷都能修復嗎？所有的軟件缺陷都要修復嗎？

能修復，但不一定所有的缺陷都要修復。

12.進行測試時產生了哪些文檔或記錄？

測試用例，測試報告，測試日報

14.功能測試在 beta 版本對外的上線標准是什么？

測試用例全部跑完並且bug都已經關閉，然后業務驗收后可以上線。

15.開發人員老是犯一些低級錯誤怎么解決？

　　a.要求開發人員進行自測，把這些問題在開發階段就解決好
　　b.通過缺陷管理系統對開發人員進行控制

16.為什么盡量不要讓時間富裕的員工去做一些測試？

　　a.非專業測試人員，沒有組織性的測試工作，沒有規律和針對性，會影響到測試的質量和版本更新的速度。
　　b.專業測試人員（但不是這個項目的測試員）這些人員不受測試計划的時候和任務約定，測試完畢后評估測試小組的工作質量，不利於bug管理。

【進階題】

1.什么是單元測試、功能測試、集成測試？

加分項：單元測試、功能測試、集成測試分別在web端、接口端、移動端的定義，你平時是怎么理解它們的？

　　單元測試：是針對程序模塊來進行正確性檢驗的測試工作；
　　功能測試：在單元測試的基礎上，測試某一個功能點；
　　集成測試：將所有模塊按照設計要求組裝成為子系統或系統，進行集成測試；
　　web端
　　單元測試/功能測試：頁面元素是否正確顯示其有效功能，如提交的action是否正確，搜索點擊是否執行；
　　集成測試：調用了后端接口的數據是否顯示正常，能否滿足需求；
　　接口端：模塊/系統之前的調用，接口是否與設計相符，模塊組合后是否滿足需求；
　　單元測試：某個函數/方法 寫的代碼是否達到編寫者的預期；
　　功能測試：為實現一個功能點，調用幾個方法/函數。

2.什么是兼容性測試？

兼容性測試是檢查軟件在不同軟件平台，硬件平台上是否可以正常運行的測試。
主要查看軟件在不同操作系統、瀏覽器、數據庫中是否運行正常.

3.白盒和黑盒的區別，你是怎么運用的？

黑盒測試：已知產品的功能設計規格，可以進行測試證明每個實現了的功能是否符合要求。利用其檢查功能是否符合需求說明書，能夠正常使用。
白盒測試：已知產品的內部工作過程，可以進行測試證明每種內部操作是否符合設計規格要求，所有內部成分是否經過檢查。
利用其檢查程序模塊的內部邏輯走向，主要覆蓋程序內的邏輯。

4.靜態測試和動態測試有什么區別？

靜態測試：不運行程序，針對PRD等檢查代碼，審查代碼，靜態結構分析，分析代碼質量；
動態測試：運行程序進行黑盒測試和白盒測試。

5.您所熟悉的測試用例設計方法都有哪些？請分別以具體的例子來說明這些方法在測試用例設計工作中的應用。

黑盒：
邊界值分析法：如參數的范圍0-128，輸入128,129,0這些值，查看是否有錯誤等；
錯誤推測法：導入功能時，表格為空表格，表格輸入1行，表格輸入10000行等；
因果圖方法：組合參數邏輯圖；
場景分析法：根據用戶操作模擬用戶操作。
白盒：
邏輯覆蓋法，基本路徑測試。

6.您在以往的測試工作中都曾經具體從事過哪些工作？其中最擅長哪部分工作？

做過web測試，小程序測試，H5頁面測試，后台測試，接口測試。最擅長接口測試，自己給公司的業務流程寫過一套自動化框架，用於回歸業務流程。

7.在您以往的工作中，一條軟件缺陷（或者叫Bug）記錄都包含了哪些內容？如何提交高質量的軟件缺陷（Bug）記錄？

前提條件、測試環境、操作步驟、預期結果、實際結果、嚴重等級、版本信息，出現概率；
問題描述和操作步驟要盡可能描述詳細，可以初步分析bug是客戶端的問題還是服務端的問題。

8.什么是內存泄漏、Http錯誤率、吞吐率。響應時間分別在web端和移動端是多少？哪些場景可以證明響應超時？

內存泄漏（Memory Leak）是指程序中己動態分配的堆內存由於某種原因程序未釋放或無法釋放，造成系統內存的浪費，導致程序運行速度減慢甚至系統崩潰等嚴重后果。
HTTP錯誤率（HTTP error rate） 在選定時間段內，HTTP錯誤數量與請求數量的比率。
吞吐率（Throughput） 是場景運行過程中服務器每秒的吞吐量。其度量單位是字節，表示每個請求連接在任何給定的每一秒從服務器獲得的數據量。
web端
當用戶在2秒以內得到響應時，會感覺系統的響應很快；
當用戶在2-5秒之間得到響應時，會感覺系統的響應速度還可以；
而當用戶在超過8秒后仍然無法得到響應時，會感覺系統糟透了，或者認為系統已經失去響應。
場景：請求超時、頁面加載失敗

【高級題】

1.什么是面向對象編程？

面向對象編程就是把具有共性的事務抽象成屬性和方法來進行編程。

2.Thread 類中的start() 和 run() 方法有什么區別？

start（）方法可以用來啟動線程，調用該方法，會創建一個新的線程，然后內部執行run（）方法；不能多次調用，否則會拋異常；
直接調用run（）方法，不會創建新的線程；可以進行多次調用。

3.說下左連接和右連接

比如有兩張表 A，B。左連接是把符合條件的所有A表的內容列出來，B表如果沒有內容匹配用NULL代替。
右連接是符合條件的所有B表的內容列出來，A表如果沒有內容匹配用NULL代替。

4.介紹下什么是索引

索引是由表或者視圖中的一列或多列生成的鍵，可以加快在表或者視圖中檢索行的速度

【接口測試相關】

1.什么是接口測試？

接口測試是測試系統組件間接口的一種測試。接口測試就是測試不同系統或模塊之間資源交互是否正確。

2.為什么要做接口測試？

因為在大部分系統和產品中，資源數據都是核心，所以接口是需要要測試的，並且接口中大部分內容都是數據，通過數據的對比可以推測系統和產品的邏輯，測試接口就是測試邏輯。所以很必要做接口測試。

3.什么時候做接口測試？

　　a.出現bug,通過接口測試，清晰找到bug的源頭，是前端還是后端的bug；
　　b.回歸測試，利用接口測試原有的接口是否正常，保證之前的業務流程沒有受影響；
　　c.接口開發完成后，可以做接口測試。

4.接口測試的工具有哪些

soapUI、postman、jemeter、insomnia、paw。

5.接口測試的流程是什么？

　　a.接口的通過性驗證：數據正確輸入，是否正確返回結果。測試接口的正常場景和異常場景；
　　b.邊界測試：不按照你接口文檔上的要求輸入參數，測試其邊界情況。比如說必填的參數不填，輸入整數類型的正常，超過參數取值范圍等；
　　c.參數組合：如果接口中有參數需要組合用的，兩個參數是組合使用，測試其各種情況；
　　d.異常驗證：測試冪等情況，並發情況，事務測試等異常情況；
　　e.接口安全：繞過驗證，敏感信息加密等情況；
　　f.性能測試：響應時間、並發數、吞吐量、服務器資源利用率。

6.請問你們公司是如何做接口測試的？

swagger 、 接口自動化腳本。

7.接口測試質量評估標准是什么？

接口表現與接口文檔的一致性；
請求參數：必選和非必選、長度、字符類型、為空、缺失、組合、重復；
返回數據：正常和異常。

【自動化測試相關】

1.如何看待自動化和手動測試？怎樣的一個比例才是健康的？

自動化適合做為回歸測試的主要方式，新上線的功能一般都是用手動測試方式，一些極端和用戶習慣操作還是手動測試比較方便。盡可能線上穩定的功能模塊都做成自動化，提供效率。

2.你們公司的自動化投入產出比怎樣？效益怎樣？

自動化主要作為回歸測試，減少測試時間。UI自動化沒有弄，基本找不到bug 。

3.完整運行一次自動化用例需要多久時間？

主要跑的是業務流，所以跑一次需要半個小時左右。

4.什么是分層自動化？

金字塔結構， 最底層UnitTest，往上接口API/集成起來的service， 最上面UI自動化。

5.你的測試數據是怎么准備的？

提前准備好，在代碼里的yaml文件。

6.測試腳本的維護成本是怎么樣的？

業務不變的情況下，一般腳本都是不壞不動的。

【性能測試相關】

1.請問你們公司是如何做性能測試的？請講訴性能測試的相關指標？

　　a.做性能需求分析，挑選了用戶使用最頻繁的功能來做性能測試，比如：登陸，搜索，提交訂單，確定性能指標，比如：事務通過率為100%，90%的事務響應時間不超過5秒，並發用戶為1000人，CPU和內存的使用率為70%以下；
　　b.性能測試計划，明確測試時間(通常在功能穩定后，如第一輪測試后進行)和測試環境和測試工具的選擇；
　　c.編寫性能測試用例；
　　d.搭建性能測試環境，准備好性能測試數據；
　　e.通過性能測試用例，編寫性能測試腳本；
　　f.性能測試腳本進行調優，設置檢查點、參數化、關聯、集合點、事務，調整思考時間，刪除冗余的腳本等；
　　g.設計性能測試場景，使用nmon工具監控服務器，運行測試場景；
　　h.分析性能測試結果，如果有問題（性能瓶頸），收集相關的日志提單給開發修改；
　　i.開發修改好后，回歸性能測試；
　　j.編寫性能測試報告；
　　相關指標：響應時間、並發數、吞吐率、資源利用率、TPS。

2.壓力測試和負載測試的區別

負載測試是模擬實際軟件系統所承受的負載條件的系統負荷，通過不斷加載（如逐漸增加模擬用戶的數量）或其它加載方式來觀察不同負載下系統的響應時間和數據吞吐量、系統占用的資源（如CPU、內存）等，以檢驗系統的行為和特性，以發現系統可能存在的性能瓶頸、內存泄漏、不能實時同步等問題。
壓力測試是在高負載情況下對系統的穩定性進行測試。是在高負載（大數據量、大量並發用戶等）下的測試，觀察系統在峰值使用情況下的表現，從而發現系統的功能隱患。
負載測試：多用戶，用戶數漸增，持續同時發同一業務請求，產出最大TPS；
壓力測試：多用戶，資源使用飽和，持續同時發同一業務請求，產出系統瓶頸或使用極限。

3.服務器中一般要監控哪些數據，如何監控的，怎么從監控數據中發現問題？

基礎監控和應用監控。
基礎監控包括機器是否死機，cpu，內存，磁盤使用率等；應用監控包括日志監控、端口監控、進程數監控等。

4.假設系統A調用系統B，我把B的接口都mock了，進行性能測試，這樣有什么好處和壞處？

好處：防止系統B出錯引起測試錯誤；不會因系統B的開發進度影響測試；mock后可以快速返回結果，提高測試效率。
壞處：很多情況下無法完全模擬出服務器的所有可能的返回情況，另外，mock掉了關聯方之后，整個環境的連通性可能測試的不到位。

5.有一天早上打車高峰，滴滴服務端掛了大概30分鍾，工程師搶修之后，馬上上線，之后又掛了，請問有哪些原因會造成這個情況？

服務器內存不夠、服務器超出負載、並發量太大、遇到惡意攻擊。

【編程相關】

1.請寫出冒泡排序。

#冒泡排序：n*n
def bubbleSort(array):
  maxindex = len(array)-1
  maxValue = array[maxindex]
  k=0
  while maxindex:
      for i in range(1,maxindex):
          if array[i-1]>array[i]:
              temp = array[i]
              array[i] = array[i-1]
              array[i-1] = temp
          k+=1
      maxindex -=1
  print(k)
  return array

2.1~9999數列中數字3出現的次數。用遞推方法解出。

 

def count_digit(number):
    return len(str(number))

def countThree(digit):
    if not isinstance(digit,int):
        raise TypeError('number is not int')
    # digit = len(str(number))
    if(digit <=0):
        return 0
    if(digit ==1):
        return 1
    return 10*countThree(digit-1) + 10 **(digit-1)

print(countThree(count_digit(9999)))

3.從一個數組中找出前4個最大的數，用最優解。

#快速排序：最快的n*logN
def qiuckSort(list):
    if len(list)<2:
        return list
    mid = list[0]
    left = [i for i in list[1:] if i <= mid]
    right = [i for i in list[1:] if i > mid]
    finallyList = qiuckSort(left)+[mid] + qiuckSort(right)
    return finallyList
array = [3, 0, 1, 832,23,45, 5, 5, 6,46, 9, 56, 897]
print(qiuckSort(array)[-4:])

4.寫一段程序，刪除字符串a中包含的字符串b，舉例 輸入a = "asdw",b = "sd" 返回 字符串 “aw”，並且測試這個程序。

def delBString(a,b):
    if not isinstance(a,str):
        raise TypeError("a is not str")
    if not isinstance(b,str):
        raise TypeError("b is not str")
    if len(a) < len(b):
        raise Exception('a length must large to b length')
    result = []
    flag = False
    i=0
    la = len(a)
    lb = len(b)
    while i <la:
        j = 0
        while j < lb:
            if i+j < la and a[i+j] == b[j]:
                j += 1
            else :
                j += 1
                flag = False
                break
            flag = True
        if flag:
            i += lb
        else:
            result.append(a[i])
            i += 1
    return "".join(result)

測試用例：
class TestdelInnerStringFunctions():
    def setUp(self):
        pass
    def tearDown(self):
        pass
    def test_nomorl1(self):
        assert delBString('asdqwe','we') == 'asdq'
    def test_nomorl2(self):
        assert delBString('asdqwe','0') == 'asdqwe'
    def test_nomorl3(self):
        assert delBString('測試asdqwe','we') == '測試asdq'
    def test_nomorl4(self):
        assert delBString('測試asdqwe','測試') == 'asdqwe'
    def test_nomorl5(self):
        assert delBString('asdqwe','') == 'asdqwe'
    def test_nomorl6(self):
        with pytest.raises(TypeError):
            delBString('', 0)
    def test_nomorl7(self):
        with pytest.raises(TypeError):
            delBString(0, 'as')
    def test_nomorl8(self):
        with pytest.raises(TypeError):
            delBString(True)
    def test_nomorl9(self):
       with pytest.raises(Exception) as excinfo:
           delBString('acd','acde')
       assert "a length must large to b length" in str(excinfo.value)
       assert excinfo.type == Exception

5.寫一個方法，把字符串轉為數字，比如 str="1234"，變成 int 1234。並且測試這個程序。

 

def StrToInt(a):
    res ,mult,flag = 0,1,1
    if not isinstance(a,str):
        raise TypeError("a is not str")
    if a[0] =='-' or a[0] == '+':
        if a[0] == '-':
            flag = -1
        a = a[1:]
    for i in range(len(a)-1,-1,-1):
        if '9' >=a[i] >= '0':
            res +=(ord(a[i]) -48) * mult
            mult = mult *10
        else :
            return 0
    return res * flag

def test_strToInt2(self):
    with pytest.raises(TypeError):
        StrToInt(34)

測試用例：
def test_strToInt3(self):
    assert StrToInt('測試賽') == 0

def test_strToInt4(self):
    assert StrToInt('+2147689') == 2147689

def test_strToInt5(self):
    assert StrToInt('45') == 45

def test_strToInt6(self):
    assert StrToInt('1a33') == 0

def test_strToInt7(self):
    assert StrToInt('-5') == -5

6.給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和為目標值的那 兩個 整數，並返回他們的數組下標。

你可以假設每種輸入只會對應一個答案。但是，你不能重復利用這個數組中同樣的元素。
示例:
給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

# Python
def TargetSum(nums,target):
    if len(nums) < 2:
        return 0
    for i in range(0,len(nums)-1):
        for j in range (i+1,len(nums)):
            if nums[i] + nums[j] == target:
                return [i,j]

# 測試用例
def test_TargetSum1(self):
    assert TargetSum([1,1,3,6,0,2],2) == [0,1]

def test_TargetSum2(self):
    assert TargetSum([1],1) == 0

def test_TargetSum3(self):
    assert TargetSum([6,2,4,3,1,2],4) == [1,5]

def test_TargetSum4(self):
    assert TargetSum([2, 7, 11, 15],9) == [0,1]

// Java
public int[] TargetSum(int nums[],int target){
  Map<Integer, Integer> map = new HashMap<>();
  for(int i=0;i<nums.length;i++){
   int temp = target - nums[i];
   if(map.containsKey(temp)){
    return new int[] { map.get(temp), i };
   }
   map.put(nums[i],i);
  }
  return null;
 }

7.給定一個已按照升序排列 的有序數組，找到兩個數使得它們相加之和等於目標數。函數應該返回這兩個下標值 index1 和 index2，其中 index1 必須小於 index2。

'''
說明:
返回的下標值（index1 和 index2）不是從零開始的。
你可以假設每個輸入只對應唯一的答案，而且你不可以重復使用相同的元素。
示例:
輸入: numbers = [2, 7, 11, 15], target = 9
輸出: [1,2]
解釋: 2 與 7 之和等於目標數 9 。因此 index1 = 1, index2 = 2 。
'''
## python
class Solution(object):
    def twoSum(self, numbers, target):
        l=0
        r=len(numbers)-1
        while(l<r):
            if(numbers[l]+numbers[r]== target):
                return [l+1,r+1]
            if(numbers[l]+numbers[r] <target):
                l += 1
            else:
                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;
    }

8.假設你正在爬樓梯。需要 n 階你才能到達樓頂。每次你可以爬 1 或 2 個台階。你有多少種不同的方法可以爬到樓頂呢？注意：給定 n 是一個正整數。

'''
示例 1：

輸入： 2
輸出： 2
解釋： 有兩種方法可以爬到樓頂。
1.  1 階 + 1 階
2.  2 階
示例 2：

輸入： 3
輸出： 3
解釋： 有三種方法可以爬到樓頂。
1.  1 階 + 1 階 + 1 階
2.  1 階 + 2 階
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)

## 推薦寫法 ##
    def climbStairs(self, n):
        if(n == 1 or n == 2):
            return n
        num1=1
        num2=2
        while(n >= 3):
            result = num1 + num2
            num1 = num2
            num2 = result
            n -=1
        return result

## Java ##
public int setpMethod(int n){
        if(n ==1 || n ==2){
        return n;
        }
        int result = 0,n1 = 1,n2 = 2;
        while (n>=3){
            result = n1 + n2;
            n1 = n2;
            n2 = result;
            n--;
        }
        return result;
    }

9.給定一個非負整數數組，你最初位於數組的第一個位置。

數組中的每個元素代表你在該位置可以跳躍的最大長度。判斷你是否能夠到達最后一個位置。

'''
示例 1:

輸入: [2,3,1,1,4]
輸出: true
解釋: 從位置 0 到 1 跳 1 步, 然后跳 3 步到達最后一個位置。
示例 2:

輸入: [3,2,1,0,4]
輸出: false
解釋: 無論怎樣，你總會到達索引為 3 的位置。但該位置的最大跳躍長度是 0 ， 所以你永遠不可能到達最后一個位置。
'''

## python ##
class Solution(object):
    def canJump(self, nums):
        need = 1
        if(len(nums) ==1):
            return True
        if(nums[0] == 0):
            return False
        for i in range(len(nums)-2,-1,-1):
            if(nums[i] == 0 or nums[i] < need):
                need += 1
            else:
                need = 1
        if(need == 1) :
            return True
        else:
            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;
        }
    }

10.以 Unix 風格給出一個文件的絕對路徑，你需要簡化它。或者換句話說，將其轉換為規范路徑。

在 Unix 風格的文件系統中，一個點（.）表示當前目錄本身；此外，兩個點 （..） 表示將目錄切換到上一級（指向父目錄）；兩者都可以是復雜相對路徑的組成部分。

更多信息請參閱：Linux / Unix中的絕對路徑 vs 相對路徑.

請注意，返回的規范路徑必須始終以斜杠 / 開頭，並且兩個目錄名之間必須只有一個斜杠 /。最后一個目錄名（如果存在）不能以 / 結尾。此外，規范路徑必須是表示絕對路徑的最短字符串。

示例 1：

輸入："/home/"
輸出："/home"
解釋：注意，最后一個目錄名后面沒有斜杠。
示例 2：

輸入："/../"
輸出："/"
解釋：從根目錄向上一級是不可行的，因為根是你可以到達的最高級。
示例 3：

輸入："/home//foo/"
輸出："/home/foo"
解釋：在規范路徑中，多個連續斜杠需要用一個斜杠替換。
示例 4：

輸入："/a/./b/../../c/"
輸出："/c"
示例 5：

輸入："/a/../../b/../c//.//"
輸出："/c"
示例 6：

輸入："/a//b////c/d//././/.."
輸出："/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

11.給定一個字符串 (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

##python##
def isMatch(self, s, p):
        si, pi, pj, sj = 0, 0, -1, -1
        while si < len(s):
            if pi < len(p) and p[pi] == '*':
                pi += 1
                pj = pi
                sj = si
            elif pi < len(p) and (p[pi] == '?' or p[pi] == s[si]):
                pi += 1
                si += 1
            elif pj != -1:
                pi = pj
                sj += 1
                si = sj
            else:
                return False
        while (pi < len(p) and p[pi] == '*'):
            pi += 1
        return pi == len(p)

12.給出兩個 非空 的鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，並且它們的每個節點只能存儲 一位 數字。如果，我們將這兩個數相加起來，則會返回一個新的鏈表來表示它們的和。您可以假設除了數字 0 之外，這兩個數都不會以 0 開頭。

示例：

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

## python ##
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        n =l1.val + l2.val
        l3 = ListNode(n%10)
        l3.next = ListNode(n//10)
        p1 = l1.next
        p2 = l2.next
        p3 = l3
        while True:
            if p1 and p2:
                sum = p1.val+ p2.val + p3.next.val
                p3.next.val = sum % 10
                p3.next.next = ListNode(sum//10)
                p1 = p1.next
                p2 = p2.next
                p3 = p3.next
            elif p1 and not p2:
                sum = p1.val + p3.next.val
                p3.next.val = sum %10
                p3.next.next = ListNode(sum // 10)
                p1 = p1.next
                p3 = p3.next
            elif not p1 and p2:
                sum = p2.val +p3.next.val
                p3.next.val = sum % 10
                p3.next.next = ListNode(sum // 10)
                p2 = p2.next
                p3 = p3.next
            else :
                if p3.next.val == 0:
                    p3.next = None
                break
        return l3