欧美vvv,亚洲第一成人在线,亚洲成人欧美日韩在线观看,日本猛少妇猛色XXXXX猛叫

新聞資訊

    組和鏈表

    Created: Apr 04, 2020 2:49 PM

    01 集合

    數據結構是以不同方式將數據組織和分組在一起的容器。 當你編寫代碼來解決問題時，總會涉及到數據-以及如何在計算機內存中存儲或構造數據會對你可以執行哪些操作以及執行這些操作的效率產生巨大影響。

    在本節中，我們將首先回顧一些您可能至少已經部分熟悉的基本數據結構。然后，隨著課程的進行，在解決不同類型的問題時，我們將考慮使用不同結構的利弊。我們將從討論非常通用的結構（集合）開始。

    集合的特性

    • 沒有特定的順序
    • 具有相同類型的對象

    02 列表

    列表特性

    • 有順序
    • 沒有固定的長度

    03 數組

    Python中數組和list的區別

    數組和列表有一些共同點：

    • 是一些單元的集合
    • 他們是一個順序的集合

    主要區別之一是數組具有索引

    要了解這一點，有助于了解如何將數組存儲在內存中。 創建數組時，始終會為其指定一些初始大小，即它應該能夠容納的元素數量（以及每個元素的大小）。 然后，計算機會找到一塊內存，并為陣列留出空間。

    重要的是，預留的空間是一個連續的塊。 也就是說，數組的所有元素都是連續的，這意味著它們在內存中都彼此相鄰。

    數組的另一個關鍵特性是所有元素的大小都相同。

    當我們直觀地表示一個數組時，我們通常將其繪制為一系列大小相同且彼此相鄰的盒子：

    因為所有元素彼此相鄰且大小相同，所以這意味著如果我們知道第一個元素的位置，就可以計算任何其他元素的位置。

    例如，如果數組中的第一個元素位于內存位置00且元素為24個字節，則下一個元素將位于位置00 + 24=24。其后的一個元素將位于24 + 24=48， 等等。

    由于我們可以輕松計算數組中任何項目的位置，因此我們可以為每個項目分配一個索引，并使用該索引快速而直接地訪問該項目

    相反，列表中的元素在內存中可能相鄰，也可能不相鄰！ 例如，在本課程的稍后部分，我們將查看鏈接列表，其中每個列表項都指向下一個列表項，但是這些項本身可能分散在內存的不同位置。 在這種情況下，知道列表中第一個項目的位置并不意味著您可以簡單地計算其他項目的位置。 這意味著我們不能像使用數組那樣使用索引直接訪問列表項。 我們將在短期內更詳細地探討鏈接列表。

    在python中我們可以使用[]創建一個列表

    >>> my_list=['a', 'b', 'c']

>>> my_list

['a', 'b', 'c']

    然后我們可以通過索引訪問列表中的元素：

    >>> my_list[0]

'a'

>>> my_list[1]

'b'

>>> my_list[2]

'c'


    我們將不會涉及所有細節，但是您需要在此課程中了解的重要事項如下：如果深入研究，您會發現Python列表實際上是像數組一樣實現的（特別是，如果您感到好奇，它的行為就像一個動態數組）。特別是，Python列表的元素在內存中是連續的，可以使用索引對其進行訪問。

    除了基礎數組之外，Python列表還包含一些其他行為。例如，您可以在Python列表上使用pop和append方法之類的東西來添加或刪除項。使用這些方法，您實際上可以利用Python列表（例如堆棧）（這是我們稍后將討論的另一種數據結構）

    通常，我們將盡量避免使用pop和append之類的東西，因為這些是高級語言功能，您可能無法使用其他語言來使用。在大多數情況下，我們將忽略Python列表附帶的額外功能，而是像使用簡單數組一樣使用它們。這將使您看到底層數據結構如何工作，而與實現這些結構所使用的語言無關。

    這是底線：

    • - Python list本質上是數組，但還包含其他高級功能
    • - 在本課程中，我們通常將忽略此高級功能，并將Python列表視為簡單數組

    這種方法將使您對底層數據結構有更好的了解。

    初始化列表

    """An Element has some value associated with it (which could be anything a”

a number, a string, a character, et cetera), and it has a variable that 

points to the next element in the linked list. """

class Element(object):

    def __init__(self, value):

        self.value=value

        self.next=None

        

"""This code is very similar a” we're just establishing that a LinkedList is

something that has a head Element, which is the first element in the list.

If we establish a new LinkedList without a head, it will default to None."""

class LinkedList(object):

    def __init__(self, head=None):

        self.head=head


    添加節點

    def append(self, value):

        """adds a new Element to the end of our LinkedList"""

        cur=self.head

        if self.head:

            while (cur.next):

                cur=cur.next

            cur.next=Element(value)

        else:

            self.head=Element(value)


    彈出節點

    def pop(self):

        cur=self.head

        if cur==None:

            return None

        if cur.next==None:

            val=cur.value

            self.head=None

            #pdb.set_trace()

            return val

        while cur.next:

            if (cur.next.next==None):

                val=cur.next.value

                cur.next=None

                return val

            cur=cur.next


    獲取對應位置的節點

    def get_position(self, position):

        """Get an Element from a particular position. Assume the first position is "1".

        Return "None" if position is not in the list."""

        if position > 0:

            current=self.head

            counter=1

            while current:

                if counter==position:

                    return current

                current=current.next

                counter +=1

            # position too large

            return None

        else:

            # position too small

            return None


    插入節點

    def insert(self, value, position):

        """Insert a new node at the given position. Assume the first position is "1".

        Inserting at position 3 means between the 2nd and 3rd elements."""

        i=position - 1

        cur=self.head

        new_element=Element(value)

        if position > 0:

            if i==0:

                new_element.next=cur

                self.head=new_element

            else:

                while(i==2):

                    #pdb.set_trace()

                    cur=cur.next

                    i -=1

                new_element.next=cur.next

                cur.next=new_element


    刪除節點

    def delete(self, value):

        """Delete the first node with a given value."""

        cur=self.head

        if cur.value==value:

            self.head=cur.next

        else:

            while cur.next:

                if cur.next.value==value:

                    cur.next=cur.next.next

                    break


    列表逆序

    def reverse(self):

        cur=self.head

        new_list=LinkedList()

        prev_node=None

        while cur:

            new_node=Element(cur.value)

            new_node.next=prev_node

            prev_node=new_node

            cur=cur.next

        

        new_list.head=prev_node

        return new_list

    遞歸實現

    遞歸問題必須可以分解為若干個規模較小，與原問題形式相同的子問題，這些子問題可以用相同的解題思路來解決

    • - 1、明確遞歸終止條件；
    • - 2、給出遞歸終止時的處理辦法；
    • - 3、提取重復的邏輯，縮小問題規模。


    """在遞去過程中解決問題"""

function recursion(大規模){

    if (end_condition){      // 明確的遞歸終止條件

        end;   // 簡單情景

    }else{            // 在將問題轉換為子問題的每一步，解決該步中剩余部分的問題

        solve;                // 遞去

        recursion(小規模);     // 遞到最深處后，不斷地歸來

    }

}

"""在歸來過程中解決問題"""

function recursion(大規模){

    if (end_condition){      // 明確的遞歸終止條件

        end;   // 簡單情景

    }else{            // 先將問題全部描述展開，再由盡頭“返回”依次解決每步中剩余部分的問題

        recursion(小規模);     // 遞去

        solve;                // 歸來

    }

}
原始序列： A-->B-->None

head.next.next=head

A-->B-->None

↑___| 

head.next=None

A-->B-->None

|________↑

B->A->None

"""


    def reverse_recursion(head):

    if head is None or head.next is None:

        return head

    	

    new_head=reverse_recursion(head.next)

    pdb.set_trace()

    head.next.next=head

    head.next=None

    

    return new_head


    合并兩個列表

    def merge(list1, list2):

    merged=LinkedList(None)

    if list1 is None:

        return list2

    if list2 is None:

        return list1

    list1_elt=list1.head

    list2_elt=list2.head

    while list1_elt is not None or list2_elt is not None:

        if list1_elt is None:

            merged.append(list2_elt)

            list2_elt=list2_elt.next

        elif list2_elt is None:

            merged.append(list1_elt)

            list1_elt=list1_elt.next

        elif list1_elt.value <=list2_elt.value:

            merged.append(list1_elt)

            list1_elt=list1_elt.next

        else:

            merged.append(list2_elt)

            list2_elt=list2_elt.next

    return merged

class NestedLinkedList(LinkedList):

    def flatten(self):

        return self._flatten(self.head)

    def _flatten(self, node):

        if node.next is None:

            return merge(node.value, None)

        return merge(node.value, self._flatten(node.next))

linked_list=LinkedList(Node(1))

linked_list.append(3)

linked_list.append(5)

second_linked_list=LinkedList(Node(2))

second_linked_list.append(4)

nested_linked_list=NestedLinkedList(Node(linked_list))

nested_linked_list.append(second_linked_list)

flattened=nested_linked_list.flatten()

node=flattened.head

while node is not None:

    #This will print 1 2 3 4 5

    print(node.value)

    node=node.next


    Add one

    ```python

'''

Add-One:

Problem Statement:

You are given a non-negative number in the form of a list elements.

For example, the number 123 would be provided as arr=[1, 2, 3]

Add one to the number and return the output in the form of a new list.

Example 1:

	input=[1, 2, 3]

	output=[1, 2, 4]

Example 2:

	input=[9, 9, 9]

	output=[1, 0, 0, 0]

Challenge:

One way to solve this problem is to convert the input array into a

number and then add one to it. For example, if we have

input=[1, 2, 3], you could solve this problem by creating the

number 123 and then separating the digits of the output number 124.

But can you solve it in some other way?

'''

import pdb

def add_one(arr):

	'''

	:param: arr - list of digits representing some number x

	return a list with digits representing int (x + 1)

	'''

	output=1;

	for i in range(len(arr), 0, -1):

		output=output + arr[i -1]

		borrow=output // 10

		pdb.set_trace()

		if borrow==0:

			arr[i - 1]=output

			break

		else:

			arr[i - 1]=output % 10

			output=borrow

	arr=[borrow] + arr

	index=0

	while arr[index]==0:

		index +=1

	return arr[index:]

def test_function(test_case):

	arr=test_case[0]

	solution=test_case[1]

	output=add_one(arr)

	for index, element in enumerate(output):

		if element !=solution[index]:

			print("Fail")

			return

	print("Pass")

arr=[0]

solution=[1]

test_case=[arr, solution]

test_function(test_case)

arr=[1, 2, 3]

solution=[1, 2, 4]

test_case=[arr, solution]

test_function(test_case)

arr=[9, 9, 9]

solution=[1, 0, 0, 0]

test_case=[arr, solution]

test_function(test_case)


    查找并返回輸入數組中連續子數組中的最大和。

    """

Problem Statement

You have been given an array containg numbers. Find and return the largest sum in a contiguous subarray within the input array.

Example 1:

arr=[1, 2, 3, -4, 6]

The largest sum is 8, which is the sum of all elements of the array.

Example 2:

arr=[1, 2, -5, -4, 1, 6]

The largest sum is 7, which is the sum of the last two elements of the array.

"""

def max_sum_subarray(arr):

    """

    :param - arr - input array

    return - number - largest sum in contiguous subarry within arr

    Author: Zhijin Li (lizhijin1993@gmail.com)

    """

    current_sum=arr[0]

    max_sum=arr[0]

    for num in arr[1:]:

    	current_sum=max(num, current_sum + num)

    	max_sum=max(current_sum, max_sum)

    return max_sum

def test_function(test_case):

    arr=test_case[0]

    solution=test_case[1]

    

    output=max_sum_subarray(arr)

    if output==solution:

        print("Pass")

    else:

        print("Fail")

# Test Case 1

arr=[1, 2, 3, -4, 6]

solution=8 # sum of array

test_case=[arr, solution]

test_function(test_case)

# Test Case 2

arr=[1, 2, -5, -4, 1, 6]

solution=7   # sum of last two elements

test_case=[arr, solution]

test_function(test_case)

# Test Case 3

arr=[-12, 15, -13, 14, -1, 2, 1, -5, 4]

solution=18  # sum of subarray=[15, -13, 14, -1, 2, 1]

test_case=[arr, solution]

test_function(test_case)

? 2020 GitHub, Inc.

Terms

Privacy

Security

Status

Help

Contact GitHub

Pricing

API

Training

Blog

About


    Pascal's triangle


    '''

問題陳述：

查找并返回列表形式的Pascal三角形的第n行。

n從0開始

例如，如果n=4，則輸出=[1、4、6、4、1]

Pascal的Triangle參考：

     https://www.mathsisfun.com/pascals-triangle.html

任何帕斯卡三角形的公式：

        

     [（n）/（k）]

     ---------------------

     [（n！）/（k！（n-k）！）]

參數：-n-索引（從0開始）

return-list（）代表Pascal三角形的第n行

'''

def nth_row_pascal(n):

    if n==0:

        return [1]

    current_row=[1]

    for i in range(1, n + 1):

        previous_row=current_row

        current_row=[1]

        for j in range(1, i):

            next_number=previous_row[j] + previous_row[j-1]

            current_row.append(next_number)

        current_row.append(1)

    return current_row

def test_function(test_case):

    n=test_case[0]

    solution=test_case[1]

    output=nth_row_pascal(n)

    if solution==output:

        print("Pass")

    else:

        print("Fail")

n=0

solution=[1]

test_case=[n, solution]

test_function(test_case)

n=1

solution=[1, 1]

test_case=[n, solution]

test_function(test_case)

n=2

solution=[1, 2, 1]

test_case=[n, solution]

test_function(test_case)

n=3

solution=[1, 3, 3, 1]

test_case=[n, solution]

test_function(test_case)

n=4

solution=[1, 4, 6, 4, 1]

test_case=[n, solution]

test_function(test_case)

			

```

### 偶數排在奇數后

```python

'''

問題陳述：

給定具有整數數據的鏈表，請以以下方式排列元素：將所有具有偶數的節點放在奇數之后。 不要創建任何新節點，并避免使用任何其他數據結構。 偶數和奇數元素的相對順序不得更改。

例：

鏈表=1 2 3 4 5 6

輸出=1 3 5 2 4 6

'''

class Node:

    def __init__(self, data):

        self.data=data

        self.next=None

# Solution

def even_after_odd(head):

    if head is None:

        return head

    even=None

    odd=None

    even_tail=None

    head_tail=None

    while head:

        next_node=head.next

        if head.data % 2==0:

            if even is None:

                even=head

                even_tail=even

            else:

                even_tail.next=head

                even_tail=even_tail.next

        else:

            if odd is None:

                odd=head

                odd_tail=odd

            else:

                odd_tail.next=head

                odd_tail=odd_tail.next

        head.next=None

        head=next_node

    if odd is None:

        return even

    odd_tail.next=even

    return odd

def create_linked_list(arr):

    if len(arr)==0:

        return None

    head=Node(arr[0])

    tail=head

    for data in arr[1:]:

        tail.next=Node(data)

        tail=tail.next

    return head

def print_linked_list(head):

    while head:

        print(head.data, end=' ')

        head=head.next

    print()

def test_function(test_case):

    head=test_case[0]

    solution=test_case[1]

    node_tracker=dict({})

    node_tracker['nodes']=list()

    temp=head

    while temp:

        node_tracker['nodes'].append(temp)

        temp=temp.next

    head=even_after_odd(head)

    temp=head

    index=0

    try:

        while temp:

            if temp.data !=solution[index] or temp not in node_tracker['nodes']:

                print("Fail")

                return

            temp=temp.next

            index +=1

        print("Pass")

    except Excemption as e:

        print("Fail")

arr=[1, 2, 3, 4, 5, 6]

solution=[1, 3, 5, 2, 4, 6]

head=create_linked_list(arr)

test_case=[head, solution]

test_function(test_case)

arr=[1, 3, 5, 7]

solution=[1, 3, 5, 7]

head=create_linked_list(arr)

test_case=[head, solution]

test_function(test_case)

arr=[2, 4, 6, 8]

solution=[2, 4, 6, 8]

head=create_linked_list(arr)

test_case=[head, solution]

test_function(test_case)


    交換節點

    鍵點

    1. `vim -u NONE -N`可以不加載vim配置和插件打開vim
    2. `vim --startuptime vim.log`可以生成vim啟動的log
    3. 使用`vim-plug`插件管理工具，給插件配置`for` or `on`可以實現插件懶加載
    4. 設置`foldmethod=syntax`會導致vim插入模式下卡頓

    用vim已經一年了，之前雖然知道vim會有性能問題，但是之前從來沒遇到過，也許也遇到過？貌似把問題推給電腦了，因為印象中，電腦用一天，內存占用會達到80%以上，那時候，vim也會卡，所以一直是想辦法把內存降下來。直到最近...

    最近用vim打開一個2000多行代碼的js文件，發現打開文件時候有一些卡頓，在輸入的時候發現，卡到爆炸，無法正常輸入，但是如果不加載`.vimrc`和插件，即用`vim -u NONE -N`打開，完全不會卡，至此確定我遇到了vim性能問題，需要優化我的vim配置。

    一般情況下，vim的性能問題都是由于我們裝插件太多導致的，本質上是因為vim不支持異步，但是現在（vim8+）支持異步了，所以很多插件都開始轉向使用異步API實現自己的功能，比如大名鼎鼎的`YouCompleteMe`，不過也不是所有的插件都會做支持，畢竟vim好多年了，也許我們用的一些插件都停更好久了。

    vim啟動優化

    為了優化vim啟動，首先可以做的一點是將**插件懶加載**，即用到哪個插件再加載哪個插件，通過`vim-plug`插件管理工具可以非常方便的做到，配置方式如下：

    Plug 'mattn/emmet-vim', { 'for': ['html', 'javascript.jsx'] }
Plug 'mxw/vim-jsx', { 'for': 'javascript.jsx' }
Plug 'scrooloose/nerdtree', { 'on': 'NERDTreeToggle' }

    `on`表示在某個條件下加載，例如上面的配置表示在輸入命令`NERDTreeToggle`的時候加載`nerdtree`插件，`for`表示該插件針對某一類文件加載，例如`vim-jsx`插件只有在文件類型為`javascript.jsx`的時候加載。

    這樣就可以讓vim在啟動的時候，不加載不必要的插件。

    vim輸入性能優化

    啟動快了，但是輸入還是很卡，所以開始尋找是哪個插件的問題。

    為了找到具體是哪個插件導致的卡頓，首先可以通過生成的vim.log文件查看vim啟動以及使用的時候每一步的時間，具體啟動方式如下：

    # 啟動vim并生成vim啟動時候的日志
vim --startuptime vim.log

    這樣就可以拿到具體vim啟動時候的各個步驟的啟動時間，但是查看了日志并沒看看出明顯的問題，所以開始嘗試第二種方法，逐個注銷vim的插件，看哪個插件注銷后，卡頓會消失。

    發現注釋掉`vim-javascript`后，輸入變得流暢，所以可以確定是這個插件導致的問題，但是這個插件是用來支持js語法的，不應該出現這么嚴重的性能問題啊，去GitHub vim-javascript 的 issues中搜索關于`performance`的帖子，最終找到一篇關于打開大的js文件嚴重卡頓的原因：[Very slow performance in large Js files](https://github.com/pangloss/vim-javascript/issues/140)，在帖子中插件的作者回復到，出現卡頓的原因是設置了foldmethod=syntax（該設置項本來是讓vim基于語法進行折疊），作者強調給vim設置該選項本身就會導致插入時候速度變慢，具體原因以及解決方法（文中的解決方案嘗試了，但是沒有效果）可以查看：[https://vim.fandom.com/wiki/Keep_folds_closed_while_inserting_text。

    解決方案：

    1. 可以給foldmethod設置其他選項（manual，indent，marker）
    2. 直接使用vim的一個插件FastFold實現代碼折疊
    3. 去掉代碼折疊設置

    總的來說就是不要在插入模式下使用`foldmethod=syntax`。

    基于以上優化，再打開大型文件，vim不再卡頓，又可以流暢的使用vim編寫代碼了。

    近，

    有人將94版《射雕英雄傳》里

    朱茵扮演的黃蓉換上了楊冪的臉

    神操作驚呆網友。

    這是朱茵飾演的黃蓉：

    替換成楊冪后：

    還是朱茵活靈活現的表情

    但五官已然變成了楊冪

    視頻看起來毫無破綻

    簡直讓人以為就是本冪演的了

    網友都被這樣的操作驚呆了，

    微博話題閱讀量瞬間飆到1.3億

    這種神奇的技術

    其實是被稱作黑科技的AI換臉！

    兩年前從國外論壇流傳開來

    而國內也有不少仿效者

    比如有網友把女主播的臉

    換成唐嫣、楊冪、劉亦菲等明星

    2017年12月，一個網名為deepfakes的程序員在Reddit上發布一則視頻，將《神奇女俠》主演蓋爾·加朵、TaylorSwift等明星的臉替換到黃色視頻中，獲得極高點擊量。

    后來，另一名用戶開發了一個名為FakeApp的應用軟件，讓普通人也可以體驗這項“換臉”技術。

    這項技術并不復雜。首先，視頻制作人在社交媒體上大量下載替代者與被替代者的靜態圖片和視頻，然后用如TensorFlow等開源軟件庫進行及其學習，經過足夠多的訓練之后，電腦就能自動識別、換臉。

    這項技術還被用于其他領域，比如制造政治家或公眾人物的假視頻，特朗普、希拉里等名人都曾中招。

    視頻中左側為真實視頻，右側是Deepfake合成

    Deepfake合成后的「希拉里·川普」

    更令人擔憂的是，隨著技術普及，一些色情視頻逐漸成為污名化、騷擾及傷害女性的新武器。

    據Business Insider（商業內幕）網站報道，

    不幸的是，這項技術已被非專業人士用于一些惡意的目的，包括用名人的面孔替換色情視頻，在某些情況下創造以假亂真的結果。

    Unfortunately, this technology is already being used by nonexperts for nefarious purposes, including inserting the faces of celebrities into pornographic videos, creating, in some instances, very convincing and disturbing results.

    作為深受其擾的明星之一，斯嘉麗·約翰遜接受采訪時說：“讓任何一個人成為這項技術的攻擊目標只是時間問題。”在過去的一年中，斯嘉麗·約翰遜已經被疊加到數十個性愛視頻中，其中一個“走光”視頻已經在一個主要的色情網站上觀看了超過 150 萬次。

    據《華盛頓郵報》報道，2018年2月，這項換臉技術已經被Reddit、Twitter和Pornhub等網站所禁止。

    Reddit禁止使用泰勒斯威夫特和蓋爾·加朵等名人面孔進行合成的“色情短片”

    Twitter也在周二緊隨其后，誓言暫停任何發布此類內容的賬戶。游戲網站Discord和GIF創建者Gfycat在（2018年）1月份禁止了deepfakes。

    Twitter followed suit on Tuesday, vowing to suspend any accounts posting such content. The gaming site Discord and the GIF creator Gfycat banned deepfakes in January.

    一個月被搜索10萬次！

    2019年1月，荷蘭DeepTrace實驗室發布了2018年度DeepFake發展報告，數據顯示2018年“deepfake”關鍵詞的谷歌搜索次數比2017年增長了1000倍。

    在 2017年11月deepfakes視頻從Reddit論壇發酵之前，每月搜索次數只有100次左右。到了2018年7月，“deepfake”每月搜索次數已經上升到100萬次-1000萬次。到12月，數字最終穩定在每月10萬次。

    （來源：Deeptrace報告）

    也就是說，這項技術正在被越來越多人使用。

    視頻“換臉”不但會助力假新聞、假視頻的滋生。在這種前沿技術面前，每個人都可能成為潛在的受害者。

    一旦被人濫用，真實照片與語音模擬器或語音合成系統相結合，就可以生成任意“假新聞”，任何人可以變成任何人。

    編輯：付慧敏

    視頻：楊藝

    實習生：陳玉琪

    中國日報綜合新聞晨報、21財聞匯、科技最前線、Washington Post、Business Insider、Deeptrace

網站首頁   |    關于我們   |    公司新聞   |    產品方案   |    用戶案例   |    售后服務   |    合作伙伴   |    人才招聘   |   

友情鏈接： 餐飲加盟

地址：北京市海淀區    電話：010-     郵箱：@126.com

備案號：冀ICP備2024067069號-3 北京科技有限公司版權所有