Зеҳн
Алгоритмсозӣ ва барномасозӣ дар забони Go

Китоби таълимии забони Go барои мактабиён, донишҷӯён ва омӯзгорон: аз алгоритм ва блок-схемаҳо то веб-сервер ва боти Телеграм. Таҷдиди китоби А. П. Назаров «Алгоритмсозӣ ва барномасозӣ дар забони Бейсик» (2009).

Агенти Зеҳнӣ · 26 октябри 2026 · 15 саҳифа

МаорифБарномасозӣТехнология
Аз аввал хондан

Боби 13. Маҷмӯаи масъалаҳои амалӣ

Боби 13. Маҷмӯаи масъалаҳои амалӣ

Ин боб маҷмӯаи мураттабшудаи масъалаҳои амалӣ аз риёзиёт, геометрия, физика ва назарияи ададҳо мебошад, ки бар асоси масъалаҳои классикии китоби таълимӣ мутобиқ ва такмил дода шудаанд. Барои ҳар як масъала шарт, ҳалли пурра бо Go ва натиҷаи иҷрои он оварда шудааст. Пеш аз дидани роҳи ҳал кӯшиш кунед, ки масъаларо худатон ҳал намоед — ҳалли мустақилона тафаккури алгоритмии шуморо тақвият медиҳад.

Барои он ки натиҷаро фавран бинед, додаҳои ибтидоӣ дар худи код навишта шудаанд. Шумо метавонед онҳоро бо воридоти корбар (fmt.Scan, боби 4) иваз кунед.

Дар ин боб меомӯзем

  • Татбиқи формулаҳои риёзӣ ва физикӣ бо бастаи math.
  • Ҷудо кардани рақамҳои адад бо амалҳои / ва %.
  • Сохторҳои шартии мураккаб ва функсияҳои мантиқӣ (bool).
  • Алгоритмҳои классикии назарияи ададҳо: Евклид, ададҳои сода ва комил, пайдарпайии Коллатс.
  • Мураттабсозии ҳубобӣ, ҷустуҷӯи дуӣ ва тоза кардани такрорҳо дар буришҳо.
  • Зарби матритсаҳо ва формулаи Гаусс барои масоҳати бисёркунҷа.

Масъалаҳо аз рӯи мавзӯъ ба панҷ гурӯҳ тақсим шудаанд:

  1. Масъалаҳои хаттӣ ва ҳисоббарориҳои риёзӣ
  2. Масъалаҳои шоханок ва мантиқӣ
  3. Масъалаҳои даврӣ, пайдарпайиҳо ва назарияи ададҳо
  4. Масъалаҳо бо массивҳо ва буришҳо
  5. Масъалаҳои геометрӣ ва физикӣ

1. Масъалаҳои хаттӣ ва ҳисоббарориҳои риёзӣ

13–1. Ҳисоби муқовимати параллелӣ: Се ноқил бо муқовиматҳои R₁, R₂ ва R₃ ба таври параллел пайваст карда шудаанд. Муқовимати умумии занҷирро аз рӯи формулаи зерин ҳисоб кунед: 1/R = 1/R₁ + 1/R₂ + 1/R₃ ⇒ R = 1 / (1/R₁ + 1/R₂ + 1/R₃)

Роҳи ҳал:

package main

import "fmt"

func main() {
	r1, r2, r3 := 2.0, 3.0, 6.0 // муқовиматҳо бо Ом

	if r1 <= 0 || r2 <= 0 || r3 <= 0 {
		fmt.Println("Муқовимат бояд мусбат бошад!")
		return
	}

	r := 1 / (1/r1 + 1/r2 + 1/r3)
	fmt.Printf("R1 = %.1f Ом, R2 = %.1f Ом, R3 = %.1f Ом\n", r1, r2, r3)
	fmt.Printf("Муқовимати умумӣ: R = %.2f Ом\n", r)
}

Натиҷа:

R1 = 2.0 Ом, R2 = 3.0 Ом, R3 = 6.0 Ом
Муқовимати умумӣ: R = 1.00 Ом

13–2. Ҷобаҷо кардани рақамҳои адади чоррақама: Адади чоррақамаи натуралии N дода шудааст (масалан 4826). Барномае нависед, ки ҷойи рақами якумро бо сеюм ва рақами дуюмро бо чорум иваз намуда, адади навро ҳосил ва чоп кунад (2648).

Роҳи ҳал: Рақамҳоро бо тақсими бутун (/) ва бақия (%) ҷудо мекунем:

package main

import "fmt"

func main() {
	n := 4826

	if n  9999 {
		fmt.Println("Адад бояд чоррақама бошад!")
		return
	}

	r1 := n / 1000     // рақами якум (ҳазорҳо)
	r2 := n / 100 % 10 // рақами дуюм (садҳо)
	r3 := n / 10 % 10  // рақами сеюм (даҳҳо)
	r4 := n % 10       // рақами чорум (воҳидҳо)

	// Тартиби нав: r3 r4 r1 r2
	nav := r3*1000 + r4*100 + r1*10 + r2
	fmt.Printf("Адади аввала: %d\n", n)
	fmt.Printf("Адади нав:    %d\n", nav)
}

Натиҷа:

Адади аввала: 4826
Адади нав:    2648

(Агар рақами сеюм 0 бошад, масалан 4806, адади нав 648 — серақама мешавад.)

13–3. Ҳисоби пасандози бонкӣ бо фоизи мураккаб: Мизоҷ маблағи P сомониро ба бонк мегузорад. Бонк ҳар моҳ ба маблағи ҷамъшуда r% фоида зам мекунад. Маблағи ниҳоии пасандозро пас аз M моҳ ҳисоб намоед: Маблағ = P · (1 + r/100)ᴹ

Роҳи ҳал: Натиҷаро ҳам бо формула (math.Pow), ҳам бо давр (моҳ ба моҳ) ҳисоб карда, муқоиса мекунем:

package main

import (
	"fmt"
	"math"
)

func main() {
	p := 1000.0 // маблағи ибтидоӣ, сомонӣ
	r := 2.0    // фоизи моҳона
	m := 12     // шумораи моҳҳо

	// 1. Бо формула
	formula := p * math.Pow(1+r/100, float64(m))

	// 2. Бо давр: ҳар моҳ фоида ба маблағи ҷамъшуда зам мешавад
	mablagh := p
	for moh := 1; moh <= m; moh++ {
		mablagh += mablagh * r / 100
	}

	fmt.Printf("Бо формула: %.2f сомонӣ\n", formula)
	fmt.Printf("Бо давр:    %.2f сомонӣ\n", mablagh)
	fmt.Printf("Фоидаи умумӣ: %.2f сомонӣ\n", formula-p)
}

Натиҷа:

Бо формула: 1268.24 сомонӣ
Бо давр:    1268.24 сомонӣ
Фоидаи умумӣ: 268.24 сомонӣ

13–4. Масофаи байни ду нуқта дар фазо: Координатаҳои ду нуқта дар фазои сеченака дода шудаанд: A(x₁, y₁, z₁) ва B(x₂, y₂, z₂). Масофаи байни онҳоро бо истифода аз бастаи math ёбед: d = √((x₁ − x₂)² + (y₁ − y₂)² + (z₁ − z₂)²)

Роҳи ҳал:

package main

import (
	"fmt"
	"math"
)

type Nuqta3D struct {
	X, Y, Z float64
}

func masofa(a, b Nuqta3D) float64 {
	dx := a.X - b.X
	dy := a.Y - b.Y
	dz := a.Z - b.Z
	return math.Sqrt(dx*dx + dy*dy + dz*dz)
}

func main() {
	a := Nuqta3D{1, 2, 3}
	b := Nuqta3D{4, 6, 15}

	fmt.Printf("A%v, B%v\n", a, b)
	fmt.Printf("Масофа: d = %.2f\n", masofa(a, b))
}

Натиҷа:

A{1 2 3}, B{4 6 15}
Масофа: d = 13.00

2. Масъалаҳои шоханок ва мантиқӣ

13–5. Калонтарин ва хурдтарини чор адад: Чор адади ҳақиқии a, b, c, d дода шудаанд. Бе истифодаи массивҳо, танҳо бо сохторҳои if калонтарин ва хурдтарини онҳоро муайян кунед.

Роҳи ҳал: Аввал адади якумро ҳам калонтарин ва ҳам хурдтарин мешуморем ва онро бо се адади дигар пай дар пай муқоиса мекунем:

package main

import "fmt"

func main() {
	a, b, c, d := 3.5, -2.0, 7.25, 0.0

	kalon, xurd := a, a

	if b > kalon {
		kalon = b
	}
	if c > kalon {
		kalon = c
	}
	if d > kalon {
		kalon = d
	}

	if b < xurd {
		xurd = b
	}
	if c < xurd {
		xurd = c
	}
	if d < xurd {
		xurd = d
	}

	fmt.Printf("Ададҳо: %g, %g, %g, %g\n", a, b, c, d)
	fmt.Printf("Калонтарин: %g\n", kalon)
	fmt.Printf("Хурдтарин:  %g\n", xurd)
}

Натиҷа:

Ададҳо: 3.5, -2, 7.25, 0
Калонтарин: 7.25
Хурдтарин:  -2

(Дар Go 1.21+ ҳамин натиҷаро функсияҳои дарунсохти max(a, b, c, d) ва min(a, b, c, d) медиҳанд.)

13–6. Соли кабиса (leap year): Соли Y аз рӯи тақвими григорианӣ дода шудааст. Муайян кунед, ки он соли кабиса (366 рӯз) аст ё соли оддӣ (365 рӯз).

Қоида: Сол кабиса аст, агар ба 4 бе бақия тақсим шавад; аммо агар ба 100 бе бақия тақсим шавад, танҳо дар ҳолате кабиса аст, ки ба 400 низ бе бақия тақсим шавад (масалан: 2000 ва 2024 кабисаанд, аммо 1900 ва 2100 кабиса нестанд).

Роҳи ҳал:

package main

import "fmt"

// kabisa true бармегардонад, агар сол кабиса бошад
func kabisa(sol int) bool {
	return sol%4 == 0 && (sol%100 != 0 || sol%400 == 0)
}

func main() {
	solho := []int{1900, 2000, 2023, 2024, 2100}

	for _, y := range solho {
		if kabisa(y) {
			fmt.Printf("%d — соли кабиса (366 рӯз)\n", y)
		} else {
			fmt.Printf("%d — соли оддӣ (365 рӯз)\n", y)
		}
	}
}

Натиҷа:

1900 — соли оддӣ (365 рӯз)
2000 — соли кабиса (366 рӯз)
2023 — соли оддӣ (365 рӯз)
2024 — соли кабиса (366 рӯз)
2100 — соли оддӣ (365 рӯз)

13–7. Ҳамворӣ ва чорякҳои координата: Координатаҳои нуқтаи P(x, y) дода шудаанд (x ≠ 0, y ≠ 0). Муайян кунед, ки ин нуқта дар кадом чоряки ҳамвории декартии координатаҳо (чоряки I, II, III ё IV) қарор дорад.

Роҳи ҳал: Сохтори switch бе ифода барои санҷиши якчанд шарт хеле қулай аст:

package main

import "fmt"

func choryak(x, y float64) string {
	switch {
	case x == 0 || y == 0:
		return "дар тири координата"
	case x > 0 && y > 0:
		return "чоряки I"
	case x  0:
		return "чоряки II"
	case x < 0 && y < 0:
		return "чоряки III"
	default:
		return "чоряки IV"
	}
}

func main() {
	nuqtaho := [][2]float64{{3, 5}, {-2, 4}, {-1, -7}, {6, -2}, {0, 3}}

	for _, n := range nuqtaho {
		fmt.Printf("P(%g, %g) — %s\n", n[0], n[1], choryak(n[0], n[1]))
	}
}

Натиҷа:

P(3, 5) — чоряки I
P(-2, 4) — чоряки II
P(-1, -7) — чоряки III
P(6, -2) — чоряки IV
P(0, 3) — дар тири координата

13–8. Тақсимкунандаи умумии калонтарин (ТУК / GCD): Ду адади натуралии A ва B дода шудаанд. Бо истифода аз алгоритми машҳури Евклид тақсимкунандаи умумии калонтарини онҳоро (ТУК) ёбед. Ғоя: ТУК(a, b) = ТУК(b, a mod b), то даме ки b = 0 шавад.

Роҳи ҳал: Ҳамзамон хурдтарин каратии умумӣ (ХКУ)-ро ҳам бо формулаи ХКУ = a · b / ТУК ҳисоб мекунем:

package main

import "fmt"

// tuk тақсимкунандаи умумии калонтаринро бо алгоритми Евклид меёбад
func tuk(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func main() {
	a, b := 84, 36

	t := tuk(a, b)
	fmt.Printf("ТУК(%d, %d) = %d\n", a, b, t)
	fmt.Printf("ХКУ(%d, %d) = %d\n", a, b, a/t*b)
}

Натиҷа:

ТУК(84, 36) = 12
ХКУ(84, 36) = 252

3. Масъалаҳои даврӣ, пайдарпайиҳо ва назарияи ададҳо

13–9. Ҳамаи ададҳои сода дар фосила: Ду адади A ва B (1 < A < B) дода шудаанд. Ҳамаи ададҳои содаеро, ки дар фосилаи [A, B] қарор доранд, чоп кунед ва шумораи умумии онҳоро нишон диҳед.

Роҳи ҳал: Тақсимкунандаҳоро танҳо то √n месанҷем — агар n тақсимкунандаи калонтар аз √n дошта бошад, ҷуфти хурдтари он аллакай ёфт мешуд:

package main

import "fmt"

// soda true бармегардонад, агар n адади сода бошад
func soda(n int) bool {
	if n < 2 {
		return false
	}
	for d := 2; d*d <= n; d++ {
		if n%d == 0 {
			return false
		}
	}
	return true
}

func main() {
	a, b := 10, 50
	shumora := 0

	fmt.Printf("Ададҳои сода дар фосилаи [%d, %d]:\n", a, b)
	for n := a; n <= b; n++ {
		if soda(n) {
			fmt.Print(n, " ")
			shumora++
		}
	}
	fmt.Printf("\nШумораи умумӣ: %d\n", shumora)
}

Натиҷа:

Ададҳои сода дар фосилаи [10, 50]:
11 13 17 19 23 29 31 37 41 43 47 
Шумораи умумӣ: 11

13–10. Ададҳои комил (Perfect numbers): Адади натуралӣ «комил» номида мешавад, агар суммаи тамоми тақсимкунандаҳои мусбати аз худаш хурдаш ба худи он баробар бошад. Масалан: 6 = 1 + 2 + 3, ё 28 = 1 + 2 + 4 + 7 + 14. Барномае нависед, ки тамоми ададҳои комилро то 10 000 пайдо кунад.

Роҳи ҳал: Тақсимкунандаҳоро ҷуфт-ҷуфт (d ва n/d) то √n ҷамъ мекунем, то барнома тез кор кунад:

package main

import "fmt"

// sumTaqsimkunandaho суммаи тақсимкунандаҳои n-ро (ғайр аз худи n) бармегардонад
func sumTaqsimkunandaho(n int) int {
	if n < 2 {
		return 0
	}
	sum := 1
	for d := 2; d*d <= n; d++ {
		if n%d == 0 {
			sum += d
			if d != n/d {
				sum += n / d
			}
		}
	}
	return sum
}

func main() {
	fmt.Println("Ададҳои комил то 10 000:")
	for n := 2; n <= 10000; n++ {
		if sumTaqsimkunandaho(n) == n {
			fmt.Println(n)
		}
	}
}

Натиҷа:

Ададҳои комил то 10 000:
6
28
496
8128

13–11. Ҳисоби тақрибии адади π бо қатори Лейбнитс: Адади π-ро аз рӯи қатори беохири зерин то N аъзо ҳисоб кунед: π = 4 · (1 − 1/3 + 1/5 − 1/7 + 1/9 − …) Дақиқии натиҷаро ҳангоми N = 100, N = 10 000 ва N = 1 000 000 муқоиса намоед.

Роҳи ҳал:

package main

import (
	"fmt"
	"math"
)

// leibniz π-ро аз рӯи n аъзои аввали қатори Лейбнитс ҳисоб мекунад
func leibniz(n int) float64 {
	sum := 0.0
	ishora := 1.0
	for k := 0; k < n; k++ {
		sum += ishora / float64(2*k+1)
		ishora = -ishora
	}
	return 4 * sum
}

func main() {
	for _, n := range []int{100, 10000, 1000000} {
		p := leibniz(n)
		fmt.Printf("N = %-8d π ≈ %.10f   хатогӣ: %.2e\n", n, p, math.Abs(p-math.Pi))
	}
	fmt.Printf("math.Pi    = %.10f\n", math.Pi)
}

Натиҷа:

N = 100      π ≈ 3.1315929036   хатогӣ: 1.00e-02
N = 10000    π ≈ 3.1414926536   хатогӣ: 1.00e-04
N = 1000000  π ≈ 3.1415916536   хатогӣ: 1.00e-06
math.Pi    = 3.1415926536

Қатори Лейбнитс оҳиста ҳамгаро мешавад: барои тақрибан як рақами даҳии иловагии дақиқӣ шумораи аъзоро тақрибан 10 маротиба зиёд кардан лозим аст.

13–12. Пайдарпайии Сиракуз (гипотезаи Коллатс): Адади дилхоҳи натуралии N-ро гиред. Агар ҷуфт бошад, онро ба 2 тақсим кунед (N = N / 2). Агар тоқ бошад, онро ба 3 зарб зада 1 зам кунед (N = 3N + 1). Ин амалро то расидан ба адади 1 такрор кунед. Барномае нависед, ки ин пайдарпайиро чоп карда, шумораи қадамҳоро ҳисоб намояд.

Роҳи ҳал:

package main

import "fmt"

// kollats пайдарпайиро чоп мекунад ва шумораи қадамҳоро бармегардонад
func kollats(n int, chop bool) int {
	qadamho := 0
	if chop {
		fmt.Print(n)
	}
	for n != 1 {
		if n%2 == 0 {
			n /= 2
		} else {
			n = 3*n + 1
		}
		qadamho++
		if chop {
			fmt.Print(" → ", n)
		}
	}
	if chop {
		fmt.Println()
	}
	return qadamho
}

func main() {
	q := kollats(6, true)
	fmt.Printf("Барои N = 6: %d қадам\n", q)

	q = kollats(27, false)
	fmt.Printf("Барои N = 27: %d қадам (пайдарпайии дароз!)\n", q)
}

Натиҷа:

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1
Барои N = 6: 8 қадам
Барои N = 27: 111 қадам (пайдарпайии дароз!)

4. Масъалаҳо бо массивҳо ва буришҳо

13–13. Мураттабсозии ҳубобӣ (Bubble Sort): Буриши ададҳои бутунро бе истифодаи бастаҳои тайёр, танҳо бо ду даври for ва иваз намудани ҷойи унсурҳо аз рӯи тартиби афзуншавӣ ба тартиб дароред.

Роҳи ҳал: Дар ҳар гузариш калонтарин унсури боқимонда мисли ҳубоб ба охир «боло мебарояд». Агар дар гузариш ягон ивазкунӣ рух надиҳад, буриш аллакай мураттаб аст ва даврро қатъ мекунем:

package main

import "fmt"

func bubbleSort(a []int) {
	n := len(a)
	for i := 0; i < n-1; i++ {
		ivaz := false
		for j := 0; j < n-1-i; j++ {
			if a[j] > a[j+1] {
				a[j], a[j+1] = a[j+1], a[j] // ҷобаҷокунӣ
				ivaz = true
			}
		}
		if !ivaz {
			break // буриш аллакай мураттаб аст
		}
	}
}

func main() {
	adadho := []int{64, 34, 25, 12, 22, 11, 90, 5}
	fmt.Println("Пеш аз мураттабсозӣ:", adadho)

	bubbleSort(adadho)
	fmt.Println("Пас аз мураттабсозӣ:", adadho)
}

Натиҷа:

Пеш аз мураттабсозӣ: [64 34 25 12 22 11 90 5]
Пас аз мураттабсозӣ: [5 11 12 22 25 34 64 90]

13–14. Ҷустуҷӯи дуӣ (Binary Search): Буриши мураттабшудаи ададҳо ва адади ҷустуҷӯшавандаи X дода шудааст. Бо тақсим кардани фосила ба ду қисм (алгоритми бинарӣ) муайян кунед, ки X дар кадом мавқеъ қарор дорад. Шумораи муқоисаҳоро нисбат ба ҷустуҷӯи оддӣ санҷед.

Роҳи ҳал:

package main

import "fmt"

// justujuiOddi мавқеи x ва шумораи муқоисаҳоро бармегардонад (-1, агар набошад)
func justujuiOddi(a []int, x int) (int, int) {
	muqoisa := 0
	for i, v := range a {
		muqoisa++
		if v == x {
			return i, muqoisa
		}
	}
	return -1, muqoisa
}

// justujuiDui дар буриши мураттаб фосиларо ҳар дафъа ду баробар хурд мекунад
func justujuiDui(a []int, x int) (int, int) {
	muqoisa := 0
	chap, rost := 0, len(a)-1
	for chap <= rost {
		miyona := chap + (rost-chap)/2
		muqoisa++
		switch {
		case a[miyona] == x:
			return miyona, muqoisa
		case a[miyona] < x:
			chap = miyona + 1
		default:
			rost = miyona - 1
		}
	}
	return -1, muqoisa
}

func main() {
	// Буриши мураттаби 1000 адади ҷуфт: 0, 2, 4, ..., 1998
	a := make([]int, 1000)
	for i := range a {
		a[i] = 2 * i
	}

	for _, x := range []int{1500, 7} {
		i1, m1 := justujuiOddi(a, x)
		i2, m2 := justujuiDui(a, x)
		fmt.Printf("X = %d: оддӣ → мавқеъ %d (%d муқоиса), дуӣ → мавқеъ %d (%d муқоиса)\n",
			x, i1, m1, i2, m2)
	}
}

Натиҷа:

X = 1500: оддӣ → мавқеъ 750 (751 муқоиса), дуӣ → мавқеъ 750 (9 муқоиса)
X = 7: оддӣ → мавқеъ -1 (1000 муқоиса), дуӣ → мавқеъ -1 (10 муқоиса)

Барои 1000 унсур ҷустуҷӯи дуӣ ҳадди аксар 10 қадам (2¹⁰ = 1024) талаб мекунад, ҷустуҷӯи хаттӣ бошад — то 1000 қадам. Дар коди боло ҳисобкунаки muqoisa шумораи қадамҳоро мешуморад: дар як қадами ҷустуҷӯи дуӣ метавонад ҳам санҷиши баробарӣ ва ҳам санҷиши хурд будан иҷро шавад.

13–15. Тоза кардани такрорҳо: Бурише дода шудааст, ки дорои ададҳои такроршаванда мебошад (масалан [1, 2, 2, 3, 4, 4, 4, 5]). Буриши наве созед, ки ҳар як адад дар он танҳо як маротиба омада бошад.

Роҳи ҳал: Бо ёрии харитаи map[int]bool (боби 10) ададҳои аллакай дидашударо қайд мекунем. Ин усул тартиби аввалини ададҳоро нигоҳ медорад ва барои буриши номураттаб низ дуруст кор мекунад:

package main

import "fmt"

func takrorhoroTozaKardan(a []int) []int {
	dida := make(map[int]bool)
	natija := make([]int, 0, len(a))
	for _, v := range a {
		if !dida[v] {
			dida[v] = true
			natija = append(natija, v)
		}
	}
	return natija
}

func main() {
	a := []int{1, 2, 2, 3, 4, 4, 4, 5}
	b := []int{7, 3, 7, 1, 3, 9, 1}

	fmt.Println(a, "→", takrorhoroTozaKardan(a))
	fmt.Println(b, "→", takrorhoroTozaKardan(b))
}

Натиҷа:

[1 2 2 3 4 4 4 5] → [1 2 3 4 5]
[7 3 7 1 3 9 1] → [7 3 1 9]

13–16. Зарби ду матритса: Ду матритсаи андозаашон 2 × 2 (ё 3 × 3) дода шудаанд. Ҳосили зарби ин ду матритсаро аз рӯи қоидаи зарби «сатр ба сутун» ҳисоб кунед: Cᵢⱼ = Σₖ Aᵢₖ · Bₖⱼ.

Роҳи ҳал: Функсия барои матритсаҳои ҳар андоза кор мекунад, ба шарте ки шумораи сутунҳои A ба шумораи сатрҳои B баробар бошад:

package main

import (
	"errors"
	"fmt"
)

func zarb(a, b [][]float64) ([][]float64, error) {
	if len(a) == 0 || len(b) == 0 || len(a[0]) != len(b) {
		return nil, errors.New("андозаи матритсаҳо барои зарб мувофиқ нест")
	}
	satrho, sutunho := len(a), len(b[0])

	c := make([][]float64, satrho)
	for i := range c {
		c[i] = make([]float64, sutunho)
		for j := 0; j < sutunho; j++ {
			for k := range b {
				c[i][j] += a[i][k] * b[k][j]
			}
		}
	}
	return c, nil
}

func main() {
	a := [][]float64{
		{1, 2},
		{3, 4},
	}
	b := [][]float64{
		{5, 6},
		{7, 8},
	}

	c, err := zarb(a, b)
	if err != nil {
		fmt.Println("Хато:", err)
		return
	}

	fmt.Println("A × B =")
	for _, satr := range c {
		for _, v := range satr {
			fmt.Printf("%6.1f", v)
		}
		fmt.Println()
	}
}

Натиҷа:

A × B =
  19.0  22.0
  43.0  50.0

5. Масъалаҳои геометрӣ ва физикӣ

13–17. Ҳаракати ҷисми ба боло партофташуда: Ҷисм бо суръати ибтидоии v₀ рост ба боло партофта шуд. Баландии ҷисм дар лаҳзаи вақти t бо формулаи h(t) = v₀t − gt² / 2 муайян мешавад (g = 9.8 м/с²). Вақти парвоз то баландии максималӣ ва баландии максималиро ҳисоб кунед.

Роҳи ҳал: Дар нуқтаи болотарин суръат сифр мешавад: v₀ − gt = 0 ⇒ tₘₐₓ = v₀ / g, ва hₘₐₓ = v₀² / (2g). Ҳамчунин ҷадвали баландиро ҳар 0.5 сония чоп мекунем:

package main

import "fmt"

const g = 9.8 // шитоби афтиши озод, м/с²

func main() {
	v0 := 20.0 // суръати ибтидоӣ, м/с

	tMax := v0 / g
	hMax := v0 * v0 / (2 * g)

	fmt.Printf("Вақти баромад то баландии максималӣ: %.2f с\n", tMax)
	fmt.Printf("Баландии максималӣ: %.2f м\n", hMax)
	fmt.Printf("Вақти умумии парвоз (то афтидан): %.2f с\n\n", 2*tMax)

	fmt.Println("  t (с)   h (м)")
	for t := 0.0; t <= 2*tMax; t += 0.5 {
		h := v0*t - g*t*t/2
		fmt.Printf("%6.1f %7.2f\n", t, h)
	}
}

Натиҷа:

Вақти баромад то баландии максималӣ: 2.04 с
Баландии максималӣ: 20.41 м
Вақти умумии парвоз (то афтидан): 4.08 с

  t (с)   h (м)
   0.0    0.00
   0.5    8.78
   1.0   15.10
   1.5   18.98
   2.0   20.40
   2.5   19.38
   3.0   15.90
   3.5    9.97
   4.0    1.60

13–18. Энергияи кинетикӣ ва потенсиалӣ: Ҷисми массааш m кг дар баландии h метр бо суръати v м/с ҳаракат дорад. Энергияи кинетикӣ (Eₖ = mv² / 2), энергияи потенсиалӣ (Eₚ = mgh) ва энергияи пурраи механикии онро (E = Eₖ + Eₚ) ҳисоб намоед.

Роҳи ҳал:

package main

import "fmt"

const g = 9.8 // м/с²

func main() {
	m := 2.0  // масса, кг
	h := 10.0 // баландӣ, м
	v := 5.0  // суръат, м/с

	ek := m * v * v / 2
	ep := m * g * h

	fmt.Printf("Энергияи кинетикӣ:  Ek = %.1f Ҷ\n", ek)
	fmt.Printf("Энергияи потенсиалӣ: Ep = %.1f Ҷ\n", ep)
	fmt.Printf("Энергияи пурраи механикӣ: E = %.1f Ҷ\n", ek+ep)
}

Натиҷа:

Энергияи кинетикӣ:  Ek = 25.0 Ҷ
Энергияи потенсиалӣ: Ep = 196.0 Ҷ
Энергияи пурраи механикӣ: E = 221.0 Ҷ

13–19. Масоҳати бисёркунҷа (формулаи Гаусс): Координатаҳои N қуллаи бисёркунҷаи сода (яъне тарафҳояш якдигарро намебуранд) бо тартиби давр задан (ба самти ақрабаки соат ё баръакс) дар буриши нуқтаҳо дода шудаанд. Масоҳати онро аз рӯи формулаи Гаусс (формулаи «банди пойафзол», shoelace) ҳисоб кунед: S = ½ · |Σ (xᵢ · yᵢ₊₁ − xᵢ₊₁ · yᵢ)|, i = 0 … N − 1, ки дар он x[N] = x[0], y[N] = y[0].

Роҳи ҳал: Қуллаи навбатӣ бо индекси (i + 1) % n гирифта мешавад — ҳамин тавр пас аз қуллаи охирин ба қуллаи аввал бармегардем:

package main

import (
	"fmt"
	"math"
)

type Nuqta struct {
	X, Y float64
}

func masohat(q []Nuqta) float64 {
	n := len(q)
	sum := 0.0
	for i := 0; i < n; i++ {
		j := (i + 1) % n // қуллаи навбатӣ (пас аз охирин — аввалин)
		sum += q[i].X*q[j].Y - q[j].X*q[i].Y
	}
	return math.Abs(sum) / 2
}

func main() {
	rostkunja := []Nuqta{{0, 0}, {4, 0}, {4, 3}, {0, 3}}
	// Бисёркунҷаи ғайриқабарии «L»-шакл
	lShakl := []Nuqta{{0, 0}, {4, 0}, {4, 1}, {1, 1}, {1, 3}, {0, 3}}

	fmt.Printf("Масоҳати росткунҷаи 4×3: %.1f\n", masohat(rostkunja))
	fmt.Printf("Масоҳати бисёркунҷаи L-шакл: %.1f\n", masohat(lShakl))
}

Натиҷа:

Масоҳати росткунҷаи 4×3: 12.0
Масоҳати бисёркунҷаи L-шакл: 6.0

Худатон бисанҷед

13–20. Воридоти корбар: Роҳҳои ҳал масъалаҳои 13–1, 13–3 ва 13–17-ро тавре тағйир диҳед, ки додаҳои ибтидоӣ бо fmt.Scan аз клавиатура ворид шаванд ва барои воридоти нодуруст (ҳарф ба ҷойи адад, қимати манфӣ) паёми хато чоп гардад.

13–21. Ғалбери Эратосфен: Ададҳои сода дар фосилаи [2, 1 000 000]-ро бо усули «ғалбери Эратосфен» (буриши []bool) ёбед ва вақти иҷроро (time.Since) бо роҳи ҳалли масъалаи 13–9 муқоиса кунед.

13–22. Мураттабсозии хонандагон: Буриши сохторҳои Xonanda (боби 10)-ро бо усули масъалаи 13–13 аз рӯи баҳои миёна бо тартиби камшавӣ мураттаб кунед ва натиҷаро бо slices.SortFunc санҷед.

Хулоса

Дар ин боб шумо 19 масъалаи риёзӣ, физикӣ ва алгоритмиро бо ҳалҳои пурра бо Go аз назар гузарондед: аз формулаҳои оддӣ то алгоритмҳои Евклид, ҷустуҷӯи дуӣ, мураттабсозии ҳубобӣ, зарби матритсаҳо ва формулаи Гаусс. Ҳар як масъалаи ҳалшуда як зина шуморо ба сатҳи барномасози моҳир наздиктар месозад.

Дар боби 14 (Замима) луғати муфассали истилоҳоти соҳавии компютерӣ бо се забон (Тоҷикӣ — Англисӣ — Русӣ) ва маълумотномаи мухтасари забони Go барои истифодаи ҳаррӯза оварда шудааст.

пешина
аз 15
навбатӣ