Distância entre dois pontos com struct

#include<stdio.h>
#include<math.h>
struct Ponto{
    int x,y;
};
void main()
{
    struct Ponto p[2];
    float dist;
    printf("Informe a posi%c%co do primeiro ponto (x,y): ",135,198);
    scanf("%d%d",&p[0].x,&p[0].y);
    printf("Informe a posi%c%co do segundo ponto (x,y): ",135,198);
    scanf("%d%d",&p[1].x,&p[1].y);
    dist=sqrt(pow((float)(p[1].y-(float)p[0].y),2)+pow((float)(p[1].x-(float)p[0].x),2));
    printf("A dist%cncia entre os pontos %c: %.2f\n\n",131,130,dist);
}

Multiplicação de matrizes alocadas dinamicamente em C

#include<stdio.h>
#include<stdlib.h>
int** aloca (int linha,int coluna)
{
int **matriz,i;
if((matriz=(int **)malloc(coluna*sizeof(int*)))==NULL)
{
printf("Mem%cria n%co dispon%cvel!",162,198,161);
exit(1);
}
else
{
for(i=0;i<linha;i++)
{
if((matriz[i]=(int *)malloc(coluna*sizeof(int)))==NULL)
{
printf("Mem%cria n%co dispon%cvel!",162,198,161);
exit(1);
}
}
}
return matriz;
}
void le_matriz (int **matriz,int linha,int coluna)
{
int i,j;
for(i=0;i<linha;i++)
{
for(j=0;j<coluna;j++)
{
printf("\nPosi%c%co %d%d: ",135,198,i+1,j+1);
scanf("%d",&matriz[i][j]);
}
}
return;
}
void multiplica (int **matriz_final,int **matriz1,int **matriz2,int l1,int c2,int l2)
{
int i,j,k;
for(i=0;i<l1;i++)
{
for(j=0;j<c2;j++)
{
matriz_final[i][j]=0;

for(k=0;k<l2;k++)
{
matriz_final[i][j]=matriz_final[i][j]+(matriz1[i][k]*matriz2[k][j]);
}
}
}
}
void imprime (int **matriz,int linha,int coluna)
{
int i,j;
for(i=0;i<linha;i++)
{
printf("%c",186);
for(j=0;j<coluna;j++)
{
printf("\t%d",matriz[i][j]);
}
printf("\t%c\n",186);
}
return;
}
int main()
{
    int **matriz1,**matriz2,**matriz_final,l1,c1,l2,c2;
printf("Informe o n%cmero de linhas e colunas da primeira matriz respectivamente: ",163);
scanf("%d%d",&l1,&c1);
printf("Informe o n%cmero de linhas e colunas da segunda matriz respectivamente: ",163);
    scanf("%d%d",&l2,&c2);
if(l2!=c1){printf("N%co %c poss%cvel realizar a multiplica%c%co com os dados informados!\n\n",198,130,161,135,198);exit(1);}
matriz1=aloca(l1,c1);
matriz2=aloca(l2,c2);
printf("\nMatriz 1:");
le_matriz(matriz1,l1,c1);
imprime(matriz1,l1,c1);
printf("\nMatriz 2:\n");
le_matriz(matriz2,l2,c2);
imprime(matriz2,l2,c2);
matriz_final=aloca(l1,c2);
multiplica(matriz_final,matriz1,matriz2,l1,c2,l2);
printf("\n\nMatriz resultante da multiplica%c%co das matrizes 1 e 2:\n",135,198);
imprime(matriz_final,l1,c2);
return 0;
 }

Lista Encadeada em C (Matrícula e nome)

#include <stdio.h>
#include<stdlib.h>
struct registro
{
    long int matricula;
    char nome[81];
    struct registro *next;
};
struct registro *raiz;
void adiciona()
{
    struct registro *novoreg=(struct registro*)malloc(sizeof(struct registro));
    if(novoreg==NULL){printf("Mem%cria insuficiente!",162); exit(1);}
    printf("\nInforme a matr%ccula do funcion%crio: ",161,160);
    scanf("%d",&novoreg->matricula);
    getchar();
    printf("Informe o nome: ");
    gets(novoreg->nome);
    novoreg->next=raiz->next;
    raiz->next=novoreg;
}
void exclui()
{
    struct registro *reg_atual, *reg_ant;
    long int matric;
    reg_atual=raiz->next;
    reg_ant = raiz;   
    printf("\nInforme a matr%ccula do funcion%crio que ser%c exclu%cdo: ",161,160,160,161);
    scanf("%d",&matric);
    while(reg_atual!=NULL)
    {
        if(matric==reg_atual->matricula)
        {
            reg_ant->next=reg_atual->next;
            printf("\nMatr%ccula exclu%cda com sucesso!",161,161);
            free(reg_atual);
            return;
        }
        reg_ant = reg_atual;
        reg_atual=reg_atual->next;
    }       
    printf("Matr%ccula n%co encontrada!\n",161,198);
}
void imp_lista()
{
    struct registro *lista;
    lista=raiz->next;
    if(lista==NULL)
    {
        printf ("\n\n\a\a\a\a\tLista Vazia\n");
        system ("pause");
        exit(1);
    }
    else
    {
        while(lista!=NULL)
        {
            printf("\nMatr%ccula: %d",161,lista->matricula);
            printf("\nFuncion%crio: %s",160,lista->nome);
            lista=lista->next;
        }
    }
}

int main ()
{
    int op=3;
    raiz=(struct registro *)malloc(sizeof (struct registro));
    if(raiz==NULL) exit(1);
    raiz->next=NULL;
    do
    {
        printf("Digite 1 para adicionar um novo registro, 2 para excluir, 3 para listar e 4 para sair: ");
        scanf("%d",&op);
        if(op==1)adiciona();
        else if(op==2)exclui();
        else if(op==3)imp_lista();
        else if(op==4)exit(1);
        printf("\n");
    }while(op!=4);
    free(raiz);
    return 0;
}

Função que recebe um vetor de char e retorna um ponteiro com o vetor duplicado

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char* dupl(char *s)
{
char *n_local;
int qtd;
qtd=strlen(s);
if((n_local=(char*)malloc((2*qtd+1)*(sizeof(char))))==NULL)
{
printf("Espaço insuficiente!");
exit(1);
}
strcpy(n_local,s);
strcat(n_local,s);
return n_local;
}

int main()
{
char cadeia[50],*c_final;
printf("Informe uma cadeia de caracteres: ");
gets(cadeia);
c_final=dupl(cadeia);
printf("%s",c_final);
printf("\n\n");
free(c_final);
return 0;
}

Alocação dinâmica em vetor

#include<stdio.h>
#include<stdlib.h>
int main()
{
int *vet,quant_int,i;
printf("Quantos inteiros serao armazenados?");
scanf("%d",&quant_int);
if((vet=(int*)malloc(quant_int*sizeof(int)))==NULL)
{
printf("Espaço insuficiente!"); exit(1);
}
for(i=0;i<quant_int;i++)
{
printf("\nInforme o valor da pos%d: ",i+1);
scanf("%d",&vet[i]);
}
for(i=0;i<quant_int;i++)
{
printf("\nvet%d: %d",i+1,vet[i]);
}
printf("\n\n");
free(vet);
return 0;
}