Комментарии / Профиль s60 / Хабр

@s60

Пользователь

0,4

Рейтинг

Подписчики

ПрофильСтатьи3ПостыНовостиКомментарии1.1K

Краш‑тест клона корпоративной системы, написанного ИИ за 48 часов

s60 24 сен в 13:53

на Youtube полно роликов где вскрывают замок двери в автомобиле за 5... 7... 10 ... 15 ... 20 тыр .... конечно есть возмущающиеся "Э.... чо так дОрога!"

Инженер устал от работы Enter-ом, где Claude Code создаёт спецификации, код, тесты, задачи, решения этих задач и отчёты

s60 24 сен в 13:36

-2

s60 24 сен в 13:31

попросил сейчас то же самое написать чатгпт - на удивление он с первого раза компилирующийся вариант .... спрогрессировал гад ... молодец .....

но реализация не такая как весной была:

код

package main

import "fmt"

type BTreeNode struct {
	keys     []int
	children []*BTreeNode
	leaf     bool
}

type BTree struct {
	root *BTreeNode
	t     int // минимальная степень дерева
}

func NewBTree(t int) *BTree {
	return &BTree{
		root: &BTreeNode{
			leaf: true,
		},
		t: t,
	}
}

// Разделяет переполненный дочерний узел.
func (tree *BTree) splitChild(parent *BTreeNode, index int) {
	t := tree.t
	full := parent.children[index]

	right := &BTreeNode{
		leaf: full.leaf,
		keys: make([]int, t-1),
	}

	// Средний ключ поднимается в parent.
	middle := full.keys[t-1]

	// Правая половина ключей.
	copy(right.keys, full.keys[t:])

	// Оставляем левую половину в full.
	full.keys = full.keys[:t-1]

	// Если это не лист, делим и детей.
	if !full.leaf {
		right.children = make([]*BTreeNode, t)

		copy(right.children, full.children[t:])
		full.children = full.children[:t]
	}

	// Добавляем новый child.
	parent.children = append(parent.children, nil)
	copy(
		parent.children[index+2:],
		parent.children[index+1:],
	)
	parent.children[index+1] = right

	// Добавляем средний ключ.
	parent.keys = append(parent.keys, 0)
	copy(parent.keys[index+1:], parent.keys[index:])
	parent.keys[index] = middle
}

// Вставка ключа в неполный узел.
func (tree *BTree) insertNonFull(node *BTreeNode, key int) {
	i := len(node.keys) - 1

	if node.leaf {
		node.keys = append(node.keys, 0)

		for i >= 0 && key < node.keys[i] {
			node.keys[i+1] = node.keys[i]
			i--
		}

		node.keys[i+1] = key
		return
	}

	for i >= 0 && key < node.keys[i] {
		i--
	}
	i++

	// Если child переполнен — сначала разделяем его.
	if len(node.children[i].keys) == 2*tree.t-1 {
		tree.splitChild(node, i)

		if key > node.keys[i] {
			i++
		}
	}

	tree.insertNonFull(node.children[i], key)
}

func (tree *BTree) Insert(key int) {
	root := tree.root

	// Корень переполнен — создаём новый корень.
	if len(root.keys) == 2*tree.t-1 {
		newRoot := &BTreeNode{
			leaf:     false,
			children: []*BTreeNode{root},
		}

		tree.root = newRoot
		tree.splitChild(newRoot, 0)

		tree.insertNonFull(newRoot, key)
		return
	}

	tree.insertNonFull(root, key)
}

// Симметричный обход B-tree.
// Для каждого узла:
//
// child[0], key[0], child[1], key[1], ...
//
// поэтому результат получается отсортированным.
func (tree *BTree) InOrder() []int {
	result := make([]int, 0)

	var walk func(*BTreeNode)

	walk = func(node *BTreeNode) {
		if node == nil {
			return
		}

		for i, key := range node.keys {
			if !node.leaf {
				walk(node.children[i])
			}

			result = append(result, key)
		}

		if !node.leaf {
			walk(node.children[len(node.children)-1])
		}
	}

	walk(tree.root)

	return result
}

// Сортировка через B-tree.
func Sort(values []int) []int {
	if len(values) == 0 {
		return nil
	}

	// t = 2 => классический 2-3-4 tree.
	tree := NewBTree(2)

	for _, value := range values {
		tree.Insert(value)
	}

	return tree.InOrder()
}

func main() {
	values := []int{
		10, 4, 7, 2, 15,
		1, 20, 8, 3, 12,
	}

	sorted := Sort(values)

	fmt.Println("До:     ", values)
	fmt.Println("После:  ", sorted)
}

весенний вариант (рабочий):

код

package main

import (
	"fmt"
	"strings"
)

// BTree represents a B-tree
type BTree struct {
	root *node
	t    int // minimum degree
}

// node represents a B-tree node
type node struct {
	keys     []int   // sorted keys
	children []*node // child nodes
	leaf     bool    // whether this node is a leaf
}

// NewBTree creates a new B-tree with the given minimum degree t
func NewBTree(t int) *BTree {
	return &BTree{
		root: &node{
			keys:     []int{},
			children: []*node{},
			leaf:     true,
		},
		t: t,
	}
}

// Search looks for a key in the tree
func (tree *BTree) Search(key int) bool {
	return tree.root.search(key)
}

// search looks for a key in the node
func (n *node) search(key int) bool {
	i := 0
	for i < len(n.keys) && key > n.keys[i] {
		i++
	}

	if i < len(n.keys) && key == n.keys[i] {
		return true
	}

	if n.leaf {
		return false
	}

	return n.children[i].search(key)
}

// Insert inserts a key into the tree
func (tree *BTree) Insert(key int) {
	root := tree.root

	// If the root is full, we need to split it
	if len(root.keys) == (2*tree.t - 1) {
		newRoot := &node{
			keys:     []int{},
			children: []*node{root},
			leaf:     false,
		}
		newRoot.splitChild(0, tree.t)
		tree.root = newRoot
	}

	tree.root.insertNonFull(key, tree.t)
}

// splitChild splits a full child of the node at index i
func (n *node) splitChild(i int, t int) {
	child := n.children[i]

	// Create a new child that will take the right half of the keys
	newChild := &node{
		keys:     make([]int, t-1),
		children: make([]*node, t),
		leaf:     child.leaf,
	}

	// Copy the last (t-1) keys to the new child
	for j := 0; j < t-1; j++ {
		newChild.keys[j] = child.keys[j+t]
	}

	// If not a leaf, copy the corresponding children
	if !child.leaf {
		for j := 0; j < t; j++ {
			newChild.children[j] = child.children[j+t]
		}
	}

	// The middle key (at index t-1) will be promoted to parent
	middleKey := child.keys[t-1]

	// Keep only the first (t-1) keys in the old child
	child.keys = child.keys[:t-1]

	// Keep only the first t children in the old child
	if !child.leaf {
		child.children = child.children[:t]
	}

	// Insert the middle key into the parent at position i
	n.keys = append(n.keys, 0)
	copy(n.keys[i+1:], n.keys[i:])
	n.keys[i] = middleKey

	// Insert the new child into the parent at position i+1
	n.children = append(n.children, nil)
	copy(n.children[i+2:], n.children[i+1:])
	n.children[i+1] = newChild
}

// insertNonFull inserts a key into a node that is guaranteed not to be full
func (n *node) insertNonFull(key int, t int) {
	i := len(n.keys) - 1

	if n.leaf {
		// Insert the key into the leaf
		n.keys = append(n.keys, 0)
		for i >= 0 && key < n.keys[i] {
			n.keys[i+1] = n.keys[i]
			i--
		}
		n.keys[i+1] = key
	} else {
		// Find which child to go to
		for i >= 0 && key < n.keys[i] {
			i--
		}
		i++

		// If that child is full, split it
		if len(n.children[i].keys) == (2*t - 1) {
			n.splitChild(i, t)
			// After splitting, choose the correct child
			if key > n.keys[i] {
				i++
			}
		}
		n.children[i].insertNonFull(key, t)
	}
}

// Delete removes a key from the tree
func (tree *BTree) Delete(key int) bool {
	if tree.root == nil {
		return false
	}

	deleted := tree.root.delete(key, tree.t)

	if len(tree.root.keys) == 0 && !tree.root.leaf {
		tree.root = tree.root.children[0]
	}

	return deleted
}

func (n *node) delete(key int, t int) bool {
	i := 0
	for i < len(n.keys) && key > n.keys[i] {
		i++
	}

	if i < len(n.keys) && key == n.keys[i] {
		if n.leaf {
			n.keys = append(n.keys[:i], n.keys[i+1:]...)
			return true
		} else {
			leftChild := n.children[i]
			rightChild := n.children[i+1]

			if len(leftChild.keys) >= t {
				pred := leftChild.getMaxKey()
				n.keys[i] = pred
				return leftChild.delete(pred, t)
			} else if len(rightChild.keys) >= t {
				succ := rightChild.getMinKey()
				n.keys[i] = succ
				return rightChild.delete(succ, t)
			} else {
				n.mergeChildren(i, t)
				return n.children[i].delete(key, t)
			}
		}
	}

	if n.leaf {
		return false
	}

	if len(n.children[i].keys) < t {
		n.fixChild(i, t)
	}

	return n.children[i].delete(key, t)
}

// getMinKey returns the minimum key in the subtree
func (n *node) getMinKey() int {
	if n.leaf {
		return n.keys[0]
	}
	return n.children[0].getMinKey()
}

// getMaxKey returns the maximum key in the subtree
func (n *node) getMaxKey() int {
	if n.leaf {
		return n.keys[len(n.keys)-1]
	}
	return n.children[len(n.children)-1].getMaxKey()
}

// mergeChildren merges the i-th and (i+1)-th children
func (n *node) mergeChildren(i int, t int) {
	child := n.children[i]
	sibling := n.children[i+1]

	child.keys = append(child.keys, n.keys[i])
	child.keys = append(child.keys, sibling.keys...)

	if !child.leaf {
		child.children = append(child.children, sibling.children...)
	}

	n.keys = append(n.keys[:i], n.keys[i+1:]...)
	n.children = append(n.children[:i+1], n.children[i+2:]...)
}

// fixChild fixes a child that has fewer than t keys
func (n *node) fixChild(i int, t int) {
	if i > 0 && len(n.children[i-1].keys) >= t {
		leftSibling := n.children[i-1]
		child := n.children[i]

		child.keys = append([]int{n.keys[i-1]}, child.keys...)

		if !child.leaf {
			child.children = append([]*node{leftSibling.children[len(leftSibling.children)-1]}, child.children...)
			leftSibling.children = leftSibling.children[:len(leftSibling.children)-1]
		}

		n.keys[i-1] = leftSibling.keys[len(leftSibling.keys)-1]
		leftSibling.keys = leftSibling.keys[:len(leftSibling.keys)-1]
		return
	}

	if i < len(n.children)-1 && len(n.children[i+1].keys) >= t {
		rightSibling := n.children[i+1]
		child := n.children[i]

		child.keys = append(child.keys, n.keys[i])

		n.keys[i] = rightSibling.keys[0]
		rightSibling.keys = rightSibling.keys[1:]

		if !child.leaf {
			child.children = append(child.children, rightSibling.children[0])
			rightSibling.children = rightSibling.children[1:]
		}
		return
	}

	if i > 0 {
		n.mergeChildren(i-1, t)
	} else {
		n.mergeChildren(i, t)
	}
}

// Print prints the tree to the console (for debugging)
func (tree *BTree) Print() {
	if tree.root == nil {
		fmt.Println("Empty tree")
		return
	}
	tree.root.print(0)
}

func (n *node) print(level int) {
	indent := strings.Repeat("  ", level)
	fmt.Printf("%sNode (leaf=%v): %v\n", indent, n.leaf, n.keys)
	if !n.leaf {
		for _, child := range n.children {
			child.print(level + 1)
		}
	}
}

func main() {
	tree := NewBTree(3)

	fmt.Println("=== Insertion ===")
	values := []int{10, 20, 5, 6, 12, 30, 7, 17}
	for _, v := range values {
		fmt.Printf("Inserting %d\n", v)
		tree.Insert(v)
		tree.Print()
		fmt.Println("---")
	}

	fmt.Println("\n=== Search ===")
	fmt.Printf("Search for 6: %v\n", tree.Search(6))
	fmt.Printf("Search for 100: %v\n", tree.Search(100))

	fmt.Println("\n=== Deletion ===")
	fmt.Printf("Deleting 6: %v\n", tree.Delete(6))
	tree.Print()
	fmt.Printf("Search for 6 after deletion: %v\n", tree.Search(6))

	fmt.Printf("\nDeleting 10: %v\n", tree.Delete(10))
	tree.Print()
}

s60 24 сен в 12:18

так ты в Перте или Мадриде ? Или в Челябинске ?

-1

s60 24 сен в 12:15

то в чем проблема решать проблемы и работать с ОАЭ, Индийцами или Европейцами?

европейцы - русофобы.... напустили себе мигрантов с Африки вот пусть они им и помогают ...

арабы - ойдануна ...

Индия - жара, влажность, рассадник антисанитарии .....

s60 24 сен в 11:10

Вот вот, даже Китай понимает. Ни с кем ни срался ни ругался, но это нисколько не спасло его от перекрытого Ормуза.

так а Сила Сибири для кого ? :)

s60 24 сен в 11:00

У создателей ИИ нет цели впарить нам свой продукт по разработке кода, заработать на этом здесь и сейчас, нет цели сделать разработчиков безработными.

... а банкиры заботятся о вас давая ипотеку для покупки, заботливо построенной строителями, квартирки с картонными стенами, которые держатся на штукатурке и обоях, с прекрасной слышимостью (живете каждый в своей норке, с соседями не общаетесь, а так вы всё про них знаете, они про вас ... З = забота) ....

Продукты теперь не кг и литр, а 978 гр.... 879 гр... 765 гр.... 988 мл... 899 мл... чтоб вы не переедали...

ОПСОсы заботятся о вас всё время урезая трафик и увеличивая цену - чтоб вы тиктоке не засиживались, а больше проводили с семьёй, время пиная любезно предоставленный вам Спортмастером мяч из аж Пакистана ....

АвтоВАЗ заботится о вас предлагая НИВУ Легенду за 2 ляма, а то как же вы без колес под жопой...

Продавцы импортных тазиков стараются, чтоб вы не ездили долго (как наши отцы в 123 мерсе или второй морковке) в одном автомобиле, это не гигиенично, меняйте их как носки - дважды в день....

Вайлдбериз спать не может пока не оденет вас в телогрейку ....

Яндекс.Такси ради вас стал монополистом и ласково заставляет таксистов возить вас куда прикажите ...

Яндекс.Карты пихают рекламу ваших конкурентов на вашем сайте чтобы вам лучше было ....

Даже проститутки всей бригадой о вас переживают ... как вы там, бедолага ... один .... на один ....

Возможно вы человек тонкой душевной организации, которого реальность может травмировать сильнее, чем Нео .... я не возьму на себя такую ответственность....

но! ... если ... вдруг... когда-нибудь .... вы захотите узнать ~~причину любой войны~~ что миром правят деньги и уставная цель коммерческой организации - извлечение прибыли, а не найти вам работу или подружку .... то просто загляните сюда.....

s60 24 сен в 06:50

Я вообще больше ориентировался на Испанию, Австралию и им подобных

жаль ты не в Австралии инженером...... эх....

s60 24 сен в 06:45

Я бы не смотрел только на этот, совсем небольшой, рынок, тем более для инженерных специальностей.

ты про инженера в Перте или Молдове ?

s60 24 сен в 06:43

Современный монтаж требует наличия одних только инструментов на несколько тыщ у.е., всякие макиты книпексы вера,

.... а накачаться можно только на KETTLER и с IVANKO

s60 24 сен в 06:42

спасибо, что ты не ...... а пока эти ребята зарабатывают свой кусок печенья...

s60 23 сен в 20:03

Так парадокс в том , что это одноразовое проталкивают манеры чтобы быстрее и больше бабла срубить, чтобы..... хлопнуть дверью своей работёнки и пойти.... потреблять этот, ими же созданный (в другой конторе такой манагер) мир: купить одноразовый автомобиль.... приехать в свой одноразовый дом..... поесть пластиковой еды... позвонить по одноразовому телефону.... посмотреть одноразовый фильм..... послушать одноразовую песню, сгенерированную нейросетью..... съесть одноразовое лекарство (потому что завтра выйдет новый вирус, от которого это лекарство не спасает) и т.д.

s60 23 сен в 19:47

Так навязывают их манагеры, которы нейронками и двух байт не переслали....

s60 23 сен в 19:06

тиндеры..... казино.... ставки на спорт..... марафоны желаний - получается, а эти чем хуже? у ни манагеры не тупее ваших....

что-то ещё никто не выкатил "убийцу виндовс" за вечер и 200 нейробаксов ....

s60 23 сен в 16:48

платная ИИшечка - это тиндер для погромистов, раньше манеры впаривали бизнесу еэрпишечки.... теперь ИИшечки.... с теми же лозунгами... им вообще всё равно что впаривать....

в задачи тиндера не входит чтоб вы с одного токена нашли то, что искали, поженились и жили вместе 100 лет ...

его задача удерживать вас на сайте с платной подпиской как можно дольше.... подсовывая иллюзию что вот-вот и ты выиграешь свой миллиард.... вон васян же выиграл.... купи ещё парочку токенов..... о! вышла новая версия....лучше прежней.... перейди сегодня и получи тапки в подарок....