Linguagem C: Classificando triangulos pelos pontos dados

A alguns anos fiz um exercicio em que pedia para classificar triangulos de acordo com os pontos dados como isosceles, equilatero, escaleno, retângulo, obtuso ou acutângulo.
Ver exercicio 6:
https://tivideotutoriais.blogspot.com/2020/03/exercicios-antigos-em-linguagem-c.html

Esse modelo mostra o tanto que era novato. Mas agora esse é atualizado, mas para linux:

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

typedef struct
{
    double x;
    double y;
} Ponto;

double semiPitagoras(Ponto p1, Ponto p2)
{
    return (pow(p2.x-p1.x,2) + pow(p2.y-p1.y,2));
}

void triangulo(Ponto p1, Ponto p2, Ponto p3)
{
    double A, B, C, ladoA, ladoB, ladoC;
    char *Classe;
    char *angulo;

    A = semiPitagoras(p1, p2);
    B = semiPitagoras(p2, p3);
    C = semiPitagoras(p3, p1);

    ladoA = sqrt(A);
    ladoB = sqrt(B);
    ladoC = sqrt(C);

    printf("\n");
    printf(" lado A = %.16lf\n", ladoA);
    printf(" lado B = %.16lf\n", ladoB);
    printf(" lado C = %.16lf\n", ladoC);

    if((ladoA == ladoB+ladoC)||(ladoB == ladoC+ladoA)||(ladoC ==ladoB+ladoA))
    {
        printf("\nIsso nao e um triangulo\n");
        exit(1);
    }



    if (ladoA == ladoB == ladoC)
    {
        Classe = "Equilatero";
    }
    else if((ladoA != ladoB)&&(ladoB != ladoC)&&(ladoC !=ladoA))
    {
        Classe = "Escaleno";
    }
    else
    {
        Classe = "Isosceles";
    }

    if (((B + C)==A)||((B + A)==C)||((A + C)==B))
    {
        angulo = "retangulo";
    }
    else if((A-B-C + 2*ladoC*ladoB <0)||(B-A-C + 2*ladoA*ladoB <0)||(C-B-A + 2*ladoC*ladoB <0))
    {
        angulo = "Obtusangulo";
    }
    else
    {
        angulo = "Acutangulo";
    }
    printf("\n Triangulo %s e %s.\n\n",Classe,angulo);
}

int main()
{
    // coordenadas de cada
    // ponto do triangulo
    Ponto p1;
    Ponto p2;
    Ponto p3;

    //equilatero acutangulo
    p1.x=0.0;     p1.y=sqrt(3.0)/2.0;
    p2.x=0.5;    p2.y=0.0;
    p3.x=1.0;     p3.y=sqrt(3.0)/2.0;
    triangulo(p1,p2,p3);

    //isosceles retangulo
    p1.x=0.0; p1.y=0.0;
    p2.x=0.0; p2.y=1.0;
    p3.x=1.0; p3.y=0.0;
    triangulo(p1,p2,p3);

    //isosceles obtusangulo
    p1.x=0.0; p1.y=0.0;
    p2.x=1.0; p2.y=0.0;
    p3.x=0.5; p3.y=0.2;
    triangulo(p1,p2,p3);

    //escaleno obtusangulo
    p1.x=0.0; p1.y=0.0;
    p2.x=1.0; p2.y=0.0;
    p3.x=0.6; p3.y=0.2;
    triangulo(p1,p2,p3);

    return 0;
}

C e javaScript : Sequência de Fibonacci / Soma n primeiro termos / Encontra termo na posição n

Em linguagem C:


// Em c:
// Para compilar:
// gcc phi.c -o phi -lm

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

// Phi e phi conjugados tal que Phi * phi = 1
#define Phi (1+sqrt(5))/2
#define phi (1-sqrt(5))/2

// Encontra n numero de Fibonacci onde a sequencia começa em 0
int Fib(int n)
{
    return round(( pow(Phi, n) - pow(phi, n) ) / sqrt(5));
}

// Soma dos primeiros n numeros de Fibonacci onde a sequencia começa em 0
int sumPhi(int n)
{
    return Fib(n+2)-1;
}

// Encontra a posição n onde Fib(n)=value
int FindPosition(int value)
{
    return floor(log(value*sqrt(5))/log(Phi));
}

int main()
{
    int a=Fib(7);
    int b=sumPhi(7);
    int c=FindPosition(13);
    printf("numero 7 da sequencia de Fibonacci:%i\n", a);
    printf("soma dos 7 primeiros temos da sequencia de Fibonacci:%i\n", b);
    printf("Numero 13 na posição da sequencia de Fibonacci:%i\n", c);
    return 0;
}

 

Em javaScript:

<script>
// Phi e phi conjugados tal que Phi * phi = 1
// Phi * phi = 1
var Phi= (1+Math.sqrt(5))/2;
var phi= (1-Math.sqrt(5))/2;

// Encontra n numero de Fibonacci onde a sequencia começa em 0
function Fib(n)
{
    return Math.round(( Math.pow(Phi, n) - Math.pow(phi, n) ) / Math.sqrt(5));
}

// Soma dos primeiros n numeros de Fibonacci onde a sequencia começa em 0
function sumPhi(n)
{
    return Fib(n+2)-1;
}

// Encontra a posição n onde Fib(n)=value
function FindPosition(value)
{
    return Math.floor(Math.log(value*Math.sqrt(5))/Math.log(Phi));
}
document.write("Sum = "+sumPhi(8));
</script>

Linguagem C: Método para realizar aproximações de um logaritmo

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

// compilar com
// gcc aproxLog.c -o aproxLog -lm
// pra executar no linux:
// ./aproxLog

#define E 2.71828182845904509080
#define radix(x, y) pow(x, 1.0/y)

typedef struct NumeroLog
{
    int *array;
    int qtInteiros; // quantidade
    double base;
    double myLog;
} NumeroLog;

int initNumeroLog(NumeroLog *numero, double b)
{
    numero->base = b;
    numero->array = malloc( sizeof(int) );
    numero->array[0]=0;
    numero->qtInteiros = 1;
    return 1;
}

void farFreeArray(NumeroLog *numero)
{
    if(numero->qtInteiros!=0)
    {
        free(numero->array);
    }
}

void calcLog(NumeroLog *numero, int limite)
{
    while(limite>0)
    {
        if(numero->myLog >= numero->base)
        {
            numero->myLog = numero->myLog/numero->base;
            numero->array = realloc(numero->array, (numero->qtInteiros+1)*sizeof(int) );
            numero->array[numero->qtInteiros]=numero->array[numero->qtInteiros-1];
            numero->qtInteiros++;
        }
        else
        {
            numero->myLog *= numero->myLog;    
            if(numero->array[numero->qtInteiros-1]==0) numero->array[numero->qtInteiros-1]=1;
            else numero->array[numero->qtInteiros-1]++;
        }
        limite--;
    }
}

int imprime(NumeroLog *numero)
{
    double resp=0;
    for(int i=0; i<numero->qtInteiros-1; i++)
    {
        resp+=1.0/pow(2,  numero->array[i]);
        printf(" + (1/pow(2,%i))",  numero->array[i]);
    }
    printf(" + log(%.16lf)/pow(2,%i) \n",  numero->myLog, numero->array[numero->qtInteiros-1]);
    resp+= log(numero->myLog) / pow(2, numero->array[numero->qtInteiros-1]) ;
    printf("resp  =  %.16lf\n" , resp);
}

int main()
{
    // metodo
    // log(A*B) = log(A) + log(B)
    // log(A/B) = log(A) - log(B)  
    // log(A^B) = B*log(A)

    // alguns numeros primos
    int primes[10]={2,3,5,7,11,13,17,19,23,29};
    int tm = sizeof(primes)/sizeof(primes[0]);
    for(int i=0; i<tm; i++)
    {
        printf(" ======================================\n");
        printf("log(%i) = \n",  primes[i]);
        NumeroLog temp;
        temp.myLog=primes[i];
        initNumeroLog(&temp, E);
        calcLog(&temp, 18);
        imprime(&temp);
        farFreeArray(&temp);
    }
    return 0;
}

Linguagem C: Trabalhando com nós / Lista encadeada

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

typedef struct No
{
    int dado;
    struct No *next;
    struct No *before;
}No;

No *createNode(int val)
{
    No *newNode = malloc(sizeof(No));
    newNode->dado = val;
    newNode->next = NULL;
    newNode->before = NULL;
    return newNode;
}

No *insertInitNode(int num, No *Node)
{
    No *novo = malloc(sizeof(No));
    novo->before = NULL;
    novo->next=Node;
    novo->dado=num;
    return novo;
}

No *insertEndNode(int num, No *Node)
{
    No *aux = Node;
    No *novo;
    novo = malloc(sizeof(No));
    novo->dado=num;
    novo->next=NULL;
    while(aux->next!=NULL)
    {
        aux=aux->next;
        if(aux->next==NULL)
        {
            novo->before=aux;
        }
    }
    aux->next=novo;
    return Node;
}

void findInNode(int busca, No *Node)
{
    int contador=1;
    No *aux;
    aux = Node;
    while (aux->next!=NULL && aux->dado!=busca)
    {
        aux = aux->next;
        contador=contador+1;
    }
    if(aux->dado==busca)
    {
        printf("O valor procurado está na posição %d\n",contador);
    }
    else
    {
        printf("O valor procurado não foi encontrado\n");
    }
}

void findAllInNodes(int busca, No *Node)
{
    int contador=1;
    No *aux;
    aux = Node;
    while (aux->next!=NULL)
    {
        aux = aux->next;
        contador=contador+1;
        if(aux->dado==busca)
        {
            printf("O valor procurado está na posição %d\n",contador);
        }
    }
}

No *EditValueNode(int target, int target2, No *Node)
{
    No *aux;
    aux = Node;
    while (aux->next!=NULL && aux->dado!=target)
    {
        aux =  aux->next;
        if (aux!=NULL && aux->dado==target)
        {
            aux->dado=target2;
        }
    }
    return Node;
}

No *EditNode(int target, int value, No *Node)
{
    int contador=1;
    No *aux;
    aux = Node;
    while (aux->next!=NULL && contador!=target)
    {
        aux = aux->next;
        contador=contador+1;
    }
    if(contador==target)
    {
        aux->dado=value;
    }
    else
    {
        printf("No não encontrado\n");
    }
    return Node;
}

No *deleteValueInNode(int target, No *Node)
{
    No *aux;
    aux=Node;
    if(Node->dado==target)
    {
        if(Node->next!=NULL)
        {
            aux=Node->next;
            free(Node);
            Node->dado=aux->dado;
            Node->next=aux->next;
        }
        else
        {
            aux=Node->before;
            free(Node);
            Node->dado=aux->dado;
            Node->next=NULL;
        }
    }
    if(Node->next!=NULL)
    {
        deleteValueInNode(target, Node->next);
    }    
    return Node;
}

No *deleteAllNodes(No *Node)
{
    No *aux;
    aux=Node;
    while(aux->next!=NULL)
    {
        aux = Node->next;
        free(Node);
        Node=aux;
    }
    free(Node);
    Node=NULL;
    return Node;
}

void imprimir(No *Node)
{
    if(Node!=NULL)
    {
        if (Node->next!=NULL);
        {
            No *novo;
            novo=Node->next;
            imprimir(novo);
        }
        printf("Dado = %d\n",Node->dado);
    }
}

int main()
{
    printf("------------------------ createNode\n");
    No *node = createNode(3);
    imprimir(node);
    printf("------------------------ insertInitNode\n");

    node = insertInitNode(2, node);
    node = insertInitNode(2, node);
    node = insertInitNode(1, node);
    imprimir(node);
    printf("------------------------ insertEndNode\n");

    node = insertEndNode(4, node);
    imprimir(node);
    printf("------------------------ findInNode\n");

    findInNode(3, node);
    findInNode(6, node);
    printf("------------------------ findAllInNodes\n");

    findAllInNodes(2, node);
    printf("------------------------ EditValueNode\n");

    node = EditValueNode(2, 3, node);
    imprimir(node);
    printf("------------------------ EditNode\n");

    node = EditNode(4, 6, node);
    imprimir(node);
    printf("------------------------ deleteValueInNode\n");

    node = deleteValueInNode(3, node);
    imprimir(node);
    printf("------------------------ deleteAllNodes\n");

    node = deleteAllNodes(node);
    imprimir(node);
    printf("------------------------\n");

    return 0;
}