From 40476b5ba4e6b6c084e78bb1fafa891cd3dcdcba Mon Sep 17 00:00:00 2001 From: marco cruz Date: Thu, 14 Dec 2023 16:18:46 -0600 Subject: [PATCH 1/5] :sparkles: add challenge-11 solution --- 2023/11-los-elfos-estudiosos/README.md | 50 ++++++++++++++++++++++ 2023/11-los-elfos-estudiosos/index.js | 21 +++++++++ 2023/11-los-elfos-estudiosos/index.test.js | 42 ++++++++++++++++++ 3 files changed, 113 insertions(+) create mode 100644 2023/11-los-elfos-estudiosos/README.md create mode 100644 2023/11-los-elfos-estudiosos/index.js create mode 100644 2023/11-los-elfos-estudiosos/index.test.js diff --git a/2023/11-los-elfos-estudiosos/README.md b/2023/11-los-elfos-estudiosos/README.md new file mode 100644 index 0000000..3e0e3ce --- /dev/null +++ b/2023/11-los-elfos-estudiosos/README.md @@ -0,0 +1,50 @@ +# Reto 11: Los elfos estudiosos + +## Problema + +En el taller de Santa, los elfos aman los acertijos 🧠. Este año, han creado uno especial: un desafío para formar un palíndromo navideño. + +**Un palíndromo es una palabra que se lee igual hacia adelante y hacia atrás.** Los elfos quieren saber si es posible formar un palíndromo haciendo, como mucho, un intercambio de letras. + +Crea una función `getIndexsForPalindrome` que reciba una cadena de caracteres y devolverá: + +- Si ya es un palíndromo, un array vacío. +- Si no es posible, null. +- Si se puede formar un palíndromo con un cambio, un array con las dos posiciones (índices) que se deben intercambiar para poder crearlo. + +Por ejemplo: + +```js +getIndexsForPalindrome('anna') // [] +getIndexsForPalindrome('abab') // [0, 1] +getIndexsForPalindrome('abac') // null +getIndexsForPalindrome('aaaaaaaa') // [] +getIndexsForPalindrome('aaababa') // [1, 3] +getIndexsForPalindrome('caababa') // null`` +``` + +Si se puede formar el palíndromo con diferentes intercambios, **siempre se debe devolver el primero que se encuentre.** + +## Mi solución + +```js +function getIndexsForPalindrome(word) { + const wordLength = word.length; + const isPalindrome = (str) => str === [...str].reverse().join(''); + + if (isPalindrome(word)) return []; + + for (let i = 0; i < wordLength; i++) { + for (let j = i + 1; j < wordLength; j++) { + const newWord = [...word]; + [newWord[i], newWord[j]] = [newWord[j], newWord[i]]; + + if (newWord.join('') === newWord.reverse().join('')) { + return [i, j]; + } + } + } + + return null; +} +``` diff --git a/2023/11-los-elfos-estudiosos/index.js b/2023/11-los-elfos-estudiosos/index.js new file mode 100644 index 0000000..b533c7f --- /dev/null +++ b/2023/11-los-elfos-estudiosos/index.js @@ -0,0 +1,21 @@ +function getIndexsForPalindrome(word) { + const wordLength = word.length; + const isPalindrome = (str) => str === [...str].reverse().join(''); + + if (isPalindrome(word)) return []; + + for (let i = 0; i < wordLength; i++) { + for (let j = i + 1; j < wordLength; j++) { + const newWord = [...word]; + [newWord[i], newWord[j]] = [newWord[j], newWord[i]]; + + if (newWord.join('') === newWord.reverse().join('')) { + return [i, j]; + } + } + } + + return null; +} + +module.exports = getIndexsForPalindrome; diff --git a/2023/11-los-elfos-estudiosos/index.test.js b/2023/11-los-elfos-estudiosos/index.test.js new file mode 100644 index 0000000..2a93e1a --- /dev/null +++ b/2023/11-los-elfos-estudiosos/index.test.js @@ -0,0 +1,42 @@ +const getIndexsForPalindrome = require('./index'); + +describe('11 => Los elfos estudiosos', () => { + const testCases = [ + { + input: 'anna', + output: [], + }, + { + input: 'abab', + output: [0, 1], + }, + { + input: 'abac', + output: null, + }, + { + input: 'aaaaaaaa', + output: [], + }, + { + input: 'aaababa', + output: [1, 3], + }, + { + input: 'caababa', + output: null, + }, + ]; + + it('should return an array type if the input is a palindrome', () => { + expect(getIndexsForPalindrome('abab')).toEqual([0, 1]); + }); + + it('should return null type if the input could not be a palindrome', () => { + expect(getIndexsForPalindrome('abac')).toBeNull(); + }); + + it.each(testCases)('should return $output', ({ input, output }) => { + expect(getIndexsForPalindrome(input)).toEqual(output); + }); +}); From 6ea18fb013cfccd08c66610a1aeca45e581e0f32 Mon Sep 17 00:00:00 2001 From: marco cruz Date: Thu, 14 Dec 2023 16:20:33 -0600 Subject: [PATCH 2/5] :sparkles: add challenge-13 solution --- 2023/13-calculando-el-tiempo/README.md | 51 ++++++++++++++++++++++ 2023/13-calculando-el-tiempo/index.js | 22 ++++++++++ 2023/13-calculando-el-tiempo/index.test.js | 26 +++++++++++ 3 files changed, 99 insertions(+) create mode 100644 2023/13-calculando-el-tiempo/README.md create mode 100644 2023/13-calculando-el-tiempo/index.js create mode 100644 2023/13-calculando-el-tiempo/index.test.js diff --git a/2023/13-calculando-el-tiempo/README.md b/2023/13-calculando-el-tiempo/README.md new file mode 100644 index 0000000..03b80eb --- /dev/null +++ b/2023/13-calculando-el-tiempo/README.md @@ -0,0 +1,51 @@ +# Reto 13: Calculando el tiempo + +## Problema + +Los elfos están preparando **la víspera de Navidad** y necesitan tu ayuda para calcular si van sobrados o no de tiempo ⏳. + +Para ello te pasan un array con la duración de cada entrega. El formato de la duración es HH:mm:ss, las entregas empiezan a las 00:00:00 y el límite de tiempo es 07:00:00. + +**Tu función debe devolver el tiempo que les faltará o el tiempo que les sobrará** para terminar las entregas. El formato de la duración devuelta debe ser HH:mm:ss. + +Si terminan antes de las 07:00:00, el tiempo restante hasta las 07:00:00 debe ser mostrado con un signo negativo. Por ejemplo, **si sobran 1 hora y 30 minutos, devuelve -01:30:00** + +```js +calculateTime(['00:10:00', '01:00:00', '03:30:00']) +// '-02:20:00' + +calculateTime(['02:00:00', '05:00:00', '00:30:00']) +// '00:30:00' + +calculateTime([ + '00:45:00', + '00:45:00', + '00:00:30', + '00:00:30' +]) // '-05:29:00' +``` + +## Mi solución + +```js +function calculateTime(deliveries) { + const deliveryLimit = 7 * 3600; // Límite de tiempo en segundos (7 horas) + let totalSeconds = 0; + + // eslint-disable-next-line no-restricted-syntax + for (const time of deliveries) { + const [hours, minutes, seconds] = time.split(':').map(Number); + totalSeconds += hours * 3600 + minutes * 60 + seconds; + } + + const remainingSeconds = deliveryLimit - totalSeconds; + const pad = (value) => (value < 10 ? `0${value}` : `${value}`); + const sign = remainingSeconds <= 0 ? '' : '-'; + const absRemainingSeconds = Math.abs(remainingSeconds); + const resultHours = pad(Math.floor(absRemainingSeconds / 3600)); + const resultMinutes = pad(Math.floor((absRemainingSeconds % 3600) / 60)); + const resultSeconds = pad(absRemainingSeconds % 60); + return `${sign}${resultHours}:${resultMinutes}` + + `:${resultSeconds}`; +} +``` diff --git a/2023/13-calculando-el-tiempo/index.js b/2023/13-calculando-el-tiempo/index.js new file mode 100644 index 0000000..376f923 --- /dev/null +++ b/2023/13-calculando-el-tiempo/index.js @@ -0,0 +1,22 @@ +function calculateTime(deliveries) { + const deliveryLimit = 7 * 3600; // Límite de tiempo en segundos (7 horas) + let totalSeconds = 0; + + // eslint-disable-next-line no-restricted-syntax + for (const time of deliveries) { + const [hours, minutes, seconds] = time.split(':').map(Number); + totalSeconds += hours * 3600 + minutes * 60 + seconds; + } + + const remainingSeconds = deliveryLimit - totalSeconds; + const pad = (value) => (value < 10 ? `0${value}` : `${value}`); + const sign = remainingSeconds <= 0 ? '' : '-'; + const absRemainingSeconds = Math.abs(remainingSeconds); + const resultHours = pad(Math.floor(absRemainingSeconds / 3600)); + const resultMinutes = pad(Math.floor((absRemainingSeconds % 3600) / 60)); + const resultSeconds = pad(absRemainingSeconds % 60); + return `${sign}${resultHours}:${resultMinutes}` + + `:${resultSeconds}`; +} + +module.exports = calculateTime; diff --git a/2023/13-calculando-el-tiempo/index.test.js b/2023/13-calculando-el-tiempo/index.test.js new file mode 100644 index 0000000..75fc6ea --- /dev/null +++ b/2023/13-calculando-el-tiempo/index.test.js @@ -0,0 +1,26 @@ +const calculateTime = require('./index'); + +describe('13 => Calculando el tiempo', () => { + const testCases = [ + { + input: ['00:10:00', '01:00:00', '03:30:00'], + output: '-02:20:00', + }, + { + input: ['02:00:00', '05:00:00', '00:30:00'], + output: '00:30:00', + }, + { + input: ['00:45:00', '00:45:00', '00:00:30', '00:00:30'], + output: '-05:29:00', + }, + ]; + + it('should return a string type', () => { + expect(typeof calculateTime(testCases[0].input)).toBe('string'); + }); + + it.each(testCases)('should return $output', (testCase) => { + expect(calculateTime(testCase.input)).toBe(testCase.output); + }); +}); From c8d1e50de4c02c95d910b9b0283dc6882af6d3dc Mon Sep 17 00:00:00 2001 From: marco cruz Date: Thu, 14 Dec 2023 16:21:30 -0600 Subject: [PATCH 3/5] :sparkles: add challenge-14 solution --- 2023/14-evita-la-alarma/README.md | 32 +++++++++++++++++++++++++++ 2023/14-evita-la-alarma/index.js | 13 +++++++++++ 2023/14-evita-la-alarma/index.test.js | 30 +++++++++++++++++++++++++ 3 files changed, 75 insertions(+) create mode 100644 2023/14-evita-la-alarma/README.md create mode 100644 2023/14-evita-la-alarma/index.js create mode 100644 2023/14-evita-la-alarma/index.test.js diff --git a/2023/14-evita-la-alarma/README.md b/2023/14-evita-la-alarma/README.md new file mode 100644 index 0000000..b154443 --- /dev/null +++ b/2023/14-evita-la-alarma/README.md @@ -0,0 +1,32 @@ +# Reto 14: Evita la alarma + +## Problema + +Con el tema de las redes sociales, Santa Claus **tiene pánico que los niños se despierten mientras él está repartiendo regalos en sus casos,** usen el móvil para grabarlo y se haga viral en TikTok. + +Quiere evitarlo a toda costa. Cada casa en esa calle tiene un número de regalos preparados. Sin embargo, **las casas tienen un sistema de seguridad conectado entre casas adyacentes,** por lo que **no puede dejar los regalos en dos casas seguidas,** o se activará la alarma que alertará a los niños. + +Dada un **array de enteros no negativos regalos** que representa la cantidad de regalos en cada casa, tu tarea es ayudar a Papá Noel a determinar la **máxima cantidad de regalos que puede entregar** en una noche sin activar ninguna alarma. + +```js +maxGifts([2, 4, 2]) // 4 (4) +maxGifts([5, 1, 1, 5]) // 10 (5 + 5) +maxGifts([4, 1, 1, 4, 2, 1]) // 9 (4 + 4 + 1) +maxGifts([1, 3, 1, 3, 100]) // 103 (3 + 100) +``` + +## Mi solución + +```js +const maxGifts = (houses) => { + let incl = 0; + let excl = 0; + + // eslint-disable-next-line no-restricted-syntax + for (const current of houses) { + [incl, excl] = [excl + current, Math.max(incl, excl)]; + } + + return Math.max(incl, excl); +}; +``` diff --git a/2023/14-evita-la-alarma/index.js b/2023/14-evita-la-alarma/index.js new file mode 100644 index 0000000..1559375 --- /dev/null +++ b/2023/14-evita-la-alarma/index.js @@ -0,0 +1,13 @@ +const maxGifts = (houses) => { + let incl = 0; + let excl = 0; + + // eslint-disable-next-line no-restricted-syntax + for (const current of houses) { + [incl, excl] = [excl + current, Math.max(incl, excl)]; + } + + return Math.max(incl, excl); +}; + +module.exports = maxGifts; diff --git a/2023/14-evita-la-alarma/index.test.js b/2023/14-evita-la-alarma/index.test.js new file mode 100644 index 0000000..ae98d24 --- /dev/null +++ b/2023/14-evita-la-alarma/index.test.js @@ -0,0 +1,30 @@ +const maxGifts = require('./index'); + +describe('14 => Evita la alarma', () => { + const testCases = [ + { + input: [2, 4, 2], + output: 4, + }, + { + input: [5, 1, 1, 5], + output: 10, + }, + { + input: [4, 1, 1, 4, 2, 1], + output: 9, + }, + { + input: [1, 3, 1, 3, 100], + output: 103, + }, + ]; + + it('should return a number type', () => { + expect(typeof maxGifts([1, 2, 3])).toBe('number'); + }); + + it.each(testCases)('should return $output', ({ input, output }) => { + expect(maxGifts(input)).toBe(output); + }); +}); From fa97c024ecaf74b9eff9f87143f0fec2dbf0aea3 Mon Sep 17 00:00:00 2001 From: marco cruz Date: Sat, 16 Dec 2023 22:07:16 -0600 Subject: [PATCH 4/5] :sparkles: add challenge-15 solution --- 2023/15-robot-autonomo/README.md | 68 +++++++++++++++++++++ 2023/15-robot-autonomo/index.js | 21 +++++++ 2023/15-robot-autonomo/index.test.js | 91 ++++++++++++++++++++++++++++ 3 files changed, 180 insertions(+) create mode 100644 2023/15-robot-autonomo/README.md create mode 100644 2023/15-robot-autonomo/index.js create mode 100644 2023/15-robot-autonomo/index.test.js diff --git a/2023/15-robot-autonomo/README.md b/2023/15-robot-autonomo/README.md new file mode 100644 index 0000000..968b47e --- /dev/null +++ b/2023/15-robot-autonomo/README.md @@ -0,0 +1,68 @@ +# Reto 15: Robot autonomo + +## Problema + +Estamos programando unos **robots** llamados giftbot 🤖🎁 que navegan de forma autónoma por los almacenes de regalos. + +Estamos creando una función a la que le pasamos: el almacén 🏬 que deben navegar y los movimientos ↔️ que pueden realizar. + +El almacén se representa como un **array de cadenas de texto,** donde: + +- `.` significa que hay vía libre. +- `*` significa que hay un obstáculo. +- `!` es la posición inicial del robot. + +Los movimientos son un **array de cadenas de texto,** donde: + +- `R` mueve al robot una posición a la derecha. +- `L` mueve al robot una posición a la izquierda. +- `U` mueve al robot una posición hacia arriba. +- `D` mueve al robot una posición hacia abajo. + +Hay que tener en cuenta que **el robot no puede superar los obstáculos ni los límites del almacén.** + +Dados un almacén y los movimientos, debemos devolver el array con la posición final de nuestro robot. + +```js +const store = ['..!....', '...*.*.'] + +const movements = ['R', 'R', 'D', 'L'] +const result = autonomousDrive(store, movements) +console.log(result) +/* +[ + ".......", + "...*!*." +] +*/ + +// El último movimiento es hacia la izquierda, pero no puede moverse porque hay un obstáculo. +``` + +Ten en cuenta que la store es **un array que puede ser de un número de filas que va de 1 a 100,** ya que tenemos almacenes de todos los tamaños. + +También que el robot **es posible que termine en su posición inicial** si no puede moverse o si está dando vueltas. + +## Mi solución + +```js +function autonomousDrive(store, movements) { + let currentRow = store.findIndex((line) => line.includes('!')); + let currentCol = store[currentRow].indexOf('!'); + store[currentRow] = store[currentRow].replace('!', '.'); + + // eslint-disable-next-line no-restricted-syntax + for (const movement of movements) { + const di = +(movement === 'D') - +(movement === 'U'); + const dj = +(movement === 'R') - +(movement === 'L'); + currentRow += +(store[currentRow + di]?.[currentCol] === '.' && di); + currentCol += +(store[currentRow][currentCol + dj] === '.' && dj); + } + + const currentLine = store[currentRow]; + store[currentRow] = `${currentLine.substring(0, currentCol)}!${ + currentLine.substring(currentCol + 1)}`; + + return store; +} +``` diff --git a/2023/15-robot-autonomo/index.js b/2023/15-robot-autonomo/index.js new file mode 100644 index 0000000..fae21e1 --- /dev/null +++ b/2023/15-robot-autonomo/index.js @@ -0,0 +1,21 @@ +function autonomousDrive(store, movements) { + let currentRow = store.findIndex((line) => line.includes('!')); + let currentCol = store[currentRow].indexOf('!'); + store[currentRow] = store[currentRow].replace('!', '.'); + + // eslint-disable-next-line no-restricted-syntax + for (const movement of movements) { + const di = +(movement === 'D') - +(movement === 'U'); + const dj = +(movement === 'R') - +(movement === 'L'); + currentRow += +(store[currentRow + di]?.[currentCol] === '.' && di); + currentCol += +(store[currentRow][currentCol + dj] === '.' && dj); + } + + const currentLine = store[currentRow]; + store[currentRow] = `${currentLine.substring(0, currentCol)}!${ + currentLine.substring(currentCol + 1)}`; + + return store; +} + +module.exports = autonomousDrive; diff --git a/2023/15-robot-autonomo/index.test.js b/2023/15-robot-autonomo/index.test.js new file mode 100644 index 0000000..ecc7f8f --- /dev/null +++ b/2023/15-robot-autonomo/index.test.js @@ -0,0 +1,91 @@ +const autonomousDrive = require('./index'); + +describe('15 => Robot autonomo', () => { + const testCases = [ + { + input: [ + ['..!....'], ['R', 'L'], + ], + output: ['..!....'], + }, + { + input: [ + ['!..', '***'], ['U', 'L'], + ], + output: [ + '!..', + '***', + ], + }, + { + input: [ + [ + '..!....', + '......*', + ], + ['R', 'D', 'L'], + ], + output: [ + '.......', + '..!...*', + ], + }, + { + input: [ + [ + '*..!..*', + '*.....*', + ], + ['R', 'R', 'R', 'D', 'D'], + ], + output: [ + '*.....*', + '*....!*', + ], + }, + { + input: [ + ['***', '.!.', '***'], ['D', 'U', 'R', 'R', 'R'], + ], + output: [ + '***', + '..!', + '***', + ], + }, + { + input: [ + ['***', '*!*', '***'], ['D', 'U', 'R', 'L'], + ], + output: [ + '***', + '*!*', + '***', + ], + }, + { + input: [ + [ + '.**.*.*.', + '.***....', + '..!.....', + ], ['D', 'U', 'R', 'R', 'R'], + ], + output: + [ + '.**.*.*.', + '.***....', + '.....!..', + ], + + }, + ]; + + it('should return an array type', () => { + expect(Array.isArray(autonomousDrive(...testCases[0].input))).toBe(true); + }); + + it.each(testCases)('should return the correct output', (testCase) => { + expect(autonomousDrive(...testCase.input)).toEqual(testCase.output); + }); +}); From 529b4ac88de3b198c66e048cb65270abeb906139 Mon Sep 17 00:00:00 2001 From: marco cruz Date: Sat, 16 Dec 2023 22:08:13 -0600 Subject: [PATCH 5/5] :sparkles: add challenge-16 solution --- 2023/16-despliegue-en-viernes/README.md | 69 +++++++++++ 2023/16-despliegue-en-viernes/index.js | 13 +++ 2023/16-despliegue-en-viernes/index.test.js | 122 ++++++++++++++++++++ 3 files changed, 204 insertions(+) create mode 100644 2023/16-despliegue-en-viernes/README.md create mode 100644 2023/16-despliegue-en-viernes/index.js create mode 100644 2023/16-despliegue-en-viernes/index.test.js diff --git a/2023/16-despliegue-en-viernes/README.md b/2023/16-despliegue-en-viernes/README.md new file mode 100644 index 0000000..f12db01 --- /dev/null +++ b/2023/16-despliegue-en-viernes/README.md @@ -0,0 +1,69 @@ +# Reto 16: Despliegue en viernes + +## Problema + +Ayer viernes alguien hizo despliegue a producción y se rompió la aplicación de montaje de árboles de Navidad. Nos han pedido que lo arreglemos lo antes posible. + +El problema es que el formato de los árboles ha cambiado. **Es un array de números… ¡pero debería ser un objeto!** Por ejemplo el árbol: `[3, 1, 0, 8, 12, null, 1]` se ve así: + +```js +// 3 +// / \ +// 1 0 +// / \ \ +// 8 12 1 +``` + +Lo que necesitamos es transformar el array en un objeto donde cada nodo del árbol tiene las propiedades value, left y right. + +Por ejemplo, al ejecutar tu función `transformTree` con `[3, 1, 0, 8, 12, null, 1]` debería devolver esto: + +```js +{ + value: 3, + left: { + value: 1, + left: { + value: 8, + left: null, + right: null + }, + right: { + value: 12, + left: null, + right: null + } + }, + right: { + value: 0, + left: null, + right: { + value: 1, + left: null, + right: null + } + } +} +``` + +El elfo que está de guardia y que intentó solucionar el problema antes de irse a casa, nos ha dejado algunas pistas: + +- Si un nodo no tiene valor, se representa con null. Por lo tanto, si un nodo tiene valor null, no tendrá hijos. +- El nodo raíz se encuentra en el índice 0 del array. +- Existe una relación entre el índice de un nodo y el índice de sus hijos. ¡Busca el patrón! + +## Mi solución + +```js +function transformTree(tree) { + // eslint-disable-next-line prefer-rest-params + const index = arguments[1] ?? 0; + return tree[index] == null + ? null + : { + value: tree[index], + left: transformTree(tree, 2 * index + 1), + right: transformTree(tree, 2 * index + 2), + }; +} +``` diff --git a/2023/16-despliegue-en-viernes/index.js b/2023/16-despliegue-en-viernes/index.js new file mode 100644 index 0000000..0446d32 --- /dev/null +++ b/2023/16-despliegue-en-viernes/index.js @@ -0,0 +1,13 @@ +function transformTree(tree) { + // eslint-disable-next-line prefer-rest-params + const index = arguments[1] ?? 0; + return tree[index] == null + ? null + : { + value: tree[index], + left: transformTree(tree, 2 * index + 1), + right: transformTree(tree, 2 * index + 2), + }; +} + +module.exports = transformTree; diff --git a/2023/16-despliegue-en-viernes/index.test.js b/2023/16-despliegue-en-viernes/index.test.js new file mode 100644 index 0000000..569af44 --- /dev/null +++ b/2023/16-despliegue-en-viernes/index.test.js @@ -0,0 +1,122 @@ +const transformTree = require('./index'); + +describe('16 => Despliegue en viernes', () => { + const testCases = [ + { + input: [], + output: null, + }, + { + input: [1], + output: { + value: 1, + left: null, + right: null, + }, + }, + { + input: [1, 2, 3], + output: { + value: 1, + left: { + value: 2, + left: null, + right: null, + }, + right: { + value: 3, + left: null, + right: null, + }, + }, + }, + { + input: [17, 0, null, null, 1], + output: { + value: 17, + left: { + value: 0, + left: null, + right: { + value: 1, + left: null, + right: null, + }, + }, + right: null, + }, + }, + { + input: [3, 1, 0, 8, 12, null, 1], + output: { + value: 3, + left: { + value: 1, + left: { + value: 8, + left: null, + right: null, + }, + right: { + value: 12, + left: null, + right: null, + }, + }, + right: { + value: 0, + left: null, + right: { + value: 1, + left: null, + right: null, + }, + }, + }, + }, + { + input: [2, 7, 5, null, 6, null, 9, null, null, 1, 11, null, null, null, 10], + output: { + value: 2, + left: { + value: 7, + left: null, + right: { + value: 6, + left: { + value: 1, + left: null, + right: null, + }, + right: { + value: 11, + left: null, + right: null, + }, + }, + }, + right: { + value: 5, + left: null, + right: { + value: 9, + left: null, + right: { + value: 10, + left: null, + right: null, + }, + }, + }, + }, + }, + ]; + + it('should return an object type', () => { + expect(typeof transformTree([1])).toBe('object'); + }); + + it.each(testCases)('should return the correct tree', ({ input, output }) => { + expect(transformTree(input)).toStrictEqual(output); + }); +});