บริษัท AI มันกาวไปซะเยอะครับ แรกๆ คนก็เชื่ออยู่บ้างตอนนี้มันเห็นแล้วว่า AI มันได้ได้เทพเหมือนที่โม้เอาไว้
แถมชื่อมันก็ชัดเจนอยู่แล้วว่า LLM(Large Language Model) หรือก็คือโมโดลภาษาขนาดใหญ่ มันไม่ใช่โมโดลคิดหรือโมเดลบริหารอะไร
งานถนัดของ LLM คือพวกงานเอกสาร สรุปความ ช่วยเขียนจดหมายหรือรายงาน
สายคนเขียนโปรแกรมนี่ชอบมากเอามาให้มันเขียนอธิบายโค๊ดให้(เขียนแล้วขี้เกียจทำเอกสารประกอบกัน) ตรวจพิมพ์ผิดพิมพ์หล่น
แต่ทว่าคนชอบเอามันไปใช้ในงานแปลกๆ ที่ไม่ใช่งานมันเหมือนกับให้เด็กศิลป์ไปเข้าแล็ปเคมีซึ่งมันไม่ใช่งานของ LLM เลย
ณ ตอนนี้ AI แชทที่เห็นทั่วไปเหมาะกับคนขี้เกียจอ่าน ขี้เกียจเขียน ขี้เกียจอธิบายมาก
ตัวอย่างเช่น โค๊ดที่ผมเขียน
@echo off
setlocal enabledelayedexpansion
rem === Get two numbers as arguments ===
if "%~1"=="" (
set /p a=Enter first number:
) else (
set a=%~1
)
if "%~2"=="" (
set /p b=Enter second number:
) else (
set b=%~2
)
rem === Calculate GCD ===
call :gcd %a% %b%
rem === Simplify ratio ===
set /a ra=%a% / %gcd_result%
set /a rb=%b% / %gcd_result%
:: echo GCD of %a% : %b% is %gcd_result% with ratio is %ra%:%rb%
echo %a%:%b% = %ra%:%rb% (%gcd_result%)
exit /b
rem === Function to calculate GCD ===
:gcd
setlocal
set "x=%~1"
set "y=%~2"
:loop
if %y%==0 (
endlocal & set "gcd_result=%x%" & exit /b
)
set /a temp=%y%
set /a y=%x%%%y%
set /a x=%temp%
goto loopโยนให้ AI มันทำเอกสารอธิบายให้
โค้ดที่คุณให้มาเป็นสคริปต์ **Batch Script** ของ Windows (`.bat` หรือ `.cmd`) ที่มีวัตถุประสงค์หลักคือ **การหาตัวหารร่วมมาก (Greatest Common Divisor - GCD)** ของตัวเลขสองตัวที่ผู้ใช้ป้อนเข้าไป จากนั้นจะนำตัวเลขทั้งสองไป **ลดรูปสัดส่วน (Simplify Ratio)** โดยใช้ค่า GCD ที่คำนวณได้
นี่คือคำอธิบายโค้ดแบบละเอียดทีละส่วนครับ:
---
### คำอธิบายส่วนประกอบหลัก
#### 1. การตั้งค่าเริ่มต้น
```batch
@echo off
setlocal enabledelayedexpansion
```
* `@echo off`: ปิดการแสดงคำสั่งต่างๆ ที่กำลังถูกรันในหน้าต่าง Command Prompt เพื่อให้เอาต์พุตดูสะอาดตาขึ้น
* `setlocal enabledelayedexpansion`: เป็นคำสั่งสำคัญที่เปิดใช้งานฟังก์ชัน **Delayed Expansion** ซึ่งอนุญาตให้เราสามารถอ้างอิงค่าตัวแปรที่ถูกเปลี่ยนแปลง *ภายใน* ลูป (loop) ได้โดยใช้เครื่องหมาย `!variable!` แทน `%variable%` (ซึ่งโค้ดนี้ใช้ในส่วนของฟังก์ชัน `:gcd` แม้ว่าการใช้งานหลักจะไม่ได้ซับซ้อนนัก แต่การเปิดไว้เป็นแนวปฏิบัติที่ดีเมื่อมีการเปลี่ยนแปลงตัวแปรภายในบล็อกคำสั่ง)
#### 2. การรับอินพุต (Get two numbers as arguments)
ส่วนนี้ทำหน้าที่ตรวจสอบว่าผู้ใช้ได้ส่งตัวเลขมาเป็นพารามิเตอร์ (Argument) เมื่อรันสคริปต์หรือไม่
```batch
rem === Get two numbers as arguments ===
if "%~1"=="" (
set /p a=Enter first number:
) else (
set a=%~1
)
if "%~2"=="" (
set /p b=Enter second number:
) else (
set b=%~2
)
```
* `%~1` และ `%~2`: หมายถึงอาร์กิวเมนต์แรกและอาร์กิวเมนต์ที่สองที่ถูกส่งเข้าสคริปต์
* **ถ้า** `%~1` ว่างเปล่า (`""`): สคริปต์จะใช้ `set /p a=Enter first number:` เพื่อ **ขอให้ผู้ใช้ป้อนค่า** สำหรับตัวแปร `a`
* **มิฉะนั้น**: สคริปต์จะกำหนดค่าจากอาร์กิวเมนต์ที่รับมา (`set a=%~1`)
* โค้ดส่วนที่สองทำซ้ำกระบวนการเดียวกันสำหรับตัวแปร `b`
#### 3. การคำนวณ GCD
```batch
rem === Calculate GCD ===
call :gcd %a% %b%
```
* `call :gcd %a% %b%`: สั่งให้สคริปต์ **เรียกใช้ (Call)** ซับรูทีน (Subroutine) ที่มีชื่อว่า `:gcd` โดยส่งค่าตัวเลข `a` และ `b` เข้าไปเป็นพารามิเตอร์
#### 4. การลดรูปสัดส่วน (Simplify Ratio)
หลังจากที่ฟังก์ชัน `:gcd` ทำงานเสร็จสิ้นและเก็บผลลัพธ์ไว้ในตัวแปร `gcd_result` แล้ว ส่วนนี้จะนำมาใช้:
```batch
rem === Simplify ratio ===
set /a ra=%a% / %gcd_result%
set /a rb=%b% / %gcd_result%
:: echo GCD of %a% : %b% is %gcd_result% with ratio is %ra%:%rb%
echo %a%:%b% = %ra%:%rb% (%gcd_result%)
exit /b
```
* `set /a ra=%a% / %gcd_result%`: คำนวณ `a` หารด้วย GCD แล้วเก็บผลลัพธ์ใน `ra` (ตัวเลขที่ถูกลดรูป)
* `set /a rb=%b% / %gcd_result%`: คำนวณ `b` หารด้วย GCD แล้วเก็บผลลัพธ์ใน `rb`
* สุดท้าย สคริปต์จะแสดงผลลัพธ์ออกมาในรูปแบบ: **ตัวเลขเดิม = ตัวเลขที่ลดรูป : ตัวเลขที่ลดรูป (GCD)**
#### 5. ฟังก์ชันการคำนวณ GCD (:gcd)
นี่คือหัวใจของสคริปต์ ซึ่งใช้ **อัลกอริทึมยุคลิด (Euclidean Algorithm)** ในการหา GCD
```batch
rem === Function to calculate GCD ===
:gcd
setlocal
set "x=%~1"
set "y=%~2"
:loop
if %y%==0 (
endlocal & set "gcd_result=%x%" & exit /b
)
set /a temp=%y%
set /a y=%x%%%y%
set /a x=%temp%
goto loop
```
* `:gcd`: เป็นป้ายกำกับ (Label) ที่ทำหน้าที่เป็นจุดเริ่มต้นของฟังก์ชัน
* `setlocal`: แยกตัวแปรที่ถูกสร้างขึ้นภายในฟังก์ชันนี้ออกจากตัวแปรภายนอก เพื่อป้องกันการปนเปื้อน
* `set "x=%~1"` และ `set "y=%~2"`: รับค่าตัวเลขที่ส่งเข้ามาเป็นพารามิเตอร์ (Argument) และเก็บไว้ในตัวแปรภายใน `x` และ `y`
* **:loop**: เป็นลูปหลักของการคำนวณ
* **เงื่อนไขหยุด**: `if %y%==0`: หากตัวหาร (`y`) เป็น 0 แสดงว่าตัวตั้ง (`x`) คือ GCD ดังนั้นจะตั้งค่า `gcd_result=%x%` แล้วออกจากการทำงานของฟังก์ชัน (`exit /b`)
* **การวนซ้ำ (Euclidean Step)**:
1. `set /a temp=%y%`: เก็บค่า `y` เดิมไว้ใน `temp`
2. `set /a y=%x%%%y%`: คำนวณเศษเหลือของ `x` หารด้วย `y` (Modulo operation) และกำหนดให้เป็นค่า `y` ใหม่
3. `set /a x=%temp%`: กำหนดให้ `x` ใหม่เป็นค่า `y` เดิมที่เก็บไว้ใน `temp`
4. `goto loop`: วนกลับไปตรวจสอบเงื่อนไขใหม่
---
### สรุปการทำงานของสคริปต์
สคริปต์นี้รับตัวเลขสองตัว (เช่น 12 และ 18)
1. **คำนวณ GCD:** มันจะใช้ Euclidean Algorithm เพื่อหาว่า GCD ของ 12 และ 18 คือ 6
2. **ลดรูปสัดส่วน:** มันจะคำนวณ $12 \div 6 = 2$ และ $18 \div 6 = 3$
3. **แสดงผลลัพธ์:** มันจะแสดงผลลัพธ์ออกมาเป็น `12:18 = 2:3 (6)`
