Vlákno názorů k článku
OpenAI představila GPT 4, nová éra lidstva je tu? od Pavel Tavoda - Mozno to nepouzivate spravne. Kolko programatorov vo vasom...

Mozno to nepouzivate spravne. Kolko programatorov vo vasom okoli zvlada aspon toto a urobi to za par sekund aj s vysvetlivkami. Medzikody som nedaval ale skutocne to generovalo kod, skuste sami:
>>> Write Java code which creates tree from item parent relationship

Here is an example of Java code that creates a tree from an array of items, where each item has a parent relationship:

import java.util.*;

class TreeNode {
    int val;
    List<TreeNode>
....

In this example, an Item class is defined with a value and a parent value. The createTree() function takes an array of Item objects as input, creates a tree node for each item, and then adds the appropriate child-parent relationships. The function returns the root node of the tree. It is also assumed that the parentVal is 0 if the item has no parent.
This is just one of the many possible ways to implement a tree from an array of items with parent relationship, It is just a basic example which can be used as a reference. More functionality or edge cases should be handled when using it in production.

>>> Now write it in typescript

Sure, here's an equivalent version of the Java code in TypeScript:

class TreeNode {
    val: number | Long;
    children: TreeNode[];
...

In this version I've also added type for val and parentVal as number | Long as it can be long or number based on the requirement. Also, in typescript, you don't need to specify the type of the variable before the constructor call like in Java, the type can be inferred by the assigned value.
As you can see, the TypeScript code is very similar to the Java version, but with a few differences in syntax and naming conventions. For example, the new keyword is not used to create instances of classes, and method names like add() and put() are replaced with push() and set(), respectively.

>>> instead of map lookup use array iteration

Sure, here's the modified version of the TypeScript code that uses array iteration instead of a Map lookup to create the tree:

class TreeNode {
    val: number | Long;
    children: TreeNode[];

    constructor(val: number | Long) {
        this.val = val;
        this.children = [];
    }
}

class Item {
    val: number | Long;
    parentVal: number | Long;

    constructor(val: number | Long, parentVal: number | Long) {
        this.val = val;
        this.parentVal = parentVal;
    }
}

function createTree(items: Item[]): TreeNode | undefined {
    // Create a array to store the tree nodes
    const nodes = new Array<TreeNode>();
    for (const item of items) {
        const node = new TreeNode(item.val);
        nodes.push(node);
    }

    // Add the child-parent relationships
    for (const item of items) {
        for (const node of nodes) {
            if (node.val === item.parentVal) {
                node.children.push(new TreeNode(item.val));
                break;
            }
        }
    }

    // Find the root node (the one with no parent)
    for (const node of nodes) {
        if (!node.children.length) {
            return node;
        }
    }
}

const items = [
    new Item(1, 0),
    new Item(2, 1),
    new Item(3, 1),
    new Item(4, 2),
    new Item(5, 4)
];
const root = createTree(items);
console.log(`Root node value: ${root?.val}`);

As you can see, I removed the use of map and replaced it with array of TreeNode, in the first loop, I created the new TreeNode instances, then in the second loop I iterated over the array nodes and checked for the matching val to parentVal of the item, when found I added the TreeNode with matching val as child. Lastly, I iterated over the nodes again to find the root node by checking if it has no children. Please note that this method will work fine with the small arrays but it will have O(n^2) time complexity which can be slow with large datasets.

Jenze na stackoverflow to mam i s hodnocenim a komentaremi.
https://stackoverflow.com/questions/19330731/tree-implementation-in-java-root-parents-and-children

Navic ten GTP nedava pokazde stejnou odpoved. A obcas je to takovy Baron Prasil. Smes faktu, polopravd a uplnych vymyslu. Jako ono to vypada hezky, ze to zabali i do textu, ale jak vite, ze si nevymysli?

Ale odpoved ktoru ste dali vy neriesi problem ktory som chcel. Vyzera ze ste nepochopili co som chcel a co ChatGPT pochopil uplne spravne. A uz vobec som nenasiel riesenie bez HashMapy.