[C] Rombo con asteriscos

[leosansan]

Acepto el reto, jeje (claro, en un nuevo post) ...

[/b]

Pues a por él, pero eso sí en forma de triángulo isósceles. La forma clásica, vamos.

Ya que te lanzo el guante te dejo que elijas "armas", es decir que empieces el tema cuando te "sientas preparado". ..... es broma, ¿ehh..?.

¡¡¡¡ Saluditos! ..... !!!!

[leosansan]

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:

Código (cpp) [Seleccionar] Expandir


#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;
}

¿Qué pasa con los expertos en C++?

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:

Código (cpp) [Seleccionar] Expandir


#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? ...

¡¡¡¡ Saluditos! ..... !!!!

[dmacias]

Vaya leosansan, siq ue le has cojido el gusto al rombo jijijijjii
haber si me dejan un poco mas de tiempo libre e intento el triangulo de pascal ese, haber que sale

[amchacon]

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?

[leosansan]

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

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

¡¡¡Vamos hombre!!!, que no se trata de crear retratos o figuras complejas, además si te animas con el triángulo de Pascal, ya que tienes que crear la forma de triángulo, te será fácil dibujar la parte inferior y así ya tienes el rombo.

Hablando del triángulo de Pascal, me da igual como se obtenga,con recursión o sin ella,  la idea es que la gente aporte soluciones variadas, como un reto, ni más ni menos. Ya luego podremos comenta rentre todos  cual ha sido el más eficiente y cosas así.

Y para que no decaiga el tema yo aporto otro granito de arena al tema de los rombos en C++, que repito soy un pardillo total. Me cuesta horrores porque no controlo las salidas por pantalla, en C tengo los printf pero en C++ ..... sólo conozco cout, pero no sus posibilidades que me imagino tendrá, y setw. Y con este último me ha salido otro código con recursividad incluida:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <iomanip>
using namespace std;
int dibuja_arriba (int a,int cont);
int dibuja_abajo (int a,int cont);

int main()
{
    int cont=25,a=0;
    /*cout << "Introduce un numero IMPAR: "<<endl;
    cin >> a;
    cout <<endl ;*/
    dibuja_arriba (a,cont);
    cout <<  "  ";
    dibuja_abajo (cont-2,a+1);
    return 0;
}

int dibuja_arriba (int a,int cont){
    if (cont<=0)
      return 1;
    cout <<setw((cont/2)+1) << " ";
    for (int i=0;i<=a;i++)
      cout<< "*";
    cout << endl;
    dibuja_arriba (a+2,cont-2);
}

int dibuja_abajo (int a,int cont){
    if (a<=0)
      return 1;
    for (int i=1;i<=a;i++)
      cout<<"*";
    cout << endl << setw(cont+2) << " ";
    dibuja_abajo (a-2,cont+1);
}

Tuve que hacer algún ajuste "extraño" pero sale bien la pirámide.

¡¡¡¡ Saluditos! ..... !!!!

[amchacon]

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

Código (cpp) [Seleccionar] Expandir

#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:

Código (cpp) [Seleccionar] Expandir

int main()
{
   ofstream fichero("cuadrada.txt");

   for (int i = 3; i < 20;i++)
   {
       DibujarSenyalCuadrada(i,'*',fichero);
       fichero<<endl;
   }
   return 0;
}

[leosansan]

Bueno que no se diga, dibujare señales cuadradas.

Pero ese no era el tema, estábamos hablando de pirámides.

Pero bueno, para que no se diga, sin array, strings ni funciones. Solamente con el misero pero potente printf y mucha imaginación:

A mi ni me caben más en la pantalla:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int main(){
  int i,j,k,l=0,cont=0,cont1=0,tam,MAX=40;
  for (tam=3;tam<=15;tam++){
    cont=cont1=0;
    for (i=0,j=0;i<MAX-1;i++,j++){
      putchar('*');
      if (j==tam-1)
        printf ("%*c", tam-2, ' ');
       if (i%tam==0){
         cont++;
         j=0;
       }
    }
    putchar ('\n');
    for (k=0;k<tam;k++){
      for (i=0,j=0;i<2*MAX/tam-1;i++,j++){
        if (cont1==cont-1)
          break;
        if (j==0)
          printf ("%*c", tam, '*');
        else
            printf ("%*c", tam-1, '*');
        if (k==tam-1  && i<(2*MAX/tam-1)/2+1){
          cont1++;
          for (l=0;l<tam-1;l++){
            putchar('*');
          }
        }
        if (i%(tam+1)==0)
          j=0;
      }
      putchar ('\n');
    }
  putchar ('\n');
  }
return 0;
}

De todas formas sería más fácil usando una función matemática. ¿Te animas?.

¡¡¡¡ Saluditos! ..... !!!!

[amchacon]

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.

De todas formas sería más fácil usando una función matemática. ¿Te animas?.[/center]

¿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.

[leosansan]

Pero es que las pirámides ya las hecho

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

Pero apenas en C++, ya te digo que no sé muy bien como imprimir de  forma avanzada. No obstante continuo con mis aportaciones, para que vean lo que puede dar de sí este tema:

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;
/*********************************/
void entrar_num_base (int &n){
  /*cout << "Introduce un numero IMPAR: "<<endl;
   cin >> n;
   cout <<endl ;*/
}
/*********************************/
void asteriscos (int &i){
 for(int j=1;j<=i;j++)
   cout<<'*'<<" ";
 cout<<endl;
}

/*********************************/
void parte_superor (int i, int n){
 for(i=1;i<=n;i+=2){
   for(int b=n-i;b>0;b--)
     cout<<" ";
   asteriscos(i);
 }
}
/*********************************/
void parte_inferior(int i,int n){
 for(i=n-2;i>=1;i-=2){
   for(int b=n-i;b>0;b--)
     cout<<" ";
   asteriscos(i);
 }
}
/*********************************/

int main(){
 int i=0,num_base=25;
 ///entrar_num_base (num_base);
 parte_superor (i,num_base);
 parte_inferior(i,num_base);
 return 0;
}

...................................................
¿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.

¡No hombre!, no pensaba en ese sistema, para eso ya tengo el Mathematica y el Matlab.

Pensaba en esta idea:

f(x)=a/2 ......    0<=x<=a/2

f(x)=-a/2 ...... -a/2<x<a

Para ello me apoyo en el uso del gotoxy, bien mediante la librería de conio, más exactamente la conio2.h:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <conio2.h>

int main(){
 int  i,j,k,l,a;
 for (a=2,l=1;a<19;a++,l+=2*a+2){
   for (k=1;k<=50;k+=2*a) {
     for (i=0;i<=a;i++){
       gotoxy(i+k,0+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(a+k,j+l);
         putchar('*');
       }
       gotoxy(i+a+k,a+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(2*a+k,j+l);
         putchar('*');
       }
     }
   }
 }
 return 0;
}

O bien en la librería de windows.h:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <windows.h>

int gotoxy(int x, int y);

int main(){
 int  i,j,k,l,a;
 for (a=2,l=0;a<20;a++,l+=2*a+2){
   for (k=0;k<=50;k+=2*a) {
     for (i=0;i<=a;i++){
       gotoxy(i+k,0+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(a+k,j+l);
         putchar('*');
       }
       gotoxy(i+a+k,a+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(2*a+k,j+l);
         putchar('*');
       }
     }
   }
 }
 return 0;
}


int gotoxy(int x, int y)
{
  COORD coord;
  HANDLE h_stdout;
  coord.X = x;
  coord.Y = y;
  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
     return 0;
  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
     return 0;
  return 1;
}


No he puesto los ejes por pereza xD.

Esta vez, en vista de que "no cabe" en la página todas las funciones que genero, de 3 a 19 o 20, las metí en un vídeo, ..... tranquilos, dura menos de un minutito:

[youtube=640,360]http://www.youtube.com/watch?v=RM-UJ-lAhWE&feature=youtu.be[/youtube]

¡¡¡¡ Saluditos! ..... !!!!

[amchacon]

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:

Código (cpp) [Seleccionar] Expandir

/** 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:

Código (cpp) [Seleccionar] Expandir

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.