Programando Sum Root to Leaf Numbers en Golang

No hay solucion que alguien hiciera en JS Javascript? :( jaja en cuanto pueda la hago y la subo jeje

Solución en java

class Solution {
    static int total;
    public int sumNumbers(TreeNode root) {
        total = 0;
        dfs(root, 0);
        return total;
    }
    static void dfs(TreeNode root, int parent) {
        int value = (parent * 10) + root.val;
        if(root.left == null && root.right == null){
            total += value;
            return;
        }

        if(root.left != null) {
            dfs(root.left, value);
        }

        if(root.left != null) {
            dfs(root.right, value);
        }
        
        return;

    }
}

Solución en c++

#include <iostream>
#include <vector>

using namespace std;

struct Node
{
    int value;
    vector<Node> childrens;
};

int dfs(const Node &root, int path, int &sum)
{
    if (root.childrens.size() == 0)
    {
        sum += path;
        return sum;
    }

    for (int i = 0; i < root.childrens.size(); i++)
    {
        dfs(root.childrens[i], path * 10 + root.childrens[i].value, sum);
    }
    return sum;
}

int main()
{
    // root
    Node root;
    root.value = 1;

    // child1
    Node child1;
    child1.value = 2;

    // grandchild1
    Node grandchild1;
    grandchild1.value = 4;
    // grandchild2
    Node grandchild2;
    grandchild2.value = 1;

    child1.childrens.push_back(grandchild1);
    child1.childrens.push_back(grandchild2);

    // child2
    Node child2;
    child2.value = 3;
    root.childrens.push_back(child2);

    root.childrens.push_back(child1);
    int result = 0;
    dfs(root, root.value, result);

    cout << result << endl;

    return 0;
}

Puede ser que el error en el codigo es que la variable caminoActual nunca se regenera?

Esta es mi solución en Kotlin:

data class Node(
    val value: Int,
    val children: List<Node>? = null,
)

fun main() {
    val root = Node(
        value = 1,
        children = listOf(
            Node(
                value = 3,
                children = listOf(
                    Node(value = 5),
                    Node(value = 8),
                )
            ),
            Node(
                value = 7,
                children = listOf(
                    Node(1)
                )
            )
        )
    )
    val total = dfs(root, "")
    println("The sum is: $total")
}

fun dfs(node: Node, number: String): Int {
    if (node.children == null) {
        return "$number${node.value}".toInt()
    }
    var total = 0
    node.children.forEach {
        total += dfs(it, "$number${node.value}")
    }

    return total
}

Solución en Python ```js def Sum_Root(nodo): if not nodo: return 0 return dfs(nodo) def dfs(nodo , caminoActual=""): if not nodo.izquierda and not nodo.derecha: return int(caminoActual + str(nodo.valor)) total = 0 if nodo.izquierda: total += dfs(nodo.izquierda , caminoActual + str(nodo.valor)) if nodo.derecha: total += dfs(nodo.derecha , caminoActual + str(nodo.valor)) return total ```

Código un poco más simplificado: package main import ( "fmt") // TreeNode represents a node in a binary tree.type TreeNode struct { Val int Left \*TreeNode Right \*TreeNode} // sumNumbers function calculates the sum of all numbers formed by root-to-leaf paths.func sumNumbers(root \*TreeNode) int { var dfs func(node \*TreeNode, currentNumber int) int dfs = func(node \*TreeNode, currentNumber int) int { if node == nil { return 0 } currentNumber = currentNumber\*10 + node.Val if node.Left == nil && node.Right == nil { return currentNumber } return dfs(node.Left, currentNumber) + dfs(node.Right, currentNumber) } return dfs(root, 0)} func main() { // Example usage: root := \&TreeNode{Val: 1} root.Left = \&TreeNode{Val: 2} root.Right = \&TreeNode{Val: 3} result := sumNumbers(root) fmt.Printf("result: %d\n", result)}

Esta es mi solucion en Node.js

var total = 0;

const sumNumbers = (root) => {
    if (nodeIsEmpty(root)) return 0;

    let sumTxt = String(root.content);
    dfs(root, sumTxt);

    console.log("Total ", total);
}

const dfs = (node, sumTxt) => {
    if (nodeIsEmpty(node.right) && nodeIsEmpty(node.left)) {
        total = total + Number(sumTxt);
    };

    calculateSum(node.right, sumTxt, total);
    calculateSum(node.left, sumTxt, total);
}

const nodeIsEmpty = (node) => {
    return node == undefined || Object.keys(node).length == 0;
}

const calculateSum = (node, sumTxt) => {
    if (nodeIsEmpty(node)) return;

    dfs(node, sumTxt + String(node.content));
}

const root = {
    content: 1,
    visited: false,
    right : {
        content: 3,
        visited: false,
        right : {
            content: 5,
            visited: false,
            right: {},
            left: {}
        },
        left: {
            content: 8,
            visited: false,
            right: {},
            left: {}
        }
    },
    left: {
        content: 7,
        visited: false,
        right: {},
        left: {
            content: 1,
            visited: false,
            right: {},
            left: {}
        }
    }
}

sumNumbers(root);

Aquí está mi solución, un poco rudimentaria pero sirve. ```js totalF = 0 class Node: def __init__(self, valor): self.valor = valor self.izquierda = None self.derecha = None nodo1 = Node(1) nodo2 = Node(2) nodo3 = Node(3) nodo4 = Node(4) nodo5 = Node(5) nodo6 = Node(6) nodo1.izquierda = nodo2 nodo1.derecha = nodo3 nodo2.izquierda = nodo4 nodo2.derecha = nodo5 nodo3.izquierda = nodo6 def sum_numbers(nodo): if nodo == None: return 0 dfs(nodo, "", 0) return totalF def dfs(nodoAct, cadenaSuma, total): global totalF if(nodoAct.izquierda == None and nodoAct.derecha == None): total += int((cadenaSuma) + str(nodoAct.valor)) if(nodoAct.izquierda != None): dfs(nodoAct.izquierda, cadenaSuma+str(nodoAct.valor), total) if(nodoAct.derecha != None): dfs(nodoAct.derecha, cadenaSuma+str(nodoAct.valor), total) if totalF != total: totalF += total else: return totalF print(sum_numbers(nodo1)) ```totalF = 0 *class* <u>Node</u>:    *def* \_\_init\_\_(*self*, *valor*):        *self*.valor = *valor*        *self*.izquierda = None        *self*.derecha = None nodo1 = <u>Node</u>(1)nodo2 = <u>Node</u>(2)nodo3 = <u>Node</u>(3)nodo4 = <u>Node</u>(4)nodo5 = <u>Node</u>(5)nodo6 = <u>Node</u>(6) nodo1.izquierda = nodo2nodo1.derecha = nodo3nodo2.izquierda = nodo4nodo2.derecha = nodo5nodo3.izquierda = nodo6 *def* sum\_numbers(*nodo*):    if *nodo* == None:        return 0    dfs(*nodo*, "", 0)    return totalF *def* dfs(*nodoAct*, *cadenaSuma*, *total*):    global totalF    if(*nodoAct*.izquierda == None and *nodoAct*.derecha == None):        *total* += <u>int</u>(*(cadenaSuma)* + <u>str</u>(*nodoAct*.valor))    if(*nodoAct*.izquierda != None):        dfs(*nodoAct*.izquierda, *cadenaSuma*+<u>str</u>(*nodoAct*.valor), *total*)    if(*nodoAct*.derecha != None):        dfs(*nodoAct*.derecha, *cadenaSuma*+<u>str</u>(*nodoAct*.valor), *total*)    if totalF != *total*:     totalF += *total*    else: return totalF print(sum\_numbers(nodo1))    

Despues de pensar un poco lo logre

class Response:
    total = 0

    def __init__(self, total):
        self.total = total

    def dfs(self, node, valor_actual):
        parcial = valor_actual + str(node.valor)

        if node.izquierda is None and node.derecha is None:
            self.total = self.total + int(parcial)
        if node.derecha is not None:
            self.dfs(node.derecha, parcial)
        if node.izquierda is not None:
           self.dfs(node.izquierda, parcial)


def sum_numbers(node, valor_actual=''):
    response = Response(0)
    response.dfs(node, valor_actual)
    return response.total

Hola 😄, les comparto la solución en Golang junto a la prueba.
.
solSRLN.go:

package main

import (
	"fmt"
	"strconv"
)

// Definición de la estructura del árbol
type Nodo struct {
	Val       int
	izquierda *Nodo
	derecha   *Nodo
}

// Creación del árbol
var arbolSRLN = &Nodo{
	Val: 1,
	izquierda: &Nodo{
		Val: 3,
		izquierda: &Nodo{
			Val:       5,
			izquierda: nil,
			derecha:   nil,
		},
		derecha: &Nodo{
			Val:       8,
			izquierda: nil,
			derecha:   nil,
		},
	},
	derecha: &Nodo{
		Val:       7,
		izquierda: nil,
		derecha: &Nodo{
			Val:       1,
			izquierda: nil,
			derecha:   nil,
		},
	},
}

// Función que realiza la suma de los números del árbol
func sumNumbers(raiz *Nodo) int {
	if raiz == nil {
		return 0
	}
	total := 0
	dfs(raiz, "", &total)
	return total
}

// Función DFS recursiva para recorrer el árbol y sumar los números
func dfs(raiz *Nodo, caminoActual string, sumaTotal *int) {
	if raiz.izquierda == nil && raiz.derecha == nil {
		valor, _ := strconv.Atoi(caminoActual + strconv.Itoa(raiz.Val))
		*sumaTotal += valor
	}
	if raiz.izquierda != nil {
		dfs(raiz.izquierda, caminoActual+strconv.Itoa(raiz.Val), sumaTotal)
	}
	if raiz.derecha != nil {
		dfs(raiz.derecha, caminoActual+strconv.Itoa(raiz.Val), sumaTotal)
	}
}

func main() {
	fmt.Println(sumNumbers(arbolSRLN))
}

.
Output:

Mi solucion en Python :

def sum_root_regresive(root):
    left = sum_function(root, 'left')
    right = sum_function(root, 'right')
    return left + right

def sum_function(root, direction, str_queue = ''):
    if root.get(direction) == None:
        return int(str_queue + str(root['value']))
    
    return sum_function(root[direction], direction, str_queue + str(root['value']))

Mi solución recursiva en python:

def sum_numbers(root: Node, start_number_with: str = '') -> int:
  if root.left is None and root.right is None:
    return int(start_number_with + str(root.value))
  
  left = 0
  right = 0
  
  if root.left is not None:
    left = sum_numbers(root.left, start_number_with + str(root.value))
  if root.right is not None:
    right = sum_numbers(root.right, start_number_with + str(root.value))

  
  return left + right