Playground: K Closest Points to Origin

Curso de Algoritmos Avanzados: Estructuras de Datos Lineales

Introducción

¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?

Lista Enlazada

Estructura de datos: Lista Enlazada

Programando listas enlazadas con Java

Cómo Invertir una Lista Enlazada

Odd Even Linked List: análisis del problema

Solución de Odd Even Linked List

Playground: Odd Even Liked List

Programando Odd Even Linked List con C++

Linked List Cycle: análisis del problema

Solución de Linked List Cycle

Playground: Linked List Cycle

Programando Linked List Cycle con Python

Palindrome Linked List: análisis del problema

Solución de Palindrome Linked List

Playground: Palindrome Linked List

Programando Palindrome Linked List con Java

Reorder List: análisis del problema

Solución de Reorder List

Programando Reorder List con JavaScript

Playground: Reorder List Without Repeated Values

Reto: LRU Caché

Ejercicios recomendados de Lista Enlazada

Ejercicios resueltos de Lista Enlazada

Pilas y colas

Estructura de datos: Pilas y Colas

Paréntesis Válido: análisis del problema

Solución de Paréntesis Válido

Playground: Paréntesis Válido

Programando Paréntesis Válido con C++

Ejercicios recomendados de Pilas

Colas de prioridad

Estructura de datos: Colas de Prioridad

K Closest Points to Origin: análisis del problema

Solución de K Closest Points to Origin

Playground: K Closest Points to Origin

Programando K Closest Points to Origin con Python

Reorganize String: análisis del problema

Solución de Reorganize String

Playground: Reorganize String

Programando Reorganize String con Python

Ejercicios recomendados de Colas de prioridad

Ejercicios resueltos de Colas de prioridad

Próximos pasos

Toma el Curso Avanzado de Algoritmos: Grafos y Árboles

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

Aportes 5

Preguntas 0

Ordenar por:

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

Miguel Ángel Reyes Moreno

hace 3 meses

propuesta: `import heapqfrom typing import List` `def kClosest(puntos: List[List[int]], K: int) -> List[List[int]]: heap = [] for punto in puntos: x, y = punto distancia_cuadrada = x*x + y*y heapq.heappush(heap, (-distancia_cuadrada, punto)) if len(heap) > K: heapq.heappop(heap) return [punto for _, punto in heap]` `response = kClosest([[1,3], [3,4], [5,6]], 1)print(response)` `response = kClosest([[13,-8], [1,20], [-5,5]], 2)print(response)`

Yojan Antonio Pardo Zabala

hace 10 meses

mi solución ```java import heapq from typing import List def kClosest(puntos: List[List[int]], K: int) -> List[List[int]]: # Tu código aquí 👇 min_heap = [] for (x,y) in puntos: dist = x**2 + y**2 heapq.heappush(min_heap, (dist, [x, y])) closest_points = [] for _ in range(K): closest_points.append(heapq.heappop(min_heap)[1]) return closest_points ```

Rafael Estiven Uribe Álvarez

hace un año

Mi respuesta: ![](https://static.platzi.com/media/user_upload/image-3521a92d-ca7d-4b8e-a933-d3916114834b.jpg)

Luis Antonio Ibarra Salgado

hace un año

Use la func ‘dist’ del modulo math para sacar las distancias

import heapq
from math import dist
from typing import List

def kClosest(puntos: List[List[int]], K: int) -> List[List[int]]:
   min_heap = []

   for p in puntos:
      distance = -(dist((0,0), p))
      if len(min_heap) < K:
         heapq.heappush(min_heap, (distance, p))
      else:
         if distance > min_heap[0][0]:
            heapq.heapreplace(min_heap, (distance, p))
   return [i[1] for i in min_heap]

Nicolas Alpargatero

hace un año

No sé porque no funciono en el playground, decía que error al llamar list pero bueno funcionó, toco con ayuda: