PIC

Essas são as implementações dos nossos desafios já devidamente comentadas!
E hoje é o grande dia, daqui a pouco nós vamos apresentar o nosso PIC !

Implementações comentadas! Contêiner!

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    system("color f0");
    //A, B e C representam as dimensões do contêiner; X, Y e Z representam as dimensões do navio
    unsigned int A,B,C,X,Y,Z;
    scanf("%u %u %u %u %u %u",&A,&B,&C,&X,&Y,&Z);
    //Imprime na tela o resultado da fórmula, ou seja, a saída
    printf("%u\n",(X/A)*(Y/B)*(Z/C));
    return 0;
}

Implementações comentadas! Contêiner!

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    system("color f0");
    //A, B e C representam as dimensões do contêiner; X, Y e Z representam as dimensões do navio
    unsigned int A,B,C,X,Y,Z;
    scanf("%u %u %u %u %u %u",&A,&B,&C,&X,&Y,&Z);
    //Imprime na tela o resultado da fórmula, ou seja, a saída
    printf("%u\n",(X/A)*(Y/B)*(Z/C));
    return 0;
}

Implementações comentadas! Quadrado Aritmético!

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    system("color f0");
    // Declaração das variáveis, tamanho da ordem da matriz, soma do quadrado aritmético, contador e índice
    unsigned int N,S,cont=1,j;
    scanf("%u %u", &N,&S);
    // Declaração de uma variável solução que recebe o valor da fórmula
    int solucao=S-N*(1+N*N)/2;
    // Estrutura que por meio da fórmula monta o quadrado aritmético
    for (S=0; S<N; S++) //Reutilização da variável S como índice
    {
        for (j=0; j<N; j++)
            //Se linha igual a 0 e solução menor que 0
            if (S == 0 && solucao < 0)
                printf("%d ", cont++ + solucao);
            else
                //Se linha igual ao tamanho do quadrado menos 1 e solução maior que 0
                if (S == N-1 && solucao > 0)
                printf("%d ", cont++ + solucao);
            else
                printf("%d ", cont++);
        printf("\n");
    }
    return 0;
}

Implementações comentadas! Ir e Vir!

#include <stdio.h>
#include <stdlib.h>
//Estruturas para a criação de filas
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
//Função para inserir valor na fila
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
//Função para remover um valor de uma fila
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
//Zerar a matriz
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    //Declaração de duas filas. Sendo G para mostrar o resultado final
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    system("color f0");
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        //Estrutura que recebe os pontos de interseção, rua e tipo de rua
        //Insere a conectividade das interseções na matriz
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        //Estrutura para verificar se conexão é satisfeita
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            //Estrutura para determinar qual linha será verificada as interseções
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            //Estrutura inserir valor 1 na matriz caso as interseções estejam ligadas
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    //Saída
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementações comentadas! Ir e Vir!

#include <stdio.h>
#include <stdlib.h>
//Estruturas para a criação de filas
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
//Função para inserir valor na fila
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
//Função para remover um valor de uma fila
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
//Zerar a matriz
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    //Declaração de duas filas. Sendo G para mostrar o resultado final
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    system("color f0");
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        //Estrutura que recebe os pontos de interseção, rua e tipo de rua
        //Insere a conectividade das interseções na matriz
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        //Estrutura para verificar se conexão é satisfeita
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            //Estrutura para determinar qual linha será verificada as interseções
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            //Estrutura inserir valor 1 na matriz caso as interseções estejam ligadas
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    //Saída
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementações comentadas! Ir e Vir!

#include <stdio.h>
#include <stdlib.h>
//Estruturas para a criação de filas
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
//Função para inserir valor na fila
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
//Função para remover um valor de uma fila
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
//Zerar a matriz
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    //Declaração de duas filas. Sendo G para mostrar o resultado final
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    system("color f0");
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        //Estrutura que recebe os pontos de interseção, rua e tipo de rua
        //Insere a conectividade das interseções na matriz
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        //Estrutura para verificar se conexão é satisfeita
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            //Estrutura para determinar qual linha será verificada as interseções
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            //Estrutura inserir valor 1 na matriz caso as interseções estejam ligadas
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    //Saída
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementações comentadas! Ir e Vir!

#include <stdio.h>
#include <stdlib.h>
//Estruturas para a criação de filas
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
//Função para inserir valor na fila
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
//Função para remover um valor de uma fila
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
//Zerar a matriz
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    //Declaração de duas filas. Sendo G para mostrar o resultado final
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    system("color f0");
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        //Estrutura que recebe os pontos de interseção, rua e tipo de rua
        //Insere a conectividade das interseções na matriz
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        //Estrutura para verificar se conexão é satisfeita
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            //Estrutura para determinar qual linha será verificada as interseções
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            //Estrutura inserir valor 1 na matriz caso as interseções estejam ligadas
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    //Saída
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementações comentadas! Ir e Vir!

#include <stdio.h>
#include <stdlib.h>
//Estruturas para a criação de filas
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
//Função para inserir valor na fila
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
//Função para remover um valor de uma fila
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
//Zerar a matriz
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    //Declaração de duas filas. Sendo G para mostrar o resultado final
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    system("color f0");
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        //Estrutura que recebe os pontos de interseção, rua e tipo de rua
        //Insere a conectividade das interseções na matriz
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        //Estrutura para verificar se conexão é satisfeita
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            //Estrutura para determinar qual linha será verificada as interseções
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            //Estrutura inserir valor 1 na matriz caso as interseções estejam ligadas
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    //Saída
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementações comentadas!

Implementações comentadas! Bússola!

#include<stdio.h>
#include <stdlib.h>
//Declaração da estrutura de hora e minuto
struct sbussola
{
    unsigned int H,M;
};
//Função para conversão do horário de 24 horas para o analógico, de 12 horas.
hora12(int H)
{
    if(H>=12)
        H=H-12;
    return H;
}
int main (void)
{
    system("color f0");
    // Declaração das variáveis
    unsigned int N,i;
    scanf("%u",&N);
    // Declaração de um vetor de tamanho igual ao número de testes
    struct sbussola bussola[N];
      for(i=0; i<N; i++)
        scanf("%u %u", &bussola[i].H,&bussola[i].M);
    // Estrutura que por meio de fórmula calcula a saída
    for(i=0; i<N; i++)
    {
        if((abs(bussola[i].M-(hora12(bussola[i].H)*5)))<30)
            printf("%u\n",(abs(bussola[i].M-(hora12(bussola[i].H)*5)))*6);
        else
            printf("%u\n",(60-(abs(bussola[i].M-(hora12(bussola[i].H)*5))))*6);
    }
    return 0;
}

Implementações comentadas!

#include<stdio.h>
#include <stdlib.h>
//Declaração da estrutura de hora e minuto
struct sbussola
{
    unsigned int H,M;
};
//Função para conversão do horário de 24 horas para o analógico, de 12 horas.
hora12(int H)
{
    if(H>=12)
        H=H-12;
    return H;
}
int main (void)
{
    system("color f0");
    // Declaração das variáveis
    unsigned int N,i;
    scanf("%u",&N);
    // Declaração de um vetor de tamanho igual ao número de testes
    struct sbussola bussola[N];
      for(i=0; i<N; i++)
        scanf("%u %u", &bussola[i].H,&bussola[i].M);
    // Estrutura que por meio de fórmula calcula a saída
    for(i=0; i<N; i++)
    {
        if((abs(bussola[i].M-(hora12(bussola[i].H)*5)))<30)
            printf("%u\n",(abs(bussola[i].M-(hora12(bussola[i].H)*5)))*6);
        else
            printf("%u\n",(60-(abs(bussola[i].M-(hora12(bussola[i].H)*5))))*6);
    }
    return 0;
}

PIC.

Hoje começaram as apresentações do PIC !!

Amanhã é a nossa equipe !

PIC !

Hoje estamos aqui no laboratório II do UNIS terminando o PIC!
O nosso professor o Agnus sedeu a sua aula pra gente !

Implementação de Ir e Vir ! ( Tinhamos esquecido de postar)

#include<stdio.h>
#include <stdlib.h>
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

Implementação de Ir e Vir ! ( havia esquecido de postar)

#include<stdio.h>
#include <stdlib.h>
struct sNo
{
    int valor;
    struct sNo *prox;
};
typedef struct sNo Tno;
struct sFila
{
    Tno *H,*T;
};
inserir(struct sFila *L,int V)
{
    Tno *P;
    P=(Tno*)malloc(sizeof(Tno));
    if(!P)
        printf("Erro de memoria!\n");
    else
    {
        P->valor=V;
        P->prox= NULL;
        if(!(L->H)&&!(L->T))
        {
            L->H=P;
            L->T=P;
        }
        else
        {
            L->T->prox=P;
            L->T=P;
        }
    }
}
remover(struct sFila *L)
{
    Tno *P;
    P=L->H;
    L->H=L->H->prox;
    if(L->H==NULL)
        L->T=NULL;
    free(P);
}
void matriz_nula(int **matriz,int tamanho)
{
    int i,j;
    for(i=0; i<tamanho; i++)
        for(j=0; j<tamanho; j++)
            matriz[i][j]=0;
}
int main(void)
{
    struct sFila G,fila;
    fila.H=NULL;
    fila.T=NULL;
    G.H=NULL;
    G.T=NULL;
    Tno *Pont;
    int N,M,v,w,p,**matriz,**matriz2,ind,acm,i,j;
    for(;;)
    {
        scanf("%d %d",&N,&M);
        matriz=(int **)calloc(N,sizeof(int*));
        for(i=0; i<N; i++)
            matriz[i] = (int*) calloc (N, sizeof(int));
        matriz_nula(matriz,N);
        if(N==0&&M==0)
            break;
        while(M--)
        {
            scanf("%d %d %d",&v,&w,&p);
            if(p == 1)
                matriz[v-1][w-1] = 1;
            else
            {
                matriz[v-1][w-1] = 1;
                matriz[w-1][v-1] = 1;
            }
        }
        for(i=0; i<N; i++)
        {
            matriz2=(int **)calloc(N,sizeof(int*));
            for(j=0; j<N; j++)
                matriz2[j] = (int*) calloc (N, sizeof(int));
            matriz_nula(matriz2,N);
            for(j=0; j<N; j++)
            {
                if(matriz[i][j]&&!matriz2[i][j]&i!=j)
                {
                    inserir(&fila,j);
                    matriz2[i][j]=1;
                }
            }
            while(!((fila.H==NULL)&&(fila.T==NULL)))
            {
                ind=fila.H->valor;
                matriz[i][ind]=1;
                for(j=0; j<N; j++)
                {
                    if(matriz[ind][j]&&!matriz2[ind][j]&&ind!=j)
                    {
                        inserir(&fila,j);
                        matriz2[ind][j]=1;
                    }
                }
                remover(&fila);
            }
        }

        acm=0;
        for(i=0; i<N; i++)
            for(j=0; j<N; j++)
                acm+=matriz[i][j];
        if(acm == N*N)
            inserir(&G,1);
        else
            inserir(&G,0);
        for(i=0; i<N; i++)
        {
            free(matriz[i]);
            free(matriz2[i]);
        }
        free(matriz);
        free(matriz2);
    }
    Pont=G.H;
    while(G.H!=NULL)
    {
        printf("%d\n",G.H->valor);
        remover(&G);
    }
    return 0;
}

A equipe na reta final do PIC !

Dia da apresentação !

Foi definido o dia da nossa apresentação: nessa terça-feira dia 31/05

Implementação de Quadrado Aritmético

#include <stdio.h>
int main()
{
    unsigned int N,S,cont=1,i,j;
    scanf("%u %u", &N,&S);
    int solucao=S-N*(1+N*N)/2;
    for (S=0; S<N; S++)
    {
        for (j=0; j<N; j++)
            if (S == 0 && solucao < 0)
                printf("%d ", cont++ + solucao);
            else
                if (S == N-1 && solucao > 0)
                printf("%d ", cont++ + solucao);
            else
                printf("%d ", cont++);
        printf("\n");
    }
    return 0;
}

Implementação de Contêineres !

#include <stdio.h>
int main(void)
{
    unsigned int A,B,C,X,Y,Z;
    scanf("%u %u %u %u %u %u",&A,&B,&C,&X,&Y,&Z);
    printf("%u\n",(A/X)*(B/Y)*(C/Z));
    return 0;
}

Implementação de Bússola !

#include<stdio.h>
struct sbussola
{
    unsigned int H,M;
};
hora12(int H)
{
    if(H>=12)
        H=H-12;
    return H;
}
int main (void)
{
    unsigned int N,i;
    scanf("%u",&N);
    struct sbussola bussola[N];
    for(i=0; i<N; i++)
        scanf("%u %u", &bussola[i].H,&bussola[i].M);
    for(i=0; i<N; i++)
    {
        if((abs(bussola[i].M-(hora12(bussola[i].H)*5)))<30)
            printf("%u\n",(abs(bussola[i].M-(hora12(bussola[i].H)*5)))*6);
        else
            printf("%u\n",(60-(abs(bussola[i].M-(hora12(bussola[i].H)*5))))*6);
    }
    return 0;
}

Implementações !

Vou postas denovo os programas que a gente fez, que tiveram modificações ! 

4º Problema do PIC

Já estamos desenvolvendo o quarto e último problema.
Em breve postaremos aqui o algoritmo e algumas atualizações dos outros problemas.

Agora ja está pronto mais uma algoritmo, só falta implementar o que o professor Fabrício entregou ontem ! Lembrando que esses algorítmos já implementados vão sofrer ainda algumas alterações !

Implementação de Quadrado Aritmétrico!

#include <stdio.h>
struct squadrado
{
    int S;
    unsigned int N;
};
typedef struct squadrado squad;
squad verif_entrada(squad entrada)
{
    do
        scanf("%u %d", &entrada.N,&entrada.S);
    while(((entrada.N>1e3)||(entrada.N<1))||((entrada.S>1e3)||(entrada.S<-1e3)));
    return entrada;
}
void saida(squad entrada)
{
    int solucao=entrada.S-entrada.N*(1+entrada.N*entrada.N)/2;
    unsigned int cont=1,i,j;
    for (i=0; i<entrada.N; i++)
    {
        for (j=0; j<entrada.N; j++)
            if (i == 0 && solucao < 0)
                printf("%d ", cont++ + solucao);
            else if (i == entrada.N-1 && solucao > 0)
                printf("%d ", cont++ + solucao);
            else
                printf("%d ", cont++);
        printf("\n");
    }
}
int main()
{
    squad entrada_quad;
    entrada_quad=verif_entrada(entrada_quad);
    saida(entrada_quad);
    return 0;
}

Implementação de Contêineres !

#include <stdio.h>
#include <stdlib.h>
struct sdimencion
{
    unsigned int a,b,c;
};
typedef struct sdimencion dimencion;
dimencion verif_entrada(dimencion entrada)
{
    do
        scanf("%u %u %u", &entrada.a,&entrada.b,&entrada.c);
    while(((entrada.a>1e6)||(entrada.b>1e6)||(entrada.c>1e6))||((entrada.a<1)||(entrada.b<1)||(entrada.c<1)));
    return entrada;
}
unsigned int cabem(dimencion conteineres, dimencion navio)
{
    unsigned int retorno;
    if(((navio.a/conteineres.a)*(navio.b/conteineres.b)*(navio.c/conteineres.c))>1e6)
        return 1e6;
    else
        return retorno=((navio.a/conteineres.a)*(navio.b/conteineres.b)*(navio.c/conteineres.c));
}
int main()
{
    dimencion conteineres,navio;
    unsigned int n_conteineres;
    conteineres=verif_entrada(conteineres);
    navio=verif_entrada(navio);
    n_conteineres=cabem(conteineres,navio);
    printf("%u\n",n_conteineres);
    return 0;
}

Implementação de Bússola !

include<stdio.h>
#include<stdlib.h>
struct sbussola
{
    unsigned int hora,minuto,angulo;
};
typedef struct sbussola sbus;
hora12(int h)
{
    if(h>=12)
        h=h-12;
    return h;
}
int abs( int x )
{
    if( x < 0 )
        return -x;
}
numeroT(unsigned int nteste)
{
    int ok=0;
    char strteste[3];
    do
        scanf("%u", &nteste);
    while((nteste>50)||(nteste<1));
    return nteste;
}
Ebussola (unsigned int nteste, sbus bussola[])
{
    int i;
    for(i=0; i<nteste; i++)
    {
        do
            scanf("%u %u", &bussola[i].hora,&bussola[i].minuto);
        while(((bussola[i].hora>23)||(bussola[i].hora<0))||((bussola[i].minuto>59)||(bussola[i].minuto<0)));
        bussola[i].hora= hora12(bussola[i].hora);
        bussola[i].angulo=abs(bussola[i].minuto-(bussola[i].hora*5));
        if(bussola[i].angulo>30)
            bussola[i].angulo=(60-bussola[i].angulo);
        bussola[i].angulo=(bussola[i].angulo*6);
    }
}
saida(unsigned int Nentrada,sbus angulos[])
{
    unsigned int j;
    for(j=0; j<Nentrada; j++)
        printf("%u\n",(angulos[j].angulo));
}
int main (void)
{
    unsigned int nteste;
    sbus bussola[50];
    nteste=numeroT(nteste);
    Ebussola(nteste,bussola);
    saida(nteste,bussola);
    return 0;
}

Dos exercícios propostos já foram desenvolvidos o da Bússola e o do Contêineres !

Exercícios do PIC !

Exercícios do PIC !

Exercícios do PIC !