go
package main

import (
	"fmt"
	"reflect"
)



// Tuple 是一个包含多个元素的结构
type Tuple struct {
	elements []interface{}
}

// NewTuple 创建一个新的 Tuple
func NewTuple(elements ...interface{}) *Tuple {
	return &Tuple{elements: elements}
}

// GetElement 获取元组中指定索引的元素
func (t *Tuple) GetElement(index int) (interface{}, error) {
	if index < 0 || index >= len(t.elements) {
		return nil, fmt.Errorf("index out of range")
	}
	return t.elements[index], nil
}

// Reverse 返回一个新的元组，包含反转顺序的元素
func (t *Tuple) Reverse() *Tuple {
	reversedElements := make([]interface{}, len(t.elements))
	copy(reversedElements, t.elements)
	for i, j := 0, len(reversedElements)-1; i < j; i, j = i+1, j-1 {
		reversedElements[i], reversedElements[j] = reversedElements[j], reversedElements[i]
	}
	return &Tuple{elements: reversedElements}
}

// Contains 检查元组中是否包含指定元素
func (t *Tuple) Contains(element interface{}) bool {
	for _, e := range t.elements {
		if reflect.DeepEqual(e, element) {
			return true
		}
	}
	return false
}

func main() {
	// 创建新的 tuple
	tuple := NewTuple(42, "Hello", 3.14)

	// 访问 tuple 元素
	for i, element := range tuple.elements {
		fmt.Printf("Element %d: %v\n", i+1, element)
	}

	// 获取元组中指定索引的元素
	index := 1
	element, err := tuple.GetElement(index)
	if err == nil {
		fmt.Printf("Element at index %d: %v\n", index, element)
	} else {
		fmt.Println("Error:", err)
	}

	// 反转元组
	reversedTuple := tuple.Reverse()
	fmt.Println("Original tuple:", tuple.elements)
	fmt.Println("Reversed tuple:", reversedTuple.elements)

	// 检查元组中是否包含指定元素
	searchElement := "Hello"
	if tuple.Contains(searchElement) {
		fmt.Printf("Tuple contains %v\n", searchElement)
	} else {
		fmt.Printf("Tuple does not contain %v\n", searchElement)
	}
}