Bienvenido al Curso

1

Introducci贸n al curso b谩sico de algoritmos y estructuras de datos

Introducci贸n a los algoritmos

2

驴Qu茅 entiende una computadora?

3

Lenguajes de programaci贸n

4

Estructuras de datos

5

驴Qu茅 es un algoritmo?

6

Metodolog铆a para la construcci贸n de un algoritmo

7

Variables y tipos de datos

8

User defined data types

9

Instalando Ubuntu Bash en Windows

10

Creando nuestro user defined data type

11

Abstract Data Types b谩sicos: Lists, Stacks, Queues

12

Explicaci贸n gr谩fica Data Types b谩sicos

13

Glosario de funciones para Abstract Data Types

14

Clases y objetos

15

Creando tu primera Queue: Arrays

16

Creando tu primera Queue: implementaci贸n.

17

Creando tu primera Queue: implementar la funci贸n enQueue

18

Creando tu primera Queue: implementar la funci贸n deQueue

19

Creando tu primera Queue: main code

Algoritmos de ordenamiento

20

Algoritmos de ordenamiento

21

Bubble sort

22

Bubble sort: implementaci贸n

23

Bubble sort: main code

24

Insertion sort

25

Desaf铆o: implementa un algoritmo de ordenamiento

Recursividad

26

Recursividad

27

La funci贸n Factorial, calculando el factorial recursivamente

28

Manejo de cadenas de caracteres

29

Arte: Generando arte recursivo

Divide and conquer y programaci贸n din谩mica

30

Divide and Conquer (divide y vencer谩s)

31

Qu茅 es la programaci贸n din谩mica (divide y vencer谩s v2.0)

32

MergeSort

33

Desaf铆o: Buscar el algortimo m谩s r谩pido de sort

34

Implementando QuickSort con Python

35

Implementando QuickSort con Python: main code

Algoritmos 'Greedy'

36

Qu茅 son los Greedy Algorithm

37

Ejercicio de programaci贸n greedy

38

Ejercio de programaci贸n greedy: main code

Grafos y 谩rboles

39

Grafos y sus aplicaciones

40

脕rboles

驴C贸mo comparar Algoritmos?

41

C贸mo comparar algoritmos y ritmo de crecimiento

驴Qu茅 sigue?

42

Cierre del curso y siguientes pasos

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Creando tu primera Queue: main code

19/42
Recursos

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.

Aportes 338

Preguntas 17

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

En esta parte, si ejecutas la funci贸n deQueue, se imprimir谩 que el queue esta vac铆o.

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

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

El ucrso y la metodolog铆a me parecen excelentes para aprender a pensar de una forma algor铆tmica. SOlo le sugiero a los compa帽eros que no est谩n muy familiarizados con el lenguaje C y qu茅 han tenido dificultades, que vean el curso de introducci贸n a C para que puedan sacarle m谩ximo provecho a este curso.

no me ha gustado mucho el curso鈥 pero nada hacerle鈥

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[]){
    ...
}

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!

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

Python

fila = []

def aadir(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()

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. 鈥榠nsert鈥 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();
}```

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

ESTA ES LA FORMA EN QUE LO HICE EN PYTHON ( estoy abierto a sugerencias.)

import queue


cola = queue.Queue(5)

def enqueue():
    while cola.qsize() < 5:
        if fullqueue():
            print(f'La cola tiene {cola.qsize()} elementos.\n')
        valor = input('Ingresa un elemento a la cola:\n')
        cola.put(valor)
        print(f'El valor {valor} se inserto correctamente en la cola.\n')


def fullqueue():
    if cola.qsize() == 5:
        True
    elif cola.qsize() == 0:
        False


def dequeue():
    if cola.qsize() > 0:
        elemento = cola.get()
        print(f'El elmento {elemento} de la cola se a retirado.')
    elif cola.empty():
        print('YA NO HAY ELEMENTOS EN LA COLA')


def mostrar_cola():
    opc = input('AL MOSTRAR LOS ELEMENTOS DE LA COLA SE PERDERAN LOS DATOS ALMACENADOS 驴QUIERES SEGUIR? [Y] [N]:\n')
    if opc.lower() == 'y':
        i = 0
        print('Los elementos en la cola son:\n')
        while cola.qsize() > 0:
            print(f'{i} => {cola.get()}')
            i += 1
        print('\nLA COLA ESTA VACIA')
    elif opc.lower() == 'n':
        print('Bye, bye ...')

def menu():
    print("""
[1] Mostrar elementos de la cola.
[2] Ingresar elementos a la cola.
[3] Retirar elementos de la cola.
[4] Salir\n""")


def main():
    fin = False
    while not fin:
        menu()
        opc = int(input('Escoje una opcion:\n'))
        if opc == 1:
            mostrar_cola()
        elif opc == 2:
            enqueue()
        elif opc == 3:
            dequeue()
        elif opc == 4:
            fin = True

if __name__ == '__main__':
    main()

En mi caso yo resolv铆 el reto asi:

#include<stdio.h>

#define SIZE 5
int items[SIZE], front = -1, rear = -1;

void enQueue(int value) {
	if (rear == SIZE - 1) 
		printf("Nuestro Queue esta lleno \n");
	else {
		if (front == -1)
			front = 0;
		
		rear++;
		items[rear] = value;
		printf("Se inserto el valor %d correctamente \n", value);
	}

}

void deQueue() {
	if (front == -1)
		printf("Nuestro Queue esta vac铆o \n");
	else {
		printf("Se elimin贸 el valor %d\n", items[front]);
		front++;
		if (front > rear || front < rear)
			front = rear = -1;
	}
}

int main(int argc, char const *argv[])
{	
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);
	deQueue();
	enQueue(6);
	return 0;
}```

Simplemente use el operador or (`||`) de C para que se evalu茅 no s贸lo cuando el Queue esta lleno si no tambi茅n cuando tiene un espacio disponible as铆:
`if (front > rear || front < rear)`

No conozco muy bien C as铆 que no se si esta es la mejor soluci贸n

He realizado 2 implementaciones en python, una utilizando las listas (linked lists) y otra empleando arrays.

C贸digo utilizando linked lists (listas de python)

import random

def de_queue(data, items):
    if(data['front'] == -1):
        print("Our queue is empty")
    else:
        print(f"The value {items[data['front']]} was removed")
        items.pop(data['front'])
        if len(items):
            data['rear'] -= 1
        else:
            data['front'] = data['rear'] = -1


def en_queue(value, data, items, SIZE):
    if data['rear'] == SIZE - 1:
        print("Our Queue is full")
    else:
        if data['front'] == -1:
            data['front'] = 0
        data['rear'] += 1
        items.append(value)
        print(f"The value {value} was added correctly")


def run(SIZE):
    items = []
    data = {
        'front': -1,
        'rear': -1
    }
    numbers_to_insert = SIZE
    numbers = [random.randint(0, 100) for i in range(numbers_to_insert)]

    for number in numbers:
        en_queue(number, data, items, SIZE)


if __name__ == '__main__':
    SIZE = 5 # limite de elementos para la cola

    run(SIZE)

C贸digo utilizando arrays (usando numpy de python)

import random
import numpy as np

def de_queue(data, items):
    if(data['front'] == -1):
        print("Our queue is empty")
    else:
        print(f"The value {items[data['front']]} was removed")
        indices = list(range(0,items.size - 1))
        values = items[1:items.size]
        np.put(items, indices, values)

        if data['rear']:
            data['rear'] -= 1
        else:
            data['front'] = data['rear'] = -1

def en_queue_arr(number, data, items, SIZE):
    if data['rear'] == SIZE - 1:
        print("Our Queue is full")
    else:
        if data['front'] == -1:
            data['front'] = 0
        data['rear'] += 1
        items[data['rear']] = number
        print(f"The value {number} was added correctly")


def np_arrays(SIZE):
    items = np.empty(SIZE)
    data = {
        'front': -1,
        'rear': -1
    }
    numbers_to_insert = SIZE
    numbers = [random.randint(0, 100) for i in range(numbers_to_insert)]

    for number in numbers:
        en_queue_arr(number, data, items, SIZE)


if __name__ == '__main__':
    SIZE = 5 # limite de elementos para la cola

    np_arrays(SIZE)

Gr谩fico comparativo de los tiempos de ejecuci贸n de las 2 implementaciones anteriores

Solucion en JavaScript

const SIZE = 5;
    let front = -1;
    let rear = -1;
    let values = [];

    function enQueue (value) {
      if (rear == SIZE-1) {
        console.log('Nuestro Queue esta lleno');
      }else {
        if (front == -1) {
          front = 0;
        }
        rear++;
        values.push(value);
        console.log(`'Se anadio el valor ${value} en la posici'on ${rear}'`);
      }
    }

    function deQueue () {
      if(front == -1) {
        console.log('Nuestro Queue esta vacio');
      }else {
        console.log(`Se elimino el valor ${front} correctamente`);
        front++;
        rear--;
        if (front == SIZE) {
          front = rear = -1;
        }
      }
    }

Soluci贸n en C

#include<stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;

void enQueue (int value) {
  if (rear == SIZE-1)
    printf("Nuestro Queue esta lleno \n");
  else {
    if (front == -1)
      front = 0;
    rear++;
    values[rear] = value;
    printf("Se inserto el valor %d correctamente\n", value);  
  }
}

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 == SIZE)
      front = rear = -1;
  }
}

Java

  • Haciendo borrado por listas completas
  • Agreagar listas de manera dinamica
  • Uso de scanner para ingresar valores por consola, solo un scanner por la cantidad x de valores ingresados

Class Impl

import java.util.ArrayList;
import java.util.List;


public class ArrayClass {
	
	String[] array; 
	List<Integer> numList = new ArrayList<>();
	int rear = -1;
	int front = -1;
	int SIZE;
	
	public void addArray(String elementos) {

	array = elementos.split("");
	SIZE = array.length;
	
	 if(front == -1) {
			 front = 0;
			 rear++;
				while(rear < SIZE) 
					
					numList.add(Integer.valueOf(array[rear]));
					System.out.println("Se inserto correctamente el valor " + numList.get(rear));
					rear++;
					}
				
	           }
	 if(rear == SIZE) {
			rear--;
		}
	 
		if(rear == SIZE-1) {
			System.out.println("Lista completa ");
		}
	}
	
	public void resetArray() {
		
		if(front == -1){
			System.out.println("Array vacio");
			}
		
			do{
				System.out.println("Se borro elemento " +  numList.get(0));
				numList.remove(0);
				front++;
			}while(front <= rear);
			
			if(front > rear) {	
				System.out.println("Se borro el array completamente");
				front = rear = -1;
			}
		}
}

Class Insert data

import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		ArrayClass add = new ArrayClass();
		String opcion;
		String elementos;
		
		do {
			System.out.println("Inserte numeros");
			String num = sc.next();
			add.addArray(num);
			System.out.println("Seleccione una opcion");
			System.out.println("1 Agregar mas elementos");
			System.out.println("2 Borrar lista");
			opcion = sc.next();
			
			if(opcion.equals("2")) {
				add.resetArray();
				System.out.println("Seleccione una opcion");
				System.out.println("1 Agregar mas elementos");
				System.out.println("2 Borrar lista");
				opcion = sc.next();
				}
			
		}while(!opcion.equals("2"));
		

	}
}

Mi c贸digo en Python 3.7 del Reto:

"""
Pasos de nuestro Algoritmo:
鈥	Crear una Queue que vaya guardando los usuarios por orden de llegada.
鈥	Si llega otro usuario solicitando un pedido y hay espacio en la Queue, este se pone en la cola siempre y cuando haya espacio.
鈥	Cuando la orden del primer usuario ya esta lista, se entrega al usuario y se remueve este del al Queue,
    y as铆 sucesivamente por orden de llegada. Siempre revisar antes si existen elementos para remover de la Queue.
"""
import os   #Libreria para manejar comandos propios del sistema operativo
from queue import Queue #Importamos la clase Queue, que simula una FIFO

def enqueue(colita, elemento):  # Funci贸n o m茅todo para insertar elementos en la cola
    if(colita.full()):  #Valida si la cola esta full
        print("No podemos atenderlo en estos momentos, estamos full")
        input("Digite 1 para seguir:")
    else:   #La cola no esta full
        colita.put(elemento)    #Funci贸n put agrega el elemento a la cola
        print("Se agrego correctamente su pedido {}".format(elemento))
        input("Digite 1 para seguir:")


def dequeue(colita): # Funci贸n o m茅todo para sacar elementos de la cola
    if(colita.empty()): #Valida si la cola esta vacia
        print("No hay pedidos para entregar")
        input("Digite 1 para seguir:")
    else: #La cola no esta vacia
        elemento = colita.get()
        print("Se entrega correctamente el pedido {}".format(elemento))
        input("Digite 1 para seguir:")

cola = Queue(5)  #Creamos el objeto cola de la clase Queue

while True:     #Bucle infinito para mostrar las opciones al usuario
    #os.system('cls')				#Limpia pantalla
    opciones = int(input("Digite el n煤mero para Opciones de Pedidos:\n 1. Ingresar un Pedido\n 2. Retirar su Pedido\n 3. Cerrar la Aplicaci贸n\n Opci贸n:"))
    if(opciones == 1): #Ingresar un pedido
        pedido = input("Ingrese su n煤mero de pedido:")
        enqueue(cola,pedido)
    elif(opciones == 2): #Retirar un pedido
        dequeue(cola)
    elif(opciones == 3): #Cerrar la aplicaci贸n
        print("Se cerro la aplicaci贸n")
        break
    else:
        print("Digite correctamente una opci贸n")```

Implementaci贸n鈥 Con apuntes incluidos.





#include <stdio.h>
#define SIZE 5

int values[SIZE], front = 0, rear = -1, emptySpots = SIZE;

void enQueue(int value)
{
	if (rear == SIZE-1) //Si el queue esta lleno no se puede a帽adir m谩s elementos.
		printf("Nuestro queue esta lleno.\n"); 
	else
	{
		printf("Se inserto el valor %d.\n", value); //Confirmaci贸n del elemento a a帽adir.
		rear++; //Al agregar un nuevo elemento al queue, el valor de rear incrementara en +1.
		emptySpots--; //Y por consiguente habr谩 un espacio vacio menos.
		values[rear] = value; //Asignara el nuevo valor a la lista (se almacenar谩 al fondo).
	}
}

void deQueue()
{
	if (emptySpots == SIZE) //Imprime el mensaje diciendo que el queue est谩 vacio si no hay valores en el.
		printf("Nuestro queue esta vacio.\n");
	else
	{
		printf("Se elimino el valor %d.\n", values[front]); //Mensaje mencionando el valor a quitar.
		for (int i = 0; i < SIZE; ++i)
		{
			values[i] = values[i + 1]; //Mueve todos los valores hacia adelante una posici贸n.
		}
		values[rear] = 0; //"Borra" el valor trasero (que ya fue movido una posici贸n adelante)
		rear--; //Mueve el rear un valor hacia adelante.
		emptySpots++; //Aumenta la cantidad de espacios vacios en el queue.
		if (emptySpots == SIZE) //Verifica si todos los valores fueron borrados.
			rear = - 1; //Restablece el valor de rear.
	}
}

void printQueue() //Imprime el queue.
{
	printf("Queue: ");
	for(int i = 0; i < SIZE; i++)
		printf("[%d]", values[i]);
	printf("\n");
}

int main(int argc, char const *argv[])
{
	for (int i = 0; i < SIZE; ++i) //Llenamos el queue.
	{
		enQueue(i + 1); 
		printQueue(); //La ultima iteraci贸n mostrar谩 [1][2][3][4][5].
	}
	enQueue(1); //Mostrar谩 que el queue est谩 lleno.
	deQueue(); //Quitamos el primer elemento de la fila.
	printQueue(); //Mostrar谩 [2][3][4][5][0].
	enQueue(1); //A帽ade 1 al final. 
	//Se soluciona el error ya que puede a帽adir nuevos elementmos independientemente de lo
	//lleno que est茅 el queue.
	printQueue(); //Mostrar谩 [2][3][4][5][1].
	for (int i = 0; i < SIZE; ++i) //Vaciar谩 el queue.
	{
		deQueue();
		printQueue(); //La ultima iteraci贸n mostrar谩 [0][0][0][0][0].
	}
	deQueue(); //Mostrar谩 que el queue est谩 lleno.
	enQueue(10); //A帽ade un 10.
	printQueue(); //Mostrar谩 [10][0][0][0][0].
	enQueue(20); //A帽ade un 20.
	printQueue(); //Mostrar谩 [10][20][0][0][0].
	enQueue(30); //A帽ade un 30.
	printQueue(); //Mostrar谩 [10][20][30][0][0].
	deQueue(); //Quitamos el primer elemento de la fila.
	printQueue(); //Mostrar谩 [20][30][0][0][0].
	return 0;
}

Dale tu FeedBack a mi solucion con implementacion sobre criptomonedas (Depositos y Retiros) :
Hice un Queue Circular que verifica si esta lleno y evita sobreescribir el valor rear en front , con esta operacion de residuo, que use en las lineas 8,16,29.

(rear+1)%SIZE 
#include <stdio.h>
#define SIZE 5

int front=-1, rear=-1, balance=0;

//Funcion para depositar saldo a la billera-function to add wallet balance
void depositWallet(int deposit){
    if ( (rear+1)%SIZE == front ) 
        printf("\n Llegaste al limite, no puedes depositar \n");
    else
    {
        balance += deposit;
        printf("\n Fondos recibidos en tu wallet: %d, tu saldo es:%d ", deposit, balance); //Confirmar monto del deposito
        if (front == -1 || front == SIZE-1)
            front = 0;        
        rear = (rear+1)%SIZE; //queue circular
        printf("\trear = %i & front = %i", rear, front);
    }       
}

//Funcion para gastar saldo de la billetera-wallet balance spending function
void withdrawWallet(int withdraw){
    if (rear == -1 || balance == 0)
        printf("\n Tu saldo es: %d, no tienes criptomoneda para gastar", balance);
    else
    {
        balance -= withdraw;
        printf("\n Enviaste: %d, tu saldo es: %d", withdraw, balance);
        front = (front+1)%SIZE;
        printf("\t \t rear = %i & front = %i", rear, front);
    }    
}

int main()
{
    depositWallet(1);
    depositWallet(3);
    depositWallet(4);
    depositWallet(1);
    depositWallet(2);
    depositWallet(4);
    withdrawWallet(2);
    withdrawWallet(3);
    depositWallet(2);
    depositWallet(5);
    depositWallet(1);
    withdrawWallet(2);
    withdrawWallet(4);
    withdrawWallet(2);
    depositWallet(1);
    depositWallet(4);
    depositWallet(3);
    depositWallet(5);
    return 0;
}

Circular Queue, se llama el tipo de cola que permite siempre reutilizar el espacio sin tener que hacer deQueue de todos los elementos para volver a agregar uno.

#include <stdlib.h>
 10 #include <stdio.h>
  9 #include <stdbool.h>
  8
  7 #define SIZE 5
  6
  5 int values[SIZE], front = -1, rear = -1, size = 0;
  4
  3 bool isEmpty(){
  2   return size == 0;
  1 }
12
  1 bool isFull(){
  2   return size == SIZE;
  3 }
  4
  5 void enQueue(int value){
  6   if(isFull()){
  7     printf("The Queue is full\n");
  8   } else {
  9     rear = (rear + 1) % SIZE;
 10     values[rear] = value;
 11     size++;
 12     printf("The value %d was inserted successfuly\n", value);
 13   }
 14 }
 15
 16 void deQueue(){
 17   if(isEmpty()){
 18     printf("The Queue is empty\n");
 19   } else {
 20     front = (front + 1) % SIZE;
 21     size--;
 22     printf("The value was dequeued successfuly\n");
 23   }
 24 }
 25

Hice algunos cambios al programa, implement茅 un arreglo circular. Cuando hay un valor almacenado en la 煤ltima posici贸n del arreglo, el siguiente valor se guarda en la primera posici贸n del arreglo (si el arreglo no est谩 lleno), para ello empleo 茅sta instrucci贸n:

rear = (rear + 1) % SIZE;

Es interactivo, puedes encolar y desencolar elementos las veces que quieras, siempre que no haya desborde y/o haya elementos en el arreglo seg煤n el caso. Se muestra como van los elementos. Claro que hay otras formas mejores de implementarlo. Aqu铆 el c贸digo:


#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void enQueue(int value) {
    if(((rear + 1) % SIZE) == front)
        printf("Nuestro Queue esta lleno\n");
    else {
        if(front == -1)
            front = 0;
        rear = (rear + 1) % SIZE;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

void deQueue() {
    if(front == -1)
        printf("Nuestro Queue esta vacio\n");
    else {
        printf("Se elimino el valor %d\n", values[front]);
        values[front] = 0; // posici贸n disponible para almacenar otro valor
        if(front == rear)
            front = rear = -1; // la cola esta vac铆a
        else
            front = (front + 1) % SIZE; // si front es la 煤ltima posici贸n del arreglo,  entonces front = 0
    }
}

void print_deQueue() {
    for(int i = front, j = 0; j < SIZE; j++) {
        if(values[i] != 0)
            printf("%d -> ", values[i]);
        i = (i + 1) % SIZE;
    }
}

int main(int argc, char const *argv[])
{
    int option, value;
    
    do
    {
        printf("\n\n1.- Enqueue\n");
        printf("2.- Dequeue\n");
        printf("3.- Salir\n");
        printf("Escoge una opcion: ");
        scanf("%d", &option);

        switch (option)
        {
            case 1:
                printf("Valor: ");
                scanf("%d", &value);
                enQueue(value);
                print_deQueue();
                break;
            case 2:
                deQueue();
                print_deQueue();
                break;
            case 3:
                printf("Fin del programa.");
                break;
            default:
                printf("Opcion No valida.");;
        }
    } while (option != 3);
    
    return 0;
}
#include <stdio.h>
#define SIZE 5
int values[SIZE],front = -1,rear = -1;

void enQueue(int value)
{
	if(rear == SIZE-1)
	{
		printf("Nuestro Queue esta lleno \n");
	}
	else
	{
		if(front == -1)
		{
			front = 0;
			rear++;
			values[rear] = value;
			printf("Se inserto el valor %d correctamente:",value);
    	}
	}	
}

void deQueue()
{
	if(front == -1)
	{
		printf("Nuestro Queue esta vacio \n");
	}
	else
	{
		printf("Se elimino el valor %d",values[front] );
		front++;
		if(front > rear )
		{
			front = rear = -1;
		}
	}
}

int main(int argc, char const *argv[])
{
	enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
	
	return 0;
}

al ejecutar mi codigo solo me inserta el numero uno, me pueden ayudar con el codigo

Quisiera hacer mas practicas con las estructuras de datos, me pueden enviar mas retos, por favor.

Les comparto el codigo con el que resolvi el reto. Use rear como variable principal y corri los datos cada vez que salia uno, dejando de esta manera el ultimo espacio disponible.

#include<stdio.h>
#define SIZE 5

int values[SIZE], front=0, rear=-1,i,j;

void enQueue(int value) {
  if (rear == SIZE-1 ) {
    printf("Nuestro Queue esta lleno\n");
  }
  else {
    rear++;
    values[rear] = value;
    printf("Se inserto el valor %d correctamente\n",value );
  }
}

void deQueue(){
  if (rear == -1) {
    printf("Nuestro Queue esta vacio\n");
  }else{
     printf("Se elimino el valor %d\n", values[front]);
     for (j=0; j<5; j++) {
       values[j]=values[j+1];
     //printf("x %d %d\n", rear,values[j]);
     }
     rear--;

  }
  }

int main() {
  enQueue(1);
  enQueue(2);
  enQueue(3);
  enQueue(4);
  enQueue(5);
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  enQueue(10);
  enQueue(11);

  for (i=0; i <5; i=i+1){
    printf("values[%d]: %d\n",i,values[i]);
  }
  return 0;
}

Otra vez problemas con la consola, mejor los compilo y ejecuto en codeblocks.

Al final he conseguido hacer la queue dinamica, funciona todo perfectamente, he eliminado el front de la ecuaci贸n para que siempre el dequeue extraiga el item en posicion 0 del array, y solo se mueve el rear.
Me ha parecido mas sencillo asi. y cuando se extrae un dato mediante queue, se mueve toda la cola una posici贸n hacia atr谩s.

using System;
namespace queue
{
    class queueImplementaci贸n
    {
        const int size = 5;
        static int rear = -1;
        static int[] items = new int[size];
        static public void enQueue(int valor)
        {
            if (rear == size - 1) Console.WriteLine("Nuestro Queue, est谩 lleno, no posible insertar: " + valor.ToString()); //Detectar si cabe otro item, sin贸, mostrar error.
            else
            {
                rear++;
                items[rear] = valor;
                Console.WriteLine("Se insert贸 el valor " + valor.ToString() + " Correctamente");
            }
        }
        static public void deQueue()
        {
            if (rear < 0)
            {
                Console.WriteLine("no hay elementos a retirar");
            }
            else
            {
                Console.WriteLine("se elimin贸 el valor: " + items[0].ToString());
                moverCola();
                rear--;
            }
        }

        private static void moverCola()
        {
            switch (rear)
            {
                case 4:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = items[3];
                    items[3] = items[4];
                    items[4] = 0;
                    break;
                case 3:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = items[3];
                    items[3] = 0;
                    break;
                case 2:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = 0;
                    break;
                case 1:
                    items[0] = items[1];
                    items[1] = 0;
                    break;
                case 0:
                    break;
                default: Console.WriteLine("error, rear");break;
            }
            
        }

        static void Main(string[] args)
        {
        }
    }
}

Lo hice en c# por comodidad, puesto que el curso es de algoritmos he obviado el lenguaje a usar.

Me gustaria saber, si hay algun problema en hacerlo sin usar el front
驴trae algun problema hacerlo de este modo?

No me gusta mucho redireccionar toda la memoria, pero es la forma mas rapida que se me ocurri贸 a las 05:00 am 馃槢.
B谩sicamente, cuando se elimina un elemento en lugar de hacer front++; opto por hacer rear--;, de ese modo el front siempre queda apuntando a 0 y luego de quitar un elemento de front, para que el mismo no muestre un valor que se elimin贸, recorro la lista de elementos y los muevo a la izquierda.

Saludos!

#include<stdio.h> // Para imprimir en pantalla
#define SIZE_QUEUE 5
#define VALUE_INIT -1

int rear = VALUE_INIT; // Posicion del ultimo elemento en la Queue
int front = VALUE_INIT; // Posicion primer elemento a tomar
int elementos[SIZE_QUEUE] = {VALUE_INIT};

int estaLlena() {
    return rear == SIZE_QUEUE - 1;
}

int noFueIniciada() {
    return front == VALUE_INIT;
}

void enQueue(int value) {
    // Si hay espacio, agregamos un elemento.
    if (estaLlena()) {
        // Esta lleno
        printf("ERROR: El Queue est谩 lleno, no se puede agregar elementos.\n");
    } else {
        if (noFueIniciada()) {
            // Es el primer elemento que se agrega a la queue, cambio el front.
            front = 0;
        }
        rear++;
        elementos[rear] = value;
        printf("OK: Se agrego el '%d' correctamente.\n", value);
    }
}

void deQueue() {
    if (noFueIniciada()) {
        printf("ERROR: No hay elementos para obtener.\n");
    } else {
        printf("INFO: Se elimin贸 el valor %d.\n", elementos[front]);
        // El front es siempre 0, pero el ultimo elemento varia
        rear--;
        if (front > rear) {
            front = VALUE_INIT;
            rear = VALUE_INIT;
        }  else {
            for (int i = 0; i < SIZE_QUEUE - 1; i++) {
                elementos[i] = elementos[i + 1];
            }
        }
    }
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    deQueue();
    return 0;
}

hola que tal un gran saludo a todos mi soluci贸n a el reto fue que al mismo c贸digo del Ing. celis antes de la linea 39 donde hace el incremento de la variable front (front++), inserte la variable rear con decremento( rear鈥) para que cada vez que se elimine un turno se pueda insertar otro, bueno buena suerte a todos.

C贸digo

#include <stdio.h>
#define SIZE 5
int values[SIZE],front=-1,rear=-1;

void enQueue(int value)
{
    if(rear  == SIZE-1){
        printf("Nuestro queque esta lleno \n");
    }else{
        if(front  == -1){
            front = 0;
        }
        rear++;
        values[rear]=value;
        printf("Se inserto el valor %d correctamente\n",value);
    }
}
void deQueue()
{
    if(front == -1){
        printf("No hay elementos en nuestro Queue");
    }else{
        printf("Se elimino el valor %d \n",values[0]);
        rear--;
        for( int i = 0 ; i < SIZE-1;i++){
            values[i]=values[i+1];
        }
    }
    if(rear == 0){
        front = rear = -1;
    }

}
main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    deQueue();
    enQueue(6);
    enQueue(7);
    return 0;
}```
**#include <stdio.h>
#define SIZE 5
int values [SIZE], front = -1, rear = -1;

void enQueue (int value) {

    if(rear == SIZE-1) {
        printf("Nuestro Queue esta lleno \n" );
    }
    else {
        rear++;
        if(front == -1) {
            front = 0;
            values [front] = value;
        }  else if (front > 0) {
            values [front] = value;
        } else {
            values [rear] = value;
        }
        printf("Se inserto el valor %d correctamente \n", value);
        
    }

}

void deQueue () {

    if(front == -1) {
        printf("Nuestro Queue esta vacio \n");
    }
    else {
        printf("Se elimino el valor %d \n", values [front]);
        front++;
        if(front > rear) {
            front = rear = -1;
        } else {
            rear--;
        }
    }

}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);

    deQueue();
    deQueue();

    enQueue(10);
    enQueue(11);
    enQueue(12);

    return 0;
}**```

Se debe tener muy buen manejo de los c贸digos para la estructuraci贸n del problema.

Me gusto mucho como quedo mi c贸digo, deje una secuencia de llamadas a las funciones que prueban todos los casos posibles. Ojala a alguien le ayude, tienen dudas no duden en ponerlo en los comentarios Saludos!

/* Para crear una Queue debemos seguir los siguientes pasos:

1 Crear un pointer para saber que hay en front y rear
2 Colocar estos valores en -1 al inicializar
3 Incrementar en 1 el valor de 鈥渞ear鈥 cuando agregamos un elemento
4 Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
5 Antes de agregar un elemento revisar si hay espacios
6 Antes de remover un elemento revisamos que existan elementos
7 Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1 y agregar el valor de 0 a 
Front al hacer nuestro primer enqueue
 */

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5

int values [SIZE];
int copyValues [SIZE];
int front = -1, rear = -1, cfront = 0;

void enQueue(int value){
    if( rear == SIZE -1 ){
        printf("Nuestro Queue esta lleno\n");
    }else{
        if(front == -1){
            front = 0;
        }
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente \n", value);
    }
}

void deQueue(){
    if(front == -1){
        printf("Nuestro Queue esta vacio\n");
    }else{
        printf("Se elimino el valor %d\n", values[cfront]);
        for (int i = 0; i < SIZE; i++)
        {
            if(values[i + 1] != 0){
            copyValues[i] = values[i + 1];
            }else{
                copyValues[i]= -1;
            }
            
        }
        for (int i = 0; i < SIZE; i++){
            if (copyValues[i] != -1){
                values[i] = copyValues[i];
            }
            else{
                values[i] = 0;
            }
        }
        rear--;
        front++;
        if(copyValues[0] == -1){
            front = rear = -1;
        } 
    }
} 

int main(){

    deQueue();
    enQueue(10);
    enQueue(5);
    enQueue(7);
    enQueue(3);
    enQueue(8);
    deQueue();
    deQueue();
    enQueue(2);
    enQueue(4);
    enQueue(6);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();

    return 0 ;
}

Implementaci贸n completa de Queue
Se vacia y se llena de forma din谩mica.

  • enQueue(): Inserta un nuevo valor
  • deQueue(): Devuelve el valor en cola
  • size(): Nos muestra cu谩ntos elementos tenemos almacenados en el queue
  • isEmpty(): Nos muestra si el queue est谩 vac铆o
  • isFull(): Nos muestra si el queue est谩 lleno
#include <stdio.h>
#define SIZE 5

int queue[SIZE], front = -1, rear = -1, saved = 0, amount = 0;

void enQueue(int value)
{
    saved = 0;

    if (rear > SIZE - 2)
    {
        if (front != 0)
        {
            rear = 0;
            saved = 1;
        }
    }
    else
    {
        if (rear + 1 != front)
        {
            rear++;
            saved = 1;
        }
    }

    if (front == -1)
        front = 0;

    if (saved)
    {
        queue[rear] = value;
        printf("Value %d was succesfully stored\n", value);
    }
    else
        printf("The queue is full, the value %d was not stored\n", value);
}

void deQueue()
{
    if (front == -1)
        printf("The queue is empty\n");
    else
    {
        printf("%d\n", queue[front]);
        if (front == rear)
        {
            front = -1;
            rear = -1;
        }
        else
        {
            if (front == SIZE - 1)
                front = 0;
            else
                front++;
        }
    }
}

void size()
{
    if (front == -1)
        amount = 0;
    else
    {
        if (rear >= front)
            amount = rear - front + 1;
        else
            amount = SIZE - (front - rear - 1);
    }
    printf("There are %d items in the queue\n", amount);
}

void isEmpty()
{
    if (front == -1)
        printf("The queue is empty\n");
    else
        printf("The queue is not empty\n");
}

void isFull()
{
    if ((front == 0 && rear == 4) || (front - rear == 1))
        printf("The queue is full\n");
    else
        printf("The queue is not full\n");
}

int main(int argc, char const *argv[])
{
    deQueue();
    enQueue(56);
    enQueue(2);
    deQueue();
    size();
    isEmpty();
    isFull();

    return 0;
}

Pase 1 hora viendo por que no compilaba, actualic茅 todo, us茅 compiladores online, instal茅 de nuevo gcc, para que me diera cuenta que lo que fallara era una 鈥渢鈥 faltante en printf() xd

Aqui mi c贸digo del reto:

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void enQueue(int value){
    if(rear == SIZE - 1)  printf("Nuestro queue esta lleno\n");
    else{
        if (front == -1) front = 0;
        rear++;
        values[rear]=value;
        printf("Se inserto el valor %d correctamente \n",value);
    }
}

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

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    return 0;
}```

Creaci贸n din谩mica de valores para Queue:

int main(int argc, char const *argv[])
{
	for(int i=0; i<5; i++){
        	enQueue(i);
	}
	for(int j=0; j<5; j++){
        	deQueue();
	}
return 0;
}

Lo malo con el codigo aqui implementado es que solo se puede alternar entre llenar y vaciar; es decir, no podemos insertar y remover elementos de manera dinamica (Como en el video, aunque elimino uno, el programa le seguia diciendo que estaba lleno. Por esto, tenia que vaciar todo el queue para poder volver a insertar mas elementos). Aqui les dejo un codigo en C++ que es bastante parecido pero que permite llenar y vaciar el Queue de manera dinamica.

#include <iostream>

#define SIZE 5

struct Queue {
  int* arr;
  int capacity; // Maxima capacidad del queue
  int front;
  int rear;
  int count; // Contador de elementos en el queue

  Queue (int cap) : capacity(cap) {
    arr = new int[cap];
    front = 0;
    rear = -1;
    count = 0;
  }

  ~Queue() { delete arr; }

  bool enQueue(int value) {
    if ( isFull() ) {
      std::cout << "Queue is full!\n";
      return 0;
    }

    rear = (rear+1) % capacity; // si se pasa del final, regresara al inicio
    arr[rear] = value;
    count++;
    return 1;
  }

  bool deQueue() {
    if ( isEmpty() ) {
      std::cout << "Queue is empty.\n";
      return 0;
    }

    front = (front+1) % capacity; // si se pasa del final, regresara al inicio
    count--;
  }

  int peek() {
    if ( isEmpty() ) {
      std::cout << "No items to show";
      return -1;
    }

    return arr[front];
  }

  bool isEmpty() {
    return count == 0;
  }

  bool isFull() {
    return count == capacity;
  }
};

int main() {
  Queue q(SIZE);
  q.enQueue(2);
  std::cout << q.peek() << "\n";

  return 0;
}

Asi solucione el reto
Elimine el 鈥渇ront++鈥, corri todos los datos hacia el lado izquierdo y le reste 1 a rear.

int items[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++;
          items[rear] = value;
          printf("The value %d was inserted correctly \n", value);
        }
}

void deQueue()
{
    if(front==-1)
     {
       printf("The Queue is empty \n");
     }
     else
        {
         printf("The value %d was deleted correctly \n", items[front]);

         items[0]= items[1];
         items[1]= items[2];
         items[2]= items[3];
         items[3]= items[4];
         rear--;
         if(front > rear)
          {
            front = rear = -1;
          }

        }
}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    printf("************************************** \n");
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    printf("************************************** \n");
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(9);
    enQueue(10);
    return 0;
}****

Mi implementaci贸n 馃槃

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

Creo que debi贸 declarar primero las variables 鈥渧alues, rear y front鈥 antes de desarrolar el c贸digo para que se entendiera mejor.

<code>
/*
Crear un pointer para saber que hay en front y rear
Colocar estos valores en -1 al inicializar
Incrementar en 1 el valor de 鈥渞ear鈥 cuando agregamos un elemento
Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
Antes de agregar un elemento revisar si hay espacios
Antes de remover un elemento revisamos que existan elementos
Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1
*/

#include <stdio.h>
#define SIZE 5
int values[SIZE];
int front = -1;
int rear = -1;

void marchQueue(){
    for(int indice=0; indice < rear; indice++ )
        values[indice] = values[indice + 1];
    rear--;
}

void enQueue(int value){
    if(rear == SIZE-1)
        printf("Nuestro Queue esta lleno\n");
    else{
        if(front == -1)
            front = 0;
        rear++;
        
        values[rear] = value;
        printf("Se inserto el valor %d correctamente \n",value);
    }
}

void deQueue(){
    if(front == -1)
        printf("Nuestro Queue esta vacio\n");
    
    else{
        printf("se elimino el valor %d\n", values[front]);
        /*front++;*/
        marchQueue();
        if(front > rear)
            front = rear = -1;
    }
    
}



int 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);
    enQueue(6);
    return 0;
}

El curso ha estado genial, hasta ahora las clases y ejemplos me han gustado, espero que los dem谩s los est茅n disfrutando tanto como yo!
Les muestro mi setup para esta clase:

Ejercicio queue con LIFO y men煤.

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1, indexer, opc = 0, v = 0;
/*- values es el arreglo en el que se formar谩 la pila, su caracter de Queue se le a帽ade con el algoritmo de las funciones
  - front funciona como apuntador al primer elemento de la pila
  - rear funciona como apuntador al ultimo elemento de la pila que ha sido introducido
  - indexer funciona como iterador, necesario para recorrer los elementos del Queue cuando se elimina un elemento, ya que se elimina el elemento en el front
    y todos los que se encuentran despues deben ser desplazzados
  - opc se utiliza como variable de selecci贸n para el men煤
  - v se usa como valor que se desea introducir para la funci贸n enQueue(); a la hora de invocar dicha funci贸n desde el men煤*/

void enQueue(int value) //funcion para agregar elementos al Queue
{
    if (rear == SIZE-1 && front == 0) //estas condiciones nos indican que nuestro Queue est谩 lleno
    {
        printf("Nuestro Queue esta lleno \n");
    }
    else
    {
        if (front == -1) //Estado inicial de Queue
        {
            front = 0; //front en su primer valor
            rear = 0; //rear en su primer valor
            values[rear] = value; //inserta el valor en la posici贸n actual del rear (en este caso podr铆a cambiarse por 0 ya que la condici贸n asegura)
            					 //que estamos en el estado en que se est谩 introduciendo por primera vez un valor a la Queue
            printf("\nSe inserto el valor correctamente: %d\n\n", value); 
            
        }
        else
        {
            rear++; //si no se cumple la condici贸n anterior, solo se desplaza el apuntador rear
            values[rear] = value;
            printf("\nSe inserto el valor correctamente: %d\n\n", value); 
        }
    }
}

void deQueue() //funci贸n para eliminar elementos del Queue
{
    if (rear == -1) //el apuntador del front no se ha iniciado en 0 porque no hay nada en el Queue
    {
        printf("Nuestro Queue esta vacio\n");
    }
    else
    {
        printf("se elimino el valor %d\n", values[rear]);
        indexer = 0; //el indexer debe iniciar en 0 cada vez que se invoca la funcion para que siempre se hagan iteraciones empezando por el elemento 0

        rear--;
        
    }
     
}

void show() //funci贸n para mostrar los elementos del Queue 
{
    indexer = 0; //el indexer debe iniciar en 0 cada vez que se invoca la funcion para que siempre se hagan iteraciones empezando por el elemento 0
    if(rear == -1)
    {
    	printf("\nNuestro Queue esta vacio\n\n");
	}
	else
	{
		while(indexer <= rear)
    	{
        	printf("Registro %d: %d\n", indexer, values[indexer]); //itera la cantidad de veces que tenga de elementos el Queue e imprime el elemento en cada posici贸n.
        	indexer++;
    	}	
	}
}

int main(int argc, char const *argv[])
{

    while (opc != 4) //while se usa para que el menu se continue mostrando hasta que se eliga la opcion "salir" en el men煤
    {
        printf("----------Queue FIFO----------\n");
        printf("Opciones:\n");
        printf("Introducir(1)\nRetirar(2)\nVer Queue actual(3)\nSalir(4)\n\n");
        printf("Por favor introduzca su opcion: ");
        scanf("%d", &opc); //selecci贸n de opci贸n para el men煤.
        
        switch (opc)
        {
            case 1:
                printf("\nPor favor introduzca el valor que desea introducir: ");
                scanf("%d", &v);
                enQueue(v); //llamada a funci贸n con parametro indicado por el usuario
                system("PAUSE"); //pausa la ejecuci贸n para poder ver el resultado de la llamada a la funci贸n
                system("cls"); //limpia la pantalla para que no se recorra la aplicaci贸n en cada ejecuci贸n
                break;
    
            case 2:
                deQueue();
                system("PAUSE");
                system("cls");
                break;

            case 3:
                show();
                system("PAUSE");
                system("cls");
                break;

            case 4:
                printf("vuelva pronto!\n");
                system("PAUSE");
                break;
            
            default:
                printf("Por favor introduzca una opcion valida\n");
                system("PAUSE");
                break;
        }
    }
    
    
    return 0;
}
#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;
//Queue -> Cola, First in, First Out (FiFo)


//enQueue -> Inserta un elemento en la cola
void enQueue(int value)
{
    if (rear == SIZE-1)  //verifica que la queue no este llena
    {
        printf("El queue esta lleno\n");
    } else {
        if (front == -1)  //verifica si la queue esta vacia
        {
            front = 0;  
        }
        rear++;  //aumenta uno a la cola
        values[rear] = value; //asigna el valor a la cola
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

//deQueue -> Remueve el frente de la cola
void deQueue()
{
    int buffer = front;
    if (front == -1)  //verifica que la queue no este vacia
    {
        printf("El queue esta vacio\n");
    } else {
        printf("Se elimino el valor %d\n", values[front]);
        for ( int i = 0; i<=rear; i++ )
        {
            values[buffer] = values[buffer+1];
            buffer++;
        }
        rear--;
        if (front > rear)
        {
            front = rear = -1;
        }
    }
}

//Main
int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(15);
    return 0;
}

Por qu茅 el profe escribe la l铆nea 鈥渞eturn 0鈥 en la funci贸n main?

Buenas noches compa帽eros y compa帽eros, les comparto la soluci贸n a la que llegue. Espero les sea de ayuda y no duden en corregirme si me he equivocado!

Ejecutado en la terminal

Y les dejo un archivo donde hago un an谩lisis a profundidad de como llegu茅 a esa respuesta

Estoy de vuelta, aqu铆 mi soluci贸n del Reto

#include <stdio.h>
#include <stdlib.h>

/* Definicion del tama帽o de la cola */
#define SIZE 5

/* Definicion de las variables para la cola y punteros de control*/
int queue[SIZE], front = -1, rear = -1;

/* Funcion para insertar un elemento en la cola */
void enQueue ( int value )
{
    if ( front == 0 && rear == SIZE-1 )
    {
        printf ( "The Queue is full \n" );
    } else {
        if ( front == -1 && rear == -1 ) {
            front++;
            rear++;
        } else {
            rear++;
        }
        queue[rear] = value;
        printf ("The value = %d was entered correctly \n", value);
    }
}

/* Funcion para eliminar un elemento en la cola */
void deQueue()
{
    if ( front == -1 && rear == -1 ) {
        printf ("The Queue is empty \n");
    } else {
        printf ( "Value %d was successfully removed \n", queue[front] );
        for ( int i = 0; i < rear; i++ ) {
            queue [i] = queue [i + 1] ;
        }
        if ( front == 0 && rear == 0 ) {
            front--;
            rear--;
        } else {
            rear--;
        }
    }
}


int main()
{
    deQueue();
    enQueue (1);
    enQueue (2);
    enQueue (3);
    enQueue (4);
    enQueue (5);
    enQueue (6);

    deQueue();
    enQueue (1);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();

    return 0;
}

dejo mi c贸digo, anduve probando otras cosas, pero no s茅 por qu茅 en vs code no genera la salida en consola y en la p谩gina https://replit.com si mostraba bien el resultado, as铆 que guarde aparte este c贸digo que si muestra salida en vs code.

#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;
int i,temporal;

void enQueue(int value){
    if (rear == SIZE-1 )
    {
        if (front == 0){
            printf("Nuestro Queue esta lleno \n");
        }
        else{
            for(i=1;i<=SIZE-1;i++){
                temporal = values[i];
                values[i-1] = temporal;
            }
            values[SIZE-1] = value;
            printf("Se inserto el valor %d correctamente\n", value);
            front--;
        }
    }
    else{
        if(front == -1)
        {
            front = 0;
        }
            
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

void deQueue(){
    int element_delete;
    if(front == -1){
        printf("Nuestro Queue esta vacio \n");
    }   
    else{
        element_delete = values[front];
        values[front] = 0;
        printf("Se elimino el valor %d \n", element_delete);
        front++;
        if(front > rear){
            front = rear =-1;
        }  
    }
}


void MostrarValoresArreglo(){
  
    printf("----------------------------------------------\n");
    for( i = 0; i <= SIZE-1; i++)
            {
                printf("Valor [%d] = %d \n", i, values[i]);
            }
    printf("----------------------------------------------\n");
}

void MostrarValoresFrontRear(){
    printf("----------------------------------------------\n");
    printf("Valor de front= %d, valor de rear= %d\n", front,rear);
}


int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    deQueue();
    deQueue();
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    enQueue(34);
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    deQueue();
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    return 0;
}

me tome mi tiempo jajaj

//1 - crear pointer para saber que hay en front y rear.


//2 - colocar estos valores en -1 al inicializar. 
//3 - incrementar en 1 el valor de "rear" cuando agregamos un elemento.
//4 - retornar el valor del front al quitar un elemento e incrementar
    //en 1 el valor de front al usar el dequeue.
//5 - antes de agregar un elemento revisar si hay esapcio.
//6 - antes de remover un elemento revisamos que existan elementos.
//7 - asegurarnos que al remover todos los elementos
    //resetear nuestro front y rear a -1 y agregar el valor de 0
    //a front al hacer nuestro primer queue.

#include <stdio.h>
#define SIZE 5
int values [SIZE], front = -1, rear = -1;

void enQueue(int value){
    if(rear == SIZE-1)
    printf("Maxima Capacidad \n");
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("seagrago el dato %d correctamenre \n", value);
    }
}

void deQueue(){
    if(front==-1)
        printf("Capacidad 0 \n");
    else{
        printf("Se elimino el valor %d \n", values[front]);
        front++;
        if(front > rear)
        front = -1;
        rear -= 1;
    }

}
int main(int argc, char const *argv[])
{
    enQueue(10);
    enQueue(1);
    enQueue(20);
    enQueue(17);
    enQueue(16);
    deQueue(10);
    enQueue(100);
    enQueue(200);
    return 0;
}

Implementando librer铆a queue en python, corrige lo del reto en un c贸digo m谩s optimo.

Outpul:

item 1 was inserted correctly
item 2 was inserted correctly
item 3 was inserted correctly
item 4 was inserted correctly
item 5 was inserted correctly
Full Queue
item 1 has been removed
item 6 was inserted correctly
item 2 has been removed
item 3 has been removed
item 4 has been removed
item 5 has been removed
item 6 has been removed
Empty Queue

Ha sido frustrante para mi tener que pasar de c a python. Aunque despu茅s de muchas horas vi que realmente era pr谩cticamente lo mismo.
Agradezco a Dios por GPT que me ayudo 馃ぃ y me explic贸 todo.

enqueue

dequeue

#run/ output

Si se ejecuta el deQueue sin tener valor asumo que leera el if con la variable front en -1 y se imprimira que el Queue esta lleno.

Yo hice el reto en C#, implementando esta clase Queue con estas modificaciones en sus m茅todos, la base de todo est谩 en el m贸dulo:

using System;

namespace EstructurasDeDatosYAlgoritmos
{
    internal class Queue
    {
        public int size = 5;
        public int rear;
        public int front;
        public int[] items;
        
        public Queue(int size)
        {
            this.rear = -1;
            this.front = -1;
            this.items = new int[size];
            this.size = size;
        }

        public void enQueue(int value)
        {
            if(rear - front == size - 1)
            {
                Console.WriteLine("Nuestro Queue est谩 lleno \n");
            }
            else
            {
                if (front == -1)
                    front = 0;
                rear++;
                items[rear % size] = value;
                Console.WriteLine($"Se inserto el valor {value} correctamente \n");

            }
        }
        public void deQueue()
        {
            if (front == -1)
                Console.WriteLine("Nuestro Queue est谩 vac铆o \n");
            else
            {
                Console.WriteLine($"Se elimin贸 el valor {items[front % size]}");
                front++;
                if(front > rear)
                {
                    front = rear = -1;
                }
            }
        }
    }
}

As铆 hice mi c贸digo, espero les sirva

#include <stdio.h>
#include <stdlib.h>

#define MAX_QUEUE_SIZE 3

int queue[MAX_QUEUE_SIZE];
int front = 0; // puntero al inicio de la cola
int rear = -1; // puntero al final de la cola
int count = 0; // n煤mero de elementos en la cola

void enqueue(int value) {
    // Comprobar si la cola est谩 llena
    if (count >= MAX_QUEUE_SIZE) {
        printf("La cola est谩 llena.\n");
    } else {
        // Actualizar posici贸n del puntero rear
        rear = (rear + 1) % MAX_QUEUE_SIZE;
        // A帽adir elemento al final de la cola
        queue[rear] = value;
        // Incrementar contador de elementos en la cola
        count++;
    }
}

int dequeue() {
    if (count <= 0) {
        printf("La cola est谩 vac铆a.\n");
        return -1;
    } else {
        int value = queue[front];
        front = (front + 1) % MAX_QUEUE_SIZE;
        count--;
        printf("se borrara: ");
        return value;
    }
}

int main() {
    enqueue(1);
    enqueue(2);
    enqueue(3);

    printf("%d\n", dequeue()); // imprime 1
    printf("%d\n", dequeue()); // imprime 2
    printf("%d\n", dequeue()); // imprime 3

    enqueue(7);
    
    for (int i = 0; i < MAX_QUEUE_SIZE; i++)
    {
        printf("%d", queue[i]);
    }
    

    return 0;
}

Reto: Llenar y vaciar el queue din谩micamente:

Reto: Llenar y vaciar el queue din谩micamente:

Esta es mi soluci贸n al reto.
Encontr茅 que se tiene que restar 1 a rear, porque lo que estamos haciendo en la funci贸n deQueue es liberar una posici贸n del arreglo y la variable rear tiene el valor del tama帽o del arreglo. Por lo que al reducir uno a esta variable nos permite seguir ingresando datos, actualizando el n煤mero de elementos
Tambi茅n agregu茅 esta condici贸n en la misma funci贸n porque as铆 permite que la funci贸n indique cuando el arreglo est谩 vac铆o:
if((front == -1)||(rear==0)){
Se aceptan comentarios para mejorar, espero que les sirva.
Saludos 馃槃 !

Soluci贸n al reto:

#include <stdio.h>

#define SIZE 5

int values[SIZE], front = -1, rear = -1;
void enQueue(int value){
    if(rear == SIZE - 1)
        printf("Nuestro queue est谩 lleno.\n");
    else{
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente.\n",value);
    }
}

void deQueue(){
    if(front == -1)
        printf("Nuestro queue esta vacio.\n");
    else{
        printf("Se elimino el valor %d.\n", values[front]);
        mover();
        if(front > rear)
            front = rear = -1;
    }
}

void mover(){
    for(int i = 0; i < rear; i++)
        values[i] = values[i + 1];
    rear--;
    front = 0;
}

void print(){
    for(int i = 0 ; i <= rear; i++)
        printf("%d ",values[i]);
    printf("\n");
}

int main(){
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    print();
    deQueue();
    deQueue();
    enQueue(6);
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    print();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    print();
    enQueue(6);
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    print();
}

Esta es mi soluci贸n, supongo que hay mejores maneras de hacerlo, pero esta me pareci贸 la m谩s l贸gica.
Aqu铆 no necesito el front porque cuando remuevo un n煤mero muevo todos los valores de array una posici贸n adelante y por eso el elemento que est谩 por salir siempre est谩 en la posici贸n 0 del array.
A m谩s le a帽ad铆 un menu para que se lo pueda usar como una aplicaci贸n normal y no tener todo quemado en al c贸digo
Este es mi c贸digo:

#include <stdio.h>

#define SIZE 5

int rear = -1, values[SIZE];

void deQueue() {
    if(rear == -1)
        printf("No se puede sacar el valor, porque el queue est谩 vacio");
    else {
        printf("Se va a eliminar el valor de %d del queue", values[0]);
        for(int i = 0; i < SIZE - 1; i++) {
            values[i - 1] = values[i];
        }
        rear--;
    }
}

void enQueue() {
    int value;
    if(rear == SIZE - 1)
        printf("No se puede ingresar m谩s valores, porque el queue est谩 lleno");
    else {
        printf("Ingrese el valor que quiere agregar: ");
        scanf("%d", &value);

        values[++rear] = value;
        printf("Se a帽adi贸 el valor de %d correctamente", value);
    }
}

int main() {
    unsigned char option;

    do {
        printf("\n驴Qu茅 desea hacer?");
        printf("\nAgregar un dato [1]");
        printf("\nQuitar un dato [2]");
        printf("\nSalir[9]");
        printf("\nOpci贸n: ");
        scanf("%hhd", &option);

        switch (option) {
            case 1:
                enQueue();
            break;
            case 2:
                deQueue();
            break;
            case 9:
            break;
            default:
                printf("Ingrese una opci贸n valida");
            break;
        }
    } while (option != 9);

    return 0;
}

// Fue lo mas interactivo que pude Hacerlo 馃懡

#include<stdio.h>
#define SIZE 5
int front = -1, rear = -1;
int values[SIZE] = {0, 0, 0, 0, 0};
// [-1, 0, 0, 0, -1]

// Agregar elemento a cola:
void enQueue(int value){
if(rear == SIZE-1)
printf(鈥淣uestro Queue esta lleno\n鈥 );
else {
if(front == -1)
front = 0;
rear++;

    values[rear] = value;
    printf("Se inserto el valor %d correctamente\n", value);

}

}

// Quitar elemento de cola:
void deQueue(){
if(front == -1)
printf(鈥淣uestro Queue esta vacio\n鈥 );
else {
printf(鈥渟e elimino el valor %d\n鈥, values[front]);
front++;
rear鈥;

    if(front > rear)
    front = rear = -1;

}

}

void elige(){
int valor = scanf;
int value;
printf(鈥淓lige una opcion: \n鈥);
printf(鈥1.- Agregar valor a queue: \n鈥);
printf(鈥2.- Remover valor a queue: \n鈥);
printf(鈥3.- Imprimir estado de queue: \n鈥);
scanf("%d", &valor);
if (valor == 1)
{
//int value;
printf(鈥淨ue valor quieres agregar? \n鈥);
scanf("%d", &value);
enQueue(value);
printf("鈥 \n");
elige();

}
else if (valor == 2){
    int ralue;
    printf("Que valor quieres Remover? \n");
    scanf("%d", &ralue);
    deQueue();
    printf("... \n");
    elige();


}
else if (valor == 3){

    printf("%d", values[rear]);
    printf("... \n");
    elige();

}
else{
    int respu = scanf;
    printf("Error 404: \n");
    printf("Reintentar: yes == 1  /  no == Cualquier tecla: \n");
    scanf("%d", &respu);
    if (respu == 1)
    {
        elige();
    }
    else {
        printf("Fin de la QueueMulation... \n");
    }
    
}

}

main(int argc, char const *argv[])
{
elige();

}

Esta es mi soluci贸n. Si encuentran alguna falla, hac茅rmela saber por favor, as铆 mejoro mi aprendizaje.
.
La 煤nica duda que tengo, es si es correcto poner vac铆o un espacio del Array usando " ". Quise ponerle 0, pero pues cero igual es un valor, as铆 que no me pareci贸 correcto.
.
Lo que hago en el c贸digo es que al borrar un valor, el resto lo re posiciono hasta el inicio del Queue, trasladando no solo su valor, sino tambi茅n el indicador de front y rear, y dejo en vac铆o las posiciones anteriores.
.
Solo esta secci贸n es lo que cambie, el resto del c贸digo es similar al de la clase.

void deQueue()
{
    if (front == -1)
        printf("Nuestro queue esta vacio \n");
    else
    {
        printf("Se elimino el valor %d\n", values[front]);
        front++;
        int i;
        for (i = front; i <= rear; i++)
        {
            values[i - 1] = values[i];
            values[i] = "";
        }
        front = front - 1;
        rear = i - 2;
        if (front > rear)
            front = rear = -1;
    }
}

En Java

Scanner sc = new Scanner(System.in);
		int op;
		int insert = 0;
		InQueue queueTest =  new InQueue();
		
		do {
			System.out.println("-- Choose an option --");
			System.out.println("1. Add an element");
			System.out.println("2. Delete and element");
			System.out.println("3. Out");
			op = sc.nextInt();
			switch (op) {
			case 1:
				queueTest.inQueue(insert);
				insert++;
				break;
			case 2:
				queueTest.delQueue();
				break;
			case 3:
				System.out.println("Bye");
				break;
			}
			
		} while (op != 3);```

Hola chicos, agregue una l贸gica adicional al metodo deQueue, para quitar y agregar din谩micamente valores a la cola. Ejemplo de entrada:
exampleOne.enQueue(1);
exampleOne.enQueue(2);
exampleOne.enQueue(3);
exampleOne.enQueue(4);
exampleOne.deQueue();
exampleOne.deQueue();
exampleOne.enQueue(5);
exampleOne.enQueue(6);

A continuaci贸n dejo el m茅todo:

private void deQueue() {
        if (front <= -1) {
            System.out.println("Our queue is empty");
        } else {
            System.out.println("front is " + front + " the value " + values[front] + " is remove");
            front++; //1
            if (front > end) {
                front = -1;
                end = -1;
            }
            int i = 0;
            while (i < values.length) {
                if (i + 1 == values.length) {
                    end--;
                    front--;
                    break;
                }
                int aux = values[i + 1];
                values[i] = aux;
                i++;
            }
        }
    }

Aqu铆 dejo mi versi贸n del c贸digo visto en clases. Este a帽ade todas las operaciones de una Queue que vimos en el glosario de funciones para ADT.

#include <stdio.h>

//Definition of the queue size
#define SIZE 5

//Declaration of queue
int values[SIZE], front = -1, rear = -1;

//Declaration of queue functions
void enQueue(int); 	//Inserts elements at the end of the queue
int deQueue();       	//Remove and returns the first element of the queue
int peek();        	//Returns the first element of the queue
int isEmpty();    	//Returns true if the queue is empty
int isFull();      		//Returns true if the queue is full

int main()
{
    deQueue();
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    enQueue(6);
    printf("The first is: %d\n", peek());
    deQueue();
    printf("The first is: %d\n", peek());
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    printf("The first is: %d\n", peek());
    
    return 0;
}

void enQueue(int value)
{
    if (isFull())
        printf("The Queue is full.\n");
    
    else
    {
        if (isEmpty())
            front = 0;
        
        rear++;
        values[rear] = value;
        printf("The value %d was inserted.\n", value); 
    }
}

int deQueue()
{
    int first = -1;

    if (isEmpty())
        printf("The Queue is empty.\n");

    else
    {
        first = values[front];
        printf("The value %d was eliminated\n", values[front]);
        front++;

        if (front > rear)
            front = rear = -1;
    }
    
    return first;
}

int peek() 
{
    if (!isEmpty())
        return values[front];

    return -1;
}

int isEmpty()
{
    if (front == -1) 
        return 1;
    
    return 0;
}

int isFull()
{
    if (rear == SIZE - 1)
        return 1;

    return 0;
}

Salida:

The Queue is empty.      
The value 1 was inserted.
The value 2 was inserted.
The value 3 was inserted.
The value 4 was inserted.
The value 5 was inserted.
The Queue is full.       
The first is: 1
The value 1 was eliminated
The first is: 2
The value 2 was eliminated
The value 3 was eliminated
The value 4 was eliminated
The value 5 was eliminated
The Queue is empty.
The first is: -1

Mi reto utilizando python.

#Creamos la cola
def create_queue():
queue = []
return queue

#Llenamos la cola
def en_queue(queue,front,rear):
if len(queue) >1:
print(鈥楨l arreglo est谩 lleno鈥)
return queue

else:
    while rear <4:
        numero = int(input('Ingresa un n煤mero: '))
        if front == -1 :
                front +=1
                rear +=1
                queue.insert(front,numero)
        else:
                rear +=1
                queue.insert(rear,numero)
                
    return queue
    print(queue)

#Vaciamos la cola
def del_queue(queue,front,rear):
if len(queue) == 0:
print(鈥楲a cola est谩 vacia鈥)
return queue
else:
print(queue[0])
queue.pop(0)
return queue

def main():
front =-1
while True:
print(鈥----------- Opciones-----------鈥)
print(鈥1. Crear arreglo鈥)
print(鈥2. Registrar un turno鈥)
print(鈥3. Llamar un turno鈥)
print(鈥4. Salir鈥)
option = int(input('Selecciona una opci贸n: '))

if option == 1:
    cola=create_queue()
    file =1
    rear = -1
    front = -1
    print(cola)
elif option == 2:
    if 'file' not in locals():
        print ('La fila no existe')
    else:
        cola=en_queue(cola,front,rear)
        if front == 0:
            rear +=1
        print(cola)
elif option ==3:
    cola=del_queue(cola,front,rear)
elif option ==4:
    print('Bye, Bye')
    break

if name == 鈥main鈥:
main()

aqui mi reto

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5

int item[SIZE], front = -1, rear = -1;

void enQueue (int valor){
    if (rear == SIZE - 1){
        printf("el queue esta lleno\n");
    }
    else{
        if (front == -1)
            front = 0;
        rear ++;
        item[rear]= valor;
        printf("se inserto el valor %i correctamente\n", valor);
    }
}

void deQueue(){
    if (front == -1)
        printf("nuestro Queue esta vacio\n");
    else{
        printf("se elimino el valor %d \n", item[front]);
        front++;
        if (front > rear)
            front = rear = -1;
    }
}

int main()
{
    enQueue(1);
    enQueue(5);
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(10);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(100);
    return 0;
}

Que tal colegas.

Yo lo implement茅 en JS.

let Ordenes = []
class Orden {
    constructor(platillo, bebida) {
        this.Orden = {
            platillo: platillo,
            bebida: bebida
        }
        this.Pointer = {
            front: false,
            rear: 0
        }
    }

    enQueue() {
        //Agrega elemento y checar si hay espacio para agregar
        console.log(this.Orden)
        if (this.Pointer.rear === 3) {
            console.log('No hay espacio para a帽adir su orden, intente m谩s tarde')
        }else {
          
            if(this.Pointer.front === false) {
                Ordenes.push(this.Orden)
                this.Pointer.front = true
            }else {
                //Sumar 1 en rear
                Ordenes.unshift(this.Orden)
                this.Pointer.rear++
            }

        }

        
    }

    deQueue() {
        //Remover elemento y checar si hay que eliminar.
        if (this.front === false) {
            console.log('No hay ordenes que entregar')
        }else {
            setTimeout(() => {
                switch(this.Pointer.rear) {
                    case 0:
                        //Eliminar el primero que llego
                        Ordenes.shift()
                        console.log('La orden ha sido entregada')
                        this.Pointer.front = false
                        this.Pointer.rear = 0
                        break;
                    case 1:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                    case 2:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                    case 3:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                }
            }, 8000)
        }
        
        //Al eliminar todos los elementos, dejar front y rear en -1
    }


}

const Rafael = new Orden('hamburguesa', 'fresca')
const Chava = new Orden ('Hotdog', 'Coca')
const George = new Orden ('pastel', 'leche')

Rafael.enQueue()
Chava.enQueue()
George.enQueue()

console.log(Ordenes)

Rafael.deQueue()
console.log(Ordenes)

Yo encontr茅 una soluci贸n diferente a las ya publicadas. Lo que hice fue inmediatamente despu茅s de eliminar un elemento muevo los restante una posici贸n hacia adelante, as铆 me aseguro de que la posici贸n 0 de la lista la ocupe siempre el pr贸ximo elemento a ser eliminado y que los espacios para agregar nuevos elementos queden al final. As铆 se evitan errores al intentar insertar un nuevo elemento cuando ya se han eliminado algunos

Yo esperaba que hicieramos una Queue con estructuras y apuntadores :c

#include<stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void enQueue(int value){
    if((rear-front)==SIZE-1)
        printf("Nuestro Queue esta lleno\n");
    else{
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

void deQueue(){
    if(front == -1 || rear == -1) // si front o rear es -1
        printf("Nuestro Queue esta vacio\n");
    else{
        printf("Se elimino el valor %d\n", values[front]);
        for(int auxiliar=0; auxiliar != rear; auxiliar++){ //Un ciclo que nos ayudara a mover los valores de posicion
            values[auxiliar] = values[auxiliar + 1];
        }
        values[rear] = 0; //esta instruccion es para que el 煤ltimo valor se muestre "eliminado"
        rear --; //el rear se mueve a la posicion anterior
        /*front++;
        if(front>rear)
            front = rear = -1;*/
    }
}

void show(){ //esta funcion muestra el contenido de la Queue y sus posiciones
    for(int i =0;i<SIZE;i++){
        printf("Valor %d en la posicion %d\n", values[i], i);
    };
}

int main(){
    show();
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    show();
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(20);
    show();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    show();

    return 0;
}```
<code>
/* Modificacion de la funcion void para que sea una cola dinamica*/
27 void deQueue(){
 1   int aux  = 0;
 2   if(front == -1)
 3     printf("Nuestro Queue esta vacio \n");
 4   else{
 5     printf("Se elimino el valor %d \n", values[front]);
 6     /*
 7       Muevo todos los valores un espacio hacia el frente, asi, mi front siempre sera 0, o el inicio de la cola. 
 8     */
 9     for(int i = 0; i < rear-1; i++){
10       aux = values[i+1];
11       values[i] = aux;
12     }
13     values[rear] = 0;
14     /*
15       Regreso en una posicion el rear despues de eliminar el primer elemento
16     */
17     rear--;
18     if(front > rear) 
19       front = rear = -1;
20   }
21 }

Logre completar el reto en php

<?php

class Queue
{

  protected $size  =  5;
  protected $front = 1;
  protected $values = [];
  protected $rear  ;

  public function enQueu(int $value)
  {
    if(count($this->values) >= $this->size )
    {
      echo "Nuestro Queue esta lleno \n";
    }
    else
    {
      $this->values[count($this->values)] = $value;
      echo "Se inserto el valor $value correctamente \n";
    }
  }

  public function deQueue()
  {
    if(count($this->values) == 0)
    {
      echo "Nuestro Queue esta vacio \n";
    }
    else{
      echo "Se elimino el valor ".$this->values[0] . "\n";
      $this->values = array_slice($this->values,$this->front);
    }
  }
}

$queue = new Queue;

$queue->enQueu(1);
$queue->enQueu(2);
$queue->enQueu(3);
$queue->enQueu(4);
$queue->enQueu(5);
$queue->enQueu(6);
$queue->enQueu(7);
$queue->deQueue();
$queue->deQueue();
$queue->deQueue();
$queue->deQueue();

$queue->enQueu(15);
$queue->enQueu(45);
 
$queue->deQueue();
$queue->deQueue();

$queue->deQueue();
$queue->deQueue();
#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;

void enQueue(int value) {
    if(rear  == SIZE - 1) {
        printf("Nuestro Queue esta lleno\n");
    } else {
        if (front == -1) {
            front = 0;
        }
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);    
    }
}

void deQueue() {
    if (front == -1) {
        printf("Nuestro Queue esta vacio\n");
    } else {
        printf("Se elimino el valor %d\n", values[front]);
        front++;
        if (front > rear) {
            front = rear = -1;
        }        
    }
}

int main(int argc, char const *argv[]) {
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(10);
    return 0;
}```

Cumpliendo el reto 馃槂
Auque es sobre una interpretaci贸n de lo que le entend铆 al profe.

Esta programaci贸n permite ingresar mas de 5 datos, siempre que supera los cinco va reordenando la cola, pasando el de segunda posici贸n al primero, el tercero al segundo y as铆 sucesivamente. Siempre que se agregue un nuevo dato se le posiciona en 煤ltima posici贸n. Y cuando se elimina (deQueue) se toma el primer valor de la cola.

#include<stdio.h>
#define SIZE 5
int values[SIZE], rear = -1;


void enQueue(int value){
    if(rear == SIZE-1){
        int i;
        for(i=0; i<rear; i++)
        {
            values[i]=values[i+1];
        }
        values[rear]=value;
        printf("Se reordena la cola e insert贸 el valor %d correspondiente \n", value);
        }
    else {
        rear++;
        values[rear] = value;
        printf("Se insert贸 el valor %d correspondiente \n", value);
        }
}

void deQueue(){
    if (rear == -1)
        printf("Nuestro Queue est谩 vac铆o\n");   
    else {
        printf("Se elimin贸 el valor %d de la primera posici贸n \n", values[0]);
        int i;
        for(i=0; i<rear; i++)
        {
            values[i]=values[i+1];
        }
        // if(rear == 0){
        //     values[rear]="";
        // }
        rear--;    
    }
}

main(int argc, char const *argv[])
{
    enQueue(1);  
    enQueue(2);  
    enQueue(3);  
    deQueue();
    deQueue();
    deQueue();
    enQueue(2);  
    enQueue(3);  
    enQueue(4);  
    enQueue(5);  
    enQueue(6);  
    enQueue(7);  
    printf("Value[0] %d \n", values[0]);
    printf("Value[1] %d \n", values[1]);
    printf("Value[2] %d \n", values[2]);
    printf("Value[3] %d \n", values[3]);
    printf("Value[4] %d \n", values[4]);
    return 0;
} ```

Aqu铆 dejo mi aporte completo:

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void enQueue(int value) {
    if(rear == SIZE - 1) {
        printf("Nuestro queue esta lleno\n");
    } else {
        if(front == -1) {
            front = 0;
        }
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

void deQueue() {
    if(front == -1) {
        printf("Nuestro Queue esta vac铆o\n");
    } else {
        printf("Se elimino el valor %d\n", values[front]);
        for(int i = 0; i < rear; i++) {
            values[i] = values[i + 1];
        }
        values[rear] = 0;
        rear--;
        if(front > rear) {
            front = rear = -1;
        }
    }
}

void printQueue() {
    printf("-----------------------------\n");
    if(rear == -1)
        printf("Nuestro Queue esta vac铆o\n");
    else{
        int i;
        for(i = 0; i <= rear; i++)
            printf("Posici贸n %d: %d\n", i, values[i]);
    }
    printf("-----------------------------\n");
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(9);
    deQueue();
    deQueue();
    enQueue(10);
    enQueue(11);
    printQueue();
    return 0;
}

Lo que agregu茅 fue:

        for(int i = 0; i < rear; i++) {
            values[i] = values[i + 1];
        }
        values[rear] = 0;
        rear--;```


void deQueue() {
if(front == -1) {
printf(鈥淣uestro Queue esta vac铆o\n鈥);
} else {
printf(鈥淪e elimino el valor %d\n鈥, values[front]);
for(int i = 0; i < rear; i++) {
values[i] = values[i + 1];
}
values[rear] = 0;
rear鈥;
if(front > rear) {
front = rear = -1;
}
}
}


#include <stdio.h>
#define  SIZE 5

int values[SIZE], front = -1, rear = -1;

void enQueue( int value ){
	if( rear == SIZE - 1 ){
		printf( "Nuestro Queue esta lleno\n" );
	}
	else{
		if( front == -1 ){
			front = 0;
		}
		rear++;
		values[rear] = value;
		printf( "Se inserto el valor %d correctamente\n", value );
	}
}

void deQueue(){
	if( front == -1 ){
		printf( "Nuestro Queue esta vacio\n" );		
	}
	else{
		printf( "Se elimino el valor %d\n", values[front] );
		front++;
		if( front > rear ){
			front = rear = -1;
		}			
	}
}

int main()
{
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);

	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();

	return 0;
}
Les comparto este link para los que estn aprendiendo a usar vim

https://www.arsys.es/blog/soluciones/comandos-vim/#Los_modos_de_Vim

Reto Cumplido

/* 1.	Crear un pointer para saber que hay en front y rear
2.	Colocar estos valores en -1 al inicializar
3.	Incrementar en 1 el valor de 鈥渞ear鈥 cuando agregamos un elemento
4.	Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
5.	Antes de agregar un elemento revisar si hay espacios
6.	Antes de remover un elemento revisamos que existan elementos
7.	Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1
 */
#include "stdio.h"
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void vaciador(){
    for (int i = 0; i > SIZE; i++ ){
        values[i] = 0;
    }
}

void aKiller(){
    for (int i = SIZE - 1; i > rear; i--)
    {
        values[i] = 0;
    }
}

void corrector(){
    values[0] = values[1];
    values[1] = values[2];
    values[2] = values[3];
    values[3] = values[4];
}

void enQueue (int value){
    if (rear == SIZE-1)
    printf("queue lleno \n");
    else
    {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("se inserto el valor %d correctamente \n", value);
    }  
}

void deQueue(){
    if(front == -1){
        printf("el queue esta vacio : ( a帽ade un numero para poder eliminarlo  \n");
    }
    else{
        printf("se elimino el valor %d\n", values[front]);
        rear --;
        
        corrector();
        aKiller(); 
    }
}

void prQueue(){
    for(int i = 0; i <= rear; i++) {
        printf("posicion: %d es = %d\n", i, values[i]);
    }
}

int main(int argc, char const *argv[])
{   
    /* inserte aca enqueue() y dequeue() */
    vaciador();
    prQueue();
    return 0;       
}

Mi aporte en Python, ahora con input para que el usuario pueda ingresar elementos y eliminar elementos.

# Python program to 
# demonstrate implementation of 
# Queue (FIFO) using lists
# with input

queue = ["","","","",""]
front = -1
rear = -1

def insert(value):
    global queue
    global front
    global rear
    if rear == len(queue)-1:
        print("Queue is full")
    else:
        if front == -1:
            front = 0
        rear += 1
        queue[rear] = value
        print(f"{value} added")

def extract():
    global queue
    global front
    global rear
    if front == -1:
        print("Queue is empty")
    elif front > rear:
        print("Queue is empty, there's nothing to delete")
        front = rear = -1
    elif front == rear:
        print(f"{queue[front]} was deleted")
        queue[front] = ""
        print("Queue is now empty")
        front = rear = -1
    else:
        print(f"{queue[front]} was deleted")
        queue[front] = ""
        front += 1
    
def run():
    option = 0
    while option != 4:
        menu = """
            Welcome, choose an option:
            1 - Add a customer
            2 - Delete the last customer
            3 - See the queue
            4 - Exit
            """

        option = int(input(menu))

        if option == 1:
            value = input("Client's name: ")
            insert(value)
        elif option == 2:
            extract()
        elif option == 3:
            print(f"{queue} front: {front} rear: {rear}\n")   
        elif option == 4:
            print("Goodbye")    
            break
        else:
            print("Incorrect Option")


if __name__ == "__main__":
    run()

Mi aporte con python

SIZE = 5
rear = -1
front = -1
items = []

def enQueue(value):

    global rear
    global front
    global items

    if rear == (SIZE - 1):
        return 'Nuestro queue esta lleno, Sorry!'
    else:
        if front == -1:
            front = 0
        rear += 1
        items.append(value)
        return 'Se inserto el valor ' + str(value) + ' correctamente'



def deQueue():
    global rear
    global front

    if front == -1:
        return "Nuestro Queue esta vacio"
    else:
        print("Se elimino el valor " + str(items[front]))
        items.pop(front)
        front = 0 

        if len(items) == 0:
            front = rear = -1 
            
        return items


def run():

    print(deQueue())
    print(enQueue(8))
    print(enQueue(10))
    print(enQueue(40))
    print(enQueue(50))
    print(enQueue(15))
    print(enQueue(100))
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(enQueue(120))



if __name__ == "__main__":
    run()

Una pregunta respecto al codigo:

#include <stdio.h>
#define SIZE
int items [SIZE];
int rear = -1;
int front = -1;
void enQueue(int value){
    if(rear = SIZE -1)
        printf("Nuestro Queue esta lleno \n");
    else {
        if(front == -1)
            front = 0;
        rear ++;
        items[rear] = value;
        printf("Se a agregado el valor correctamente: %d \n", value);
    }
}
void deQueue(){
    if (front == -1)
        printf("Nuestro Queue esta vacio \n");
    else{
        printf("Se elimino el valor:  %d \n",items[front]);
        front++;
        if(front > rear){
            front = rear = 0;
        }
    }
}
int main(int argc, char const *argv[])
{
    deQueue();
    return 0;
}

por que las if no tienen llaves y aun asi funcionan?

Este es mi codigo en python

class Queue:

    def __init__(self, size):
        self.size = size
        self.values = []
        self.rear = -1
        self.front = -1

    def enQueue(self, value):
        if self.rear == self.size-1:
            print('Nuestro Queue esta lleno')
        else:
            if self.front == -1:
                self.front = 0
            self.rear += 1
            self.values.append(value)
            print(f'Se inserto el valor {value} correctamente\n')

    def deQueue(self):
        if self.front == -1:
            print('Nuestro Queue esta vacio\n')
        else:
            print(f'Se elimino el valor {self.values[self.front]}')
            self.values.pop(self.front)
            self.front += 1
            if self.front > self.rear:
                self.front = self.rear = -1
            else:
                self.front -= 1
                self.rear -= 1

    def show(self):
        print(self.values)


if __name__ == "__main__":
    lista = Queue(5)
    lista.deQueue()
    lista.show()
    lista.enQueue(10)
    lista.show()
    lista.enQueue(11)
    lista.show()
    lista.enQueue(12)
    lista.show()
    lista.enQueue(13)
    lista.show()
    lista.enQueue(14)
    lista.show()
    lista.enQueue(15)

Dejo el c贸digo del reto y la implementaci贸n de los m茅todos de la queue.

#include<stdio.h>
#include <stdbool.h>
#define SIZE 5
int values[SIZE], front = -1, rear= -1;

int Size(){
    return (rear-front)+1;
}

bool isFull(){
    return Size() == SIZE;
}

bool isEmpity(){
    return front == -1;
}

void printQueue(){
    int index;
    for(index=front;index<=rear;index++){
        printf("%d",values[index]);
        if (index+1<=rear)
            printf(" -> ");
    }
    printf("\n");
}

void enQueue(int value){
    if( isFull())
        printf("Nuestro Queue esta lleno\n" );
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    
    }
    printQueue();
}

void deQueue(){
    if(isEmpity())
        printf("Nuestro Queue esta vacio\n" );
    else{
        printf("se elimino el valor %d\n", values[front]);
        front++;
        if(front > rear)
        front = rear = -1;
    }
    printQueue();
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    deQueue();    
    deQueue();
    enQueue(7);
    enQueue(8);
    enQueue(9);    
    deQueue();
    enQueue(9);
    deQueue();
    enQueue(10);
    return 0;
}
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;
        }
}

Les comparto mi desafio

#include <stdio.h>
#define SIZE 5//Definir el tamano del ARRAY. NO lleva ;
int values[SIZE], front = -1, rear = -1, total =5;//Separar con , cuando todas las variables


//enQueue Agrega un elemento al final de la estructura
void enQueue(int value) //void no retorna ningun valor, solo guarda el valor
{
	if(rear == total - 1) //Verificar que tenemos espacios disponibles en el array
		printf("Nuestro Queue esta lleno \n"); // \n salto de linea
	else
	{
		if(front == -1)
			front = 0;
			rear++; // ++incrementa en 1 la variable
			values[rear] = value; //Guardando el valor en la posicion que estamos generando
			printf("Se inserto el valor %d correctamente\n", value);
	}
}


//Dequeue Remueve un elemento al inicio de la estructura
void deQueue() // NO requiere argumentos
{
	if(front == -1) //Verificar que tenemos valores en front
		printf("Nuestro Queue esta vacio \n");
	else
	{
		printf("Se elimino el valor %d \n", values[front]);
		front++;
		total++;
		if(front > rear)
			front = rear = -1;
	}
}


//main code
int main(int argc, char const *argv[])
{
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);
	enQueue(6);
	deQueue();
	deQueue();
	enQueue(7);
	enQueue(8);
	enQueue(9);
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	return 0;
}

Me doy por vencido en la programaci贸n.

驴oye pero no estamos tratando el queue como lifo env茅s de fifo?

Una posible soluci贸n al reto!.


#include<stdio.h>
#define SIZE 5

int values [SIZE], front = -1, rear = -1;

void enQueue(int value)
{
    if(rear == SIZE-1)
        printf("Nuestro Queue esta lleno \n");
    else
    {
        if (front == -1) 
        {
            front = 0;
        }
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %i correctamente \n", value);
    }
}
void deQueue()
{
    if (front == -1) 
        printf("Nuestro Queue esta vacio \n");
    else
         printf("Se ELIMINO el valor %i CORRECTAMENTE \n", values[front]);
         rear -= 1; /* Se resta un valor al rear */
        front++;

    if (front > rear)
        front = rear = -1; 
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(6);
    deQueue();
    enQueue(7);
    enQueue(8);
    
    return 0;
}
void deQueue()
{
    if(front == -1)
    {
        printf("La cola esta vacia\n");
    }
    else
    {
        //Cambie el valor del indice front por rear
        printf("Se elimino el valor %d \n",values[rear]);
        front++;
        //Decremento la variable rear
        rear--;

        if(front>rear)
        {
            front=rear=-1;
        }
    }
    
}

excelente forma de explicar me encanta!!!

gracias ricardo

A continuaci贸n les dejo mi aportaci贸n en Java.
Si alguien pregunta la raz贸n por la que utilic茅 un ArrayList, fue para poder almacenar tambi茅n el valor 0 dentro de nuestros posibles valores.

<code>
package PrimerA;

import java.util.ArrayList;
import java.util.List;

public class Queue {

	private static final int SIZE = 5;

	List<Integer> values = new ArrayList<>(SIZE);
	
	public int front = -1, rear = -1, init = 0;

	public void enqueue(int value) {
		if (rear == SIZE - 1) {
			System.out.println("Nuestro queue est谩 lleno");
		} else {
			if (front == -1) {
				front = 0;
			}
			rear++;
			

			if (init == 0) {
				values.add(rear, value);
			} else {

				values.set(rear, value);
			}
			System.out.println("Se insert贸 el valor " + value + " correctamente");

		}

	}

	public void dequeue() {

		if (front == -1) {
			System.out.println("Nuestra Queue est谩 vac铆a");
		} else {
			System.out.println("Se elimin贸 el valor " + values.get(front));
			
			values.set(front, null);

			if (values.get(0) == null) {
				values.set(0, values.get(1));
				values.set(1, null);
			}
			if (values.get(1) == null) {
				values.set(1, values.get(2));
				values.set(2, null);
			}
			if (values.get(2) == null) {
				values.set(2, values.get(3));
				values.set(3, null);
			}
			if (values.get(3) == null) {
				values.set(3, values.get(4));
				values.set(4, null);
			}
			if (values.get(4) == null) {
				values.set(4, null);
			}

		}

		rear--;

		init = 1;

		if (front > rear) {
			front = rear = -1;
		}
	}

	public static void main(String args[]) {

		Queue queue1 = new Queue();

		queue1.enqueue(1);

	
		queue1.enqueue(2);
		queue1.enqueue(3);
		queue1.enqueue(4);
		queue1.enqueue(5);
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.enqueue(19);
		queue1.enqueue(23);
		queue1.enqueue(34);

	
	}

}

Saludos.

Hola! Yo busque como podria hacerse para sacar un elemento de un array, pero no encontre lo que buscaba.

Lo unico que encontre fueron bucles que cambian de lugar los valores de los indices para que parezca que el elemento se elimino, pero el array tiene la misma cantidad de elementos.

for (c = position - 1; c < n - 1; c++){
         array[c] = array[c+1];
         printf("El valor de C %d \n", array[c]);
        }
      printf("Resultant array:\n");
 
      for (c = 0; c < n - 1; c++)
         printf("%d\n", array[c]);

- 

Nos da a elegir una posicion que queremos eliminar, pero como la posicion es de 1 a 5 y no de 0 a 4
lo que hace es restarle 1 a position para que sea el indice correcto y no se pase de 4.

Luego compara c con n - 1, (n es la cantidad de numeros) al restarle 1 a n obtenemos la cantidad de indices.
Iguala el valor del indice que queremos 鈥渆liminar鈥 con el valor del indice siguiente.
Luego de la igualacion se hace un bucle que imprima todos los numeros menos el ultimo para que parezca que se elimino el numero que queriamos.
驴Por que no se imprimen todos los numeros?
Solo imprime 4 numeros porque cuando C vale 4 no se imprime nada, porque C seria igual a n y no menor como la condicion lo pide.

pues yo todav铆a no se programar en 鈥渃鈥, pero no se tan complejo como dicen xd

Mi solucion

#include "stdlib.h"
// #include "stdio.h"
#define SIZE_ARRAY 5

int values[SIZE_ARRAY], front = -1, rear  = -1, total = -1;

void enQueue(int value){
    if (total == SIZE_ARRAY - 1)
        printf("Nuestro Queue esta lleno\n"); 
    else{
        if (front == -1)
            front = 0;
        rear+=1;
        total+=1;
        values[rear] = value;
        printf("se ha insertado el valor %d correctamente:\n ", value);
    }
}

void deQueue(){
    if(front == -1)
        printf("Nuestro Queue esta vacio \n");
    else{
        printf("se elimino el valor: %d \n", values[front]);
        front+=1;
        total-=1;
        if(front > rear)
            front = rear = -1;
    }
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);

    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define  SIZE 5
int values[SIZE], front=-1, rear=-1;

void enQueue (int value){
 if (rear == SIZE-1)
    printf("nuestro Queue esta lleno \n");
 else{
    if (front == -1)
        front=0;
    rear++;
    values[rear] =value;
    printf("se inserto el valor %d Correctamente \n", value);}}

void deQueue(){
if (front == -1)
    printf("Nuestro queue esta vacio\n");
else{
    printf("se elimino el valor %d \n", values[front]);
    front++;
    rear=rear-1;
    if(front>rear)
        front=rear=-1;}}

int main()
{
    enQueue(10);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    deQueue();

    enQueue(23);
    enQueue(55);
    enQueue(5);

    return 0;
}```

Resolv铆 el reto modificando las funciones a partir de otra (showStatus) que me sirvi贸 para ir depurando errores hasta la versi贸n final. Como no s茅 como se representan o utilizan los nulls, reserv茅 el valor 0 para que sirva como valor vac铆o.

void enQueue(int value){
    if(rear == SIZE -1 && queue[rear] != 0 )                           
        printf("Queue is already full. Try again later.\n");
    else{ 
        if(front == -1){                                                                         
            front = 0;
            rear = 0;
        }
        if(value <= 0)                                                 
            printf("You can't add 0 (zero) or smaller number.\n");    
        else{                                                      
            while (queue[rear] != 0) rear++;                           
            queue[rear] = value;                                   
            printf("Number %d has been succesfully added.\n", value);
            if (rear < SIZE-1) rear++;                                 
        }
    }
}

void deQueue(){
    if( rear == -1 || queue[front] == 0 )                              
        printf("Queue is already empty.\n");
    else{
        printf("Number %d is being deleted.\n", queue[front]);         
        queue[select] = 0;
        while( (queue[select + 1]) != 0 ) {                             
            queue[select] = queue[select + 1];
            select++;
        }
        if( (queue[select + 1]) == 0 || select == rear){               
            queue[select] = 0;
            rear--;
        }
        select = 0;
    }
}

void showStatus(){
    printf("\n ---Status--- \n\n");
    printf("Index 0 is %d \n", queue[0]);
    printf("Index 1 is %d \n", queue[1]);
    printf("Index 2 is %d \n", queue[2]);
    printf("Index 3 is %d \n", queue[3]);
    printf("Index 4 is %d \n\n", queue[4]);
    printf("selector @ %d \n", select);
    printf("front @ %d \n", front);
    printf("rear @ %d \n\n", rear);

}