#15129 #15129 Yo haria algo asi, nose lo he intntado con ts pero lo tengo mal xd
spoilerconst input = ["-", "-", "."];
interface NodeTree {
value: string;
left: NodeTree;
right: NodeTree;
}
const Tree = {};
const getLeft = (node: NodeTree) => node.left;
const getRight = (node: NodeTree) => node.right;
const getGetter = (command: string) => {
if (command === "-") {
return getLeft;
}
if (command === ".") {
return getRight;
}
}
interface Monad {
acc: NodeTree[],
current: NodeTree
}
input.map(c => getGetter(c)).forEach(console.log);
const fold = (monad: Monad) => (instruction: string) => {
const node = getGetter(instruction)(monad.current);
monad.acc = [node];
monad.current = node;
return monad;
}
const initialTree: Monad = {
acc : [],
current : {
value : "2",
left : null,
right : null,
}
}
input.reduce(fold, initialTree)
Para el segundo metodo tansolo tienes que cambiar la operacion fold o la operacion reduce(que esto es lo que me peta ya que tengo el codigo del reves creo deberia ser monadTree.apply(fold, input) creo... no se no tengo ganas de pensar y lo he hecho en 15 min. (nota es la diferencia entre un foldl y un foldr en haskell). El initial tree seria donde tienes todos los nodes, conforme vas mapeando/bindeando/aplicando tus funciones te guardas el resultado en el acc y actualizas tu current node/pointer. yo ya he hecho un array para que se vea la idea de como hacer el segundo caso, tansolo conun array y guardandote en una variable array de enteros los indices de elementos a explorar. edit: aqui no entiendo si tengo 2 variables y me das una orden de quedarme el izquierda si mapeara a 2, entiendo que si, se puede simplificar aun mas creo pero no me lajuego de toque de cabeza.
para el segundo caso tansolo necesitas un metodo que te devuelva ambos nodos y en el fold mismo lo puedes gestionar... si te encuentras algo invalido deberias gestionarlo en tu custom reduce/apply pero me ha dado palo acabarlo y mirar como van las signaturas del reduce en ts.
como nota si quieres puedes guardarte las funciones directamente en este tipo de solucion a alto nivel y hacer una solucion lazy... lo bueno que tiene es que puedes ir hacia adelante y hacia atras en el arbol si quieres y poder aceptar simbolos de tirar para atras... yo creo que lo a;adiria si no es mucho lio en codigo, depende del lenguaje.
Nse yo lo haria asi vamos, mas o menos. Se ve que el segundo caso en realidad lo he resuelto en el primero y solo es un detalle de una funcion y la gestion de errores (propagar los null/ el either pipelining) que es un tema que no tiene una unica solucion, hay gente que hace eithers y los propaga otros cortan en seco, ahi al gusto.
