# Function: Calculate the sum of squares of even numbers from 1-10 (demonstrates list comprehensions, built-in functions)
def calculate_even_square_sum():
    # List comprehension to filter even numbers and calculate squares
    even_squares = [x*x for x in range(1, 11) if x % 2 == 0]
    return sum(even_squares)

# Call the function and print the result
result = calculate_even_square_sum()
print(f"Sum of squares of even numbers from 1-10: {result}")  # Output: 220

// Function: Clicking a button to modify page text (demonstrates DOM manipulation, arrow functions, event listening)
document.addEventListener('DOMContentLoaded', () => {
  // Get button and text elements
  const btn = document.getElementById('changeTextBtn');
  const textElem = document.getElementById('targetText');
  
  // Arrow function binding click event
  btn.addEventListener('click', () => {
    const newText = `Updated time: ${new Date().toLocaleString()}`;
    textElem.textContent = newText; // Modify text content
    textElem.style.color = '#2c3e50'; // Modify style
  });
});

// HTML structure (needs to be used in conjunction)
/*
<button id="changeTextBtn">Click to Update</button>
<p id="targetText">Waiting for update...</p>
*/

// Function: Define animal interface and implementation (demonstrates Go's implicit interface implementation feature)
package main

import "fmt"

// Define interface
type Animal interface {
	Sound() string // Interface method
}

// Define struct
type Dog struct {
	Name string
}

type Cat struct {
	Name string
}

// Dog implements the Animal interface
func (d Dog) Sound() string {
	return fmt.Sprintf("%s: Woof Woof", d.Name)
}

// Cat implements the Animal interface
func (c Cat) Sound() string {
	return fmt.Sprintf("%s: Meow Meow", c.Name)
}

func main() {
	animals := []Animal{Dog{"Wangcai"}, Cat{"Mijiang"}}
	for _, animal := range animals {
		fmt.Println(animal.Sound()) // Polymorphic call
	}
}

// Function: Abstract class and subclass implementation (demonstrates core OOP features)
abstract class Shape {
    // Abstract method (subclasses must implement)
    public abstract double calculateArea();
}

// Circle subclass
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius; // Circle area formula
    }
}

// Rectangle subclass
class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height; // Rectangle area formula
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        
        System.out.printf("Circle area: %.2f\n", circle.calculateArea()); // 78.54
        System.out.printf("Rectangle area: %.2f\n", rectangle.calculateArea()); // 24.00
    }
}

// Function: Template functions + vector containers (demonstrates generic programming and STL usage)
#include <iostream>
#include <vector>
#include <algorithm> // For sort function

// Template function: Print any type of vector
template <typename T>
void printVector(const std::vector<T>& vec) {
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

int main() {
    // Integer vector
    std::vector<int> nums = {3, 1, 4, 1, 5, 9};
    std::cout << "Before sorting: ";
    printVector(nums);
    
    // STL sort function
    std::sort(nums.begin(), nums.end());
    std::cout << "After sorting: ";
    printVector(nums);
    
    return 0;
}

// Function: LINQ query to filter object lists (demonstrates C# LINQ features)
using System;
using System.Collections.Generic;
using System.Linq;

// Define student class
public class Student {
    public string Name { get; set; }
    public int Age { get; set; }
    public double Score { get; set; }
}

class Program {
    static void Main() {
        // Student data list
        List<Student> students = new List<Student> {
            new Student { Name = "Zhang San", Age = 18, Score = 92.5 },
            new Student { Name = "Li Si", Age = 19, Score = 88.0 },
            new Student { Name = "Wang Wu", Age = 18, Score = 95.0 }
        };

        // LINQ query: Filter students aged 18 with scores ≥ 90
        var qualifiedStudents = from s in students
                               where s.Age == 18 && s.Score >= 90
                               select new { s.Name, s.Score };

        // Print results
        Console.WriteLine("Qualified students under 18:");
        foreach (var student in qualifiedStudents) {
            Console.WriteLine($"Name: {student.Name}, Score: {student.Score}");
        }
    }
}

<?php
// Function: Array processing + file content reading (demonstrates PHP array features and file operations)
header("Content-Type: text/html; charset=utf-8");

// Associative array: Store user information
$users = [
    ["name" => "Xiaoming", "gender" => "Male", "age" => 22],
    ["name" => "XiaoHong", "gender" => "Female", "age" => 20]
];

// Traverse array and print
echo "<h3>User List</h3>";
foreach ($users as $user) {
    echo "Name: {$user['name']}, Gender: {$user['gender']}, Age: {$user['age']}<br>";
}

// Read file content (ensure the file exists)
$filePath = "test.txt";
if (file_exists($filePath)) {
    $content = file_get_contents($filePath);
    echo "<h3>File Content</h3>";
    echo nl2br($content); // Preserve line breaks
} else {
    echo "File not found!";
}
?>

# Function: Hash table operations + iterators (demonstrates Ruby's concise syntax)
# Define hash table: Store product information
products = {
  "apple" => { name: "Apple", price: 5.99, stock: 100 },
  "banana" => { name: "Banana", price: 3.99, stock: 150 },
  "orange" => { name: "Orange", price: 4.99, stock: 80 }
}

# Iterate hash table: Print products with stock ≥ 100
puts "Products with sufficient inventory:"
products.each do |code, info|
  if info[:stock] >= 100
    puts "#{info[:name]} - Price: #{info[:price]} Yuan, Stock: #{info[:stock]} Pieces"
  end
end

# Calculate total price of all products (assuming buy one each)
total_price = products.sum { |code, info| info[:price] }
puts "\nTotal price for buying one each: #{total_price.round(2)} Yuan"

// Function: Interface definition + type constraints (demonstrates TS static typing features)
// Define user interface
interface User {
  id: number;
  username: string;
  email: string;
  isActive?: boolean; // Optional property
}

// Define function: Format user information
function formatUser(user: User): string {
  const status = user.isActive ? "Active" : "Inactive";
  return `ID: ${user.id}, Username: ${user.username}, Email: ${user.email}, Status: ${status}`;
}

// Instantiate user object
const user1: User = {
  id: 1,
  username: "johndoe",
  email: "john@example.com",
  isActive: true
};

// Call function and print
console.log(formatUser(user1));
// Output: ID: 1, Username: johndoe, Email: john@example.com, Status: Active

<!-- Function: Simple counter component (demonstrates frontend trio cooperation) -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>Counter</title>
    <style>
        .counter {
            display: flex;
            align-items: center;
            gap: 10px;
            font-size: 18px;
            padding: 20px;
            max-width: 300px;
            margin: 20px auto;
            border: 1px solid #eee;
            border-radius: 8px;
        }
        .btn {
            padding: 8px 16px;
            border: none;
            border-radius: 4px;
            background: #2c3e50;
            color: white;
            cursor: pointer;
        }
        .btn:hover {
            background: #34495e;
        }
        #count {
            font-weight: bold;
            color: #e74c3c;
        }
    </style>
</head>
<body>
    <div class="counter">
        <button class="btn" id="decrease">-</button>
        <span>Current count: <span id="count">0</span></span>
        <button class="btn" id="increase">+</button>
    </div>

    <script>
        let count = 0;
        const countElem = document.getElementById('count');
        const increaseBtn = document.getElementById('increase');
        const decreaseBtn = document.getElementById('decrease');

        // Increase counter
        increaseBtn.addEventListener('click', () => {
            count++;
            countElem.textContent = count;
        });

        // Decrease counter (not less than 0)
        decreaseBtn.addEventListener('click', () => {
            if (count > 0) count--;
            countElem.textContent = count;
        });
    </script>
</body>
</html>

This is the first paragraph, containing regular text content.
Line end with two spaces  （here are two spaces）
Achieve forced line break.

This is the second paragraph（blank line separated from the previous paragraph）, Markdown will automatically handle paragraph spacing.

*Italic text* (single asterisk)
_Italic text_ (single underscore)
**Bold text** (double asterisks)
__Bold text__ (double underscores)
***Bold and Italic text*** (three asterisks)
___Bold and Italic text___ (three underscores)
~~Strikethrough text~~ (two wave brackets)

- Unordered list item 1 (hyphen)
* Unordered list item 2 (asterisk)
+ Unordered list item 3 (plus sign)

1. Ordered list item 1
2. Ordered list item 2
5. Ordered list item 3 (number is not continuous, rendered as 3)

- Outer unordered list
    1. Inner ordered list 1
    2. Inner ordered list 2
        - Inner nested unordered list
- Outer unordered list 2

[Hugo Official Documentation](https://gohugo.io/ "Hugo Official Website")
[My Blog](https://example.com) (No Title)

This is [Hugo Documentation][hugo-docs], this is [GitHub][github].

[hugo-docs]: https://gohugo.io/ "Hugo Docs"
[github]: https://github.com/ "GitHub"

[Jump to First Level Title](#First Level Title)
[Jump to List Section](#4-List Ordered Unordered Nested)

# Inline Image (Network Image)
![Hugo -logo](https://gohugo.io/images/hugo-logo-wide.svg "Hugo Official Logo")

# Inline Image (Local Image, Hugo needs to be placed in the static directory)
![Local Image Example](./images/photo.jpg "Local Image")

# Reference Image (Reusing Address)
![GitHub Logo][github-logo]
[github-logo]: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png

> This is a first-level citation (single arrow)
> Citation content can be line-breaked, just add > at the beginning of each line.
>> This is a second-level citation (double arrow, nested)
>>> This is a third-level citation (triple arrow)
>
> Citation can include other syntax:
> - Unordered list
> **Bold text**

Inline code example: `print("Hello Markdown")`, `const x = 10`

```go
// Go language code block (combined with Hugo highlighting)
package main
import "fmt"
func main() {
    fmt.Println("Hello Code Block!")
}

| Name   | Age | Score  |
|--------|-----|--------|
| Zhang San | 18 | 92.5 |
| Li Si | 19 | 88.0 |
| Wang Wu | 18 | 95.0 |

# Aligned Table
| Left-aligned | Right-aligned | Centered |
|:------------|--------------:|:---------:|
| Text1       | Number1       | Content1  |
| Text2       | Number2       | Content2  |

- [x] Complete Markdown syntax learning
- [x] Write code snippets
- [ ] Publish Hugo blog
- [ ] Optimize website style

This is text that needs annotation[^1], this is another annotation[^note].

[^1]: This is detailed explanation of the first footnote (supports line breaks and links: [Hugo](https://gohugo.io))
[^note]: This is the explanation of the second footnote, identifiers can be letters or numbers

Markdown
: A lightweight markup language for quickly writing documents
: Compatible with most blog platforms and static site generators (such as Hugo)

Hugo
: Static site generator
    - Developed in Go language
    - Fast rendering speed
    - Built-in code highlighting