Ya que tenemos nuestra lógica agreguemos nuestras variables faltantes, nuestro main y corramos el código de nuestro Queue.
No olvides realizar el reto de esta clase.
Vander Idme
Tomas Ap
Increíble como esta explicación didáctica punto por unto me ayudó a comprender más al respecto. Gracias compañero, super interesante cómo planteaste el problema. Me guardaré las imagenes para volver a revisarlas en un futuro.
Ivan Ezequiel Mazzalay
Excelente! Muy bueno, me sirvió muchísimo! Muchas gracias!
Danelia Sanchez Sanchez
En esta parte, si ejecutas la función deQueue, se imprimirá que el queue esta vacío.
Alberto González
¡Exacto! También pensé lo mismo.
Ricardo Celis
ProfesorJusto eso :)
Pablo Benedix
Ricardo Celis
ProfesorEstá excelente ! Justo esa es la magia de conocer sobre algoritmos
Juan Camilo Cuervo Say
Es muy ingenioso, aunque el rear ahora sera mayor que 4 y podre usar deQueue sin necesidad de usar antes un enQueue.
Así fue como lo hice yo
#include <stdio.h> #define SIZE 5 int items[4] = {2}, values[SIZE], front = -1, rear = -1; void enQueue(int value){ if (rear == SIZE -1) printf("Queue is full \n"); else { if (front == -1) front = 0; rear++; values[rear] = value; printf("We just added \"%d\" value successfully \n", values[rear]); } } void deQueue(){ if ( front == -1) printf("Our queue is empty\n"); else{ printf("We have deleted the %d value\n", values[front]); for (int counter = 0; counter != rear; counter++) values[counter] = values[counter + 1]; rear--; } } int main (int argc, char const *argv[]) { enQueue(1); enQueue(2); enQueue(3); enQueue(4); deQueue(); enQueue(6); enQueue(7); return 0; }
Henry Gutierrez Mora
no me ha gustado mucho el curso.. pero nada hacerle..
Victor Godoy Roa
el curso se entiende, pero faltó mostrar gráficamente lo que va ocurriendo paso a paso.
Carlos Isaac Rosales Castellanos
Ricardo Celis
ProfesorHolaaaa Selas! excelente trabajo aquí, gracias por además explicar tu código de forma tan clara, cómo te está pareciendo el curso? quedo pendiente!
Carlos Isaac Rosales Castellanos
@ricardocelis Muy bueno por ahora, muchas gracias por la atención!
Cesar Ruiz Navarro
Duda. ¿Porque Ricardo comenzo escribiendo su codigo por las funciones y no declaro las variables primero?? Al principio me confundi un poco por eso😂 ¿Es una buena practica o solo queria mostrar como funcionada el algoritmo primero?
Jean Paul Yepes
Para resolver un problema, suele ser útil descomponerlo en funciones mas pequeñas en las cuales puedes resolver subproblemas por aparte, es mas como comerse un sapo por pedazos que es mas fácil que el sapo completo
Juan Pablo Celiz
¡Buenas!
Particularmente me gusta codear de esta manera, al armar las funciones te das cuenta qué variables precisas y cómo debes trabajar con esas variables, que scope y contexto deberán tener, entre otras cosas. No creo que sea una mala ni buena práctica sino que es una forma distinta de encarar los problemas :D
Gabriel Ospina
Lo que mas me tomó tiempo de este ejercicio fue lograr compliar en C, tuve que investigar hasta que descubri que debia descgargar gcc hasta que lo logre. Porque todos ya sabian C o lo tenian configurados en sus equipos?. De igual forma me gusta el curso y lo que hacemos. Saludos a todos!
Alan Alexis Arostegui Maranto
Yo utilicé Paisa para compilar online, me dio flojera investigar como se hacía en mac jaja
Sebastián Pineda Ospina
Yo lo sabía ya que estoy siguiendo la ruta de IoT y para ver este curso se recomienda ver antes el de "terminal y línea de comandos" e "introducción a C". Allí enseñan muchas cosas que anda haciendo el profe.
Brandon Ramirez
Alguien me puede decir como sirve la consola de ubuntu en windows??
Gabriel De Andrade
Hola! Lo que hace es tener el Kernel de Linux corriendo dentro de Windows de manera super eficiente, haciendo posible ejecutar todo tipo de comandos Linux desde Windows :D
Edward Toledo López
Hola! Por si alguien llega a tener la misma duda:
Esto fue lo que se instaló con el Ubuntu Bash, los pasos vienen en esta clase: https://platzi.com/clases/1469-algoritmos/18427-instalando-ubuntu-bash-en-windows/
Lo que hace es crear una carpeta dónde corre el Kernel de Ubuntu de forma segura. Si tienen más dudas de su funcionamiento, hay todo dos cursos: uno que forma parte de la rutade Fundamentos de Programación y otro que es para Bases de Datos desde cero. Ambos se llaman Introducción a la Terminal y Línea de Comandos. Tocan los mismos temas pero de distinta forma (distinto profesor). Ambos son muy buenos :)
Juan Guillen Fortich
Tu sabes fue muy buena esta sección.
Juan Sebastian Montealegre Calle
Aaron Gabriel Jaimes Santofimio
Francisco Aguilar
Python
fila = [] def añadir(i, s): if i <= 4: i += 1 s += 1 fila.append(i) print(fila, ' \n') else: print(fila, ' \n', 'Fila llena', ' \n') return i, s def eliminar(s): if len(fila) > 0: del fila[0] s += 1 print(fila, ' \n') else: print('Fila vacia', ' \n') return s def run(): i = 0 s = 0 while True: num = int(input('Que deceas hacer 1-Agregar, 2-Eliminar ')) if num == 1: i, s = añadir(i, s) else: s = eliminar(s) if s >= 9 and len(fila) == 0: s = 0 i = 0 if __name__ == '__main__': run()
cxyz cripto
Ricardo Celis
Profesorse utiliza el testin! platzi.com/testing
Johan Mora
Nicolas Castañeda
Mi solucion fue en la funcion deQueue() eliminar el corrimiento de front dejandolo fijo al principio del arreglo y realizando un corrimiento al resto del mismo dejo el codigo:
void deQueue(){ if(front == -1) printf("Nuestro Queue esta vació \n"); else{ printf("se elimino el valor de %d \n",values[front]); //*Corrimiento del arreglo for (int i = 0; i < rear; i++){ values[i]=values[i+1]; } //*Borro el valor actual de rear ya que fue movido values[rear]=0; //* Resto a uno rear para que este al final de la cola despues del corrimiento rear--; if(front > rear) front = rear = -1; } }
Brayan Clavijo
No entiendo el reto, ¿Qué quiere decir con mejorar, mejorar qué?
Miguel Torres
Hola, @BrayanCC27. :D
Celis se refiere a mejorar en que no tengas que esperar a que se vacíe la fila para que puedas vaciar y llenar sin esperar a que esté completamente vacío. Si te das cuenta originalmente no puedes hacer enQueue de nuevo hasta que esté vacío completamente.
Eber Laurente Lliuyacc
Pues sí no se entiende bien, pero con la explicación de @Migue ya se tiene claro a lo que se refiere :)
María Angélica Pérez Gutiérrez
Alguien me puede explicar que significa lo que va dentro de la función main?
main (int argc, char const *argv[])
Antonio Foncubierta Vazquez
Ahi dentro tienes que poner las funciones que quieres ejecutar ejemplo: enQueue(10) para insertar el numero 10 en el array!! Un saludo.
Carlos Eduardo Magallon Zepeda
Carlos Nassif Trejo Garcia
RETOOO!!!!!!! y mis apuntes
Codigo completo
#include<stdio.h> #define SIZE 5 int values[SIZE]; int front = -1; int rear = -1; void imprimir(int v[]){ for(int i=front; i<=rear; i++){ printf("%d, ", v[i]); } printf("\n"); } void enQueue(int value){ if((rear - front) == SIZE-1) { printf("Nuestro Queue esta lleno "); imprimir(values); } else { if (front == -1) { front = 0; } rear++; values[rear] = value; printf("Se inserto el valor %d correctamente ", value); imprimir(values); } } void deQueue(){ if(front == -1) { printf("Nuestro Queue esta vacio \n"); } else { printf("Se elimino el valor %d correctamente ", values[front]); front++; imprimir(values); if(front > rear) { front = -1; rear = -1; } } } main(int argc, char const *argv[]) { enQueue(10); enQueue(20); enQueue(30); enQueue(40); enQueue(50); enQueue(60); deQueue(); deQueue(); deQueue(); deQueue(); deQueue(); deQueue(); enQueue(60); enQueue(70); enQueue(80); enQueue(90); enQueue(100); enQueue(110); return 0; }
Así me quedo el reto, la verdad pensaba que era mucho mas difícil y empece a poner puros IFs y Whiles jajajajajaj.
void deQueue(){ if(front == -1){ printf("Nuestro Queue esta vacio\n"); } else{ printf("Se elimino el valor %d\n", values[front]); front++; rear++; if (front > rear) { front = rear = -1; } } }
lo unico que agregue fue el rear++. puesto que si front y rear aumentan se mantiene el mismo tamaño del Queue y queda un espacio en rear para un nuevo value
Buenas a todos! Aquí está el código del reto propuesto por el profe en esta clase.
Unas cosas que aclarar:
1.- Agregue una función más para imprimir el contenido de la Queue, su nombre es printQueue.
2.- Modifiqué la función deQueue de forma que al momento de eliminar el valor, sea realizado un ciclo que va a mover todos los números ingresados una posición más adelante para al final eliminar la posición final dejándola en 0 y retrocediendo el valor de rear un espacio. El ciclo se vale del valor de la variable rear para determinar cuántos espacios debe retroceder.
3.- La variable front quedó renegada a únicamente marcar cuando esté vacía/en uso la lista.
Espero que les quede claro con el código lo que acabo de decir!
#include <stdio.h> #define SIZE 5 int values[SIZE], front= -1, rear= -1; void enQueue(int value){ if(rear == SIZE-1) printf("The Queue is full.\n"); else { if(front == -1) front = 0; rear++; values[rear] = value; printf("%d has been inserted correctly\n", value); } } void deQueue(){ if(front == -1) printf("The Queue is empty.\n"); else{ printf("%d has been deleted correctly\n", values[front]); int i; for(i = 0; i < rear; i++) values[i] = values[i+1]; values[rear] = 0; rear--; if(front > rear) front = rear = -1; } } void printQueue(){ if(rear == -1) printf("The Queue is empty.\n"); else{ int i; for(i = 0; i <= rear; i++) printf("Position %d: %d\n", i, values[i]); } } int main(int argc, char const *argv[]){ ... }
Esta es mi solucion al reto... Busque la manera de hacerlo lo mas eficientemente posible, por que notaba que despues de insertar o borrar cierta cantidad de datos no tenia el mismo resultado.
#include<stdio.h> #define SIZE 5 int values[SIZE], front = -1, rear= -1; void enQueue(int value){ if(rear == SIZE-1) printf("The Queue is full\n" ); else { if(front == -1) front = 0; rear++; values[rear] = value; printf("The value %d stored correctly\n", value); } } void deQueue(){ if(front == -1) printf("The Queue is empity\n" ); else{ printf("Deleted the value %d\n", values[front]); front++; rear--; if (front == SIZE || front > rear) front = rear = -1; } } main(int argc, char const *argv[]) { enQueue(1); enQueue(2); enQueue(3); enQueue(4); enQueue(5); enQueue(6); deQueue(); deQueue(); deQueue(); deQueue(); deQueue(); deQueue(); enQueue(6); deQueue(); deQueue(); return 0; }```
Aquí esta mi solución al reto hecha en python (soy nuevo en este lenguaje si alguien sabe como podría optimizar mi código leeré su respuesta mucho gusto)
# Declaracion de constantes SIZE = int(5) # Declaracion de variables front = int(-1) rear = int(-1) # Declaracion de arreglos values = [None] * SIZE # Funcion para agregar datos a la queue def en_queue(value): global rear, front, values # si el indicador de la parte final es igual al tamaño del queue entonces if rear == SIZE - 1: print("Nuestro Queue esta lleno \n") else: # inicializa el indicador de la cabeza en cero if front == -1: front = 0 # aumenta el indicador de la cabeza en uno y agrega el valor rear = rear + 1 values[rear] = value print("Se agrego el valor {} correctamente \n".format(value)) # Funcion para eliminar datos a la queue def de_queue(): # llamado de las variables globales global front, rear, SIZE # si el indicador de la cabeza es -1 if front == -1: print("\n\nNuestro Queue esta vacio\n") else: print("Se elimino el valor {}\n".format(values[front])) front += 1 # ciclo que mueve todos los datos a la siguiente posicion en la queue y modifica el indicador de cola for x in range(1, 5): values[x - 1] = values[x] values[x] = None if x == 4: rear = rear - 1 break # si el arreglo queda vacio entonces reinicia los indicadores if front > rear: front, rear = -1, -1 # Funcion para imprimir los valores de la queue def imprimir_queue(): print("\nEstado actual de la Queue") for x in range(0, 4): # Si el campo de la queue es diferente de vacio entonces if values[x] is not None: print(values[x]) if __name__ == "__main__": en_queue(1) en_queue(2) en_queue(3) en_queue(4) en_queue(5) de_queue() de_queue() en_queue(10) imprimir_queue()
**Resultado: **
Se agrego el valor 1 correctamente Se agrego el valor 2 correctamente Se agrego el valor 3 correctamente Se agrego el valor 4 correctamente Se agrego el valor 5 correctamente Se elimino el valor 1 Se elimino el valor 3 Se agrego el valor 10 correctamente Estado actual de la Queue 3 4 5 10
Mi código para resolver el reto:
#include <stdio.h> #define SIZE 5 // int values[SIZE], firstOut = -1; int total = 0, insert = 0; void enQueue(int value) { if (total == SIZE) { printf("Queue full\n"); } else { if (total == 0) { firstOut = insert; } values[insert] = value; insert++; if (insert == SIZE) { insert = 0; } total++; printf("The value %d was added sucessfully\n", value); } } void deQueue() { if (total == 0) { printf("Queue empty\n"); } else { printf("The value %d was eliminated\n", values[firstOut]); firstOut++; if (firstOut == SIZE) { firstOut = 0; } total--; } } int main(int argc, char const *argv[]) { ... return 0; }
Lo que trato de representar son indicadores (insert y firstOut) que me señalen la situación de la cola. 'insert' dice cual es la posición en la que un valor se debe ubicar respecto al último de la cola, y firstOut el valor en cola que debe ser atendido.
Haciendo el reto me surgio la duda en como comprueban que el código es correcto, hice pruebas pero todo de forma manual y tediosa xd, supongo que habrán mejores formas. ¿Cómo hacen ustedes para comprobar que sus códigos son correctos?
Aquí dejo mi aporte espero lo entiendan, lo logré después de darle un par de vueltas encima
#include <stdio.h> #define SIZE 5 int values[SIZE], front, rear; void inicializar(){ // Función que inicializa las variables por defecto front = -1; rear = -1; int i; for(i = 0; i < SIZE; i++){ values[i] = 0; } } void mostrarQueue(){// Función para mostrar la Queue por pantalla int i; for(i = 0; i < SIZE; i++){ if(values[i] != 0){ printf("%d", values[i]); } } printf("\n"); } void enQueue(int value){ if(rear == SIZE - 1){ printf("Queue full.\n"); }else{ if(front == -1){ front++; } if(rear < SIZE){//Si el rear no ha llegado al final del Queue aumenta en uno y guarda el valor en la Queue rear++; values[rear] = value; printf("%d insertado correctamente en la Queue. \n", value); } } } void deQueue(){ if(front == -1){ printf("Queue vacio.\n"); }else{ printf("%d Removido correctamente. \n", values[front]); int i; // Código para reordenar el Queue corriendolo un indice a la izquierda para así poder insertar un nuevo valor en la ultima posición int aux; for(i = 0; i < SIZE; i++){ aux = values[i]; // Método burbuja para ordenar el Queue values[i] = values[i+1]; values[i+1] = aux; } values[rear] = 0;//La ultima posición del rear se convierte 0 para poder alojar un valor nuevo values[SIZE -1] = 0;//También se convierte en 0 las posiciones a su derecha por si se elimina más de una vez rear--;// Se resta el rear para poder liberar la condición de la función enQueue para guardar un valor nuevo if(rear == -1){//Avistador cuando la Queue se queda vacia por borrar todos sus elementos front--; } } } void main(){ inicializar(); }```
Si te refieres a la parte que dice
(int argc, char const * argv[])
Esto sirve para pasarle argumentos desde la linea de comandos a tu programa.
# En gnu/linux ./archivo_compilado.out argumento1 argumento2
Lo que hayas puesto como argumento1 y argumento2 estarán disponibles en el array argvc y puedes usarlos como tu quieras en tu programa.
Mi implementación :D
#include <stdio.h> #define SIZE 5 int values[SIZE]; int front = -1, rear = -1; // Optimiza los espacios y recorre los valores al inicio void cleanQueue() { // No hay elementos if ( front == -1 ) { printf("No hay elementos, todo bien\n"); rear = -1; return; } // Ya esta al inicio if ( front == 0 ) { printf("Nada que optimizar, la queue esta al inicio\n"); return; } // Cuantos valores hay? int rango = rear - front + 1; //Temporal para ver donde ir insertando int insertarIzq = 0; // Recorrer los elementos he ir insertando a la izquierda for ( int i = front; i <= rango; i++ ) { values[insertarIzq] = values[i]; insertarIzq++; } // Resetear elementos front = 0; rear = rango-1; } // Pop al elementos mas viejo void deQueue() { // Hay elementos? if ( front == -1 ) { printf("No hay mas elementos\n"); return; } int valor = values[front]; printf("Se elimino el valor %d\n", valor); front++; // No mas elementos, resetenado if ( front > rear ) { front = rear = -1; } // Optimizar el queue cleanQueue(); } // Insertar un valor a la cola void enQueue( int value ) { // Condicion de ver si la cola ya esta llena if ( rear == ( SIZE - 1 ) ) { printf("Nuestro queue esta lleno\n"); return; } // Si no hay elementos, inicializar el front if ( front == -1 ) { front = 0; } // Extender el rear e insertar el valor rear++; values[rear] = value; printf("Se inserto el valor %d correctamente\n", value); } void printAll() { printf("\n----------\n"); for ( int i = 0; i < SIZE; i++ ) { printf("%d, ", values[i]); } printf("\n"); for ( int i = front; i <= rear; i++ ) { printf("%d, ", values[i]); } printf("\n----------\n"); } int main(int argc, char const *argv[]) { enQueue(1); enQueue(2); enQueue(3); enQueue(4); enQueue(5); deQueue(); enQueue(6); deQueue(); deQueue(); enQueue(7); deQueue(); deQueue(); deQueue(); deQueue(); deQueue(); return 0; }
