Perdonen que vuelva a la carga, pero creo que esto no está terminado .

Antes que nada poner un caso que se me traspapelo entre tanto rombo. Es el caso de distinguir entre el borde y el interior:

#include <stdio.h>
 
int main(){
  int i=0,j,k=1,l,a=21;
  /*do{
    printf("\nBase del rombo(numero impar positivo): \n");
    scanf("%d",&a);
    }while ( a <=0 || (a % 2) == 0);*/
    char A[a+4][a+4],cad[]="L E O S A N S A N";
    for ( i=0;i<=a+4;i++)
      for ( j=0;j<=a+4;j++)
        A[i][j]='0';
    A[0][a/2]=254;
    i=1;
    while (i<=a/2){
      l=i;
      for ( j=(a/2)-i;j<=i+(a/2);j++){
        if (j==(a/2)-l || j==l+(a/2))
          A[i][j]=254;
        else
          A[i][j]='*';
      }
      i++;
    }
    k=i;
    while (i>=(a/2) && i<=a){
      --k;
      l=k;
      for ( j=(a/2)+1-k;j<(a/2)+k;j++)
        if (j==(a/2)+1-l || j==(a/2)+l-1)
          A[i][j]=254;
        else
          A[i][j]='*';
      i++;
    }
    if (a>20){
      for ( i=(a/2)-8,k=0;i<(a/2)+10;i++,k++)
        A[i][a+1]=cad[k];
    }
    for ( i=0;i<a;i++){
      printf("\t\t");
      for ( j=0;j<a+2;j++){
         if (A[i][j]=='0')
            printf("%c",' ');
          else
            printf("%c",A[i][j]);
      }
      putchar ('\n');
    }
    putchar ('\n');
    return 0;
}

A ver si se animan a colgar algo de código en C++.

Yo en dicho lenguaje soy un total neófito, pero por lo menos se traducir algo de C  a C++. Así me salió esto:

#include <iostream>
using namespace std;
int main()
{
int n,fila,col;
cout<<"Introduce un numero IMPAR: "<<endl;
cin >> n;
    for(fila=1;fila<=n;fila++){
        for(col=1;col<=n-fila;col++)
           cout<<(" ");
        for(col=1;col<=2*fila-1;col++)
          cout<<("*");
    cout<<endl;
    }
    for(fila=n-1;fila>=1;fila--) {
        for(col=1;col<=n-fila;col++)
          cout<<(" ");
        for(col=1;col<=2*fila-1;col++)
        cout<<("*");
    cout<<endl;
    }
}

Pero claro, yo espero más de los expertos en C++, que haberlos hay los, todo está en que se animen con nuevas aportaciones.

Y todavía estoy a la espera que yoel_alejandro intervenga, que me dijo me iba a sorprender. No lo dejes estar mucho tiempo que se enfría el tema.

Y dedicado precisamente a yoel_alejandro al que rete en mi anterior mensaje, le dejo una versión "made in leosansan" del triángulo de Pascal, en este caso para que sea más a tono con el tema que se trata, de la pirámide de Pascal .... si ya sé que me acabo de inventar el término, pero ¿a qué queda bien? ...

Huy, a mi dibujar formas en ASCII me da un dolor de cabeza... Es de los ejercicios que no puedo xD

Solo decir que las llamadas a printf/cout tienen mucho retraso, es más eficiente pintar línea a línea que caracter a caracter.

Pero vamos, son detallitos. Para que empezases a notar la diferencia tendría que ser rombos de más de 1000 o cosa así.

PD: El triangulo de pascal... ¿Recursivo?

Bueno que no se diga, dibujare señales cuadradas. Aquí teneís varias a distintas escalas:

#include <iostream>
#include <fstream>
#include <cmath>
using namespace std;
 
void DibujarSenyalCuadrada(const int frecuencia = 1,char caracter = '*',ostream &fout = cout);
 
int main()
{
    int frecuencia;
    //cout<<"Introduca frecuencia: ";
    //cin>>frecuencia;
    for (int i = 3; i < 20;i++)
    {
        DibujarSenyalCuadrada(i);
        cout<<endl;
    }
    return 0;
}
 
void DibujarSenyalCuadrada(const int frecuencia,char caracter,ostream &fout)
{
    const int max_asci = 50;
    int j = 0;
    string separador(frecuencia-2,' ');
    string escalon(frecuencia,caracter);
 
    while (j < max_asci)
    {
        fout<<escalon;
        fout<<separador;
        j += 2*frecuencia;
    }
 
    fout<<endl;
    // escalones de bajada
 
    for (int i = 0; i < frecuencia;i++)
    {
        j = 0;
        fout<<' ';
        while (j < max_asci)
        {
            fout<<separador;
            fout<<caracter;
            j += frecuencia;
        }
        fout<<endl;
    }
 
    // barreras inferiores
 
    fout<<separador;
    fout<<' ';
    j = 0;
 
    while (j < max_asci)
    {
        fout<<escalon;
        fout<<separador;
        j += 2*frecuencia;
    }
    fout<<endl;
}

Notese que escribo en fout en vez de cout. De esa forma puedo decirle a la función que escriba en un fichero externo en vez de la pantalla:

int main()
{
    ofstream fichero("cuadrada.txt");
 
    for (int i = 3; i < 20;i++)
    {
        DibujarSenyalCuadrada(i,'*',fichero);
        fichero<<endl;
    }
    return 0;
}

Pero esque las piramides ya las hecho

Pensé en hacer un circulo, pero hacer un circulo en una consola ASCII no es trivial. Para que te quedara bien habría que hacer "anti-alising" con alguna letra más redondita.

¿Más fácil? De eso nada xD

Para empezar rompe el enfoque arriba-abajo, además para sacarla tendrías que hacer unas series de fourier muy divertidas... Y probablemente alguna casilla te salga mal ya que no es exacta y las casillas no admiten decimales.

Chachi ^^. Un paso curioso sería hacerlas animadas (borrando y reescribiendola con otra posición cada x tiempo).

Yo de florituras en la pantalla, ni se me dan bien ni me gustan mucho. Por no dejar el tema a medias he hecho algo más de mi gusto: Una class Triangulo_Pascal:

/** Resumen de los metodos públicos:
 
- Constructor(int n = 0): Genera un triangulo de pascal de tamanyo N
- Constructor(triangulo_pascal): Constructor copia.
- getPosicion(int x,int y): Devuelve el valor en la posicion en la posicion x,y. Lanza una excepcion si es una posición incorrecta
- getSize(): Devuelve el tamanyo actual del triangulo
- resize(int n): Reconstruye el triangulo para un ancho n
- clear(): Borra el triangulo dejandolo con un tamanyo 0.
- toString(): Obtiene una expresion escrita del triangulo.
 
Operadores:
 
triangulo_pascal = triangulo_pascal   /** asignacion *
triangulo_pascal == triangulo_pascal  /** iguales? *
triangulo_pascal != triangulo_pascal  /** diferentes? *
**/
 
class triangulo_pascal
{
    int** Matriz;
    int TAM;
    string texto;
 
    int contar_cifras() const
    {
        int cifras = 1;
        int aux = Matriz[TAM-1][TAM/2];
 
        while (aux > 9)
        {
            cifras++;
            aux /= 10;
        }
 
        return cifras;
    }
 
    void generar(const int n)
    {
        TAM = n;
        Matriz = new int*[n];
        Matriz[0] = new int[1];
        Matriz[0][0] = 1;
 
        for (int i = 1; i < n;i++)
        {
            Matriz[i] = new int[i+1];
 
            Matriz[i][0] = 1;
            for (int j = 1; j < i;j++)
            {
                Matriz[i][j] = Matriz[i-1][j-1]+Matriz[i-1][j];
            }
            Matriz[i][i] = 1;
        }
 
        generarString();
    }
 
    void generarString()
    {
        stringstream ss;
 
        const int size = contar_cifras();
 
        for (int i = 0; i < TAM;i++)
        {
            for (int k = 0; k <= (TAM-i-2);k++)
                ss<<" ";
 
            ss<<Matriz[i][0];
 
            for (int j = 1; j <= i;j++)
            {
                ss<<" ";
 
                ss<<setw(size)<<Matriz[i][j];
            }
 
            ss<<endl;
        }
 
        texto = ss.str();
    }
public:
    triangulo_pascal(int n = 0)
    {
        if (n != 0)
        {
            generar(n);
        }
        else Matriz = NULL;
    }
 
    triangulo_pascal(const triangulo_pascal &a)
    {
        if (a.getSize() != 0)
            generar(a.getSize());
        else Matriz = NULL;
    }
 
    triangulo_pascal& operator=(const triangulo_pascal &a)
    {
        if (a.getSize() != 0)
            generar(a.getSize());
        else Matriz = NULL;
    }
 
    bool operator==(const triangulo_pascal &b)
    {
        return TAM == b.TAM;
    }
 
    bool operator!=(const triangulo_pascal &c)
    {
        return TAM != c.TAM;
    }
 
    int getPosicion(int x,int y) const
    {
        if (y < TAM || (x > y)) throw "Error, fuera de rango";
        return Matriz[x][y];
    }
 
    int getSize() const { return TAM;}
 
    void resize(int n)
    {
        if (n < 0) throw "Error, tamanyo negativo";
 
        clear();
 
        if (n == 0){return;}
 
        generar(n);
    }
 
    void clear()
    {
        if (Matriz == NULL) return;
 
        for (int i = 0; i < TAM;i++)
            delete[] Matriz[i];
 
        delete[] Matriz;
 
        Matriz = NULL;
        TAM = 0;
    }
 
    string toString() const
    {
        return texto;
    }
 
    operator string()
    {
        return toString();
    }
 
    ~triangulo_pascal()
    {
        clear();
    }
};
 

De la cual, podemos hacer algunas pruebas:

int main()
{
    triangulo_pascal mi_triangulo(5);
 
    cout<<mi_triangulo.toString()<<endl;
    mi_triangulo.resize(4);
    cout<<mi_triangulo.toString()<<endl;
 
    triangulo_pascal segundo(1);
 
    if (mi_triangulo != segundo)
    {
        cout<<"Son diferentes :("<<endl<<endl;
    }
 
    cout<<(string)segundo<<endl; // otra forma de pasarlo a string es usando los casts
    return 0;
}
 

El mayor fallo que tiene es la función para pasarlo a string, que aunque siempre genera el triangulo, lo hace un poco "raro" para algunos valores de N.