----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

// tamanho máximo da fila
#define TAM_MAX 10

// vamos precisar de algumas variáveis globais
int fila[TAM_MAX]; // vetor de inteiros que servirá como fila
unsigned int tamanho = 0; // tamanho atual da fila
unsigned int inicio = 0; // índice que aponta para o início da fila
unsigned int fim = TAM_MAX - 1; // índice que aponta para o final da fila

// protótipo das funções (sim, alguns compiladores exigem isso)
void exibir_fila();
void enfileirar(int valor);
int desenfileirar();
int fila_cheia();
int fila_vazia();
int retornar_inicio();
int retornar_fim();

// função principal do programa
int main(int argc, char *argv[]){
  // variáveis usadas na resolução do exercício
  int opcao, valor, continuar = 1;
	
  setlocale(LC_ALL,""); // para acentos do português
  
  // laço infinito para o menu de opções
  while (continuar){
    printf("--------------------------------------\n");
    printf("         SIMULAÇÃO DE FILA EM C       \n");
    printf("--------------------------------------\n");
    printf("1. Enfileirar\n");
    printf("2. Desenfileirar\n");
    printf("3. Tamanho da Fila\n");
    printf("4. Retornar Início da Fila\n");
    printf("5. Retornar Final da Fila\n");
    printf("6. Sair do Programa\n");
    printf("--------------------------------------\n");
    printf("Sua opção: ");

    // lê a opção informada pelo usuário
    scanf("%d", &opcao);
    
    // trata as opções usando um menu switch
    switch(opcao){
      case 1: // enfileira um novo valor na fila
        printf("\nInforme o valor a ser enfileirado: ");
        scanf("%d", &valor);

        // enfileira o valor
	if(!fila_cheia()){
	  enfileirar(valor);
          printf("\nValor enfileirado com sucesso.\n\n");
          exibir_fila();
        }
	else{
	  printf("\nA fila está cheia.\n\n");
	}
      
	break;
			  
      case 2: // desenfileira um valor da fila
        if(!fila_vazia()){
	  valor = desenfileirar();
          printf("\nValor desenfileirado: %d\n\n", valor);
          exibir_fila();
        }
	else{
	  printf("\nA fila está vazia.\n\n");
	}
      
	break;

      case 3: // retorna o tamanho da fila
        printf("\nA fila possui %d elementos.\n\n", tamanho);
      
	break;
				
      case 4: // retorna o elemento no início da fila
        if(!fila_vazia()){
	  valor = retornar_inicio();
          printf("\nValor no início da fila: %d\n\n", valor);
        }
	else{
	  printf("\nA fila está vazia.\n\n");
	}
      
	break;
				
      case 5: // retorna o elemento no final da fila
        if(!fila_vazia()){
	  valor = retornar_fim();
          printf("\nValor no final da fila: %d\n\n", valor);
        }
	else{
	  printf("\nA fila está vazia.\n\n");
	}
      
	break;
				
      case 6: // sai do menu de opções
        printf("\nObrigado por usar o programa.\n");
        continuar = 0;
      
	break;		  
    }
  }
	
  printf("\n\n");
  system("PAUSE");	
  return 0;
}

// função que exibe o conteúdo da fila
void exibir_fila() {
  int i;
	
  // a fila está vazia
  if(fila_vazia()){
    printf("\nA fila está vazia.\n\n");
  } 
  else {
    printf("Conteúdo da fila:\n\n");
    
    for (i = inicio; i <= fim; i++) {
      printf("Item[%d]: %d\n", (i + 1), fila[i]);
    }
    
    printf("\n");
  }
}

// função que testa se a fila está cheia
int fila_cheia(){
  return (tamanho == TAM_MAX);
}

// função que testa se a fila está vazia
int fila_vazia(){
  return (tamanho == 0);
}

// retorna o elemento no início da fila
int retornar_inicio(){
  return fila[inicio];
}

// retorna o elemento no fim da fila
int retornar_fim(){
  return fila[fim];
}

// função que permite enfileirar um novo valor na fila
void enfileirar(int valor){
  // assegura que o final da fila não ultrapasse os limites
  // do vetor
  fim = (fim + 1) % TAM_MAX;

  // aumentamos o tamanho da fila
  tamanho++;

  // enfileiramos o novo valor
  fila[fim] = valor;
}

int desenfileirar(){
  int valor;

  // desenfileira um valor da fila
  valor = fila[inicio];

  // vamos evitar que o início da fila não ultrapassa
  // os limites do vetor
  inicio = (inicio + 1) % TAM_MAX;

  // reduzimos o tamanho da fila
  tamanho--;

  // e retornamos o valor desenfileirado
  return valor;
}

--------------------------------------
         SIMULAÇÃO DE FILA EM C
--------------------------------------
1. Enfileirar
2. Desenfileirar
3. Tamanho da Fila
4. Retornar Início da Fila
5. Retornar Final da Fila
6. Sair do Programa
--------------------------------------
Sua opção: 1

Informe o valor a ser enfileirado: 39

Valor enfileirado com sucesso.

Conteúdo da fila:

Item[1]: 56
Item[2]: 39
...

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

int main(int argc, char *argv[])
{
  char frase1[100] = "Gosto";
  strcat(frase1, " muito de ");
  strcat(frase1, " programar em C");

  // exibe o resultado
  printf("%s\n\n", frase1);

  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

int main(int argc, char *argv[])
{
  // declara e inicializa duas strings
  char frase1[100] = "Gosto muito de ";
  char frase2[15] = "programar em C";
  char *res = strcat(frase1, frase2);

  // exibe o resultado
  printf("%s\n\n", res);

  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

double modf(double x, double * intpart);

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

int main(int argc, char *argv[])
{
  double valor = 34.27;
  
  // vamos separar o valor em suas partes inteira e fracionária
  double inteira = 0.0, fracionaria = 0.0;
  fracionaria = modf(valor, &inteira);
  
  // vamos exibir o resultado
  printf("Parte inteira: %f\n", inteira);
  printf("Parte fracionaria: %f\n", fracionaria);
  
  printf("\n\n");
  system("pause");
  return 0;
}

void contar_recursivamente(int n){
  // sua implementação aqui
}

10
9
8
7
6
5
4
3
2
1
0

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>   
   
// função recursiva que conta de 10 até 0;
void contar_recursivamente(int n){
  // vamos exibir o número atual
  printf("%d\n", n);
	
  // devemos prosseguir com a recursividade?
  if(n > 0){
    // decrementa o valor de n
    n--;  
    contar_recursivamente(n); // e faz uma nova chamada recursiva
  }
}
   
int main(int argc, char *argv[]){
  setlocale(LC_ALL,""); // para acentos do português
	
  // efetua uma chamada ao método recursivo fornecendo 
  // o primeiro valor
  contar_recursivamente(10);
	
  printf("\n\n");
  system("pause");
  return 0;
}

double a = 0.0 / 0;
System.out.println(a);