wannaphong/clean_thaiwikipedia huggingface dataset:
# อาเล็คส์ มันนิงเงอร์
อเล็คซันเดอร์ มันนิงเงอร์ (เกิดวันที่ 4 มิถุนายน ค.ศ. 1977) เป็นอดีตนักฟุตบอลชาวออสเตรียซึ่งลงเล่นในตำแหน่งผู้รักษาประตู เขาเคยลงเล่นให้กับทีมชาติออสเตรียทั้งหมด 33 นัด รวมถึงการแข่งขันในฟุตบอลชิงแชมป์แห่งชาติยุโรป 2008 และเคยลงเล่นให้กับหลายสโมสรในอิตาลี เยอรมนี ออสเตรีย และอังกฤษ

 สถิติอาชีพ 
 สโมสร 

สโมสรฤดูกาลลีกถ้วยลีกคัพอื่น ๆทั้งหมดระดับลงเล่นประตูลงเล่นประตูลงเล่นประตูลงเล่นประตูลงเล่นประตูเอสเฟาซัลซ์บวร์ก1995–96ออสเตรียนบุนเดิสลีกา1000—0010Vorwärts Steyr 1995–96ออสเตรียนบุนเดิสลีกา5000—0050Grazer AK1996–97ออสเตรียนบุนเดิสลีกา23000—00230อาร์เซนอล1997–98พรีเมียร์ลีก705040001601998–99พรีเมียร์ลีก602020001001999–2000พรีเมียร์ลีก1501010702402000–01พรีเมียร์ลีก110100020140ทั้งหมด390907090640ฟีออเรนตีนา (ยืมตัว)2001–02เซเรียอา24000—50290อัสปัญญ็อล2002–03ลาลิกา0000—0000โตรีโน2002–03เซเรียอา3000—0030โบโลญญา2003–04เซเรียอา0000—0000Siena (ยืมตัว)2004–05เซเรียอา18000—00180เรดบูลล์ซัลซ์บวร์ก2005–06ออสเตรียนบุนเดิสลีกา16000—00160Siena2006–07เซเรียอา38000—003802007–08เซเรียอา26000—00260ทั้งหมด64000—00640เรดบูลล์ซัลซ์บวร์ก2008–09ออสเตรียนบุนเดิสลีกา0000—0000อูดีเนเซ2008–09เซเรียอา0000—0000ยูเวนตุส2008–09เซเรียอา16000—502102009–10เซเรียอา11010—201402010–11เซเรียอา0000—50502011–12เซเรียอา0000—0000ทั้งหมด27010—120400เอาก์สบวร์ค2012–13บุนเดิสลีกา12010—001302013–14บุนเดิสลีกา13010—001402014–15บุนเดิสลีกา9000—00902015–16บุนเดิสลีกา2000—0020ทั้งหมด36020—00380ลิเวอร์พูล2016–17พรีเมียร์ลีก0000000000ทั้งหมด2560120702603010

 ทีมชาติ 

 ทีมชาติออสเตรียปีลงเล่นประตู199930200020200130200260200300200440200500200610200760200870200910ทั้งหมด330

 เกียรติประวัติ 
อาร์เซนอล
 พรีเมียร์ลีก: 1997–98
 เอฟเอคัพ: 1998
 เอฟเอคอมมิวนิตีชีลด์: 1998, 1999

ยูเวนตุส
 เซเรียอา: 2011–12

บุคคล
 ผู้เล่นยอดเยี่ยมประจำเดือนของพรีเมียร์ลีก: มีนาคม 1998
# หมู่เกาะฮาวาย
หมู่เกาะฮาวายเป็นกลุ่มเกาะที่ประกอบด้วย 8 เกาะใหญ่, อะทอลล์, เกาะเล็ก ๆ และภูเขาใต้ทะเลในมหาสมุทรแปซิฟิกเหนือ ทอดตัวยาวเป็นระยะทาง 2,400 กิโลเมตรจากเกาะฮาวายทางตอนใต้ไปถึงอะทอลล์เคอร์ทางตอนเหนือ ในอดีตชาวยุโรปและชาวอเมริกันเรียกกลุ่มเกาะนี้ว่า"หมู่เกาะแซนวิช"อันเป็นชื่อที่เจมส์ คุกตั้งให้เพื่อเป็นเกียรติแก่จอห์น มอนทากิว เอิร์ลที่ 4 แห่งแซนด์วิช ปัจจุบันเรียกชื่อว่าหมู่เกาะฮาวายตามชื่อของเกาะที่ใหญ่ที่สุดในกลุ่มเกาะนี้

การปกครองแบบราชาธิปไตยฮาวายถูกล้มล้างใน ค.ศ. 1893 ทำให้เกาะอยู่ภายใต้การปกครองแบบสาธารณรัฐและถูกผนวกเข้าเป็นส่วนหนึ่งของสหรัฐใน ค.ศ. 1898 ปัจจุบันรัฐฮาวายและพื้นที่ของกลุ่มเกาะเกือบทั้งหมดเป็นรัฐของสหรัฐ (รวมถึงหมู่เกาะฮาวายตะวันตกเฉียงเหนือซึ่งเป็นเกาะที่ไม่มีคนอยู่อาศัย) ยกเว้นมิดเวย์อะทอลล์ซึ่งเป็นหมู่เกาะและดินแดนห่างไกลที่ไม่มีหน่วยงานปกครองภายในสหรัฐ

หมู่เกาะฮาวายเป็นยอดของเทือกเขาใต้ทะเลที่เรียกว่าเทือกเขาใต้ทะเลฮาวาย–เอมเพอเรอะซึ่งเกิดจากกิจกรรมทางภูเขาไฟและจุดร้อน เกาะนี้อยู่ห่างจากชายฝั่งทวีปที่ใกล้ที่สุด 3,000 กิโลเมตรMacdonald, Abbott, and Peterson, 1984

 เกาะและปะการัง 
หัวข้อเรื่องการตั้งถิ่นฐานครั้งแรกบนหมู่เกาะนี้ยังเป็นที่ถกเถียง แต่มีหลักฐานทางโบราณคดีบ่งบอกถึงการตั้งถิ่นฐานในช่วง ค.ศ. 124

เจมส์ คุก พบเกาะนี้ครั้งแรกในวันที่ 18 มกราคม ค.ศ. 1778 พร้อมตั้งชื่อให้ว่า "หมู่เกาะแซนวิช" เพื่อเป็นเกียรติแก่จอห์น มอนทากิว เอิร์ลที่ 4 แห่งแซนด์วิชตำแหน่งที่ปรึกษาใหญ่รัฐบาลด้านกิจการราชนาวีหนึ่งในผู้สนับสนุนเขา ชื่อนี้ถูกใช้ต่อจนถึงทศวรรษที่ 1840 เมื่อชื่อท้องถิ่นอย่าง "ฮาวาย" เริ่มมีความสำคัญขึ้น

หมูเกาะฮาวายมีพื้นที่รวมประมาณ 16,636.5 ตารางกิโลเมตร (ไม่รวมมิดเวย์อะทอลล์) เกาะและเกาะเล็กเหล่านี้รวมกันเป็นรัฐฮาวาย รัฐที่ 50 ของสหรัฐ

 เกาะหลัก 
 เกาะ ชื่อเล่น ขนาด (ตร.กม.) ประชากร(ค.ศ. 2010) ความหนาแน่น (คน : ตร.กม.) จุดสูงสุด ความสูง อายุ (ล้านปีก่อน)Blay, Chuck, and Siemers, Robert. Kauai‘’s Geologic History: A Simplified Guide. Kaua‘i: TEOK Investigations, 2004. . (Cited in) ที่ตั้ง ฮาวาย The Big Island 1 10,432.5 185,079 4 17.7407 ภูเขาไฟเมานาเคอา 1 0.4  เมาวี The Valley Isle 2 1,883.4 144,444 2 76.692 ภูเขาไฟฮาเลอาคาลา 2 1.3–0.8  โอวาฮู The Gathering Place 3 1,545.4 953,207 1 616.78 คาอาลา 5 3.7–2.6  คาไว The Garden Isle 4 1,430.5 66,921 3 46.783 คาไวคีนี 3 5.1  โมโลไก The Friendly Isle 5 673.4 7,345 5 10.9074 คามาคุ 4 1.9–1.8  ลาไน The Pineapple Isle 6 363.9 3,135 6 8.615 ลาไนฮาเล่ 6 1.3  นีเฮา The Forbidden Isle 7 180.0 170 7 0.944 พานิเอา 8 4.9  คาโฮโอลาวี The Target Isle 8 115.5 0 8 0 ปูโมโลอานุย 7 1.0 
เกาะหลัก 8 เกาะของรัฐฮาวาย (บางเรียกเกาะฮาวายวินด์เวิร์ด) อยู่ในตารางนี้ทั้งหมด เกาะทั้งหมดนอกจากเกาะคาโฮโอลาวีล้วนมีคนอาศัยอยู่
# การเรียงลำดับแบบลูกปัด
การจัดเรียงแบบลูกปัด หรือที่เรียกอีกชื่อว่า การจัดเรียงแบบแรงโน้มถ่วง เป็นขั้นตอนวิธีการเรียงลำดับแบบธรรมชาติ พัฒนาโดย Joshua J. Arulanandham, Cristian S. Calude และ Michael J. Dinneen ในปี ค.ศ.2002
thumb|ใส่ลูกปัดตามข้อมูลที่มี
thumb|ทำการจัดเรียง

 ลักษณะการทำงาน 
การจัดเรียงแบบลูกปัดเริ่มแรกโดยให้จำนวนเสาที่ใส่ลูกปัดเท่ากับค่าของข้อมูลตัวนั้นๆ โดยจำนวนแถวแนวตั้งเท่ากับจำนวนทั้งหมดของข้อมูลที่ต้องการจะเรียงลำดับ เมื่อใส่ลูกปัดตามข้อมูลที่มีอยู่จนครบแล้ว ลูกที่ลอยอยู่โดยไม่มีอะไรรองรับจะตกลงโดยแรงโน้มถ่วง

 ความซับซ้อนของการทำงาน 
O(1) : ลูกปัดทั้งหมดเคลื่อนที่พร้อมกันในหน่วยเวลาเดียวกันเช่นเดียวกับตัวอย่างทางกายภาพที่เรียบง่ายข้างต้น นี่คือความซับซ้อนที่เป็นนามธรรมและไม่สามารถนำไปปฏิบัติได้

O(√n) : ในรูปแบบทางกายภาพที่สมจริงที่ใช้แรงโน้มถ่วงเวลาที่ใช้ในการปล่อยให้ลูกปัดตกลงมาเป็นสัดส่วนกับรากที่สองของความสูงสูงสุดซึ่งเป็นสัดส่วนกับ n (จำนวนข้อมูลทั้งหมด)

O(n) : ลูกปัดจะถูกย้ายไปทีละแถว นี่คือกรณีที่ใช้ในโซลูชั่นฮาร์ดแวร์อนาล็อกและดิจิทัล

O(S) : โดย S คือผลรวมของจำนวนเต็มในชุดข้อมูล ลูกปัดแต่ละลูกจะถูกย้ายทีละลูก นี่เป็นกรณี่จัดเรียงแบบลูกปัดโดยไม่มีกลไกเพื่อช่วยในการหาช่องว่างด้านล่างของลูกปัด

 ตัวอย่างการเขียนโปรแกรม 
ตัวอย่างการเขียนโปรแกรมด้วยภาษาไพทอน (Python) โปรแกรมนี้ใช้ได้เฉพาะกับชุดข้อมูลที่มีสมาชิกภายในเป็น จำนวนเต็มบวก หรือ มากกว่า 0def Gravity(obj):
    n = len(obj)
    if all([type(x) == int and x >= 0 for x in obj]):
        reference = [range(x) for x in obj]
    else:
        raise ValueError("All elements must be positive integers")

    intermediate = []
    index = 0
    previous = n

    while previous:
        intermediate.append(range(previous))
        index += 1
        previous = sum([1 for x in reference if len(x) > index])

    index = 0
    previous = len(intermediate)] # จำนวนที่มากที่สุด
    out = [0 for x in range(n)]
    out[n-1] = previous
    
# แปลงเป็นชุดข้อมูลแบบตัวเลข
    for i in range(0,n-1):       
        previous = sum([1 for x in intermediate if len(x) > n-i-1])
        out[i] = previous

    return out  

obj = [2, 4, 1, 3, 3]
print(Gravity(obj)) # [1, 2, 3, 3, 4]
# การเรียงลำดับสลีป
การเรียงลำดับแบบสลีป  เป็นอัลกอริทึมการเรียงลำดับตามเวลา ทำงานโดยเชื่อมโยงตัวนับเวลากับแต่ละไอเท็มที่ต้องการจะเรียงลำดับ เคาน์เตอร์แต่ละตัวจะตั้งค่าเริ่มต้นด้วยค่าขององค์ประกอบที่จะสั่ง เคาน์เตอร์จะลดลง แล้วที่ความเร็วเท่ากัน เมื่อตัวนับที่กำหนดสิ้นสุดลงองค์ประกอบที่เชื่อมโยงจะถูกเพิ่มลงในตอนท้ายของรายการ เนื่องจากตัวนับหยุดขึ้นอยู่กับขนาดขององค์ประกอบรายการจะเรียงลำดับเมื่อเคาน์เตอร์ทั้งหมดถูกหยุดลง สามารถใช้งานได้โดยใช้ตัวจับเวลาระบบปฏิบัติการเช่นโดยการแยกแต่ละกระบวนการออกเป็นส่วน ๆ หรือใช้เวคเตอร์ตัวนับ

 ประสิทธิภาพ 
Sleep sort จะก่อให้เกิดกระบวนการหนึ่งสำหรับแต่ละอาร์กิวเมนต์ แต่ละกระบวนการรอประมาณ n วินาทีจากนั้นพิมพ์ n ออกมา ซึ่งหมายความว่าใช้เวลา 1 วินาทีในการพิมพ์ "1", 2 วินาทีเพื่อพิมพ์ "2", 100 วินาทีเพื่อพิมพ์ "100" ซึ่งหมายความว่าส่วนใหญ่ตัวเลขจะถูกพิมพ์ออกมาตามลำดับขนาดของมันดังนั้นจึงเป็นการ "เรียงลำดับ" อาร์กิวเมนต์

ความซับซ้อนของอัลกอริธึมนี้ในโลกที่สมบูรณ์แบบคือ O(max (args)) เนื่องจากจะใช้เวลาสูงสุด (args) วินาทีในการพิมพ์ arg ที่ขนาดใหญ่ที่สุด ในความเป็นจริงความซับซ้อนคือ O(n ^ 2 + max (args)) เนื่องจากการรักษากระบวนการพื้นหลังหลายระบบขึ้นอยู่กับระบบปฏิบัติการเพื่อจัดการการสลับบริบทและจัดลำดับความสำคัญของกระบวนการดังนั้นอัลกอริทึมจึงใช้การจัดเรียงที่แท้จริงของเคอร์เนล

นอกจากนี้ยังไม่มีการค้ำประกันว่าผลลัพธ์ของการจัดเรียงเป็นจริงถูกต้องซึ่งเป็นคุณลักษณะที่อัลกอริทึมการเรียงลำดับอื่น ๆ ส่วนใหญ่ไม่มี

thumb|220x220px|
+ClassSorting AlgorithmData StructureArrayWorst-case performanceO(n²+max(input))Best-case performanceO(max(input))

 Coding 

 Python 
from time import sleep

from threading import Timer 

def sleepsort(values):

    sleepsort.result = []

    def add1(x):

s       leepsort.result.append(x)

    mx = values[0]

    for v in values:

        if mx < v:

            mx = v

        Timer(v, add1, [v]).start

    sleep(mx+1)

    return sleepsort.result

x = [5, 1, 3, 7]

print sleepsort(x)

Result = [1, 3, 5, 7]
# การเรียงลำดับแบบรังนกพิราบ
การเรียงลำดับแบบรังนกพิราบ  เป็นขั้นตอนวิธีการเรียงลำดับที่เหมาะกับการเรียงลำดับรายการส่วนย่อยที่จำนวนส่วนย่อย (n) และความยาวของพิสัยค่าหลักที่เป็นไปได้ (N) ประมาณเท่า ๆ กัน ต้องใช้ O(n + N) ครั้ง การเรียงลำดับแบบนี้คล้ายกับการเรียงลำดับนับ แต่ต่างกันที่การเรียงลำดับนี้ "ย้ายรายการสองครั้ง ครั้งหนึ่งเข้าแถวลำดับที่ฝากข้อมูลแล้วอีกครั้งย้ายกับจุดหมายสุดท้าย"

 การทำงานของการเรียงลำดับ 
กำหนดให้เป็น array ของค่าที่จะเรียงลำดับ โดยกำหนด array ที่จะช่วยในการเรียงลำดับ array มีชื่อว่า holes ซึ่งเป็น array ว่างเปล่าที่รอรับจำนวนสมาชิกเป็นช่วงของ array เดิม
ที่ array ที่ต้องการจัดเรียงเราใส่ค่าแต่ละ array ลงใน holes ที่ตรงกับตำแหน่งของ array เดิม
ทำซ้ำใน holes โดยเขียนทับ array เดิมตามองค์ประกอบของ holes ว่าอยู่ตำแหน่งไหนบ้าง

 การวิเคราะห์ความซับซ้อนของขั้นตอนวิธี 
ในการนับเพื่อเพิ่มค่าของหลุม (holes) จะทำเท่ากับสมาชิกของอเรย์ หากให้สมาชิกของอเรย์เท่ากับ n จะได้ O(n)
ในการนับเพื่อที่จะเขียนทับไปยังอเรย์เดิมจะทำเท่ากับจำนวนของสมาชิกใน size ซึ่งมากจาก ค่าสูงสุดของอเรย์-ค่าต่ำสุดของอเรย์ +1 กำหนดให้เป็น m และเงื่อนไงของการที่จะเขียนทับลงไปยังอเรย์เดิมคืออเรย์ที่ holes ใด ๆ ต้องมากกว่า 0 กำหนดให้เป็น x ดังนั้นสรุปได้ว่าความซับซ้อนจะมีค่าเป็น O(mx)
ดังนั้นเราสามารถสรุปได้ว่าขั้นตอนความซับซ้อนของการเรียงลำดับนี้คือ O(n+mx) ซึ่ง n=x เนื่องจากจากเงื่อนไงของ x มาจากจำนวนของ n ดังนั้นความซับซ้อนเท่ากับ O(n+mn) เมื่อให้ N = mn จะได้ความซับซ้อนของขั้นตอนวิธี O(n+N)
ในกรณีที่ของมูลมีค่าหเมือนกันจะส่งผลให้ 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] < array[i-1]:
         return False
   return True

class test_sorting(unittest.TestCase):
   def test_ipigeonhole_sort(self):
      max_size = 1500
      for size in range(1, max_size + 1):
         array = [random.randrange(20) for num in range(size)]
         sorted = Pigeonhole_sort(array)
         self.assertTrue(is_sorted(sorted))
# ต้นไม้ค้นหาไตรภาค
ในวิทยาการคอมพิวเตอร์ ต้นไม้ค้นหาไตรภาค  เป็นทรัยประเภทหนึ่งซึ่งมีการจัดเรียงบัพแบบที่คล้ายกับต้นไม้ค้นหาทวิภาค แต่มีบัพลูกสามบัพแทนที่จะมีสองบัพ ต้นไม้ค้นหาไตรภาคสามารถใช้เป็นโครงสร้างแผนที่สัมพันธ์ที่มีความสามารถค้นหาสายอักขระแนวเดิม อย่างไรก็ดี ต้นไม้ค้นหาไตรนามใช้พื้นที่มีประสิทธิภาพกว่าเมื่อเทียบกับต้นไม้เติมหน้ามาตรฐานแต่มีความเร็วช้ากว่า การใช้ต้นไม้ค้นหาไตรภาคทั่วไป เช่น การตรวจสอบตัวสะกดและการเติมคำอัตโนมัติ

 การดำเนินการของต้นไม้ค้นหาไตรภาค 
ตัวชี้ซ้ายชี้ไปที่โหนดที่มีค่าต่ำกว่าค่าในโหนดปัจจุบัน (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 ' <end>'),
                        ('' 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.left = self.add(node.left,string)
    elif 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.left, string)
    elif 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)
# สโมสรฟุตบอลปานาซีไนโกส
สโมสรฟุตบอลปานาซีไนโกส  สโมสรฟุตบอลอาชีพของประเทศกรีซ มีที่ตั้งอยู่ใน กรุงเอเธนส์ ทุกวันนี้พวกเขาเป็นส่วนหนึ่งของ ปานาซีไนโกส เอโอ สโมสรกีฬาแบบครบวงจรที่โด่งดังที่สุดของกรีซและพวกเขาเป็นสโมสรฟุตบอลที่เก่าแก่ที่สุดของกรีซที่ยังทำกิจกรรมอยู่

สโมสรปานาซีไนโกสก่อตั้งเมื่อ ค.ศ. 1908 โดย จอร์จอส คาลาฟาติส และเพื่อนนักกีฬากว่า 40 คนโดยแยกออกมาจากสโมสรกีฬาแห่งหนึ่งภายหลังจากทางสโมสรกีฬาแห่งนั้นตัดสินใจยุติการทำทีมฟุตบอลโดยปานาซีไนโกสในยุคแรกถูกก่อตั้งขึ้นเพื่อฝึกสอนกีฬาเท่านั้น

ต่อมาทางสโมสรได้เข้าร่วม ซูเปอร์ลีกกรีซ และกลายเป็นหนึ่งในสโมสรที่ประสบความสำเร็จมากที่สุดในวงการฟุตบอลกรีซและเป็นหนึ่งในสามสโมสรที่ไม่เคยตกชั้นจากลีกสูงสุดร่วมกับ เออีเค เอเธนส์ และ โอลิมเปียกอส

สโมสรฟุตบอลปานาซีไนโกสเป็นสโมสรฟุตบอลของกรีซที่ประสบความสำเร็จมากที่สุดในการแข่งขันฟุตบอลยุโรปเป็นทีมเดียวของกรีซที่ได้เข้าสู่รอบชิงชนะเลิศของฟุตบอล ยูโรเปียน คัพ (ยูฟ่าแชมเปียนส์ลีก ในปัจจุบัน) ปี ค.ศ. 1971 ภายใต้การคุมทีมของ แฟแร็นตส์ ปุชกาช ตำนานยอดกองหน้าของ ทีมชาติฮังการี และ เรอัลมาดริด แต่แพ้ให้กับ อายักซ์ อัมสเตอร์ดัม เข้าถึงรอบรองชนะเลิศถึง 2 ครั้งคือปี ค.ศ. 1985 และ ค.ศ. 1996 และเป็นทีมเดียวของกรีซที่ได้ลงแข่ง ฟุตบอลชิงแชมป์สโมสรยุโรปและอเมริกาใต้ (1971) นอกจากนี้พวกเขายังเข้าถึงรอบก่อนรองชนะเลิศของแชมเปียนส์ลีกถึง 2 ครั้งใน ค.ศ. 1992 และ ค.ศ. 2002 และรอบก่อนรองชนะเลิศของ ยูฟ่า คัพ อีก 2 ครั้งใน ค.ศ. 1988 และ ค.ศ. 2003 พวกเขายังคว้าแชมป์ บอลข่าน คัพ ใน ค.ศ. 1977 ปานาซีไนโกสเป็นสมาชิกของ สมาคมสโมสรฟุตบอลยุโรป

 
ป
หมวดหมู่:สโมสรกีฬาที่ก่อตั้งในปี พ.ศ. 2451
# ซอฟต์ฮีป
ในวิทยาการคอมพิวเตอร์ โดย 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)และ เพื่อคำนวณหาค่าที่ต่ำที่สุดของแผนภูมิต้นไม้อีกด้วย
# ขั้นตอนวิธีบอยเออร์–มัวร์–ฮอร์สพูล
การจับคู่สตริงแบบฮัวส์ปัวร์ 
การจับคู่สตริงแบบฮัวส์ปัวร์ หรือ 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 <= len_text - len_pattern:
		skip = 0
		text_part = text[index:index + len_pattern][::-1]
		
		for index2, current_char in enumerate(text_part):
			if pattern[len_pattern - index2 - 1] != current_char:
				skip = table[ord(current_char)]
				break
		else:
			results.append(index)
			skip = 1
		index += skip
	return results

 แหล่งอ้างอิง 
kagan94  Boyer Moore Horspool algorithm ค้นหาเมื่อ 25 มีนาคม 2561

Nelson Rush BOYER-MOORE-HORSPOOL STRING SEARCHING  ค้นหาเมื่อ 28 มีนาคม 2561

mtu Space and Time Tradeoffs ค้นหาเมื่อ 28 มีนาคม 2561
# ต้นไม้นิพจน์ทวิภาค
ต้นไม้พิจน์ทวิภาค  เป็นต้นไม้แบบไบนารี (Binary Tree) ที่มีการสร้างขึ้นจากตัวกระทำ (operand) และ เครื่องหมาย (operators) ทางคณิตศาสตร์ของนิพจน์ โดยการวางตัวกระทำที่ leaf node และวางเครื่องหมายไว้ที่ root node

 การสร้าง Expression Tree 
จะมีการนำ Postfix Expression มาใช้ในการทำ Expression tree 

เริ่มจากการอ่านนิพจน์ทางคณิตศาสตร์ (Expression) ทีละตัว
ถ้าตัวที่ได้เป็น Operand (ตัวถูกดำเนินการ) ให้สร้างโหนดของ tree หนึ่งโหนดแล้ว push ข้อมูลลงบน Stack
หากตัวที่อ่านได้เป็น 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 
center|thumb|เป็นตัวอย่างต้นไม้นิพจน์ของ (a+(b*c)) + ((d+e)*f)

 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
# อินเตอร์สเตต 2
อินเตอร์สเตต 2  เป็นทางหลวงอินเตอร์สเตตแนวตะวันออก–ตะวันตก มีเส้นทางผ่านภูมิภาคหุบเขารีโอแกรนด์ของเท็กซัสใต้ เริ่มต้นที่ทางแยกบนทางหลวงสหรัฐหมายเลข 83 ในเพนิทัส (Penitas) มุ่งหน้าไปทางทิศตะวันออกก่อนที่จะสิ้นสุดบนอินเตอร์สเตต 69 อี, อินเตอร์สเตต 77, และทางหลวงสหรัฐหมายเลข 83 ในนครฮาร์ลินจิน ระยะทางทั้งหมดของอินเตอร์สเตต 2 มีการใช้เส้นทางร่วมกันกับทางหลวงสหรัฐหมายเลข 83 และมีเส้นทางขนานไปกับทางหลวงเม็กซิโกหมายเลข 2 ซึ่งเป็นเส้นทางหลักแนวตะวันออก–ตะวันตกในฝั่งประเทศเม็กซิโกขนานไปกับพรมแดนประเทศเม็กซิโก–สหรัฐซึ่งเป็นแนวแม่น้ำรีโอแกรนด์

 ภาพ
# อาการกลัวผี
อาการกลัวผี  หมายถึง ความกลัวผีอย่างรุนแรงและไม่สมเหตุสมผล ซึ่งเป็นความเชื่องมงายชนิดหนึ่ง
# การยกบรรทัดและยกคำ
การแบ่งบรรทัด หรือการยกคำ  เป็นกระบวนการแบ่งส่วนหนึ่งของข้อความเป็นบรรทัด ๆ โดยที่พออยู่ในความกว้างที่มีอยู่ของหน้า หน้าต่างหรือพื้นที่แสดงผลอื่น ในการแสดงผลข้อความ การยกบรรทัด (line wrap) เป็นคุณลักษณะการต่อเนื่องขึ้นบรรทัดใหม่เมื่อบรรทัดเต็ม เช่น แต่ละบรรทัดพออยู่ในหน้าต่างที่ชมได้ ทำให้สามารถอ่านข้อความจากบนลงล่างโดยไม่ต้องมีการเลื่อนในแนวนอน การยกคำเป็นคุณลักษณะเพิ่มเติมของโปรแกรมแก้ไขข้อความ โปรแกรมประมวลคำและเว็บเบราว์เซอร์ส่วนใหญ่ซึ่งแบ่งบรรทัดระหว่างคำแทนภายในคำถ้าเป็นไปได้
# อุษมาน ฏอฮา
อุษมาน อิบน์ อับดุฮ์ อิบน์ ฮุซัยน์ อิบน์ ฏอฮา อัลคุรดี (หรือ อุษมาน ฏอฮา,) เป็นนักวาดลายวิจิตรภาษาอาหรับชาวซีเรียที่โด่งดังจากมุศฮัฟอัลมะดีนะฮ์โดยโรงพิมพ์อัลกุรอานของกษัตริย์ฟาฮัดGhawi, Ahmad. "Uthman Taha ", AlRiyadh newspaper, November 23, 2006.

เขาเกิดใน ค.ศ. 1934 ในย่านชนบทของอะเลปโป, ประเทศซีเรีย ได้รับปริญญาสาขาชะรีอะฮ์จากมหาวิทยาลัยดามัสกัส และได้เรียนรู้ภาษาอาหรับ, ศิลปะอิสลาม และวาดภาพ

เขาเขียนมุศฮัฟแรก (การคัดลอกฉบับของอัลกุรอาน) ในปีค.ศ. 1970 ในปีค.ศ. 1988 เขาเดินทางไปประเทศซาอุดีอาระเบียและมอบหมายให้นักเขียนลายมือกับนักเขียนลายวิจิตรอักษรของโรงพิมพ์อัลกุรอานของกษัตริย์ฟาฮัดที่มะดีนะฮ์
# คอเนอร์ มาสเตอร์สัน
คอเนอร์ มาสเตอร์สัน (เกิด 8 กันยายน ค.ศ. 1998) นักฟุตบอลอาชีพชาวไอร์แลนด์ปัจจุบันเล่นให้กับ ลิเวอร์พูล แห่งศึก พรีเมียร์ลีก

มาสเตอร์สันเริ่มต้นเส้นทางการเป็นนักฟุตบอลกับสโมสรฟุตบอลในท้องถิ่นก่อนเซ็นสัญญาย้ายมาร่วมทีมลิเวอร์พูลด้วยค่าตัว 900,000 ปอนด์ในวันคล้ายวันเกิดอายุครบ 16 ปีเมื่อ ค.ศ. 2014