เข้าเว็บ เดี๋ยวนี้มักต้องมีการต้องใส่อักขระยืนยันว่าเราเป็นคน ไม่ใช่ซอฟท์แวร์ 

ปัญหาจะเกิดกับคนสายตาไม่ดี ซึ่งต้องป้อนซ้ำเพราะอ่านผิดบ่อย หรือต้องเคาะผ่าน ให้เครื่องรายงานว่ากรอกผิด เพื่อรอรหัสชุดใหม่ที่ตัวเองอ่านเห็นชัดกว่า

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

วิธีแก้แรกคือการเดา เช่นเดาว่า 1 (หนึ่ง) กับ l (แอลเล็ก) คล้ายกัน จึงตัดออกทั้งคู่

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

อย่ากระนั้นเลย ผู้พัฒนาระบบสามารถทำวิจัยเองอย่างง่าย ๆ ได้เลย

ผมมีข้อเสนอลำดับขั้นตอนกรรมวิธีที่เป็นระบบปรับตัวเองได้โดยใช้แนวคิดแบบผุดบังเกิด (bootstrap) ซึ่งเชื่อว่า สามารถปรับไปใช้กับ font อะไรก็ได้ ภาษาอะไรก็ได้ ที่เข้ากับระบบนั้น ๆ โดยเฉพาะ โดยผมจะสมมติตัวเลขเป็นตัวอย่าง จะได้นึกภาพตามได้ เพราะรายการนี้เขียนโปรแกรมไม่ยาก

เงื่อนไข:

1. ระบบต้องบันทึก รหัสสุ่ม ดังกล่าว และรูปแบบการ login

2. ต้องกรองเอาการ login ของแต่ละัคนที่มาจาก iP เดียวกันออกมาแจกแจงก่อน เพื่อคัดว่า กรณีใด ที่ login แล้วครั้งเดียวผ่าน และกรณีใด ที่ต้อง login หลายครั้ง จึงจะผ่าน โดยตัดการ login ที่เกิน 5 ครั้งต่อวันออก เพราะต้องสงสัยว่าเป็นพวก software ไม่ใช่คน และบันทึกไว้ด้วยว่า login ครั้งไหน ถือว่าสำเร็จ และครั้งไหนถือว่าล้มเหลว

วิธีคำนวณ

1. สร้าง array แจกแจงคู่ลำดับตัวอักขระที่ใช้ทั้งหมด คู่กับ array น้ำหนักถ่วง

      อักขระ                 น้ำหนักถ่วง (เริ่มต้น)

       a                           0

       b                           0

       c                           0

      ...                          ...

2. นำชุดรหัสแต่ละครั้ง มาดูทีละตัว เช่น gk5Fw ก็แตกเป็น {g,k,5,F,w} นำอักขระแต่ละตัวไปถ่วงน้ำหนักในช่อง array น้ำหนักถ่วง โดยให้เพิ่มขึ้นอีก 1 ถ้าเป็นการ login ที่สำเร็จ และลดลงอีก 1 ถ้า login ล้มเหลว

      อักขระ                 น้ำหนักถ่วง (หลังใช้งานไปสักพัก)

       a                           588 (=1+1+1-1+1-1+1+1...)

       b                           325 (=1-1-1+1+1+1+...)

       c                           400 (=1+1+1-1+1-1...)

      ...                          ...

     

3. ในระยะยาว เมื่อเรียง array ของอักขระ เรียงตามน้ำหนักถ่วง จากมากไปน้อย ก็จะได้ลำดับของอักขระที่เรียงจากตัวที่ดูง่าย ไปหาตัวที่ดูยากขึ้นเรื่อย ๆ ตามลำดับ

ลำดับยอดนิยม      อักขระ      น้ำหนักถ่วง (หลังใช้งานไปสักพัก)

 1                        m                           850

 2                        p                            766

 3                        s                            652

...                        ...

74                       ีu                             3

75                       v                             -2

...

4. น้ำหนักถ่วงติดลบ แสดงว่ามีปัญหาร้ายแรง ไม่ควรใช้ให้เสียเวลาอีกต่อไป จึงควรกุดหางแถวให้ยุติลงเมื่อน้ำหนักถ่วงกลายเป็นลบ ทำให้คัดกรองตัวอักขระที่ไม่เป็นมิตรออกไปได้

ตัวอย่างข้างบน ก็ตัดมาใช้งานจริงเพียง 74 รายการ 

5. ในอนาคต เมื่อจะเรียกใช้ตัวสร้างอักขระสุ่ม ก็ให้ความสำคัญกับตัวอักขระที่น้ำหนักถ่วงมาก ให้ออกมาง่ายกว่าตัวอักขระที่น้ำหนักถ่วงน้อย เช่น สมมติว่าเรียงใหม่ตามลำดับ 1..M ใด ๆ เวลาใช้ เมื่อก่อนอาจใช้สูตร i = N * random() ซึ่งจะสุ่มแบบเสมอภาค คราวนี้หันไปใช้สูตร i = M * (random() ยกกำลังสอง) ซึ่งจะทำให้ตัวชี้สุ่ม จะสุ่มแบบลำเอียงต้น ๆ แถวบ่อยขึ้น โดยท้ายแถวก็ยังอาจชี้บ้าง แต่จะไม่บ่อย

              ตัวชี้ตำแหน่งอักขระที่ 1 = 74 * random()^2

              ตัวชี้ตำแหน่งอักขระที่ 2 = 74 * random()^2               ตัวชี้ตำแหน่งอักขระที่ 3 = 74 * random()^2

              ตัวชี้ตำแหน่งอักขระที่ 4 = 74 * random()^2

              หยิบอักขระ 4 ตัวจากตำแหน่งดังกล่าวมาผสมคำ

 

ข้อดีของวิธีนี้ก็คือ ถ้าเราเปลี่ยน design เช่น เปลี่ยนประเภท font ระบบนี้ก็จะยังใช้ได้

เช่น ป้อน ช ช้าง กับ ซ โซ่ ถ้า font เล็กมาก รับรองดูแยกไม่ออก แต่ถ้า font ใหญ่มาก ก็ไม่น่าจะมีปัญหา

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