¡Te damos la bienvenida a este reto!

1

¡Bienvenido al mundo de JavaScript!

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

Día 2

6

Operadores

7

Hoisting y coerción

8

Playground - Calcula la propina

9

Alcance de las variables

Día 3

10

Condicionales

11

Playground - Calcula años bisiestos

12

Switch

13

Playground - Obten información de mascotas según su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

Día 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

20

Playground - encuentra el palindromo más grande

Día 6

21

Reasignación y redeclaración

22

Modo estricto

Día 7

23

Debugging y manejo de errores

24

Programación funcional

Quiz: Día 7

Día 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio método map

Día 9

29

ECMAScript

30

TC39

Quiz: Día 9

Día 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

Día 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

Día 12

39

Arrays a profundidad

40

Métodos de arrays: Every, Find y findIndex

41

Playground - Válida el formulario

Día 13

42

Métodos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

Métodos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicación del valor buscado

Día 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

Métodos de arrays: sort

49

Playground - Ordena los productos

Día 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

Día 16

51

Programación orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

Día 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

Día 18

57

Abstracción en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

Día 19

61

Herencia en JavaScript

62

Playground - Jerarquía de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

Día 20 - Checkpoint

65

Playground - Agenda de vuelos

Día 21

66

Patrones de diseño

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

Día 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el código usando builder pattern

Día 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajería

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementación de Observador en Newsletter

Día 24 - Checkpoint

77

Playground - Crea un task manager con patrones de diseño

Día 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementación de un array

80

Hash tables en JavaScript

81

Playground - Implementación de una HashTable para Contactos

Día 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

Día 27

86

Singly Linked List en JavaScript

87

Playground - Agrega métodos a la singly linked list

88

Playground - Implementación de una singly linked list

Día 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

Día 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

Día 30

93

¡Lo lograste!

Live Class

94

30 días de JS con Juan DC

95

30 días de JS con Nicobytes

96

30 días de JS con GNDX

97

30 días de JS con LeoCode

98

30 días de JS con Teffcode

99

Sesión: Cierre de los 30 días de JavaScript

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprende Inglés, Programación, AI, Ciberseguridad y mucho más.

Antes: $249

Currency
$209
Suscríbete

Termina en:

4 Días
9 Hrs
36 Min
33 Seg

Playground - Encuentra la ubicación del valor buscado

45/99

Aportes 80

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

¡Hola 😃!

Mi solución,
Se detalla hasta abajo.⬇



export function searchValue(array, value)
{
  let flat = array.flat(1).includes(value);
  if (!flat)
    throw new Error("Valor no encontrado");

  let rta;
  const result = array.map((array, index) => {
    if (array.includes(value))
      rta = { row: index, column: array.indexOf(value) }
  });
  return rta;
}

🛡️Escudo anti-spoilers🛡️

Aqui esta mi codigo:

export function searchValue(array, value) {
  if (!array.flat().includes(value))
    throw new Error("Valor no encontrado");


  for (let i = 0; i < array.length; i++){
    const row = array[i]
    if (row.includes(value))
      return {
        row: i,
        column: (row.indexOf(value))
      }
  }
}

🛡️Escudo anti-spoilers🛡️

Aqui mi código

export function searchValue(array, value) {
  if (!array.flatMap(x => x).find(obj=>obj == value ))
    throw new Error("Valor no encontrado");
  return {
    row:
      array.findIndex(obj => obj.includes(value)),
    column:
       array.find(obj => obj.includes(value))
            .findIndex(obj => obj == value),
  }
}

#My solution

.
.
:

export function searchValue(array, value) {
  const row = array.findIndex((row) => row.includes(value))
  if (row !== -1) {
    const column = array[row].indexOf(value)
    return {row, column}
  } else {
    throw Error("Valor no encontrado");
  }
}

dejo mi solucion a este reto
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈
  const flatArray = array.flat(1);
  if (!flatArray.includes(value)) {
    throw new Error("Valor no encontrado");
  } else {
    const row = array.findIndex(el => el.includes(value))
    const column = array[row].findIndex(el => el === value);
    return {row: row, column: column}
  }
}

Mi aporte

export function searchValue(array, value) {
  // Tu código aquí 👈
  let row = null;
  let column = null;
  for (let i = 0; i < array.length; i++) {
    for (let j = 0; j < array.length; j++) {
      console.log(array[i][j])
      if (array[i][j] === value) {
        row = i;
        column = j;
      }
    }
  }

  if (row === null && column === null) {
    throw new Error("Valor no encontrado");
  } else {
   return  result = {
      row: row,
      column: column
    }
  }
}

Esta es mi solución, cuidado con los spoilers!:
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let output = false;

  array.flatMap((val, index) => {
    let fIndex = val.findIndex(v => v === value);
    if (fIndex != -1) {
      output = {"row": index, "column": fIndex}
    }
  })

  if (output) {
    return output;
  }
  else {
    throw new Error("Valor no encontrado")
  }
}

No se hagan spoilers !!!

Les comparto mi solucion 😁 ```js function searchValue(array, value) { const result = { row: 0, column: 0, } const indexRow = array.findIndex(row => row.find((num) => num === value)); result.row = indexRow; const indexColumn = array[indexRow].findIndex((num) => num === value); result.column = indexColumn; return result; }; ```

Este ejercicio fue echo sin usar el metodo include()

const array = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
]
const value = 8
export function searchValue(array, value) {
  const unaDimension = array.flat()
  const valor = unaDimension.find(x => { return x === value })
  if (valor === value) {
    for (const cadaDimension of array) {
      const primeraDimension = cadaDimension.indexOf(value)
      if (primeraDimension >= 0) {
        const indexRow = array.findIndex(x => x[primeraDimension] === value)
       return { row: indexRow, column : primeraDimension}
      }
    }
  }
    else if (valor === undefined) {
      throw new Error('valor no encontrado')
    }
    
}
searchValue(array, value)


export function searchValue(array, value) {
  const flat = array.flat(1).includes(value)
  if (!flat) {
    throw new Error("Valor no encontrado");
  }
  let result = {};
  array.forEach((arr, row) => {
    let column = arr.indexOf(value);
    if (column > -1) {
      result.row = row;
      result.column = column;
    }
  })
  return result;
}

Old school solution
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈

  if (!array.flat().includes(value))
    throw new Error("Valor no encontrado");

  for (let i = 0; i < array.length; i++) {
    for (let j = 0; j < array[i].length; j++) {
      if (value === array[i][j]) {
        return {
          row: i,
          column: j
        }
      }
    }
  }
}

No entendí por qué usaría el flat o flatmap, al menos en este ejercicio, pero lo resolví así…













export function searchValue(array, value) {
let valueRow = -1, valueColumn = -1
let r = 0, c = 0, res
array.forEach(valarr => {
valarr.forEach(val => {
if (val == value) {
valueRow = r
valueColumn = c
res = {
row: valueRow,
column: valueColumn
}
}
c++
})
r++
c = 0
})

if (valueColumn == -1) {
throw new Error(“Valor no encontrado”)
}
return res
}

Solución 😄

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Encuentra la ubicación del valor buscado

export function searchValue(array, value) {
  // Tu código aquí 👈
  let result = undefined;
  array.forEach((element, index) => {
    if (element.includes(value)) {
      result = {
        row: index,
        column: element.indexOf(value),
      };
    }
  });
  if (!result) {
    throw new Error("Valor no encontrado");
  }
  return result;
}

Mi solución (sin usar flatMap):

function searchValue(array, value) {
    // Tu código aquí 👈
    const row=array.map(column=>column.includes(value)).findIndex(x=>x===true);
    if (row===-1){
        throw new Error("Valor no encontrado");
    }
    const column=array[row].findIndex(x=>x===value);
    
    return {row:row,column:column};
  }
export function searchValue(array, value) {
  const flatArray = array.flat();
  let finalRow;
  let finalColumn;
  for (let row = 0; row < array.length; row++) {
    for (let column = 0; column < array[row].length; column++) {
      if (value === array[row][column]) {
        finalRow = row;
        finalColumn = column;
      }
    }
  }
  if (finalRow == null || finalColumn == null) {
    throw new Error("Valor no encontrado");
  }
  return {
    row: finalRow,
    column: finalColumn,
  };
}

Aquí mi solución al reto, un poco distinta a las demás por lo que veo… Uso una función de Math que no nos han dado pero creo que no debería haber problema.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  //Convierto todo en un único array
  let flatArray = array.flat();

  //Busco el índice del valor buscado
  let index = flatArray.indexOf(value);

  //Si no lo encuentra devolvemos error
  if (index === -1) throw new Error("Valor no encontrado");

  //Si no devuelve error, entonces podemos calcular la fila y la columna
  let row = Math.trunc(index / array.length);
  let column = index % array[0].length;

  return {
    row: row,
    column: column,
  }
}

Mi soluciooooooooooooooon!
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let row
  let column
  const aplanar = array.flat(1).includes(value);
  if (!aplanar || column === -1) {
    throw new Error('Valor no encontrado')
  } else {
    row = array.findIndex(sub => sub.includes(value));
    column = array[0].indexOf(value)
  }
  return {row, column}
}

Mi aporte:
|
||
|
||
|
|
||
|
|
|
||
|

export function searchValue(array, value) {
  // Tu código aquí 👈
  let row = 0;
  let column = 0;
  const flatArray = array.flatMap(element => element);
  if (flatArray.includes(value)) {
    row = array.findIndex(row => row.includes(value));
    if (row !== -1) {
      column = array[row].indexOf(value);
      return {
        row,
        column
      }
    }
  } else throw new Error("Valor no encontrado");
}

Comparto mi código:

.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈
  let flat = array.flat(1).includes(value);
  if (!flat) { 
    throw new Error("Valor no encontrado");
  }

  let result = {};
  for (let i = 0; i < array.length; i++) { 
    const row = array[i];
    if (row.includes(value)) { 
      result.row = i;
      result.column = row.indexOf(value);
      }
    }
  return result;
}

Mi solución 💚

Considero que es eficiente debido a que solo uso un ciclo para recorrer las filas y uso solo el método indexOf() donde si me otorga un índice diferente a -1 significa que ya encontró en esa fila el valor y pues ya dentro de esa condicional ocupo un break; para parar el ciclo y dejar de buscar.

function searchValue(array, value) {
  let row = -1;
  let column = -1;

  for (let indexRow = 0; indexRow < array.length; indexRow++){
    let indexColumn = array[indexRow].indexOf(value)

    if (indexColumn !== -1) {
      row = indexRow;
      column = indexColumn;
      break;
    }
  }

  if (row === -1 || column === -1)
    throw new Error("Valor no encontrado");

  return { row, column }
  
}
export const searchValue = (array, value) => {
  console.log(array, value);
  const index = array.flat().findIndex(num => num == value);
  const rows = array.length;
  let columns, row;

  if (index === -1) throw new Error("Valor no encontrado");

  columns = array[0].length;
  row = Math.floor(index / rows);

  return {
    row,
    column: index - (columns * row)
  }
}

Otra versión:

export const searchValue = (array, value) => {
  let found = false;
  let row, column;

  for (row = 0; row < array.length; row++) {
    for (column = 0; column < array[row].length; column++) {
      if (array[row][column] == value) {
        found = true;
        break;
      }
    }

    if (found) break;
  }

  if (!found) throw new Error("Valor no encontrado");

  return {
    row,
    column
  }
}


.
.
.
.
.
.

export function searchValue(array, value) {
    if (!array.flat().includes(value)) {
      throw new Error("Valor no encontrado");
    }
    let output;
    array.map((subArray, index) => {
      if (subArray.includes(value))
        output = {
          row: index,
          column: subArray.indexOf(value)
        }
    });
    return output;
}

MI solución sin iterar la matriz:

export function searchValue(array, value) {
  const arrayPosition = array.flat(1).indexOf(value);

  if (-1 === arrayPosition) {
    throw new Error('Valor no encontrado');
  }

  const row = Math.floor(arrayPosition / array.length);
  const column = arrayPosition % array[row].length;

  return { row, column };
}
export function searchValue(array, value) {
  const valueExist = array.flat().includes(value);
  if (valueExist) {
    const obj = {
      row: 0,
      column: 0
    }
    array.forEach((data, index) => {
      if (data.includes(value)) {
        obj.row = index;
        obj.column = data.findIndex(element => element === value)
      }
    })
    return obj;
  } else {
    throw new Error("Valor no encontrado");
  }
}
export function searchValue(array, value) {

  let row = 0
  let flag = false

  //recorremos cada arreglo y buscamos el índice del value con findIndex
  array.forEach(element => {
    let col = element.findIndex(number => number == value)
    if (col != -1) {
      console.log({
        row: row,
        column: col
      })
      flag = true
      return
    }
    row++
  });

  if (!flag) {
    throw new Error("Valor no encontrado");
  }
}

Dejo mi solución:

P.D: esta solución solo es viable si el array bidimensional es uniforme
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  //obtenemos el número de columnas para poder calcular la posición del valor buscado
  let numColumnas = array[0].length;
  //se obtiene el índice que el valor buscado tendría de ser el array unidimensional
  let index = array.flat().findIndex(item => item == value);
  //De obtner -1 como índice, se lanza el error solicitado
  if (index == -1) { throw new Error("Valor no encontrado"); }
  //se divide el índice entre el número de columnas y se trunca el resultado, obteniendo así la fila correspondiente al valor buscado
  let fila = Math.trunc(index / numColumnas);
  //se obtiene el resto de la divición entre el índice y el número de columnas, consiguiendo así la columna correspondiente al valor buscado 
  let columna = index % numColumnas;
  return {
    row: fila,
    column: columna
  };
}

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución un poco peculiar:

export function searchValue(array, value) {
  let size = array[0].length
  let row, column = 0;
  let flat = array.flat();
  let index = flat.findIndex(n => n === value);
  if (index < 0) throw new Error('Número no encontrado')
  index++
  let res = index % size
  column = index % size
  column = (column != 0) ? column - 1 : size - 1;
  row = Math.floor(index / size)
  row = (res != 0) ? row : row - 1;
  return { row, column }
} 

dejo mi respuesta por acá, aunque no se me ocurrió como aplicar el flat() en este ejercicio

export function searchValue(array, value) {
  var existValue = false;
  var result = {}
  for (let i = 0; i < array.length; i++) {
    for (let j = 0; j < array.length; j++) {
      if (array[i][j] === value) {
        existValue = true;
        return result = {
          row: i,
          column: j,
        }
      }
    }
  }
  if (existValue == false) {
    throw new Error("Valor no encontrado");
  }
}

Hola mi solución al problema.

💚
💚💚
💚💚💚
💚💚💚💚
💚💚💚💚💚
💚💚💚💚💚💚
💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚
💚💚💚💚💚💚
💚💚💚💚💚
💚💚💚💚
💚💚💚
💚💚
💚

export function searchValue(array, value) {
  // Tu código aquí 👈
  let result;
  array.forEach((element, index) => {
    const valueIndex = element.indexOf(value);

    if (valueIndex > -1) {
      result = { row: index, column: valueIndex };
    }
  });

  if (result === undefined) {
    throw new Error("Valor no encontrado");
  }

  return result;
}

Hola que tal en un dia llegue hasta aqui!
saludos mi aporte sobre este Ejercicio
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈
  let search = array.flat();
  if (search.includes(value)) {
    let rta;
    const result = array.map((array, index) => {
      if (array.includes(value))
        rta = { row: index, column: array.indexOf(value) }
    });
    return rta;
  } else {
    throw new Error("Valor no encontrado");
  }
}

mi aporte


SPOILER

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

<code> export function searchValue(array, value) {
  // Tu código aquí 👈
  let isExist = array.flat().includes(value);
  let objResp = {};
    if (isExist) {
      for (let e of array) {
        if (e.includes(value)) {
          objResp = { row: array.indexOf(e), column: e.indexOf(value) }
          return objResp
        }

    }
  } else {
      throw new Error("Valor no encontrado");
  }
}

Acá dejo mi solución…

v
v
v
v
v
v
v
v
v
v
v
v

export function searchValue(array, value) {
  let pos = [];
  array.flatMap((a) => {
    pos.push(a.indexOf(value))
  })
  const posIndex = pos.findIndex((n) => n >= 0)
  if (posIndex === -1) {
    throw new Error("Valor no encontrado");
  }
  else {
  return {
    row: posIndex,
    column: pos[posIndex]
  }
  }
}

Challenge Exceeded

export function searchValue(array, value) {
  // Tu código aquí 👈

  const newArray = array.map(arr =>
    arr.findIndex(number => number === value)
  )

  const row = newArray.findIndex(rowPosition => rowPosition !== -1)

  const column = newArray.filter(columnPosition => columnPosition !== -1)

  if (row === -1)
    throw new Error("Valor no encontrado")
  
  return {
    row,
    column: +column.join()
  }
}

Solución

function searchValue(array, value) {
  // Tu código aquí 👈
  

  for (let row = 0; row < array.length; row++) {

    for (let column = 0; column < array[row].length; column++) {
      if (value === array[row][column]) return {row, column}
    } 
  }
  throw new Error("Value not found")
}

Mi solución sin refactorizar
Falta explorar qué pasa cuando las filas no tienen la misma cantidad de columnas.
Ver
Ver
Ver
Ver
Ver
Ver
Ver
Ver
Ver
Ver
Ver

export function searchValue(array, value) {
  
  let r = 0;
  let c = 0;
  // Determinar el tamaño de la matriz
  const cols = array.length;
  const rows = array[0].length;
  // Saber si existe el valor 
  const existValue = array.flatMap(x => x).includes(value);
  
  if(existValue){
    for(let i = 0; i < cols; i++){
      // Booleano para saber en cuál lugar del array se encuentra el valor
      const val = array[i].includes(value);
      // Saber en cuál fila se encuentra el valor buscado
      val ? r = i : console.log(`En la fila ${i} no está`);
      // Saber en cuál columna se encuentra el valor buscado
      val ? c = array[r].findIndex(ind => ind === value) : '';
    }
  }else{
     throw new Error("Valor no encontrado");
  }
  
  return {
    /*dim: `${rows} x ${cols}`,*/
    row: r,
    column: c
  }
}

mi solucion, espero sus devoluciones

export function searchValue(array, value) {
  if (array.flat().find(x => x === value)) {
    for (let y = 0; y < array.length; y++) {
      for (let x = 0; x < array[y].length; x++) {
        if (array[y][x] == value) {
          return { row: y, column: x };
        }
      }
    }
  } else {
    throw new Error("Valor no encontrado");
  }
}

que bien poder aprender de la comunidad,
el que sabe sabe

Aqui vamos
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  const rowSize = array[0].length;
  const fArray = array.flat();
  const where = fArray.findIndex((item)=>item == value);
  if (where == -1) {
    throw new Error("Valor no encontrado");
  } else {
    return {
      row: Math.floor(where / rowSize) ,
      column: Math.floor(where % rowSize) ,
    }
  }
}




**
*
*
*
*
*
*
*
*
*

export function searchValue(array, value) {
  let searcher = array.flat().includes(value)
  let row = 0
  let column = 0
  if (!searcher) {
    throw new Error("Valor no encontrado");
  }

  let rta = array.flatMap((elem, index) => {
    if (elem.includes(value)) {
      row = index;
      column = elem.indexOf(value);
     }
  })

 return {row,column}
}

Otra solucion:
.
.
.
.
.
.
.
.
.
.
.
.
.
export function searchValue(array, value) {
// Tu código aquí 👈
const row = array.findIndex((fila) => fila.includes(value));
const column = array[row].findIndex((elemento) => elemento === value);
return {row,column}
}

Conociendo la posición de la fila se puede obtener fácilmente la posición de la columna…

export function searchValue(array, value) {
  //Validar si el valor existe
  if (!array.flat().includes(value)) {
    throw new Error('Valor no encontrado');
  } else {
    //Obtener el número de fila
    let row = array.findIndex(element => element.includes(value));
    //Conociendo la fila, buscar la columna
    let column = array[row].indexOf(value);
    //Crear el objeto
    let result = {
      row: row,
      column: column,
    };
    //Retornar el objeto
    return result;
  }
}

mi versión:

  let indexRow;
  let indexCol;
  for (let i = 0; i < array.length; i++){
       indexRow   = i;
       let arraBi = array[i];
       indexCol = arraBi.findIndex((col => col === value))
       if (indexCol != -1){ //Si lo encontro
           break;
       };
  }
  if (indexCol === -1){
    throw new Error("Valor no encontrado");

  } else{

    let coor = {
      row: indexRow,
      column: indexCol
    } 
    return coor;
  }

Mirando varias soluciones, la que mas me gusto fue esta:
*
*
*
*
*
*
*
*
*
*

export function searchValue(array, value) {
  const valueLocation = array.flatMap(arr => {
    const index = arr.indexOf(value);
    return index != -1 ? { column: index, row: array.indexOf(arr) } : [];
  })[0];
  if (valueLocation) return valueLocation;
  throw new Error("Valor no encontrado");
}

Mi sencilla solución al problema… 😃

export function searchValue(array, value) {
  // Tu código aquí 👈
  let find = array.flat().includes(value);

  if (find) {
    for (let num = 0; num < array.length; num++) {
      let column = array[num].indexOf(value);

      if (column >= 0) {
        return {
          row: num,
          column
        }
      }
    }
  } else {
    throw new Error("Valor no encontrado");
  }
}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
    // Tu código aquí 👈
    const position = {};
  
    const isThereValue = array.flat().find(number => number === value);
    if (!isThereValue) throw new Error("Valor no encontrado");
  
    for (let i = 0; i < array.length; i++){
      for (let j = 0; j < array[i].length; j++){
        if (array[i][j] === value) {
          position.row = i;
          position.column = j;
        }
      }
    }
  
    return position;
  }

Mi sencilla solucion sin flateo

export function searchValue(array, value) {
  let row
  let column

  for (const iterator of array) {
    iterator.map(item => {
      if (item === value) {
        column = iterator.indexOf(item)
        row = array.indexOf(iterator)
      }
    })
  }
  if (row === undefined) throw new Error("Valor no encontrado");


  return {row,column}
}

Ez

export function searchValue(array, value) {
  // Tu código aquí 👈
  if (!array.flat().includes(value))
    throw new Error("Valor no encontrado")


  let position = null;
  for (let i = 0; i < array.length; i++) {
    if (!position && array[i].includes(value)) {
      position = { row: i, column: array[i].indexOf(value) }
      break
    }
  }

  return position
}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let res = undefined;
  array.forEach((nums, index) => {
    if (nums.includes(value)) {
      res = {
        row: index,
        column: nums.indexOf(value)
      }
    }
  });
  if (!res) throw new Error("Valor no encontrado")
  return res;
}

Mi solución:

export function searchValue(array, value) {
  const flatArray = array.flat()
  const index = flatArray.indexOf(value)
  if (flatArray.includes(value)) {
    const row = Math.floor(index / array[0].length)
    const column = index % array[0].length
    return { row, column }
  } else {
    throw new Error("Valor no encontrado")
  }
}

Mi humilde solución usando for in:

export function searchValue(array, value) {
  for (let row in array) {
    for (let column in array[row]) {
      if (array[row][column] === value) { row = Number(row); column = Number(column); return { row, column }; }
    }
  }
  throw new Error("Valor no encontrado");
}

Aquí una solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
    let posicion = {row:"", column:""}
    //verifica si el valor existe en el array
    let bIncludes = array.flat().includes(value)
    //bincludes retorna true si existe / false no existe
    if (!bIncludes) {
        throw new Error("Valor no encontrado");
    }
    //verificamos cada elemnto del array si tiene el valor
    array.map((element, index) => {
        if (element.includes(value)){
            posicion['row']=index,posicion['column']= element.indexOf(value)
        }
    }) 
    return posicion 
} 

🛡️Escudo anti-spoilers🛡️

export function searchValue(array, value) {
  let row = 0;
  let column = 0;

  if (array.flat(1).includes(value)) {
    for (let index = 0; index < array.length; index++) {
      const element = array[index];
      if (element.includes(value)) {
        row = index;
        column = element.findIndex(item => item === value);
        break;
      }
    }
    return { row, column }
  }
  else {
    throw new Error("Valor no encontrado");
  }
}

the sol :

export function searchValue(array, value) {
  for (let i = 0; i < array.length; i++){
    for (let j = 0; j < array[i].length; j++){
      if (array[i][j] === value) {
        return { row: i, column: j }
      }
    }
  }
  throw new Error("Valor no encontrado");
}

Mi solucion, como varios de los metodos de recorrido de arrays aceptan un segundo argumento (el index), con ese argumento pude detectar el lugar del elemento en el array.
.
.
.

function searchValue(array, value) {
  let coordinates = {row:"", column:""} 
  if (array.flat().includes(value)) {
    array.map((ele,index) => {
      if (ele.includes(value)){coordinates.row=index,coordinates.column= ele.indexOf(value) }
    })
  } else {
    throw new Error("Valor no encontrado")
  }
  return coordinates
}

😎Aquí mi solución, primero el escudo anti spoilers
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  const flatArray = array.flat();
  const isValueInArray = flatArray.includes(value);

  if (isValueInArray) {
    for (let row = 0; row < array.length; row++) {
      const isInThisRow = array[row].includes(value);
      if (isInThisRow) {
        for (let column = 0; column < array[row].length; column++){
          if (array[row][column] === value) {
            return { row, column };
          }
        }
      }
    }
  } else {
    throw new Error("Valor no encontrado");
  } 
}
export function searchValue(array, value) {
  // Tu código aquí 👈
  if (!array.flat().includes(value)) throw new Error("Valor no encontrado")

  const index = array.flat().indexOf(value)
  const row = Math.trunc(index / array.length)
  const decimals = Number("0." + ((index / array[0].length).toString().split(".")[1] || "0"))

  const column = Math.round(decimals * array[0].length)

  const position = {
    row,
    column,
  }

  return position
}

Mi solución compañeros:
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈
  let flat = array.flat()
  let index = flat.findIndex((item) => item === value)

  if (index < 0) {
    throw new Error("Valor no encontrado")
  }

  const row = Math.trunc(index / array.length);
  const column = index % array[0].length;


  return {
      row,
      column
  }
}

Mi solución:
.
.
.
.
.
.
.
.
.
Sin usar flat():

export function searchValue(array, value) {
  const position = {}
  for (const row of array) {
    if (row.includes(value)) {
      position['row'] = array.indexOf(row);
      position['column'] = row.indexOf(value);
      return position;
    }
  }
  throw new Error("Valor no encontrado");
}

Usando flat():

export function searchValue(array, value) {
  const index = array.flat().indexOf(value);
  if(index == -1) throw new Error("Valor no encontrado");

  const position = {}

  const columns = array[0].length;

  position['row'] = Math.floor(index / columns);
  position['column'] = index % columns;
  
  return position
}


.
.
.
.
.

function searchValue(array, value) {
  // Tu código aquí 👈

    let result = {};
    const newArray = array.flat()
    //Si el valor no se encuentra, omitimos el proceso de búsqueda
    if(newArray.includes(value)){
        
        /* Buscamos el número con un for(filas) y un map(columnas) y en donde el número coincida con
        value entonces retornamos el result con los índices respectivos */
        const obj = (function (){
            for (let index = 0; index < array.length; index++) {
                const item = array[index];
                item.map((num, indexColumn) => {
                    if(num === value){
                        result = {
                            row: index,
                            column: indexColumn,
                        }
                    }
                    return result;
                })
            }
            return result;
        })();

        return obj;
    
    }else{
        throw new Error("Valor no encontrado");
    }
}

Hola!
Les dejo mi solucion
.
.

.
.

export function searchValue(array, value) {
  if (!array.flat().includes(value)) {
    throw new Error('Valor no encontrado');
  }

  const row = array.findIndex((innerArray) => innerArray.includes(value));
  const column = array[row].findIndex((element) => element === value);

  return {
    row,
    column,
  };
}

Mi solución
.
.
.
.
.
.

export function searchValue(array, value) {
  if (!array.flat(1).includes(value)) {
    throw new Error("Valor no encontrado");
  }

  const row = array.findIndex((rows) => rows.includes(value));
  const column = array[row].findIndex((col) => col === value);

  return {
    row: row,
    column: column,
  };
}

Mi solución

export function searchValue(array, value) {
  // Tu código aquí 👈
  let rta = undefined;
  array.forEach((row, rowIndex) =>
    row.forEach((ele, columnIndex) => {
      if (array[rowIndex][columnIndex] === value) {
        rta = { row: rowIndex, column: columnIndex };
      };
    })
  )
  if (rta) {
    return rta;
  } else {
    throw new Error("Valor no encontrado");
  } 
}

Solución… 😄
.
En primer lugar, aplanamos el array mediante flat() y lo guardamos en una variable.
.
En esta última con includes(value) verificamos si existe el valor. Si no existe lanzamos el error, sino determinamos las posiciones del valor en el array.
.
Entonces, para la fila ‘row’ utilizamos findIndex() sobre el array, donde recorreremos cada elemento, hasta encontrar que ‘element’ que a su vez es un array incluya el valor que estamos buscando, mediante includes().
.
Para la columna ‘column’ realizamos el mismo proceso, pero ahora sabiendo la posición del arreglo en la que se encuentra el valor, entonces realizamos findIndex() sobre array[row], y ‘element’ ya es solo un número así que si element es igual al valor, devolvemos la posición.
.
Por último, devolvemos el objeto con su fila y columna ‘row’ y ‘column’.
.

export function searchValue(array, value) {
  let flatAr = array.flat();

  if (flatAr.includes(value)) {
    let row = array.findIndex((element) => element.includes(value));

    let column = array[row].findIndex((element) => element === value);

    return { row , column };

  } else { 
    throw new Error("Valor no encontrado");
  }
}

Mi solución:

function searchValue(array, value) {
  // Tu código aquí 👈

  let flatArray = array.flat();
  let includeValue = flatArray.includes(value);

  if (!includeValue) {
    throw new Error("Valor no encontrado")
  } else {

    let row = 0;
    let column = 0;

    for (let i = 0; i < array.length; i++) {

      if (array[i].includes(value)) {
        column = array[i].indexOf(value)
        row = i
      };

    };

    return {
      row,
      column
    }
  };

}

**Solucion **
Usando un forEach y un findIndex para que en cada lista que esté adentro de la lista principal, busque la posición del número, sino encuentra nada retornará -1.
Si al final está el -1, retornará el valor, sino mandará las coordenadas.

export function searchValue(array, value) {
  let coordinates = { row: -1, column: null };

  array.forEach(element => {
    if (coordinates.column == -1 || coordinates.column == null) {
      coordinates.row += 1;
      coordinates.column = element.findIndex(index => index == value);
    }
  });
  if (coordinates.column == -1 || coordinates.column == null) {
    throw new Error("Valor no encontrado");
  }
  return coordinates;
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  // Tu código aquí 👈
  let newobject = {
    row: 0,
    column: 0
  };
  if (!array.flat().includes(value)) {
    throw new Error("Valor no encontrado");
  } else {
    array.flatMap((x, i) => {
      if (x.includes(value)) {
        newobject.row = i;
        newobject.column = (x.findIndex(x => x === value))
      }   
    })
    return newobject
  }
}

Me encanta a pesar de parecer simple, existen muchas maneras de resolverlo la idea es como aplicar los conceptos ya dados para hacer el mejor código
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  if (!array.flat().includes(value)) throw new Error("Valor no encontrado");
  const row_value = array.findIndex((element) => element.includes(value));
  const column_value = array[row_value].indexOf(value);
  return { row: row_value, column: column_value };
}

Mi solución:

function searchValue(array, value) {
  let objeto = {};

  array.flatMap((c,d)=>{
    if (array[d].includes(value)) objeto = { row: array.indexOf(c), column: c.indexOf(value) };
      else if(!array.flat().includes(value)) throw new Error("Valor no encontrado");
    });

  return objeto;
}

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

Podria ser mejor pero :3

export function searchValue(array, value) {

  let column = null
  let row = null

  array.forEach((currentValue, index) => {

    if (currentValue.includes(value)) {
      column = currentValue.indexOf(value)
      row = index
    }
    
  })

  if (column===null || row===null) {
    throw new Error("Valor no encontrado");
  }

  return {row, column}

}

Mi solución:
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let isInArray = array.flatMap(num => num).includes(value);
  if (!isInArray) throw new Error("Valor no encontrado");

  for (let i = 0; i < array.length; i++) {
    let row = i;
    let column = array[i].findIndex(num => num == value);
    if (column !== -1) {
      return {
        row,
        column,
      }
    }
  }
}

Capaz en mi solución esta demás el calculo de la dimensión de las filas pero por si las moscas jejeje

.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  const dimensions = [array.length, array[0].length]
  let pos = array.flat().findIndex((number) => number === value)

  if (pos === -1) throw new Error("Valor no encontrado");

  return {
    row: Math.floor(pos / dimensions[1]),
    column: pos % dimensions[1]
  }
}

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

const ubicacion = {
        row: null, 
        column: null
    }
    array.forEach((item, row) => {
        item.forEach((subitem, col) => {
            if(subitem === value) {
                ubicacion.row = row;
                ubicacion.column = col;
            }
        });
    });
    if(ubicacion.row === null || ubicacion.column === null){
        throw new Error("Valor no encontrado");
    }
    return ubicacion;

Solución

export function searchValue(array, value) {
  // Tu código aquí 👈  
  if (array.flatMap(x => x).includes(value)) {
    let flag = false;
    let output = {
      row: 0,
      column: 0
    };
    for (let i = 0; i < array.length; i++) {
      for (let j = 0; j < array[i].length; j++) { 
        if (array[i][j] === value) {
          flag = true;
          output.row = i;
          output.column = j;
          break;
        }
      }
      if (flag) break;
    }
    return output;
  } else {
    throw new Error("Valor no encontrado");
  }
}

Mi solución:
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let row = null
  let column = null
  // la ventaja de usar some para este tipo de búsquedas, es que apenas encuentre el primer resultado, retorno un true para dejar de recorrer el arreglo, haciendo el algoritmo más eficiente. Además some, así como map y muchos de los métodos de arreglos, pueden recibir un segundo argumento que es la posición del primero argumento dentro del arreglo
  array.some((lvl1, i) => lvl1.some((lvl2, j) => {
    if (lvl2 === value) {
	// i es la posición de lvl1 en array. En otras palabras: array[i] = lvl1
      row = i
	// j es la posición de lvl2 en lvl1. En otras palabras: lvl1[j] = lvl2
      column = j
      return true
    }
  }))
  if (typeof row === 'number')
    return {
      row,
      column
    }
  throw new Error("Valor no encontrado")
}

Mi respuesta:
.
.
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let row, column;

  array.forEach(element => {
    if (element.includes(value)) {
      row = array.indexOf(element);
      column = element.findIndex(item => item === value);
    } 
  });
  if (row == undefined) { throw new Error("Valor no encontrado"); } 

  return { "row": row, "column": column }
}
export function searchValue(array, value) {
  let response = {
    row: null,
    column: null,
  };

  for (let i = 0; i < array.length; i++)
    for (let j = 0; j < array[0].length; j++) {
      if (array[i][j] === value) {
        response.row = i;
        response.column = j;
        return response;
      }
    }

  throw new Error("Valor no encontrado");
}

Les dejo mi solución!
.
.
.
.
.
.
.
.
.

export function searchValue(array, value) {
  let ubicacion

  //Recorro todo el arreglo
  array.forEach(fila => {
    //Si la fila incluye el valor buscado lo guardo en ubicación
    if (fila.includes(value)) {
      ubicacion = {
        //row va a contener el índice donde se encuentra fila
        row: array.indexOf(fila),
        //column va a contener el índice donde se encuentra value dentro de fila
        column: fila.indexOf(value)
      }
    }
  })

  if (!ubicacion) {
    throw new Error("Valor no encontrado")
  }

  return ubicacion
}

Spoiler:
.
.
.
.
.
.
.
.
.
.

function searchValue(array, value) {
    let obj = array.map((ele, ind) => {
        if(ele.includes(value)){
            return {
                row: ind,
                column: ele.indexOf(value)
            }
        }
    }).filter((ele) => ele);

    if(!obj[0]){throw new Error("Valor no encontrado")};
    return obj[0]
};
undefined