pythainlp/thai-wiki-dataset-v3 huggingface dataset:
ขั้นตอนวิธีของพริม

ขั้นตอนวิธีของพริม (Prim's algorithm)Prim's Algorithm ถูกพัฒนาโดยนักคณิตศาสตร์ชื่อ Vojtech Jarnik ในปี1930 ต่อมาถูก พัฒนาต่อโดยนักคอมพิวเตอร์ชื่อ Robert C. Prim ในปี1957 และ Edsger Dijkstra ในปี1959 ดังนั้น อัลกอริทึมนี้บางทีจึงมักเรียกว่า DJP Algorithm , Jarnik Algorithm หรือ Prim-Jarnik Algorithm ซึ่งเป็นอัลกอริทึมที่ใช้ในการหาขนาด หรือน้ำหนักของต้นไม้ทอดข้ามที่น้อยที่สุด
เราจะเริ่มจากการทำ minimum spanning tree เล็ก ๆในกราฟก่อน จากนั้นจะค่อยๆเลือก edge ที่ ไม่ต่อกับ minimum spanning tree ย่อย ๆเดิมมาต่อเพิ่มไปเรื่อย ๆ จนได้ครบทุก node ซึ่ง algorithm ตัวนี้ จะ implement คล้ายๆกับ Dijkstra's Algorithm

==codeขั้นตอนวิธีของพริม==
import heapq
def prim(nodes,edges):
if nodes==None and edges==None:
return None
conn = {}
for u, v, w in edges:
if u not in conn:
conn[u] = [(w,u,v)]
print(conn[u])
else:
conn[u].append((w, u, v))
print(conn[u])
if v not in conn:
conn[v] = [(w,v,u)]
print(conn[v])
else:
conn[v].append((w, v, u))
print(conn[v])
node = nodes[0]
usable_edges = conn[node]
heapq.heapify(usable_edges)
Q = set(node)
mst = []
while len(usable_edges) > 0:
wt, from_node, to_node = heapq.heappop(usable_edges)
if to_node not in Q:
Q.add(to_node)
mst.append((from_node, to_node, wt))
print(mst)
for edge in conn[to_node]:
ww, uu, vv = edge
if vv not in Q:
heapq.heappush(usable_edges, (ww, uu, vv))
return mst
=== testcase ขั้นตอนวิธีของพริม ===
import heapq
from prim import prim
scenario1:กราฟทั่วไป
Given:มีเส้นเชื่อมดังที่กำหนด
When:หาระยะที่สั้นที่สุดที่เชื่อมทุกnode
Then:ได้ผลลัพธ์คือ[('A', 'D', 5),('D', 'F', 6),('A', 'B', 7),('B', 'E', 7),('E', 'C', 5),('E', 'G', 9)]
def test_case1:
edges = [ ("A", "B", 7), ("A", "D", 5),
("B", "C", 8), ("B", "D", 9), ("B", "E", 7),
("C", "E", 5),
("D", "E", 15), ("D", "F", 6),
("E", "F", 8), ("E", "G", 9),
("F", "G", 11)]
nodes = ["A","B","C","E","F","G"]
mst=[('A', 'D', 5),('D', 'F', 6),('A', 'B', 7),('B', 'E', 7),('E', 'C', 5),('E', 'G', 9)]
assert prim(nodes,edges )==mst
scenario2:กราฟทั่วไปแต่มีขนาดที่เล็กลง
Given:มีเส้นเชื่อมดังที่กำหนด
When:หาระยะที่สั้นที่สุดที่เชื่อมทุกnode
Then:ได้ผลลัพธ์คือ[ ("A", "C", 3),("A", "B", 4),("B", "D", 2)]
def test_case2:
edges = [ ("A", "B", 4),("A", "C", 3),("A", "D", 5),("B", "D", 2)]
nodes = ["A","B","C",]
mst=[ ("A", "C", 3),("A", "B", 4),("B", "D", 2)]
assert prim(nodes,edges )==mst
scenario3:ไม่มีกราฟ
Given:มีเส้นเชื่อมดังที่กำหนด
When:หาระยะที่สั้นที่สุดที่เชื่อมทุกnode
Then:ได้ผลลัพธ์คือNone
def test_case3:
edges =None
nodes =None
mst=None
assert prim(nodes,edges )==mst
scenario4:มีค่าซ้ำกัน
Given:มีเส้นเชื่อมดังที่กำหนด
When:หาระยะที่สั้นที่สุดที่เชื่อมทุกnode
Then:ได้ผลลัพธ์คือ[ ("A", "B", 2),("A", "E",2 ),("A", "C", 3),("B", "D", 4)]
def test_case4:
edges =[ ("A", "B", 2), ("A", "E", 2),("A", "C", 3),("B", "D", 4), ("D", "C", 5), ("E", "C", 6)]
nodes =["A","B","C","E"]
mst=[ ("A", "B", 2),("A", "E",2 ),("A", "C", 3),("B", "D", 4)]
assert prim(nodes,edges )==mst
== Big-o ==
Big-o Prim’s algorithm
Big o=o(n^2logn)
Best case กรณีไม่มีmatrix
Big o=o(1)
Worst case กรณีมีmatrix
Big o=o(n^2logn)
ขั้นตอนวิธีกราฟ
ต้นไม้ทอดข้าม
อัลกอริทึม
แฮชชิงคู่

แฮชชิ่งคู่ (Double Hashing) เป็นเทคนิคการเขียนโปรแกรมคอมพิวเตอร์ โดยใช้ตารางแฮชเพื่อป้องกันการชนกันของแฮช ในกรณีที่สองค่าที่แตกกต่างกันค้นหาคีย์แฮชเดียวกัน ซึ่งการแฮชสองชั้นเป็นเทคนิค Open Address การแฮชแบบสองชั้นถูกนำไปใช้ในคลังโปรแกรมที่นิยมมาก
== หลักการทำงาน ==
1. กำหนดความกว้างของตารางแฮช และ ค่าที่ใช้เพื่อเลื่อนค่าจากตำแหน่งเดิม
2. กำหนดข้อมูลที่เราต้องการ อย่างตัวอย่างจะกำหนดให้คือ 26, 54, 94, 17, 31, 77, 44 และ 51 ความกว้างของตาราง คือ 13 ค่าที่ใช้เพื่อเลื่อนค่าจากตำแหน่งเดิม คือ 5
3. นำข้อมูลที่กำหนดให้มาคำนวณ โดย ข้อมูล ณ ตำแหน่งที่ Mod ความกว้างของตาราง (k\bmod length
) จะได้ 26\mod3=0 ซึ่งเป็นค่าในตำแหน่งของตารางแฮช แล้วทำต่อให้ครบทุกค่า
4. หาค่าการแฮชสองชั้นโดยใช้ ค่าที่ใช้เพื่อเลื่อนค่าจากตำแหน่งเดิม ลบกับ ข้อมูล ณ ตำแหน่งที่ Mod ค่าที่ใช้เพื่อเลื่อนค่าจากตำแหน่งเดิม  ( N-k\mod N ) จะได้ 5-k\mod 5
5. นำค่าที่ได้ในข้อที่ 3 ไปใส่ยังตารางในข้อที่ 2
5.1 ค่า 26 ตำแหน่งที่ 0
5.2  ค่า 54 ตำแหน่งที่ 2
5.3 ค่า 94 ตำแหน่งที่ 3
5.4 ค่า 17 ตำแหน่งที่ 4
5.5 ค่า 31 ตำแหน่งที่ 5
5.6 ค่า 77 ตำแหน่งที่ 12
5.7 ค่า 44 ตำแหน่งที่ 5 (กรณีค่าที่ตำแหน่งทับกัน จะนำค่าจากตารางในข้อที่ 4 มา บวกกับ ค่าตารางที่ 1 จะได้ 5 + 1 แล้ว Mod ด้วยความกว้างของตารางแฮช จะเท่ากับ 6)
เมื่อได้ค่าเท่ากับ 6 แล้ว จะเป็นค่าตำแหน่งใหม่ที่ใส่ลงในตาราง
ค่า 51 ตำแหน่งที่ 12 (กรณีค่าที่ตำแหน่งทับกัน จะนำค่าจากตารางในข้อที่ 4 มา บวกกับ ค่าตารางที่ 1 จะได้ 12 + 4 แล้ว Mod ด้วยความกว้างของตารางแฮช จะเท่ากับ 3)
เมื่อได้ค่าเท่ากับ 3 แล้ว จะเป็นค่าตำแหน่งใหม่ที่ใส่ลงในตาราง แต่เมื่อกรณียังมีค่าในตารางให้นับเพิ่มอีก 3
กรณียังมีค่าในตารางให้นับเพิ่มอีก 3
กรณียังมีค่าในตารางให้นับเพิ่มอีก 3 แต่เมื่อเจอช่องที่ว่างเปล่า สามารถนำค่านั้นลงในตารางได้ทันที
== ความซับซ้อนในการทำงาน ==
จะสรุปได้ว่า Big(O) = O(n^2) Best Case คือ ขนาดของข้อมูลเป็น 0 มีค่าเดียว หรือข้อมูลมีค่ามากกว่าตาราง O(1) Worst Case คือ ขนาดของข้อมูลที่ให้ฟังก์ชั่นทำงานครบทั้งหมด O(n^2)
== ตัวอย่างการเขียนโปรแกรม ==
def doubleHashing(data, hashTableSize, doubleHashSize):
if len(data) > hashTableSize:
return None
listOfHashTable = [None] * hashTableSize
for i in range(len(data)):
primaryHash = data[i] % hashTableSize
doubleHash = primaryHash
if listOfHashTable[primaryHash] is None:
listOfHashTable[primaryHash] = data[i]
else:
while listOfHashTable[doubleHash] is not None:
secondary = doubleHashSize - (data[i] % doubleHashSize)
doubleHash = (doubleHash + secondary) % hashTableSize
listOfHashTable[doubleHash] = data[i]
return listOfHashTable
== อ้างอิง ==
Mohit Makhija . Double Hashing Code2begin. Retrieved 1 May 2018.
ขั้นตอนวิธีการค้นหา
การแฮช
สโมสรฟุตบอลปานาซีไนโกส

สโมสรฟุตบอลปานาซีไนโกส (ΠΑΕ Παναθηναϊκός Α.Ο.; Panathinaikos F.C.) สโมสรฟุตบอลอาชีพของประเทศกรีซ มีที่ตั้งอยู่ใน กรุงเอเธนส์ ทุกวันนี้พวกเขาเป็นส่วนหนึ่งของ ปานาซีไนโกส เอโอ สโมสรกีฬาแบบครบวงจรที่โด่งดังที่สุดของกรีซและพวกเขาเป็นสโมสรฟุตบอลที่เก่าแก่ที่สุดของกรีซที่ยังทำกิจกรรมอยู่
สโมสรปานาซีไนโกสก่อตั้งเมื่อ ค.ศ. 1908 โดย จอร์จอส คาลาฟาติส และเพื่อนนักกีฬากว่า 40 คนโดยแยกออกมาจากสโมสรกีฬาแห่งหนึ่งภายหลังจากทางสโมสรกีฬาแห่งนั้นตัดสินใจยุติการทำทีมฟุตบอลโดยปานาซีไนโกสในยุคแรกถูกก่อตั้งขึ้นเพื่อฝึกสอนกีฬาเท่านั้น
ต่อมาทางสโมสรได้เข้าร่วม ซูเปอร์ลีกกรีซ และกลายเป็นหนึ่งในสโมสรที่ประสบความสำเร็จมากที่สุดในวงการฟุตบอลกรีซและเป็นหนึ่งในสามสโมสรที่ไม่เคยตกชั้นจากลีกสูงสุดร่วมกับ เออีเค เอเธนส์ และ โอลิมเปียกอส
สโมสรฟุตบอลปานาซีไนโกสเป็นสโมสรฟุตบอลของกรีซที่ประสบความสำเร็จมากที่สุดในการแข่งขันฟุตบอลยุโรปเป็นทีมเดียวของกรีซที่ได้เข้าสู่รอบชิงชนะเลิศของฟุตบอล ยูโรเปียน คัพ (ยูฟ่าแชมเปียนส์ลีก ในปัจจุบัน) ปี ค.ศ. 1971 ภายใต้การคุมทีมของ แฟแร็นตส์ ปุชกาช ตำนานยอดกองหน้าของ ทีมชาติฮังการี และ เรอัลมาดริด แต่แพ้ให้กับ อายักซ์ อัมสเตอร์ดัม เข้าถึงรอบรองชนะเลิศถึง 2 ครั้งคือปี ค.ศ. 1985 และ ค.ศ. 1996 และเป็นทีมเดียวของกรีซที่ได้ลงแข่ง ฟุตบอลชิงแชมป์สโมสรยุโรปและอเมริกาใต้ (1971) นอกจากนี้พวกเขายังเข้าถึงรอบก่อนรองชนะเลิศของแชมเปียนส์ลีกถึง 2 ครั้งใน ค.ศ. 1992 และ ค.ศ. 2002 และรอบก่อนรองชนะเลิศของ ยูฟ่า คัพ อีก 2 ครั้งใน ค.ศ. 1988 และ ค.ศ. 2003 พวกเขายังคว้าแชมป์ บอลข่าน คัพ ใน ค.ศ. 1977 ปานาซีไนโกสเป็นสมาชิกของ สมาคมสโมสรฟุตบอลยุโรป
 
ป
สโมสรกีฬาที่ก่อตั้งในปี พ.ศ. 2451
ต้นไม้ค้นหาไตรภาค

ในวิทยาการคอมพิวเตอร์ ต้นไม้ค้นหาไตรภาค (ternary search tree) เป็นทรัยประเภทหนึ่งซึ่งมีการจัดเรียงบัพแบบที่คล้ายกับต้นไม้ค้นหาทวิภาค แต่มีบัพลูกสามบัพแทนที่จะมีสองบัพ ต้นไม้ค้นหาไตรภาคสามารถใช้เป็นโครงสร้างแผนที่สัมพันธ์ที่มีความสามารถค้นหาสายอักขระแนวเดิม อย่างไรก็ดี ต้นไม้ค้นหาไตรนามใช้พื้นที่มีประสิทธิภาพกว่าเมื่อเทียบกับต้นไม้เติมหน้ามาตรฐานแต่มีความเร็วช้ากว่า การใช้ต้นไม้ค้นหาไตรภาคทั่วไป เช่น การตรวจสอบตัวสะกดและการเติมคำอัตโนมัติ
=== การดำเนินการของต้นไม้ค้นหาไตรภาค ===
•    ตัวชี้ซ้ายชี้ไปที่โหนดที่มีค่าต่ำกว่าค่าในโหนดปัจจุบัน (LEFT NODE)
•    ตัวชี้ที่เท่ากันชี้ไปที่โหนดที่มีค่าเท่ากับค่าในโหนดปัจจุบัน (MID NODE or EQUAL NODE)
•    ตัวชี้ด้านขวาชี้ไปที่โหนดที่มีค่ามากกว่าค่าในโหนดปัจจุบัน (RIGHT NODE)
=== ตัวอย่าง ===
c
/ | \
a  u  h
|  |  | \
t  t  e  u
/  / |   / |
s  p  e  i  s
จากกราฟนี้แสดงให้เห็นแต่ละโหนดที่ถูก insert หรือเพิ่มเข้ามาเป็นโครงสร้างของ TST โดยมีการเพิ่มข้อมูล "cute","cup","at","as","he","us" and "i" ตามลำดับ โดยข้อมูลที่ถูกเพิ่มเข้ามาก่อนนั้นจะเป็นกราฟ tree ที่อยู่ในตำแหล่งตรงกลาง และข้อมูลลำดับถัดไปหากลำดับตัวอักษรมีค่าน้อยกว่า parent node ก็จะเป็นกราฟ child node ที่อยู่ซ้ายมือ เช่นเดียวกันหากข้อมูลที่เพิ่มเข้ามามีค่าลำดับตัวอักษรมากกว่า parent node ก็จะอยู่ child node ขวามือ
=== CODE(PYTHON) ===
คุณสมบัติของโหนด
class Node:
def __init__(self, data):
self.data = data
self.end = False
self.left = None
self.mid = None
self.right = None
def print_(self):
return .join(['[', self.data,
( if not self.end else ' '),
( if self.left is None else ' left: ' + self.left.print_),
( if self.mid is None else ' mid: ' + self.mid.print_),
('' if self.right is None else ' right: ' + self.right.print_), ']'])
การเพิ่มข้อมูล
def add(self, node, string):
if len(string) == 0:
return node
head = string[0]
tail = string[1:]
if node is None:
node = Node(head)
if head  node.data:
node.right = self.add(node.right,string)
else:
if len(tail) == 0:
node.end = True
else:
node.mid = self.add(node.mid, tail)
return node
การค้นหาข้อมูล
def search(self, node, string):
if node is None or len(string) == 0:
return False
head = string[0]
tail = string[1:]
if head  node.data:
return self.search(node.right, string)
else:
if len(tail) == 0 and node.end:
return True
return self.search(node.mid, tail)
ต้นไม้ (โครงสร้างข้อมูล)
ขั้นตอนวิธีการค้นหา
การเรียงลำดับแบบรังนกพิราบ

การเรียงลำดับแบบรังนกพิราบ (pigeonhole sorting) เป็นขั้นตอนวิธีการเรียงลำดับที่เหมาะกับการเรียงลำดับรายการส่วนย่อยที่จำนวนส่วนย่อย (n) และความยาวของพิสัยค่าหลักที่เป็นไปได้ (N) ประมาณเท่า ๆ กัน ต้องใช้ O(n + N) ครั้ง การเรียงลำดับแบบนี้คล้ายกับการเรียงลำดับนับ แต่ต่างกันที่การเรียงลำดับนี้ "ย้ายรายการสองครั้ง ครั้งหนึ่งเข้าแถวลำดับที่ฝากข้อมูลแล้วอีกครั้งย้ายกับจุดหมายสุดท้าย"
=== การทำงานของการเรียงลำดับ ===
•     กำหนดให้เป็น array ของค่าที่จะเรียงลำดับ โดยกำหนด array ที่จะช่วยในการเรียงลำดับ array มีชื่อว่า holes ซึ่งเป็น array ว่างเปล่าที่รอรับจำนวนสมาชิกเป็นช่วงของ array เดิม
•     ที่ array ที่ต้องการจัดเรียงเราใส่ค่าแต่ละ array ลงใน holes ที่ตรงกับตำแหน่งของ array เดิม
•     ทำซ้ำใน holes โดยเขียนทับ array เดิมตามองค์ประกอบของ holes ว่าอยู่ตำแหน่งไหนบ้าง
=== การวิเคราะห์ความซับซ้อนของขั้นตอนวิธี ===
1.ในการนับเพื่อเพิ่มค่าของหลุม(holes) จะทำเท่ากับสมาชิกของอเรย์ หากให้สมาชิกของอเรย์เท่ากับ n จะได้ O(n)
2.ในการนับเพื่อที่จะเขียนทับไปยังอเรย์เดิมจะทำเท่ากับจำนวนของสมาชิกใน size ซึ่งมากจาก ค่าสูงสุดของอเรย์-ค่าต่ำสุดของอเรย์ +1 กำหนดให้เป็น m และเงื่อนไงของการที่จะเขียนทับลงไปยังอเรย์เดิมคืออเรย์ที่ holes ใดๆ ต้องมากกว่า 0 กำหนดให้เป็น x ดังนั้นสรุปได้ว่าความซับซ้อนจะมีค่าเป็น O(mx)
3.ดังนั้นเราสามารถสรุปได้ว่าขั้นตอนความซับซ้อนของการเรียงลำดับนี้คือ O(n+mx) ซึ่ง n=x เนื่องจากจากเงื่อนไงของ x มาจากจำนวนของ n ดังนั้นความซับซ้อนเท่ากับO(n+mn) เมื่อให้ N = mn จะได้ความซับซ้อนของขั้นตอนวิธี O(n+N)
4.ในกรณีที่ของมูลมีค่าหเมือนกันจะส่งผลให้ max-min+1 มีค่าเท่ากับ 1 และความซับซ้อนของ m=1 จะได้ความซับซ้อนของขั้นตอนวิธีเท่ากับ O(n+n) หรือ O(2n) นั่นเอง
=== CODE (PYTHON) ===
def Pigeonhole_sort(array):
min_arr = min(array)
size = max(array) - min_arr + 1
holes = [0] * size
for i in array:
holes[i - min_arr] += 1
i_array = 0
for count in range(size):
while holes[count] > 0:
array[i_array] = count + min_arr
holes[count] -= 1
i_array += 1
return array
=== TEST CASE ===
import unittest
from PigeonholeSorting import Pigeonhole_sort
import random
def is_sorted(array):
n = len(array)
for i in range(1,n):
if array[i] 
ขั้นตอนวิธีการเรียงลำดับ
การเรียงแบบเสถียร
ซอฟต์ฮีป

ในวิทยาการคอมพิวเตอร์ โดย Soft heap เป็นตัวแปรในโครงสร้างข้อมูล(Data structure) heap ง่ายๆ ซึ่งมีคำสั่งที่สามารถสั่งงานได้ 5 ชนิด นี่คือการลุล่วงคำสั่งโดยการ " corrupting(ทำความเสียหาย)" (การเพิ่มขึ้น) เป็นกุญแจสำคัญในค่าของจำนวนที่แน่นอนที่อยู่ใน Heap โดยมีคำสั่งที่ให้ในการดำเนินการดังนี้
create(S): สร้างsoft heap(S) ขึ้นมาใหม่
insert(S, x): แทรกสมาชิก (x) ใน soft heap (S)
meld(S, S’): รวม 2 รายการที่อยู่ใน soft heaps เป็นอันเดียว(สร้างSoft Heap ใหม่)และทำลายทั้งสองทิ้ง(อันเก่า)
delete(S, x): ลบสมาชิก(x)จาก soft heap (S)
findmin(S): เรียกคืนค่า(return)สมาชิกใน Soft Heap (S) กับค่าKeysที่เล็กที่สุด
Heapอื่น ๆ เช่น heaps Fibonacci สามารถทำคำสั่งได้สำเร็จมากที่สุดโดยไม่มีจำเป็นต้องมี"corrupting", แต่ไม่สามารถให้ขอบเขตเวลาคงที่บนการดำเนินการในคำสั่ง “ลบ” (delete) ที่สำคัญได้ ปริมาณของ Corruptionสามารถควบคุมได้โดยการเลือกพารามิเตอร์ “ε”, แต่การตั้งค่าต่ำกว่านี้จำเป็นต้องมีการใส่เวลามากขึ้นด้วยเช่นกัน (O(log 1/ε) สำหรับอัตราการผิดพลาดของ ε)
ท้ายที่สุดอัลกรอลิทึมจะมีลักษณะดังนี้:
function softHeapSelect(a[1..n], k)
if k = 1 then return minimum(a[1..n])
create(S)
for i from 1 to n
insert(S, a[i])
for i from 1 to n/3
x := findmin(S)
delete(S, x)
xIndex := partition(a, x)  // Returns new index of pivot x
if k < xIndex
softHeapSelect(a[1..xIndex-1], k)
else
softHeapSelect(a[xIndex..n], k-xIndex+1)
ค่าตัวแปรทั่วไปที่ใช้ในการเรียงลำดับความสำคัญ เรียกว่า “Soft Heap” โครงสร้างข้อมูลจะถูกสนับสนุนโดยกระบวนการหลักดังนี้ : insert(การแทรก), delete(การลบ), meld(การรวม), findmin(หาค่าที่น้อยที่สุด) เป็นที่น่าแปลกใจมากที่มันมีความสามารถในการเอาชนะขอบเขตของลอกาลึทึมบนความซับซ้อนของ Heap ในแบบจำลองการเปรียบเทียบพื้นฐาน เพื่อที่ทำลายอุปสรรค์ของทฤษฎีนี้ เอนโทรปีของโครงสร้างข้อมูลจะถูกทำให้ลดลงโดยค่าบางค่าในKeys ซึ่งมีการผสมลำดับของ n คำสั่งกับค่าของความผิดพลาด(Error rate, ε) จะมีค่าอยู่ระหว่าง (0< ε ≤ 1/2) สิ่งที่เป็นข้อยืนยันคือในเวลาใดๆ ส่วนมาก ε*n มันจะมี keys จะถูกยกขึ้นมาใช้งาน ,การหักล้างความซับซ้อนของแต่ละคำสั่งนั้นเป็นที่แน่นอน ยกเว้นในคำสั่ง Insert ซึ่งจะใช้เวลา O(Log 1/ε) ครั้ง
Soft Heap จะดีที่สุดก็ต่อเมื่อมีค่าของ ε อยู่ในแบบจำลองการเปรียบเทียบพื้นฐาน โดยโครงสร้างข้อมูลนั้นจะมีแค่Pointer อยู่อย่างเดียว ไม่มี Array ใดๆที่จะใช้ค่าเลขสมมุติในการสร้าง Keys ได้ แนวความคิดหลักของ Soft Heap คือการเคลื่อนย้ายรายการข้ามโครงสร้างข้อมูลไม่ใช่ทีละรายการแต่เป็นกลุ่ม นั้นเป็นไปอย่างปกติ, ในโครงสร้างข้อมูลจะมีลักษณะคล้ายกับ Carpooling (การร่วมโดยสารกันไปในเส้นทางเดียวกัน โดยในยานพาหนะเดียวกัน) Keys จะต้องขึ้นอยู่กับผลของมัน เพื่อที่จะรักษาลำดับโครงสร้างข้อมูลของ Heap เอาไว้ Soft Heap สามารถใช้การคำนวณได้อย่างแน่นอนหรือ มีค่ามัธฐาน และค่าเปอร์เซ็นสูงสุด มันมีประโยชน์มากสำหรับการประมาณค่าการเรียงลำดับข้อมูล(Sorting)และ เพื่อคำนวณหาค่าที่ต่ำที่สุดของแผนภูมิต้นไม้อีกด้วย
== อ้างอิง ==
Chazelle, Bernard (November 2000). "The soft heap: an approximate priority queue with optimal error rate" (PDF). J. ACM. 47 (6): 1012–1027. CiteSeerX10.1.1.5.9705 . doi:10.1145/355541.355554
ฮีป (โครงสร้างข้อมูล)
โครงสร้างข้อมูลแบบถัวเฉลี่ย
อินเตอร์สเตต 2

อินเตอร์สเตต 2 (Interstate 2 หรือ I-2) เป็นทางหลวงอินเตอร์สเตตแนวตะวันออก–ตะวันตก มีเส้นทางผ่านภูมิภาคหุบเขารีโอแกรนด์ของเท็กซัสใต้ เริ่มต้นที่ทางแยกบนทางหลวงสหรัฐหมายเลข 83 ในเพนิทัส (Penitas) มุ่งหน้าไปทางทิศตะวันออกก่อนที่จะสิ้นสุดบนอินเตอร์สเตต 69 อี, อินเตอร์สเตต 77, และทางหลวงสหรัฐหมายเลข 83 ในนครฮาร์ลินจิน ระยะทางทั้งหมดของอินเตอร์สเตต 2 มีการใช้เส้นทางร่วมกันกับทางหลวงสหรัฐหมายเลข 83 และมีเส้นทางขนานไปกับทางหลวงเม็กซิโกหมายเลข 2 ซึ่งเป็นเส้นทางหลักแนวตะวันออก–ตะวันตกในฝั่งประเทศเม็กซิโกขนานไปกับพรมแดนประเทศเม็กซิโก–สหรัฐซึ่งเป็นแนวแม่น้ำรีโอแกรนด์
== ภาพ ==
ไฟล์:US Highway 83 in McAllen, Texas.jpg|อินเตอร์สเตต 2 และทางหลวงสหรัฐหมายเลข 83 ผ่านนครมิแกลลิน รัฐเท็กซัส ในปี ค.ศ. 2005
== อ้างอิง ==
== แหล่งข้อมูลอื่น ==
Interstate-guide.com: Interstate 2
02
ถนนในรัฐเท็กซัส
ขั้นตอนวิธีบอยเออร์–มัวร์–ฮอร์สพูล

== การจับคู่สตริงแบบฮัวส์ปัวร์ ==
การจับคู่สตริงแบบฮัวส์ปัวร์ หรือ Boyer-Moore-Horspool เป็นอัลกอริทึมที่ใช้ในการจับคู่สตริง (String Matching) ด้วยการเปรียบเทียบ pattern จากทางด้านขวาไปด้านซ้าย มีการปรับปรุงมาจาก Boyer Moore โดยเลือกใช้ Bad-Charactor เฉพาะ Last occurrence (การเกิดขึ้นครั้งสุดท้าย)
=== การเลื่อนตำแหน่ง ===
จะมีการสร้าง Bad Match Table โดย
จำนวนครั้งที่เลื่อน = ความยาวของ Pattern - ตำแหน่งของตัวอักษร - 1
=== ตัวอย่างของการทำงาน ===
Text :      [a, b, a, b, a, b, c, a, c]
Pattern : [b, a, c, c, a]
เนื่องจากตัวที่ไม่ตรงกันกับ Text คือ c และ มี a ปรากฏใน Pattern จึงทำการเลื่อนตำแหน่งให้ a ใน Patern ตรงกับ a ใน Text โดยมีจำนวนครั้งการเลื่อน = 5 - 1 - 1 = 3
Text :      [a, b, a, b, a, b, c]
Pattern :             [b, a, c, c, a]
=== ความซับซ้อนของการทำงาน ===
Worst-case จะเป็นกรณีที่มีการเลื่อนของตัวอักษรถัดไปน้อย จะมีตวามซับซ้อนเป็น O(nm)
Best-case จะคล้ายกับของ Boyer-Moore ซึ่งก็คือ หากไม่มีตัวอักษรอยู่เลย จะส่งผลให้เกิดการเปลี่ยนแปลงด้วยความยาวของ pattern (m) จะมีความซับซ้อนเป็น O(n/m)
=== Code Python ของ การจับคู่สตริงแบบฮัวส์ปัวร์ ===
def horspool(text,pattern):
len_text = len(text)
len_pattern = len(pattern)
results = []
if len_pattern>len_text or len_text==0 or len_pattern==0:
return results
table = {index: len_pattern for index in range(256)}
for index, char in enumerate(pattern):
table[ord(char)] = len_pattern - index - 1
index = 0
while index 
== แหล่งอ้างอิง ==
kagan94  Boyer Moore Horspool algorithm ค้นหาเมื่อ 25 มีนาคม 2561
Nelson Rush BOYER-MOORE-HORSPOOL STRING SEARCHING ค้นหาเมื่อ 28 มีนาคม 2561
mtu Space and Time Tradeoffs ค้นหาเมื่อ 28 มีนาคม 2561
ขั้นตอนวิธีการจับคู่สายอักขระ
ต้นไม้นิพจน์ทวิภาค

ต้นไม้พิจน์ หรือ binary expression tree เป็นต้นไม้แบบไบนารี (Binary Tree) ที่มีการสร้างขึ้นจากตัวกระทำ(operand) และ เครื่องหมาย(operators) ทางคณิตศาสตร์ของนิพจน์ โดยการวางตัวกระทำที่ leaf node และวางเครื่องหมายไว้ที่ root node
== การสร้าง Expression Tree ==
จะมีการนำ Postfix Expression มาใช้ในการทำ Expression tree
1. เริ่มจากการอ่านนิพจน์ทางคณิตศาสตร์ (Expression) ทีละตัว
2. ถ้าตัวที่ได้เป็น Operand (ตัวถูกดำเนินการ) ให้สร้างโหนดของ tree หนึ่งโหนดแล้ว push ข้อมูลลงบน Stack
3. หากตัวที่อ่านได้เป็น Operator (ตัวดำเนินการ) ให้ทำการ pop ข้อมูลออกจาก Stack 2 ครั้ง เนื่องจาก Operator ใช้เป็น Binary Operator (Operator 1 ตัว ต้องการ Operand 2 ตัว) ซึ่งจะได้ trees T1 และ T2 (T1 นำออกก่อน) แล้วให้นำมาสร้างเป็น tree ใหม่ที่มีราก (root) เป็นตัว operator และมี left และ right children เป็น T2 และ T1 ตามลำดับ จากนั้นให้ใส่ tree ใหม่นี้กลับลง stack
=== ตัวอย่างของ Expression Tree ===

=== Code ของ Expression Tree ===
class ExpressionTree:
def __init__(self , value):
self.value = value
self.left = None
self.right = None
def isOperator(char):
if (char == '+' or char == '-' or char == '*'
or char == '/' or char == '^'):
return True
else:
return False
def buildTree(postfix):
stack = []
for char in postfix :
if not isOperator(char):
t = ExpressionTree(char)
stack.append(t)
else:
t = ExpressionTree(char)
t1 = stack.pop
t2 = stack.pop
t.right = t1
t.left = t2
stack.append(t)
t = stack.pop
return t
def inorder(t):
alist = []
if t is not None:
alist.append(t.value)
alist = inorder(t.left) + alist + inorder(t.right)
return alist
== แหล่งอ้างอิง ==
geeksforgeeks Expression Tree ค้นหาเมื่อ 30 มีนาคม 2561
nattee ต้นไม้นิพจน์ ค้นหาเมื่อ 30 มีนาคม 2561
ต้นไม้ทวิภาค
ต้นไม้เซกเมนต์

ต้นไม้เซกเมนต์ หรือ Segment Tree เป็นโครงสร้างข้อมูลชนิดหนึ่งมีลักษณะเป็นต้นไม้ทวิภาค (Binary Tree)  ที่มีจุดเด่นในการเก็บ และ ถามข้อมูลเป็นช่วงมีขนาดคงที่ เมื่อโครงสร้างของข้อมูลถูกสร้างขึ้น โครงสร้างของไฟล์จะไม่สามารถเปลี่ยนแปลงได้ แต่สามารถปรับปรุงค่าของโหนดได้
  โดยรากของ Segment Tree แสดงถึง Array ทั้งหมด A[0 : N - 1] จากนั้นจะแบ่งออกเป็นสองส่วน โดยทางด้านซ้ายจะมีการเก็บข้อมูลในช่วง A[0 : (N-1)/2] และทางด้านชวาจะเก็บข้อมูลในช่วง A[((N-1)/2) + 1 : (N-1)]
=== ต้นไม้เซกเมนต์ มีการดำเนินการ 2 แบบ ===
==== Update ====
เพื่อปรับปรุงองค์ประกอบของ Array และ สะท้อนถึงการเปลี่ยนแปลงที่สอดคล้องกันในโครงสร้างของ Segment Tree สามารถดำเนินการได้โดย ค้นหาใบที่มีองค์ประกอบเพื่อการอัพเดต ซึ่งสามารถทำได้โดยไปที่ด้านซ้ายหรือด้านขวาของNode ตามช่วงเวลาที่มีองค์ประกอบ เมื่อพบใบแล้วจะมีการปรับปรุงเปลี่ยนแปลงที่สอดคล้องกันในเส้นทางจากใบนั้นไปยังราก ซึ่งผลรวมของธาตุจากดัชนี l ถึง r โดยที่ 0  ค่าที่ส่งคืนในโหนด
2.ถ้าช่วงโหนดอยู่นอก qs และ qe => infinite
3.นอกเหนือที่กล่าวมา => (ลูกซ้ายของโหนด, qs, qe), (ลูกขวาของโหนด, qs, qe)
ตัวอย่างของ Segment Tree (หาผลบวกของช่วงที่กำหนด)

ช่วงผลรวมที่กำหนด
1. ถ้าช่วงของโหนดอยู่ภายใน l และ r  => ค่าที่ส่งคืนในโหนด
2.ถ้าช่วงโหนดอยู่นอก l และ r => 0
3.นอกเหนือที่กล่าวมา => (ลูกซ้ายของโหนด, l, r) + (ลูกขวาของโหนด, l, r)
=== ความซับซ้อนของเวลา ===
1. แบบสอบถาม
- เวลาสำหรับการก่อสร้างต้นไม้คือ O (n) มีโหนด 2n-1 ทั้งหมดและค่าของโหนดทุกตัวจะคำนวณเพียงครั้งเดียวในการสร้างโครงสร้าง
- ความซับซ้อนของเวลาในการค้นหาคือ O (log n) เราจะประมวลผลได้มากที่สุด 2 โหนดในทุกระดับและจำนวนของระดับคือ O (log n)
2. Update
- เวลาสำหรับการก่อสร้างต้นไม้คือ O(n) มีโหนด 2n-1 ทั้งหมดและค่าของโหนดทุกตัวจะคำนวณเพียงครั้งเดียวในการสร้างโครงสร้าง
- ความซับซ้อนของเวลาในการค้นหาคือ O(log n) ในการค้นหาผลรวมเราประมวลผลได้มากที่สุดสี่โหนดในทุกระดับและจำนวนของระดับคือ O(log n)
- ความซับซ้อนของเวลาในการอัพเดทก็คือ O(log n) เราจะประมวลผลโหนดหนึ่งที่ทุกระดับและจำนวนของระดับคือ O (log n)
== Code การเพิ่ม ==
def _add(self, start, end, weight, in_start, in_end):
key = (in_start, in_end)
if in_start == in_end:
self.max_value[key] += weight
self.sum_value[key] += weight
self.len_value[key] = 1 if self.sum_value[key] > 0 else 0
return
mid = in_start + int((in_end - in_start) / 2)
if mid >= end:
self._add(start, end, weight, in_start, mid)
elif mid+1 
== Code ค่าmax ==
def _query_max(self, start, end, in_start, in_end):
if start == in_start and end == in_end:
ans = self.max_value[(start, end)]
else:
mid = in_start + int((in_end - in_start) / 2)
if mid >= end:
ans = self._query_max(start, end, in_start, mid)
elif mid+1 
== อ้างอิง ==
leonsim segmenttree ค้นหาเมื่อ 29 เมษายน 2561
geeksforgeeks Segment Tree | Set 1 (Sum of given range)  ค้นหาเมื่อ 29 เมษายน 2561
geeksforgeeks Segment Tree | Set 2 (Range Minimum Query) ค้นหาเมื่อ 29 เมษายน 2561
Akash Sharma Segment Trees ค้นหาเมื่อ30 เมษายน
ต้นไม้ทวิภาค
โครงสร้างข้อมูลกราฟิกคอมพิวเตอร์
มิสเตอร์อินเตอร์เนชันแนลไทยแลนด์ 2017

มิสเตอร์อินเตอร์เนชันแนลไทยแลนด์ 2017 การประกวดรอบตัดสินจัดขึ้นเมื่อวันที่ 24 ธันวาคม พ.ศ. 2560 ณ โรงละคร หิมพานต์ อวตาร SHOW DC, กรุงเทพมหานคร โดยผู้ชนะการประกวดในครั้งนี้ คือ ภารัณ ปิติจิรากุล (พงศ์สรรค์ สุวรรณลิวงศ์) ซึ่งจะได้เป็นตัวแทนประเทศไทยเข้าร่วมประกวดมิสเตอร์อินเตอร์เนชันแนล 2018
== ผลการประกวด ==
=== ลำดับ ===
§ ได้รับการโหวตเข้ามาอยู่ใน 12 คนสุดท้าย
=== ลำดับการประกาศชื่อ ===
{|
|valign="top" width=10%|
12 คนสุดท้าย
MIT18 – อภิวัฒน์ บุพพันเหรัญ
MIT19 – ปิยบุตร ปานบุญ
MIT05 – ภารัณ ปิติจิรากุล (พงศ์สรรค์ สุวรรณลิวงศ์)
MIT10 – ณวรรธ โออินทร์
MIT13 – พิชัยรัตน์ พิมลมาส
MIT20 – ดุลยาธาร พยุงสุวรรณ
MIT07 – อดิศร สุวรรณ
MIT12 – เสกสรร ยามพิทักษ์
MIT16 – ภาณุ คุยบึงสิม
MIT06 – กรกวี นุ่มน้อย
MIT17 – ศักดิ์อรุณ คุนทา
MIT01 – ศิริชัย มีลาภ
|valign="top" width=10%|
6 คนสุดท้าย
MIT20 – ดุลยาธาร พยุงสุวรรณ
MIT16 – ภาณุ คุยบึงสิม
MIT06 – กรกวี นุ่มน้อย
MIT05 – ภารัณ ปิติจิรากุล (พงศ์สรรค์ สุวรรณลิวงศ์)
MIT01 – ศิริชัย มีลาภ
MIT19 – ปิยบุตร ปานบุญ
|}
== รางวัลพิเศษ ==
== ผู้เข้าประกวด ==
ผู้ที่ผ่านรอบคัดเลือกเข้าสู่รอบ 20 ผู้เข้าประกวดที่ได้รับการยืนยัน:
== อ้างอิง ==
== แหล่งข้อมูลอื่น ==
การประกวดความงามชายในประเทศไทย
2017
ประเทศไทยในปี พ.ศ. 2560
อาการกลัวผี

อาการกลัวผี (phasmophobia) หมายถึง ความกลัวผีอย่างรุนแรงและไม่สมเหตุสมผล ซึ่งเป็นความเชื่องมงายชนิดหนึ่ง
== อ้างอิง ==
โรคกลัว
ความเชื่องมงาย
ผี
จังหวัดซัมบวงกาเดลซูร์

จังหวัดซัมบวงกาเดลซูร์ (Chavacano: Provincia de Zamboanga del Sur; เซบัวโน: Probinsya sa Zamboanga del Sur; Subanen: S'helatan Sembwangan/Sembwangan dapit Shelatan; Iranun: Pagabagatan a Diambangan) เป็นจังหวัดในเขตตังไวนางซัมบวงกา เกาะมินดาเนา ประเทศฟิลิปปินส์ เมืองศูนย์กลางคือปากาดีอัน ส่วนซัมบวงกาซิตีถือเป็นเมืองอิสระที่ปกครองแยกจากตัวจังหวัด
ซัมบวงกาเดลซูร์มีอาณาเขตติดต่อกับจังหวัดฮีลากังซัมบวงกาทางทิศเหนือ ติดกับจังหวัดซัมบวงกาซีบูไกทางทิศตะวันตก ติดกับจังหวัดคันลูรังมีซามิสทางทิศตะวันออกเฉียงเหนือ ติดกับจังหวัดฮีลากังลาเนาทางทิศตะวันออก และติดกับอ่าวโมโรทางทิศใต้
== ภูมิศาสตร์ ==
จังหวัดซัมบวงกาเดลซูร์มีพื้นที่ 4,499.46 ตารางกิโลเมตร ครอบคลุมพื้นที่ทางใต้ของคาบสมุทรซัมบวงกา ซึ่งตั้งอยู่ทางตะวันตกของมินดาเนา ตัวจังหวัดตั้งอยู่ที่ลองจิจูด 122° 30"" และละติจูด 7° 15"" เหนือ ถ้านับรวมพื้นที่ซัมบวงกาซิตี ซึ่งเป็นเมืองอิสระเข้าไปด้วยแล้ว ตังจังหวัดจะมีพื้นที่ 5,914.16 ตารางกิโลเมตร
=== ภูมิอากาศ ===
== อ้างอิง ==
== แหล่งข้อมูลอื่น ==
เว็บไซต์อย่างเป็นทางการของจังหวัดซัมบวงกาเดลซูร์
Daily Zamboanga Times 
จังหวัดซัมบวงกาเดลซูร์
เขตตังไวนางซัมบวงกา
ต