Playground - Encuentra la ubicación del valor buscado

¡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))
      }
  }
}

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")
  }
}

🛡️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),
  }
}

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
    }
  }
}

**
*
*
*
*
*
*
*
*
*

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;
  }

૮ ˶ᵔ ᵕ ᵔ˶ ა

export function searchValue(array, value) {

  let flatArray = array.flat()
  let arrayLength = array[0].length
  let index = flatArray.findIndex(x => x === value)

  if (index >= 0) {

    return {
      row: Math.ceil((index + 1) / arrayLength) - 1,
      column: Math.ceil((index + 1) % arrayLength) - 1
    }

  } else {

    throw new Error('Valor no encontrado')

  }

}

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]
};