programa_piramide

#include <stdio.h>

main(){

int n,i,total;/*O total define o número de repetições do laço de impressão e também o valor máximo de posições do vetor.*/
int vetor[30],n_inicial,n_final;/*n_inicial e n_final representam, respectivamente, a 1ª e a última posições do vetor.*/

/*Primeiro definimos o número de alocações que o usuário quiser*/

puts("Entre com o numero desejado:\n");

scanf("%d",&n);
puts("\n");

/*Veja que "total" é igual a "n"*/

total=n;

/*Esse número sera colocado no índice do vetor e gerará "n" alocações*/
/*Agora geraremos automaticamente os elementos do vetor*/

for(i=1;i<=n;i++)
    vetor[i]=i;

/*Agora, desenvolver o algoritmo para eliminar a primeira posição e a última do vetor. Devemos definir que vetor[1] é
o elemento n-inicial.*/

n_inicial=vetor[1];

/*Definimos o elemento n-final, que é simplesmente o vetor [n]. Por exemplo, Uma entrada de 5 posições, o n_inicial,
a partir do elemento 1, é o número 1, e o vetor[n] é igual ao elemento n_final, que é o 5. */

n_final=vetor[n];

/**Essa parte não aparecerá, apenas se for da vontade do programador de verificar essas variáveis**/
/*
puts("Vetor N-INICIAL");
printf("%d\n",n_inicial);
puts("\n");

puts("Vetor N-FINAL");
printf("%d\n",n_final);
puts("\n");*/

/**---------------Agora o algoritmo para imprimir o vetor sem o n_inicial e sem o n_final--------------------------**/

/*As condições são: "De n_inicial+1" até "n_final" sem incluir n_final. Ou seja, Sempre eliminará a primeira e
a última posição do vetor.*/

/*Agora, a extensão que é mais importante:
Primeiro, criamos um laço for que irá repetir o laço de impressão do vetor, com cada vez menos elementos.
Teremos um valor n que servirá de índice de contagem para o laço que repete o algoritmo de redução.*/

/*Observe que o valor de n é igual ao valor de entrada do usuário. Porque assim podemos pegar exatamente
o tamanho do vetor, aplicar isso na redução do vetor, que será a cada nova rodada do laço assim:

Suponha que o usuário definiu 10 elementos.

Ciclo 1 do laço de dentro imprime:
1 2 3 4 5 6 7 8 9 10

Observe que total vai até 10, ou seja, 10 elementos, ou 10 posições de memória.
Queremos, no ciclo 2 do laço, reduzir o primeiro elemento e o último elemento. São eles, respectivamente,
as variáveis n_inicial e n_final.

Ou seja, queremos que o laço agora tenha as condições: (de n+n_inicial+1), sendo que n começa de 0. Em passos, significa:

Ciclo 1: n=0 (com limite 10). Início é n+n_inicial (n_inicial, no caso, é 1) + 1 (ou seja, o elemento seguinte ao n_inicial).
Isso dá: 0+1+1 (ou seja, começa do dois), e termina no n_final - n, ou seja, no ciclo 1, n_final é 10 - n (que é 0), e fica no 10.

Ciclo 2: n=1. n + n_inicial+1 = (1+1+1), ou seja, começa da posição 3. E terminaria na posição n_final - n, ou seja,
na posição (10-1), a penúltima.

Ciclo 3: n=2. n+ n_inicial+1 = (2+1+1)=posição 4. E termina em n_final - 2=posição 8.

......
......
......

Ciclo n: n=n=10. n+n_inicial+1 = 10+1+1, ou seja, sem início. E o fim é n_final - n= 0.

Assim se forma a pirâmide.

*/

/*Agora imprimimos apenas a base da pirâmide*/

for(i=1;i<=n;i++)
    printf("%d ",vetor[i]);
    puts("\n");

/*E abaixo dela, imprimimos o restante do algoritmo de redução:*/

/*Vamos apenas definir um método de adicionar um "espaço" a cada nova repetição do algoritmo, para formar a figura da
pirâmide.*/

/*Analisando os laços abaixo:
O primeiro FOR é para repetir o algoritmo geral de redução. Ou seja, ele vai repetir n vezes, cada n vez diminuindo mais a
pirâmide. Logo após ele, colocamos logo um printf vazio de dois espaços. Ou seja, ocorre isso:

ciclo 1: imprime printf, imprime ciclo 1;

Depois, criamos um printf com um laço de repetição pra ele mesmo, isso ainda fora do algoritmo de repetição em si. O laço dele
deve ter o limite em n. O efeito é:

printf dois espaços, printf o primeiro ciclo; depois, a partir do primeiro ciclo, o segundo printf imprimirá cada vez mais
espaços, o que ajustará a pirâmide perfeitamente.
*/

for(n=0;n<total;n++){
    printf("  ");
    for(i=0;i<n;i++){
    printf("  ");}
    for(i=n_inicial+n+1;i<n_final-n;i++){
    printf("%d ",vetor[i]);}
    puts("\n");
}
puts("\n");

system("pause");
return 0;

}