# คู่มือการใช้งาน MegaCode

MegaCode เป็นแพลตฟอร์มการเขียนโปรแกรมภาษา Python ที่ทำงานบนเบราว์เซอร์ ออกแบบมาเพื่อให้นิสิตฝึกฝนการเขียนโปรแกรมด้วยโจทย์ปัญหาทางฟิสิกส์และความน่าจะเป็น

## 📋 สารบัญ

1. [การเริ่มต้น](#การเริ่มต้น)
2. [โครงสร้างของฟังก์ชัน](#โครงสร้างของฟังก์ชัน)
3. [คำสั่ง return](#คำสั่ง-return)
4. [ระบบตรวจสอบคำตอบ](#ระบบตรวจสอบคำตอบ)
5. [ตัวอย่างโจทย์และวิธีแก้](#ตัวอย่างโจทย์และวิธีแก้)
6. [ข้อผิดพลาดที่พบบ่อย](#ข้อผิดพลาดที่พบบ่อย)
7. [เคล็ดลับ](#เคล็ดลับ)

---

## 🚀 การเริ่มต้น

### 1. เลือกโจทย์
- คลิกที่โจทย์ที่ต้องการทำจากรายการ
- อ่านคำอธิบายโจทย์ให้เข้าใจ
- ศึกษาตัวอย่างผลการรัน (Sample Output)

### 2. เขียนโค้ด
- แก้ไขโค้ดในช่องแก้ไข (Code Editor)
- ใช้คำสั่ง `pass` เป็นตัวยืนยืนของฟังก์ชัน
- เขียนโค้ดของคุณแทนที่ `pass`

### 3. ทดสอบ
- คลิกปุ่ม "Run" เพื่อรันโค้ด
- ดูผลลัพธ์ในช่อง Output
- ถ้าผลลัพธ์ถูกต้อง จะแสดงข้อความ "✅ ผ่าน!"

---

## 📝 โครงสร้างของฟังก์ชัน

### รูปแบบพื้นฐาน

```python
def function_name(parameters):
    # โค้ดของคุณ
    return result
```

### ส่วนประกอบสำคัญ

1. **def** - คำสั่งกำหนดฟังก์ชัน
2. **function_name** - ชื่อฟังก์ชัน (ต้องตรงกับที่โจทย์กำหนด)
3. **parameters** - ค่าที่รับเข้ามา (ถ้ามี)
4. **:** - ใช้เครื่องหมาย colon ปิดท้ายบรรทัดแรก
5. **indentation** - ย่อหน้า 4 ช่องว่าง (มาตรฐาน Python)
6. **return** - คำสั่งคืนค่าผลลัพธ์

### ตัวอย่างที่ถูกต้อง

```python
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    return total
```

### ตัวอย่างที่ผิด

```python
# ❌ ผิด: ไม่มี return
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    # ไม่มี return ฟังก์ชันจะคืนค่า None

# ❌ ผิด: print แทน return
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    print(total)  # พิมพ์แต่ไม่คืนค่า
```

---

## 🔄 คำสั่ง return

### ทำไมต้องใช้ return?

- **return** ใช้เพื่อคืนค่าผลลัพธ์จากฟังก์ชัน
- ระบบตรวจสอบจะเปรียบเทียบค่าที่ return กับคำตอบที่ถูกต้อง
- ถ้าไม่มี return ฟังก์ชันจะคืนค่า `None` เสมอ

### ตัวอย่างการใช้ return

```python
# ✅ ถูกต้อง - คืนค่าตัวเลข
def calculate_area(radius):
    area = 3.14159 * radius ** 2
    return area

# ✅ ถูกต้อง - คืนค่าข้อความ
def greet(name):
    return f"Hello, {name}!"

# ✅ ถูกต้อง - คืนค่าลิสต์
def get_even_numbers(nums):
    result = []
    for num in nums:
        if num % 2 == 0:
            result.append(num)
    return result

# ✅ ถูกต้อง - คืนค่า True/False
def is_positive(number):
    return number > 0
```

### การคืนค่าหลายค่า

```python
def get_stats(numbers):
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return minimum, maximum, average  # คืนค่าเป็น tuple

# การใช้งาน
min_val, max_val, avg_val = get_stats([1, 2, 3, 4, 5])
```

---

## ✅ ระบบตรวจสอบคำตอบ

### วิธีทำงานของระบบ

1. **รันโค้ด** - ระบบจะรันฟังก์ชันของคุณ
2. **เปรียบเทียบ** - เปรียบเทียบค่าที่ return กับคำตอบที่ถูกต้อง
3. **แสดงผล** - แสดงผลลัพธ์ว่าผ่านหรือไม่ผ่าน

### ประเภทของการตรวจสอบ

#### 1. การเปรียบเทียบตรงๆ (Direct Comparison)

```python
# โจทย์: เขียนฟังก์ชันที่คืนค่าผลรวม
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    return total  # ระบบจะเปรียบเทียบค่านี้กับคำตอบ
```

#### 2. การเปรียบเทียบค่าใน output

```python
# โจทย์: คำนวณและแสดงผล
def calculate_rms_speed():
    temperature = float(input("Enter temperature (K): "))
    mass = float(input("Enter mass (kg): "))
    
    if temperature <= 0 or mass <= 0:
        print("Temperature and mass must be positive.")
        return
    
    from scipy.constants import Boltzmann
    k = Boltzmann
    v = (3 * k * temperature / mass) ** 0.5
    print(f"Root-mean-square speed = {v:.2f} m/s")
```

#### 3. การเปรียบเทียบข้อความที่แสดง

```python
# โจทย์: โปรแกรมที่แสดงผลลัพธ์
def calculate_kinetic_energy():
    mass = float(input("Enter mass (kg): "))
    velocity = float(input("Enter velocity (m/s): "))
    
    if mass <= 0 or velocity < 0:
        print("Mass must be positive and velocity must be non-negative")
        return
    
    ke = 0.5 * mass * velocity ** 2
    print(f"Kinetic energy: {ke:.2f} J")
    # ระบบจะตรวจสอบว่ามีข้อความนี้ใน output
```

### ตัวอย่าง Test Cases

```python
# ในไฟล์ tasks.js
{
  functionName: 'sum_list',
  testCases: [
    { args: [[1, 2, 3]], expected: 6 },      # sum_list([1,2,3]) ต้องคืนค่า 6
    { args: [[-1, 0, 1]], expected: 0 },     # sum_list([-1,0,1]) ต้องคืนค่า 0
    { args: [[]], expected: 0 },             # sum_list([]) ต้องคืนค่า 0
  ]
}
```

---

## 💡 ตัวอย่างโจทย์และวิธีแก้

### ตัวอย่างที่ 1: ผลรวมของลิสต์

**โจทย์:** เขียนฟังก์ชัน `sum_list(nums)` ที่คืนค่าผลรวมของตัวเลขทั้งหมดในลิสต์

**วิธีแก้ที่ถูกต้อง:**
```python
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    return total  # ✅ คืนค่าผลรวม
```

**วิธีแก้ที่ผิด:**
```python
def sum_list(nums):
    total = 0
    for num in nums:
        total += num
    print(total)  # ❌ พิมพ์แต่ไม่คืนค่า
```

### ตัวอย่างที่ 2: ความเร็วรากที่สองของโมเลกุลก๊าซ

**โจทย์:** คำนวณความเร็วรากที่สองของโมเลกุลก๊าซ

**วิธีแก้ที่ถูกต้อง:**
```python
from scipy.constants import Boltzmann

def calculate_rms_speed():
    # รับค่า input
    temperature = float(input("Enter temperature (K): "))
    mass = float(input("Enter mass of molecule (kg): "))
    
    # ตรวจสอบค่า
    if temperature <= 0 or mass <= 0:
        print("Temperature and mass must be positive.")
        return
    
    # คำนวณ
    k = Boltzmann
    v = (3 * k * temperature / mass) ** 0.5
    
    # แสดงผลลัพธ์
    print(f"Root-mean-square speed = {v:.2f} m/s")
```

### ตัวอย่างที่ 3: ความน่าจะเป็นไพ่ดอกเดียวกัน

**โจทย์:** คำนวณความน่าจะเป็นที่ไพ่ 2 ใบจะมีดอกเดียวกัน

**วิธีแก้ที่ถูกต้อง:**
```python
def calculate_same_suit_probability():
    # สร้าง list ของไพ่ 52 ใบ
    suits = ['H', 'D', 'C', 'S']  # Hearts, Diamonds, Clubs, Spades
    ranks = list(range(1, 14))   # 1-13
    cards = []
    
    for suit in suits:
        for rank in ranks:
            cards.append(f"{suit}{rank}")
    
    # นับกรณีที่เป็นไปได้
    favorable = 0
    total = 0
    
    for i in range(52):
        for j in range(i + 1, 52):
            total += 1
            if cards[i][0] == cards[j][0]:  # เปรียบเทียบดอก
                favorable += 1
    
    # คำนวณความน่าจะเป็น
    probability = favorable / total
    print(f"Probability: {probability:.4f}")
```

---

## ⚠️ ข้อผิดพลาดที่พบบ่อย

### 1. ไม่มีคำสั่ง return

```python
# ❌ ผิด
def add(a, b):
    result = a + b
    # ไม่มี return

# ✅ ถูก
def add(a, b):
    result = a + b
    return result
```

### 2. ใช้ print แทน return

```python
# ❌ ผิด
def multiply(a, b):
    print(a * b)

# ✅ ถูก
def multiply(a, b):
    return a * b
```

### 3. ไม่ตรงตามชื่อฟังก์ชันที่กำหนด

```python
# ❌ ผิด - ชื่อไม่ตรง
def calculate_sum(nums):  # โจทย์กำหนดชื่อ sum_list
    return sum(nums)

# ✅ ถูก
def sum_list(nums):  # ชื่อตรงตามโจทย์
    return sum(nums)
```

### 4. ลืมตรวจสอบเงื่อนไข

```python
# ❌ ผิด - ไม่มีการตรวจสอบ
def divide(a, b):
    return a / b  # จะ error ถ้า b = 0

# ✅ ถูก
def divide(a, b):
    if b == 0:
        return "Cannot divide by zero"
    return a / b
```

### 5. การย่อหน้าไม่ถูกต้อง

```python
# ❌ ผิด - ย่อหน้าไม่ถูก
def my_function():
result = 10
return result

# ✅ ถูก
def my_function():
    result = 10
    return result
```

---

## 🎯 เคล็ดลับ

### 1. อ่านโจทย์ให้ละเอียด
- สังเกตชื่อฟังก์ชันที่ต้องใช้
- ดูว่าต้องรับพารามิเตอร์อะไร
- ตรวจสอบว่าต้องคืนค่าประเภทใด

### 2. เริ่มจากการเขียน pseudo-code
```python
# ตัวอย่าง pseudo-code
def solve_problem():
    # 1. รับค่า input
    # 2. ตรวจสอบค่า
    # 3. คำนวณ
    # 4. แสดงผลลัพธ์
    pass
```

### 3. ทดสอบทีละส่วน
```python
def solve_problem():
    # ทดสอบส่วนรับค่าก่อน
    x = float(input("Enter x: "))
    print(f"Received: {x}")  # ดูว่ารับค่าถูกไหม
    
    # ทดสอบส่วนคำนวณ
    result = x * 2
    print(f"Result: {result}")  # ดูว่าคำนวณถูกไหม
    
    return result
```

### 4. ใช้คอมเมนต์ช่วยจำ
```python
def calculate_something(value):
    # ตรวจสอบว่าค่าเป็นบวก
    if value > 0:
        # คำนวณสูตรที่ 1
        result = value ** 2
    else:
        # คำนวณสูตรที่ 2
        result = abs(value)
    
    return result
```

### 5. ใช้ตัวอย่างจากโจทย์
- ดูตัวอย่างผลการรัน
- ให้ output ของคุณตรงกับตัวอย่าง
- ใช้รูปแบบการแสดงผลเหมือนตัวอย่าง

---

## 📚 แหล่งข้อมูลเพิ่มเติม

### เอกสาร Python ที่เกี่ยวข้อง
- [Python Official Documentation](https://docs.python.org/)
- [Python Functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)
- [SciPy Documentation](https://docs.scipy.org/)

### แนวทางการเขียนโค้ด
- ใช้ชื่อตัวแปรที่มีความหมาย
- เขียนคอมเมนต์อธิบายโค้ดที่ซับซ้อน
- ทดสอบโค้ดทีละส่วน
- ตรวจสอบ edge cases (ค่าพิเศษ)

---

## 🆘 การขอความช่วยเหลือ

ถ้าพบปัญหาในการใช้งาน:
1. อ่านข้อความ error ให้ละเอียด
2. ตรวจสอบว่ามีการใช้ return หรือไม่
3. ตรวจสอบว่าชื่อฟังก์ชันตรงตามโจทย์
4. ดูตัวอย่างจากโจทย์อื่นๆ เปรียบเทียบ

---

## 📝 สรุป

1. ✅ **ต้องมีคำสั่ง return** เพื่อคืนค่าผลลัพธ์
2. ✅ **ชื่อฟังก์ชันต้องตรง** ตามที่โจทย์กำหนด
3. ✅ **ตรวจสอบเงื่อนไข** ตามที่โจทย์ระบุ
4. ✅ **รูปแบบ output ต้องตรง** ตามตัวอย่าง
5. ✅ **ใช้ย่อหน้า 4 ช่องว่าง** ตามมาตรฐาน Python

---

**ขอให้สนุกกับการเขียนโปรแกรม! 🚀**

หากมีข้อสงสัยเพิ่มเติม สามารถสอบถามอาจารย์หรือผู้ช่วยสอนได้