# I tried LeetCode every day 141. Linked List Cycle (Python, Go)

#### What is Leetcode

leetcode.com This is the practice of coding interviews for software developers. A total of more than 1,500 coding questions have been posted, and it seems that the same questions are often asked in actual interviews.

Introduction to golang + algorithm I will solve it with go and Python to strengthen the brain. (Python is weak but experienced)

#### the issue's details

Given `head`, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. Note that `pos` is not passed as a parameter.

Return `true` if there is a cycle in the linked list. Otherwise, return `false`.

Japanese translation

`head` If given at the beginning of a linked list, determines if the linked list contains cycles.

If there are nodes in the list that can be reached again by continuously following the `next` pointer, then there is a cycle in the linked list. Internally, `pos` is used to indicate the index of the node to which the tail`next` pointer is connected. ** Note that this `pos` is not passed as a parameter **.

`true` * Return * if there is a cycle in the linked list *. Otherwise, it returns `false`.

Example 1:

``````Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
``````

Example 2:

``````Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.
``````

Example 3:

``````Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.
``````

#### Way of thinking

1. Prepare fast that advances two nodes at a time and slow that advances only one node at a time.
2. Loop processing until fast catches up with slow or runs out of values.
3. True when catching up, False when nil

``````def hasCycle(self, head):
while fast and fast.next:
fast = fast.next.next
slow = slow.next
if slow == fast:
return True
return False
``````

--I'll write it in Go too!

``````func hasCycle(head *ListNode) bool {
return false
}
for p1 != p2 {
if p2 == nil || p2.Next == nil {
return false
}
p1 = p1.Next
p2 = p2.Next.Next
}
return true
}
``````