sierpinski_relatorio

03.
primeiramente tentei achar um padrão no triangulo de sierpinski, é facil de entender como funciona, mas não é facil
implementar algo que replique esse padrão, nao com o que aprendemos ate agora. conversando com o Saulo, aprendi que
podemos usar o binomio de newton, no triangulo de Newton se selecionarmos apenas os numeros impares, obtemos o triangulo de
sierpinski. o problema com esse approach, é que para calcularmos o binomio de newton usamos fatorial, e um numero fatorial fica grande muito
rapidamente. com ele conseguimos apenas o triangulo de ordem 3 antes que haja o overflow do integer, usando o long long int acredito que
conseguimos o de ordem 4 e talvez o de 5. conseguindo implementar uma função diferenciada para calcular o binomio de newton calculando os
fatoriais envolvidos ao mesmo tempo, e fazendo as divisoes assim que possivel, não deixando que a variavel cresca demais.
porem mesmo com ela, o binomial fica grande demais, com isso, consegui chegar ao triangulo de ordem 6 quase completo. poderiamos continuar com
essa ideia tentando achar uma forma de descobrir se o numero apos os calculos termina impar ou par(poderiamos ter pesqusiado se havia uma forma).
no final usamos a solução do rosetta code, implementando nosso proprio conversor pra numero binario e comparação bitwise AND.

soluções:

01.
#include <stdio.h>

int fatorial(int valor);
int b_newton(int n, int k);

int main(){
    int n, pot;

    while(1){
        printf("De um grau: ");
        scanf("%d", &n);
        pot = pow(2, n);

        for(int alt = pot; alt; alt--){
            for(int esp = alt; esp; esp--) printf(" ");

            for(int k = 0; k <= pot-alt; k++){
                int bin = b_newton(pot-alt, k);

                if(bin < 0) printf("x ");
                else if(bin%2) printf("* ");
                else printf("  ");
            }

            printf("\n");
        }
    }
    return 0;
}

int fatorial(int valor){
    int fat = 1;

    for(int i = 2; i <= valor; i++) fat *= i;

    return fat;
}

int b_newton(int n, int k){
    int binomio;

    binomio = fatorial(n)/(fatorial(k)*fatorial((n - k)));

    return binomio;
}
---------------------------------------------------------------------------------------------------------------------------------------
02.
#include <stdio.h>

void sierpinski(int ordem);
long long int b_newton(int n, int k);

main()
{
    int a, pot;

    while(1){
        scanf("%d", &a);

        pot = pow(2, a);
        sierpinski(pot);
    }
}

void sierpinski(int ordem)
{
        for(int a = 0; a < ordem; a++){
            printf("%17s", " ");
        for(int esp = ordem; esp  >a; esp--) printf(" ");

        for(int b = 0; b <= a; b++){
            long long int bin = b_newton(a, b);

            if(bin < 0) printf("x");
            else if(bin%2) printf("*");
            else printf(" ");

            printf(" ");
        }
        printf("\n");
    }
}

long long int b_newton(int n, int k){
    long long int binomio = 1,
        a, b, c, fator;

    a = 2, b = 2, c = 2;

    while(a <= n){

        binomio *= a;

        while(1){
            if(binomio%b == 0 && b <= k){
                binomio /= b;
                b++;
            }
            else break;
        }

        while(1){
            if(binomio%c == 0 && c <= n-k){
                binomio /= c;
                c++;
            }
            else break;
        }
        a++;
    }
    return binomio;
}
---------------------------------------------------------------------------------------------------------------------------------------
03(final).
#include <stdio.h>

int binario(int decimal);
int compara(int bin1, int bin2);

int main()
{
    int tamanho, y, x, i;

    printf("ORDEM: ");
    scanf("%d", &tamanho);
    tamanho = pow(2, tamanho);

    for (y = tamanho - 1; y >= 0; y--) {
        for (i = 0; i < y; i++) printf(" ");

        for (x = 0; x + y < tamanho; x++){
            if (compara(x, y)) printf("* ");
            else printf("  ");

        }
        printf("\n");
    }
    return 0;
}

int binario(int decimal){
    int binario = 0, aux = 1;

    while(decimal){
        if (decimal%2)
            binario += aux;
        decimal /= 2;
        aux *= 10;
    }
    return binario;
}

int compara(int dec1, int dec2)
{
    int bin1, bin2;

    bin1 = binario(dec1);
    bin2 = binario(dec2);

    while(bin1 || bin2){
        if((bin1%2) && (bin2%2)) return 0;
        bin1 /= 10, bin2 /= 10;
    }
    return 1;
}