Playground: Merge Two Sorted Lists

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Introducción

Dos Apuntadores

Ventana Deslizante

Búsqueda Binaria

Próximos pasos

35
Estructuras de Datos Lineales: Conceptos y Aplicaciones
00:36 min

Tomar examen

Playground: Merge Two Sorted Lists

Comentarios

David Higuera

student

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
   i = m - 1
   j = n - 1
   k = m + n - 1

   while k > -1:
      if i >= 0 and (j < 0 or nums1[i] > nums2[j]):
         nums1[k] = nums1[i]
         i -= 1
      else:
         nums1[k] = nums2[j]
         j -= 1
      k -= 1
   return nums1

Marcos Mesias

student

•

Este es mi código, se resuelve en un solo ciclo, ni se utiliza funciones de ordenamiento ni una nueva lista, mi código es:

O(n+m) Lineal.

Mario Andrés Castro Martínez

student

Mi solución

def merge_sorted_list(nums1: list, m: int, nums2: list, n: int):
    if len(nums1) == m + n:
        nums1 = sorted([item for x in (nums1, nums2) for item in x if item != 0])
    return nums1

Israel Cruz

student

bro pero la idea del ejercicio era hacer un código que no sea O(n log n) en complejidad temporal

Edgar Diego Piña Vargas

student

Lo que comenta Isrra es cierto, el código se ve muy limpio, la retroalimentación aqui seria que estas usando sorted para hacer ordenamiento, para practicar lo del video podrías implementarlo mediante 2 apuntadores (en python son índices)

Ángel Vargas Casavantes

student

Comparto mi solución en JS :]

function merge_lists(nums1, m, nums2, n) {
	//? En caso de que la lista mayor sea la segunda?
	if (nums1.length < nums2.length) { 
		const temp = nums1
		nums1 = nums2;
		nums2 = temp;
	}

	let p1 = m - 1, p2 = n - 1, orderPointer = m + n; // Apuntadores para ordenamiento

	for (let i = orderPointer; i > 0; i--) {
		const p1Val = nums1[p1];
		const p2Val = nums2[p2];
		let biggerNum;

		console.log(p1Val, p2Val);

		// Evualuación de valores
		//* Si el valor de una lista resulta undefined, se asigna el valor de la lista contraria
		if (p1Val >= p2Val || !p2Val) {
			biggerNum = p1Val;
			p1--;
		} else if (p1Val < p2Val || !p1Val) {
			biggerNum = p2Val;
			p2--;
		}

		nums1[i - 1] = biggerNum;
	}

	return nums1;
}

Luis Ruiz

student

supongo se puede optimizar en las condiciones:

def merge_lists(nums1, m, nums2, n):
   firstListPointer = m-1
   secondListPointer = n-1
   for orderPointer in reversed(range(m+n)):

      if secondListPointer == -1:
         nums1[orderPointer]=nums1[firstListPointer]
         firstListPointer-=1
         break
      
      if firstListPointer == -1:
         nums1[orderPointer]=nums2[secondListPointer]
         secondListPointer-=1
         break

      if nums1[firstListPointer]>nums2[secondListPointer]:
         nums1[orderPointer]=nums1[firstListPointer]
         firstListPointer-=1
      else :
         nums1[orderPointer]=nums2[secondListPointer]
         secondListPointer-=1
   return nums1

Rodrigo Martinez

student

•

N(nlogn) ganamos en tiempo asintotico, aunque sea lento para listas pequenas podemos hacer esto absudamente mas rapido para grandes listas

def merge_lists(nums1, m, nums2, n):
   a = nums1[:m] + nums2
   a.sort()
   return a

Milton Velazquez

student

•

def merge_lists(nums1, m, nums2, n):
    if m == 0: return nums2
    if n == 0: return nums1
    nums1 = nums1[:m]
    nums2 = nums2[:n]
    finished = False
    new_list = []
    while not finished:
        if nums1[0] <= nums2[0]:
            new_list.append(nums1.pop(0))
        else:
            new_list.append(nums2.pop(0))
        
        if not nums1: 
            new_list = new_list + nums2
            finished = True
        if not nums2: 
            new_list = new_list + nums1
            finished = True
    
    return new_list

Elías Uriel Méndez Hernández

student

Mi solución con python:

def merge_lists(nums1, m, nums2, n):
   for index in range(1, n+1):
      if nums2[-index] > nums1[-index] and nums2[-index] > nums1[m-1]:
         nums1[-index] = nums2[-index]
      else:
         aux:int = None
         for half_idx in range(m):
            if aux is not None:
               aux, nums1[half_idx] = nums1[half_idx], aux
            elif nums2[-index] <= nums1[half_idx]:
               aux = nums1[half_idx]
               nums1[half_idx] = nums2[-index]
         if aux is not None:
            nums1[m] = aux 

         m += 1

   return nums1

Ulises Antonio Sámano Galván

student

Este es mi código utilizando JavaScript

let nums2Pointer = 0

const result = []

for(let nums1Iterator = 0;nums1Iterator < nums1.length; nums1Iterator++)

{

const number = nums1[nums1Iterator]

if(number === 0) {

const restantNumbers = nums2.slice(nums2Pointer) result.push(...restantNumbers)

break

}

if(number >= nums2[nums2Pointer]) {

result.push(nums2[nums2Pointer]) result.push(number) nums2Pointer++ } else {

result.push(number)

}

return result

Ulises Antonio Sámano Galván

student

Este es mi código

def merge_lists(nums1, m, nums2, n):

result = [] nums1_iterator = 0 nums2_pointer = 0 while nums1_iterator < len(nums1): number = nums1[nums1_iterator] if number == 0: restant_numbers = nums2[nums2_pointer:] result.extend(restant_numbers) break if number >= nums2[nums2_pointer]: result.append(nums2[nums2_pointer]) result.append(number) nums2_pointer += 1 else: result.append(number) nums1_iterator += 1 return result

Andres Silva Vega

student

En javascript:

const merge_listas2 = function (lista1, n1, lista2, n2){
    let ap_put = n1 + n2 -1;
    n1 -= 1;
    n2 -= 1;
    while(ap_put > -1){
        if(n1 < 0 || (n2 > -1 && lista1[n1] < lista2[n2])){
            lista1[ap_put] = lista2[n2];
            n2 =  n2 - 1;
        } else {
            lista1[ap_put] = lista1[n1];
            n1 =  n1 - 1;
        } 
        ap_put -= 1;
    }
    return lista1;
}
```En python:

```python
def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
   ap_put = m+n-1
   m -= 1
   n -= 1
   while ap_put > -1:
      if m < 0 or (n >-1 and nums1[m] < nums2[n]):
         nums1[ap_put] = nums2[n]
         n -= 1
      else:
         nums1[ap_put] = nums1[m]
         m -= 1
      ap_put -= 1 
   return nums1

Edwin Garcés Saucedo

student

Dejo acá mi solución en JS:

const joiningListsV2 = (nums1 = [], nums2 = [], m = 1, n = 1) => {
  let pointer1 = m - 1
  let pointer2 = n - 1
  let pointer3 = m + n - 1
  while (pointer3 >= 0) {
    const shouldCompare = pointer2 >= 0 && pointer1 >= 0
    if (shouldCompare && nums1[pointer1] < nums2[pointer2]) {
      nums1[pointer3] = nums2[pointer2]
      pointer2--
      pointer3--
    } else if (shouldCompare && nums1[pointer1] > nums2[pointer2]) {
      nums1[pointer3] = nums1[pointer1]
      pointer1--
      pointer3--
    } else if (pointer1 >= 0) {
      nums1[pointer3] = nums1[pointer1]
      pointer1--
      pointer3--
    } else if (pointer2 >= 0) {
      nums1[pointer3] = nums2[pointer2]
      pointer2--
      pointer3--
    }
  }
  console.log(nums1)
}

John Eduard Meneses González

student

This is my solution:

def merge_lists(nums1, m, nums2, n):
    # Punteros de las posiciones finales de los elementos válidos
    i = m - 1  # Última posición válida en nums1
    j = n - 1  # Última posición en nums2
    k = m + n - 1  # Última posición total en nums1 (donde irán los elementos ordenados)

    # Fusionar nums1 y nums2 desde el final
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:  # Si nums1 tiene el mayor valor
            nums1[k] = nums1[i]
            i -= 1
        else:  # Si nums2 tiene el mayor valor
            nums1[k] = nums2[j]
            j -= 1
        k -= 1  # Mover el puntero final

    # Si quedan elementos en nums2, los copiamos en nums1 (nums1 ya está en su lugar)
    while j >= 0:
        nums1[k] = nums2[j]
        j -= 1
        k -= 1

    return nums1
```def merge\_lists(nums1, m, nums2, n):    # Punteros de las posiciones finales de los elementos válidos    i = m - 1  # Última posición válida en nums1    j = n - 1  # Última posición en nums2    k = m + n - 1  # Última posición total en nums1 (donde irán los elementos ordenados)
    # Fusionar nums1 y nums2 desde el final    while i >= 0 and j >= 0:        if nums1\[i] > nums2\[j]:  # Si nums1 tiene el mayor valor            nums1\[k] = nums1\[i]            i -= 1        else:  # Si nums2 tiene el mayor valor            nums1\[k] = nums2\[j]            j -= 1        k -= 1  # Mover el puntero final
    # Si quedan elementos en nums2, los copiamos en nums1 (nums1 ya está en su lugar)    while j >= 0:        nums1\[k] = nums2\[j]        j -= 1        k -= 1
    return nums1

Bryan Castano

student

Hiii Guys \n Yo dejo mi pequeno codigo por aqui tambien junto los demas , My codigo es O ( n + m ) Lineal como muchos otros por aqui, Yo me inspirado en el Clasico Metodo Recurtsivo de Divide & Conquer : 'MergeSort ' para resolver este Reto . \n .

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇.....
   #check dor nums1 Size ...
   if ( n+m < len(nums1) ) :

      return -1

   p1 = m-1 
   p2 = n -1 

   itr = m + n -1 

   while ( p1 >= 0 and p2 >= 0 )  : 

      if ( nums1[ p1 ] > nums2[ p2 ] ) :

         nums1[ itr ] = nums1[ p1 ]
         p1 = p1 - 1 

      else : 

         nums1[ itr ] = nums2[ p2 ] 
         p2 = p2 - 1 

      itr = itr -1 

   while ( p1 >= 0 ) :

      nums1[ itr ] = nums1[ p1 ] 

      p1 = p1 -1 
      itr = itr -1

   while ( p2 >= 0 ) : 

      nums1[ itr ] = nums2[ p2 ] 
      
      p2 = p2 - 1 
      itr = itr -1

   return nums1 

```def merge\_lists(nums1, m, nums2, n):   # Tu código aquí 👇.....   #check dor nums1 Size ...   if ( n+m < len(nums1) ) :
&#x20;     return -1
&#x20;  p1 = m-1    p2 = n -1&#x20;
&#x20;  itr = m + n -1&#x20;
&#x20;  while ( p1 >= 0 and p2 >= 0 )  :&#x20;
&#x20;     if ( nums1\[ p1 ] > nums2\[ p2 ] ) :
&#x20;        nums1\[ itr ] = nums1\[ p1 ]         p1 = p1 - 1&#x20;
&#x20;     else :&#x20;
&#x20;        nums1\[ itr ] = nums2\[ p2 ]          p2 = p2 - 1&#x20;
&#x20;     itr = itr -1&#x20;
&#x20;  while ( p1 >= 0 ) :
&#x20;     nums1\[ itr ] = nums1\[ p1 ]&#x20;
&#x20;     p1 = p1 -1       itr = itr -1
&#x20;  while ( p2 >= 0 ) :&#x20;
&#x20;     nums1\[ itr ] = nums2\[ p2 ]             p2 = p2 - 1       itr = itr -1
&#x20;  return nums1&#x20;

Cesar Augusto Mora Castilo

student

Mi solución:

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
       # Inicializar punteros
    # Se asume la array nums1 es igual o mas larga que nums2
    p1 = m - 1
    p2 = n - 1
    p = len(nums1)-1
    print(nums1, nums2)

    while p >= 0:
        print(p, p1,p2)
        if p2 == -1: # No hay mas numeros para comparar en nums2
            break
        # se llegó al inicio de nums1 no hay mas numeros para comparar
        # ya se desplazaron todos los numeros de nums1 hacia la derecha
        # Queda un último numero en nums2 y es el menor de todos    
        if p1 == -1: 
            p1 = 0
            nums1[p] = nums2[p2]
            break

        if nums1[p1] <= nums2[p2]:
            nums1[p] = nums2[p2]
            p2 -= 1
        elif nums1[p1] >= nums2[p2]:
            nums1[p] = nums1[p1]
            p1 -= 1
        p -= 1

    return nums1

# Arrays de prueba 1
nums1 = [1,2,3,0,0,0]
m = 3
nums2 = [2,5,6]
n = 3
response = merge_lists(nums1, m, nums2, n)
print(response)

# Arrays de prueba 2
nums1 = [1,2,3,0,0,0,0]
m = 3
nums2 = [-4,2,3,9]
n = 4
response = merge_lists(nums1, m, nums2, n)
print(response)
```def merge\_lists(nums1, m, nums2, n):   # Tu código aquí 👇       # Inicializar punteros    # Se asume la array nums1 es igual o mas larga que nums2    p1 = m - 1    p2 = n - 1    p = len(nums1)-1    print(nums1, nums2)
&#x20;   while p >= 0:        print(p, p1,p2)        if p2 == -1: # No hay mas numeros para comparar en nums2            break        # se llegó al inicio de nums1 no hay mas numeros para comparar        # ya se desplazaron todos los numeros de nums1 hacia la derecha        # Queda un último numero en nums2 y es el menor de todos            if p1 == -1:             p1 = 0            nums1\[p] = nums2\[p2]            break
&#x20;       if nums1\[p1] <= nums2\[p2]:            nums1\[p] = nums2\[p2]            p2 -= 1        elif nums1\[p1] >= nums2\[p2]:            nums1\[p] = nums1\[p1]            p1 -= 1        p -= 1
&#x20;   return nums1
\# Arrays de prueba 1nums1 = \[1,2,3,0,0,0]m = 3nums2 = \[2,5,6]n = 3response = merge\_lists(nums1, m, nums2, n)print(response)
\# Arrays de prueba 2nums1 = \[1,2,3,0,0,0,0]m = 3nums2 = \[-4,2,3,9]n = 4response = merge\_lists(nums1, m, nums2, n)print(response)

Javier Villegas

student

Comparto mi solucion en phpfunction

function merge_lists( array $nums1 , int $m , array $nums2,  int $n): array {

    $k = $m + $n - 1;
    $m = $m -1;
    $n = $n -1;
    do{
        echo "m: ".$m." n: ".$n."\n";
        if($nums1[$m] >= $nums2[$n]){
            $nums1[$k] = $nums1[$m];
            $m--;
            $k--;
        }else{
            $nums1[$k] = $nums2[$n];
            $k--;
            $n--;
        }
    }while($m>= 0  || $n >=0);
    return $nums1;
}

Leonardo Bazán Márquez

student

def merge_lists(nums1, m, nums2, n):
   if n+m < len(nums1):
      return print("Error, invalid size")
   i = m + n - 1
   j = m - 1
   k = n - 1

   while j >= 0 and k >= 0:   
      if nums1[j] > nums2[k] :
         nums1[i] = nums1[j]
         j-=1
      else:
         nums1[i] = nums2[k]
         k-=1
      i-=1
   while j >= 0:
      nums1[i] = nums1[j]
      j-=1
      i-=1
   while k >= 0:
      nums1[i] = nums2[k]
      k-=1
      i-=1
   return nums1
```Esta es mi solución

Miguel Angel Reyes Moreno

student

Mi solución en Python:

def merge\_two\_sorted\_lists(nums1, nums2):   &#x20;
&#x9;nums1 = \[n for n in nums1 if n != 0]   &#x20;
&#x9;return sorted(nums1 + nums2)

Efren Galarza

student

Mi solución en TS :)

jhancarlos lenis

student

esta es mi solucion en DART

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
   i = m - 1
   j = n - 1
   k = m + n - 1

   while k > -1:
      if i >= 0 and (j < 0 or nums1[i] > nums2[j]):
         nums1[k] = nums1[i]
         i -= 1
      else:
         nums1[k] = nums2[j]
         j -= 1
      k -= 1
   return nums1

function merge_lists(nums1, m, nums2, n) {
	//? En caso de que la lista mayor sea la segunda?
	if (nums1.length < nums2.length) { 
		const temp = nums1
		nums1 = nums2;
		nums2 = temp;
	}

	let p1 = m - 1, p2 = n - 1, orderPointer = m + n; // Apuntadores para ordenamiento

	for (let i = orderPointer; i > 0; i--) {
		const p1Val = nums1[p1];
		const p2Val = nums2[p2];
		let biggerNum;

		console.log(p1Val, p2Val);

		// Evualuación de valores
		//* Si el valor de una lista resulta undefined, se asigna el valor de la lista contraria
		if (p1Val >= p2Val || !p2Val) {
			biggerNum = p1Val;
			p1--;
		} else if (p1Val < p2Val || !p1Val) {
			biggerNum = p2Val;
			p2--;
		}

		nums1[i - 1] = biggerNum;
	}

	return nums1;
}

def merge_lists(nums1, m, nums2, n):
   firstListPointer = m-1
   secondListPointer = n-1
   for orderPointer in reversed(range(m+n)):

      if secondListPointer == -1:
         nums1[orderPointer]=nums1[firstListPointer]
         firstListPointer-=1
         break
      
      if firstListPointer == -1:
         nums1[orderPointer]=nums2[secondListPointer]
         secondListPointer-=1
         break

      if nums1[firstListPointer]>nums2[secondListPointer]:
         nums1[orderPointer]=nums1[firstListPointer]
         firstListPointer-=1
      else :
         nums1[orderPointer]=nums2[secondListPointer]
         secondListPointer-=1
   return nums1

def merge_lists(nums1, m, nums2, n):
    if m == 0: return nums2
    if n == 0: return nums1
    nums1 = nums1[:m]
    nums2 = nums2[:n]
    finished = False
    new_list = []
    while not finished:
        if nums1[0] <= nums2[0]:
            new_list.append(nums1.pop(0))
        else:
            new_list.append(nums2.pop(0))
        
        if not nums1: 
            new_list = new_list + nums2
            finished = True
        if not nums2: 
            new_list = new_list + nums1
            finished = True
    
    return new_list

def merge_lists(nums1, m, nums2, n):
   for index in range(1, n+1):
      if nums2[-index] > nums1[-index] and nums2[-index] > nums1[m-1]:
         nums1[-index] = nums2[-index]
      else:
         aux:int = None
         for half_idx in range(m):
            if aux is not None:
               aux, nums1[half_idx] = nums1[half_idx], aux
            elif nums2[-index] <= nums1[half_idx]:
               aux = nums1[half_idx]
               nums1[half_idx] = nums2[-index]
         if aux is not None:
            nums1[m] = aux 

         m += 1

   return nums1

const merge_listas2 = function (lista1, n1, lista2, n2){
    let ap_put = n1 + n2 -1;
    n1 -= 1;
    n2 -= 1;
    while(ap_put > -1){
        if(n1 < 0 || (n2 > -1 && lista1[n1] < lista2[n2])){
            lista1[ap_put] = lista2[n2];
            n2 =  n2 - 1;
        } else {
            lista1[ap_put] = lista1[n1];
            n1 =  n1 - 1;
        } 
        ap_put -= 1;
    }
    return lista1;
}
```En python:

```python
def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
   ap_put = m+n-1
   m -= 1
   n -= 1
   while ap_put > -1:
      if m < 0 or (n >-1 and nums1[m] < nums2[n]):
         nums1[ap_put] = nums2[n]
         n -= 1
      else:
         nums1[ap_put] = nums1[m]
         m -= 1
      ap_put -= 1 
   return nums1

const joiningListsV2 = (nums1 = [], nums2 = [], m = 1, n = 1) => {
  let pointer1 = m - 1
  let pointer2 = n - 1
  let pointer3 = m + n - 1
  while (pointer3 >= 0) {
    const shouldCompare = pointer2 >= 0 && pointer1 >= 0
    if (shouldCompare && nums1[pointer1] < nums2[pointer2]) {
      nums1[pointer3] = nums2[pointer2]
      pointer2--
      pointer3--
    } else if (shouldCompare && nums1[pointer1] > nums2[pointer2]) {
      nums1[pointer3] = nums1[pointer1]
      pointer1--
      pointer3--
    } else if (pointer1 >= 0) {
      nums1[pointer3] = nums1[pointer1]
      pointer1--
      pointer3--
    } else if (pointer2 >= 0) {
      nums1[pointer3] = nums2[pointer2]
      pointer2--
      pointer3--
    }
  }
  console.log(nums1)
}

def merge_lists(nums1, m, nums2, n):
    # Punteros de las posiciones finales de los elementos válidos
    i = m - 1  # Última posición válida en nums1
    j = n - 1  # Última posición en nums2
    k = m + n - 1  # Última posición total en nums1 (donde irán los elementos ordenados)

    # Fusionar nums1 y nums2 desde el final
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:  # Si nums1 tiene el mayor valor
            nums1[k] = nums1[i]
            i -= 1
        else:  # Si nums2 tiene el mayor valor
            nums1[k] = nums2[j]
            j -= 1
        k -= 1  # Mover el puntero final

    # Si quedan elementos en nums2, los copiamos en nums1 (nums1 ya está en su lugar)
    while j >= 0:
        nums1[k] = nums2[j]
        j -= 1
        k -= 1

    return nums1
```def merge\_lists(nums1, m, nums2, n):    # Punteros de las posiciones finales de los elementos válidos    i = m - 1  # Última posición válida en nums1    j = n - 1  # Última posición en nums2    k = m + n - 1  # Última posición total en nums1 (donde irán los elementos ordenados)
    # Fusionar nums1 y nums2 desde el final    while i >= 0 and j >= 0:        if nums1\[i] > nums2\[j]:  # Si nums1 tiene el mayor valor            nums1\[k] = nums1\[i]            i -= 1        else:  # Si nums2 tiene el mayor valor            nums1\[k] = nums2\[j]            j -= 1        k -= 1  # Mover el puntero final
    # Si quedan elementos en nums2, los copiamos en nums1 (nums1 ya está en su lugar)    while j >= 0:        nums1\[k] = nums2\[j]        j -= 1        k -= 1
    return nums1

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇.....
   #check dor nums1 Size ...
   if ( n+m < len(nums1) ) :

      return -1

   p1 = m-1 
   p2 = n -1 

   itr = m + n -1 

   while ( p1 >= 0 and p2 >= 0 )  : 

      if ( nums1[ p1 ] > nums2[ p2 ] ) :

         nums1[ itr ] = nums1[ p1 ]
         p1 = p1 - 1 

      else : 

         nums1[ itr ] = nums2[ p2 ] 
         p2 = p2 - 1 

      itr = itr -1 

   while ( p1 >= 0 ) :

      nums1[ itr ] = nums1[ p1 ] 

      p1 = p1 -1 
      itr = itr -1

   while ( p2 >= 0 ) : 

      nums1[ itr ] = nums2[ p2 ] 
      
      p2 = p2 - 1 
      itr = itr -1

   return nums1 

```def merge\_lists(nums1, m, nums2, n):   # Tu código aquí 👇.....   #check dor nums1 Size ...   if ( n+m < len(nums1) ) :
&#x20;     return -1
&#x20;  p1 = m-1    p2 = n -1&#x20;
&#x20;  itr = m + n -1&#x20;
&#x20;  while ( p1 >= 0 and p2 >= 0 )  :&#x20;
&#x20;     if ( nums1\[ p1 ] > nums2\[ p2 ] ) :
&#x20;        nums1\[ itr ] = nums1\[ p1 ]         p1 = p1 - 1&#x20;
&#x20;     else :&#x20;
&#x20;        nums1\[ itr ] = nums2\[ p2 ]          p2 = p2 - 1&#x20;
&#x20;     itr = itr -1&#x20;
&#x20;  while ( p1 >= 0 ) :
&#x20;     nums1\[ itr ] = nums1\[ p1 ]&#x20;
&#x20;     p1 = p1 -1       itr = itr -1
&#x20;  while ( p2 >= 0 ) :&#x20;
&#x20;     nums1\[ itr ] = nums2\[ p2 ]             p2 = p2 - 1       itr = itr -1
&#x20;  return nums1&#x20;

def merge_lists(nums1, m, nums2, n):
   # Tu código aquí 👇
       # Inicializar punteros
    # Se asume la array nums1 es igual o mas larga que nums2
    p1 = m - 1
    p2 = n - 1
    p = len(nums1)-1
    print(nums1, nums2)

    while p >= 0:
        print(p, p1,p2)
        if p2 == -1: # No hay mas numeros para comparar en nums2
            break
        # se llegó al inicio de nums1 no hay mas numeros para comparar
        # ya se desplazaron todos los numeros de nums1 hacia la derecha
        # Queda un último numero en nums2 y es el menor de todos    
        if p1 == -1: 
            p1 = 0
            nums1[p] = nums2[p2]
            break

        if nums1[p1] <= nums2[p2]:
            nums1[p] = nums2[p2]
            p2 -= 1
        elif nums1[p1] >= nums2[p2]:
            nums1[p] = nums1[p1]
            p1 -= 1
        p -= 1

    return nums1

# Arrays de prueba 1
nums1 = [1,2,3,0,0,0]
m = 3
nums2 = [2,5,6]
n = 3
response = merge_lists(nums1, m, nums2, n)
print(response)

# Arrays de prueba 2
nums1 = [1,2,3,0,0,0,0]
m = 3
nums2 = [-4,2,3,9]
n = 4
response = merge_lists(nums1, m, nums2, n)
print(response)
```def merge\_lists(nums1, m, nums2, n):   # Tu código aquí 👇       # Inicializar punteros    # Se asume la array nums1 es igual o mas larga que nums2    p1 = m - 1    p2 = n - 1    p = len(nums1)-1    print(nums1, nums2)
&#x20;   while p >= 0:        print(p, p1,p2)        if p2 == -1: # No hay mas numeros para comparar en nums2            break        # se llegó al inicio de nums1 no hay mas numeros para comparar        # ya se desplazaron todos los numeros de nums1 hacia la derecha        # Queda un último numero en nums2 y es el menor de todos            if p1 == -1:             p1 = 0            nums1\[p] = nums2\[p2]            break
&#x20;       if nums1\[p1] <= nums2\[p2]:            nums1\[p] = nums2\[p2]            p2 -= 1        elif nums1\[p1] >= nums2\[p2]:            nums1\[p] = nums1\[p1]            p1 -= 1        p -= 1
&#x20;   return nums1
\# Arrays de prueba 1nums1 = \[1,2,3,0,0,0]m = 3nums2 = \[2,5,6]n = 3response = merge\_lists(nums1, m, nums2, n)print(response)
\# Arrays de prueba 2nums1 = \[1,2,3,0,0,0,0]m = 3nums2 = \[-4,2,3,9]n = 4response = merge\_lists(nums1, m, nums2, n)print(response)

function merge_lists( array $nums1 , int $m , array $nums2,  int $n): array {

    $k = $m + $n - 1;
    $m = $m -1;
    $n = $n -1;
    do{
        echo "m: ".$m." n: ".$n."\n";
        if($nums1[$m] >= $nums2[$n]){
            $nums1[$k] = $nums1[$m];
            $m--;
            $k--;
        }else{
            $nums1[$k] = $nums2[$n];
            $k--;
            $n--;
        }
    }while($m>= 0  || $n >=0);
    return $nums1;
}

def merge_lists(nums1, m, nums2, n):
   if n+m < len(nums1):
      return print("Error, invalid size")
   i = m + n - 1
   j = m - 1
   k = n - 1

   while j >= 0 and k >= 0:   
      if nums1[j] > nums2[k] :
         nums1[i] = nums1[j]
         j-=1
      else:
         nums1[i] = nums2[k]
         k-=1
      i-=1
   while j >= 0:
      nums1[i] = nums1[j]
      j-=1
      i-=1
   while k >= 0:
      nums1[i] = nums2[k]
      k-=1
      i-=1
   return nums1
```Esta es mi solución

Introducción

Patrones de Arreglos y Strings: Ventana Deslizante y Dos Apuntadores

Arrays y Strings: Funcionamiento y Complejidades Temporales

Dos Apuntadores

Patrón de Dos Apuntadores en Algoritmos de Lista

Verificación de Orden en Diccionario Alienígena

Ordenamiento de Palabras en Idiomas Alienígenas

Playground: Verifying Alien Dictionary

Ordenación de Palabras en Diccionario Alienígena

Combinar Listas Ordenadas en un Array Ascendente

Ordenamiento de Listas con Complejidad Óptima y Espacio Constante