[C] creare scritta di asterischi

**unomichisiada** · 01-02-2005, 13:22

Originariamente inviato da maiosyet_2
Ok, io programmo da poco, però a occhio e croce non mi sembra così complesso

Basta prendere in input la parola "ciao" e confrontare carattare per carattere con un bello switch ogni lettera, che verrà associata a una cosa del tipo:

codice:

switch(lett) {
		 
		 case 'a': printf ("********\n");
	                   printf ("*      *\n");
		           printf ("*      *\n");
		           printf ("********\n");
		           printf ("*      *\n");
		           printf ("*      *\n");
		           break;

No?

Ti credevi più furbo eh?

No scherzo,è fattibile ma come dice Lele richiede un lavoraccio,non la puoi liquidare semplicemente come volevii fare tu.

**maiosyet_2** · 01-02-2005, 16:31

Originariamente inviato da LeleFT
...
Se tu noti, alla fine di ciascuna riga che compone una lettera, tu hai aggiungo un carattere " \n ": questo riporta a capo la riga dopo la sua stampa... come ci appiccichi le altre lettere dopo, se sei appena tornato a capo?

Acc...hai ragione

In Linux esiste un programma chiamato figlet che fa più o meno quello che vuole... cioè

codice:

[maiosyet]@[alcibiade]-[~] $ figlet r0x
       ___
 _ __ / _ \__  __
| '__| | | \ \/ /
| |  | |_| |>  <
|_|   \___//_/\_\

[maiosyet]@[alcibiade]-[~] $

Però il source è decisamente incasinato

Buona fortuna...

**netarrow** · 01-02-2005, 17:35

se ogni lettera è formata da 5 asterischi di altezza e mettiamo 4 di larghezza, si potrebbe fare un array di stringhe per ogni lettera, ogni elemento rappresenta la riga sempre + bassa, esempio:

codice:

char* C[5] {
"****",
"*   ",
"*   ",
"*   ",    
"****"  
};

Quindi se abbiamo ciao scriveremo:

codice:

C[0] I[0] A[0] 0[0].
C[1] I[1] A[1] O[1]
ecc...

Non sarà veloce da preparare, ma dopo il codice va riutilizzato; non ho considerato gli intoppi, ovviamente nel caso ne troviate uno fatemi notare

**cso** · 01-02-2005, 18:58

Io ho pensato a una cosa un po' più facile:

Si prepara uno swith con tutte le lettere ma prima di stampare ogni riga di ogni lettera si mette un GoTOXY con un valore intero sommato a una variabile che aumenta di un valore specifico per ogni lettera inserita tipo:

GotoXY(1+i,1);
printf ("********");
GotoXY(1+i,2);
printf ("* *");

ecc...

alla prossima lettura del char si aumenta i di 10 (in modo da non sovrapporre la prossima stampa a video) e poi ancora...

**netarrow** · 01-02-2005, 19:38

Originariamente inviato da cso
...
Si prepara uno swith con tutte le lettere
...

è questo il lavoraccio di base

VVoVe:

Altro problema è che una funzione gotoXY non esiste nell'ANSI, quindi o si limita il funzionamento per una OS/compilatore solo o si fa una funzione di un livello più astratta con qualche direttiva, cosa neanche tanto complicata del resto.

**cso** · 01-02-2005, 19:50

Originariamente inviato da netarrow
è questo il lavoraccio di base

VVoVe:

Altro problema è che una funzione gotoXY non esiste nell'ANSI, quindi o si limita il funzionamento per una OS/compilatore solo o si fa una funzione di un livello più astratta con qualche direttiva, cosa neanche tanto complicata del resto.

Coma la fai tragica

Ha chiesto una cosa difficile e non si può aspettare una risoluzione facile (non vale per tutto ma in questo caso) o veloce da fare.

**LeleFT** · 01-02-2005, 22:36

L'ho realizzato! Non mi passava niente e l'ho fatto:

codice:

#include <stdio.h>

/* Questa funzione costruisce il singolo array di asterischi in base a 5 parametri
 * array --> l'array di asterischi che conterrà gli asterischi da stampare
 * lettera --> la lettera che si sta esaminando
 * posY --> Quale parte della lettera sto costruendo
 * posX --> A quale posizione nell'array di asterischi sono arrivato
 * ultima --> valore che indica se è l'ultima lettera o meno 
 */
void costruisci(char **array, char lettera, int posY, int posX, int ultima);  /* Implementata dopo */

int main(int argc, char **argv) {

   char **prima;
   char **seconda;
   char **terza;
   char **quarta;
   char **quinta;
   int i = 0, j = 0;
   int len = 0;
   
   if (argc != 2) {
      printf("Introdurre un parametro da visualizzare!\n\n");
      exit(1);
   }

   prima = (char **) malloc(strlen(argv[1]) * sizeof(char*));
   seconda = (char **) malloc(strlen(argv[1]) * sizeof(char*));
   terza = (char **) malloc(strlen(argv[1]) * sizeof(char*));
   quarta = (char **) malloc(strlen(argv[1]) * sizeof(char*));
   quinta = (char **) malloc(strlen(argv[1]) * sizeof(char*));
   
   len = strlen(argv[1]);
   
   for (i=0; i<len; i++) {
      costruisci(prima, (char) argv[1][i], 0, i, !(len-i-1));
      costruisci(seconda, (char) argv[1][i], 1, i, !(len-i-1));
      costruisci(terza, (char) argv[1][i], 2, i, !(len-i-1));
      costruisci(quarta, (char) argv[1][i], 3, i, !(len-i-1));
      costruisci(quinta, (char) argv[1][i], 4, i, !(len-i-1));
   }

   printf("  ");
   for (i=0; i<len; i++) {
      printf("%s  ", prima[i]);
   }
   for (i=0; i<len; i++) {
      printf("%s  ", seconda[i]);
   }
   for (i=0; i<len; i++) {
      printf("%s  ", terza[i]);
   }
   for (i=0; i<len; i++) {
      printf("%s  ", quarta[i]);
   }
   for (i=0; i<len; i++) {
      printf("%s  ", quinta[i]);
   }
   
   return 0;
}

void costruisci(char **array, char lettera, int posY, int posX, int ultima) {
   array[posX] = (char*) malloc(7 * sizeof(char));
   switch (lettera & 223) {  /* Considero ciascuna lettera come MAIUSCOLA */
      case 'A':
         switch (posY) {
            case 0:
            case 2:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 3:
            case 4:
               strcpy(array[posX], "*   *");
               break;
         }
         break;
      case 'B':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "**** ");
               break;
            case 1:
            case 3:
               strcpy(array[posX], "*   *");
               break;
            case 2:
               strcpy(array[posX], "*****");
               break;
         }
         break;
      case 'C':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 2:
            case 3:
               strcpy(array[posX], "*    ");
               break;
         }
         break;
      case 'D':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "**** ");
               break;
            case 1:
            case 2:
            case 3:
               strcpy(array[posX], "*   *");
               break;
         }
         break;
      case 'E':
         switch (posY) {
            case 0:
            case 2:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 3:
               strcpy(array[posX], "*    ");
               break;
         }
         break;
      case 'F':
         switch (posY) {
            case 0:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 3:
            case 4:
               strcpy(array[posX], "*    ");
               break;
            case 2:
               strcpy(array[posX], "***  ");
               break;
         }
         break;
      case 'G':
         switch (posY) {
            case 0:
            case 2:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "*    ");
               break;
            case 3:
               strcpy(array[posX], "*   *");
               break;
         }
         break;
      case 'H':
         switch (posY) {
            case 0:
            case 1:
            case 3:
            case 4:
               strcpy(array[posX], "*   *");
               break;
            case 2:
               strcpy(array[posX], "*****");
               break;
         }
         break;
      case 'I':
         switch (posY) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
               strcpy(array[posX], "  *  ");
               break;
         }
         break;
      case 'J':
         switch (posY) {
            case 0:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "  *  ");
               break;
            case 2:
            case 3:
               strcpy(array[posX], "* *  ");
               break;
            case 4:
               strcpy(array[posX], "***  ");
               break;
         }
         break;
      case 'K':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*   *");
               break;
            case 1:
            case 3:
               strcpy(array[posX], "*  * ");
               break;
            case 2:
               strcpy(array[posX], "***  ");
               break;
         }
         break;
      case 'L':
         switch (posY) {
            case 0:
            case 1:
            case 2:
            case 3:
               strcpy(array[posX], "*    ");
               break;
            case 4:
               strcpy(array[posX], "*****");
               break;
         }
         break;
      case 'M':
         switch (posY) {
            case 0:
            case 3:
            case 4:
               strcpy(array[posX], "*   *");
               break;
            case 1:
               strcpy(array[posX], "** **");
               break;
            case 2:
               strcpy(array[posX], "* * *");
               break;
         }
         break;
      case 'N':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*   *");
               break;
            case 1:
               strcpy(array[posX], "**  *");
               break;
            case 2:
               strcpy(array[posX], "* * *");
               break;
            case 3:
               strcpy(array[posX], "*  **");
               break;
         }
         break;
      case 'O':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 2:
            case 3:
               strcpy(array[posX], "*   *");
               break;
         }
         break;
      case 'P':
         switch (posY) {
            case 0:
            case 2:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "*   *");
               break;
            case 3:
            case 4:
               strcpy(array[posX], "*    ");
               break;
         }
         break;
      case 'Q':
         switch (posY) {
            case 0:
               strcpy(array[posX], "**** ");
               break;
            case 1:
            case 2:
               strcpy(array[posX], "*  * ");
               break;
            case 3:
               strcpy(array[posX], "* ** ");
               break;
            case 4:
               strcpy(array[posX], "*****");
               break;
         }
         break;
      case 'R':
         switch (posY) {
            case 0:
            case 2:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "*   *");
               break;
            case 3:
               strcpy(array[posX], "*  * ");
               break;
            case 4:
               strcpy(array[posX], "*   *");
               break;
         }
         break;
      case 'S':
         switch (posY) {
            case 0:
            case 2:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "*    ");
               break;
            case 3:
               strcpy(array[posX], "    *");
               break;
         }
         break;
      case 'T':
         switch (posY) {
            case 0:
               strcpy(array[posX], "*****");
               break;
            case 1:
            case 2:
            case 3:
            case 4:
               strcpy(array[posX], "  *  ");
               break;
         }
         break;
      case 'U':
         switch (posY) {
            case 0:
            case 1:
            case 2:
            case 3:
               strcpy(array[posX], "*   *");
               break;
            case 4:
               strcpy(array[posX], "*****");
               break;
         }
         break;
      case 'V':
         switch (posY) {
            case 0:
            case 1:
            case 2:
               strcpy(array[posX], "*   *");
               break;
            case 3:
               strcpy(array[posX], " * * ");
               break;
            case 4:
               strcpy(array[posX], "  *  ");
               break;
         }
         break;
      case 'W':
         switch (posY) {
            case 0:
            case 1:
               strcpy(array[posX], "*   *");
               break;
            case 2:
            case 3:
               strcpy(array[posX], "* * *");
               break;
            case 4:
               strcpy(array[posX], " * * ");
               break;
         }
         break;
      case 'X':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*   *");
               break;
            case 1:
            case 3:
               strcpy(array[posX], " * * ");
               break;
            case 2:
               strcpy(array[posX], "  *  ");
               break;
         }
         break;
      case 'Y':
         switch (posY) {
            case 0:
               strcpy(array[posX], "*   *");
               break;
            case 1:
               strcpy(array[posX], " * * ");
               break;
            case 2:
            case 3:
            case 4:
               strcpy(array[posX], "  *  ");
               break;
         }
         break;
      case 'Z':
         switch (posY) {
            case 0:
            case 4:
               strcpy(array[posX], "*****");
               break;
            case 1:
               strcpy(array[posX], "   * ");
               break;
            case 2:
               strcpy(array[posX], "  *  ");
               break;
            case 3:
               strcpy(array[posX], " *   ");
               break;
         }
         break;
   }
   if (ultima) {
      array[posX][5] = '\n';
   }
}

Prende in considerazione solo parole senza spazi!

Ciao.

**netarrow** · 01-02-2005, 22:50

codice:

 *****  *****  *****    *    *   *  *****
 *   *    *      *      *    ** **  *   *
 *   *    *      *      *    * * *  *   *
 *   *    *      *      *    *   *  *   *
 *****    *      *      *    *   *  *****

 *      *****  *   *  *****  *****  *****
 *      *   *  *   *  *   *  *   *  *   *
 *      *****  *   *  *   *  *****  *   *
 *      *   *   * *   *   *  *  *   *   *
 *****  *   *    *    *****  *   *  *****

 *      *****  *      *****  *****  *****
 *      *      *      *      *        *
 *      *****  *      *****  ***      *
 *      *      *      *      *        *
 *****  *****  *****  *****  *        *

**LeleFT** · 01-02-2005, 22:51

Grazie!

Ciao.

**LeleFT** · 02-02-2005, 13:26

Ho modificato un po' il codice, così risulta più snello e in più ho aggiunto la caratteristica di poter stampare anche le frasi composte da più di una parola (quindi accetta anche gli spazi).
Il nuovo main è questo:

codice:

int main(int argc, char **argv) {

   char ***matrice;
   int i = 0, j = 0, h = 0, k = 0;
   int len = 0, lenWord = 0;
   
   if (argc < 2) {
      printf("Introdurre un parametro da visualizzare!\n\n");
      exit(1);
   }

   matrice = (char***) malloc(5 * sizeof(char**));

   for (h=0; h<argc-1; h++) {
      lenWord += strlen(argv[h+1]);
      if (h < (argc-2)) {
         lenWord++;
      }
   }
   for (j=0; j<5; j++) {
      matrice[j] = (char**) malloc(lenWord * sizeof(char*));
   }
   
   
   for (j=0; j<5; j++) {
      for (h=0; h<argc-1; h++) {
         len = strlen(argv[h+1]);
         for (i=0; i<len; i++) {
            costruisci(matrice[j], ((char) argv[h+1][i]) & 223, j, k, !((len-i-1) || (argc-h-2)));
            k++;
         }
         if (h < (argc-2)) costruisci(matrice[j], ' ', j, k++, 0);
      }
      k = 0;
   }

   printf("  ");
   for (j=0; j<5; j++) {
      for (i=0; i<lenWord; i++) {
         printf("%s  ", matrice[j][i]);
      }
   }
   
   return 0;
}

Se notate ho spostato la trasformazione da carattere minuscolo a maiuscolo nel main, così da evitare la trasformazione all'interno della funzione: questo perchè, la trasformazione bit a bit mi trasformerebbe anche lo spazio... si poteva ovviare in altro modo, ma ho preferito questo modo, più rapido.

E', inoltre, sufficiente aggiungere un case per accettare il carattere SPAZIO, alla funzione che crea i caratteri:

codice:

      /* Nella funzione costruisci() */
      ...
      case ' ':
         strcpy(array[posX], "     ");
         break;

Poi, ho notato che avevo inserito uno switch per niente nella costruzione della lettera I. Eccolo modificato:

codice:

      case 'I':
         strcpy(array[posX], "  *  ");
         break;

Ciao.

Discussione: [C] creare scritta di asterischi

Strumenti discussione

Ricerca discussione

Visualizza

Permessi di invio