¡Buenas!

Estaba corrigiendo el código para que tuviese en cuenta los espacios y las eñes, y la parte de los espacios va sobre ruedas, pero por lo menos en Debian no reconoce las eñes, ni introduciendolas como caracteres ni introduciendo sus valores, ni con signo ni sin signo...

¿Alguien puede confirmarmelo?

#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
char mayus(char c)
{
    if(c == 'ñ')
        return 'Ñ';
 
    return toupper(c);
}
 
int palindromo(char *s)
{
    int ini = 0 , fin = strlen(s) - 1;
 
    while(ini < fin)
    {
        while(isspace(s[ini]) && s[ini])
            ini++;
 
        while(isspace(s[fin]) && fin > 0)
            fin--;
 
        if(ini < fin && mayus(s[ini]) != mayus(s[fin]))
            return 0;
 
        ini++;
        fin--;
    }
 
    return 1;
}
 
int main ()
{
    char text[100]="dabale\n \t Arroz a      la zorra el abad";
    char texto[100]="   aMa \n ña ÑamA";
    int i=0;
 
    printf("%d %d\n", (unsigned char)'ñ' , (unsigned char) 'Ñ');
 
    printf("%s",text);
    for(;text[i]==text[strlen(text)-i-1] && strlen(text)/2>i++;);
 
    printf (i>strlen(text)/2 ? "\n Es un palindromo ": "\n No es un palindromo ");
    printf(palindromo(text) ? "\n Es un palindromo ": "\n No es un palindromo ");
    printf(palindromo(texto) ? "\n Es un palindromo ": "\n No es un palindromo ");
 
    return 0;
}
 

¡Saludos!
________________________________________________________________________________________________________

PD: Cambiando la condición isspace por !isalnum ignoraréis cualguier cosa que no sea un caracter o un número (incluida la ñ...). Por ejemplo:

#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
int mayus(int c)
{
    if(c == 'ñ')
        return 'Ñ';
 
    return toupper(c);
}
 
int palindromo(char *s)
{
    int ini = 0 , fin = strlen(s) - 1;
 
    while(ini < fin)
    {
        while(!isalnum(s[ini]) && s[ini++]);
 
        while(!isalnum(s[fin]) && fin-- > 0);
 
        if(ini < fin && mayus(s[ini++]) != mayus(s[fin--]))
            return 0;
    }
 
    return 1;
}
 
int main ()
{
    char texto[100]="a man, \n a p\tlan, a canal, panama";
    int i;
 
    printf("%s",texto);
 
    for(;texto[i]==texto[strlen(texto)-i-1] && strlen(texto)/2>i++;);
 
    printf (i>strlen(texto)/2 ? "\n Es un palindromo ": "\n No es un palindromo ");
    printf(palindromo(texto) ? "\n Es un palindromo ": "\n No es un palindromo ");
 
    return 0;
}
 

Lo de la ñ debe ser porque lo considera un caracter multibyte..., ahora investigo un poco mas.

Con la última modificación ha quedado un poco mas compacto pero un poco menos legible XD.

¡Saludos!
________________________________________________________________________________________________________

sizeof('ñ') en Debian, me está diciendo que son 4 bytes...

Una razón para no cambiar de movil: ¡El mío aún funciona!!

Bueno, pues yo te diré que gnome 3 es una maravilla, que lo tienes todo a mano con un solo golpe de raton una vez que lo hayas configurado un poco, y que con el no echaras para nada de menos el escritorio tradicional. De todas formas busca tu entre todo lo que hay y quédate con lo que mas te guste. Nosotros te podemos decir lo que nos gusta, y ya ves que son opiniones muy distintas, pero no podemos decirte lo que te tiene que gustar a ti. Decide por ti mismo.

¡Saludos!

PD: No solo existen gnome o kde. Entre otros, también tienes, xfce, lmde, mate, cinnamon, enlightenment, openbox, etoilé... y un montón mas de entornos de escritorio. ¡¡¡Colecciónalos todos!!! XD

Otra forma mas. Esta considerando la pantalla una matriz de 20X80 caracteres y dibujando así sobre la matriz el rombo.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_FILAS 20
#define MAX_COLUMNAS 80
 
void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas)
{
    int i;
 
    for(i = 0 ; i < n_filas ; i++)
        pantalla[i][abs(n_filas / 2 - i)] = pantalla[i][n_filas - abs(n_filas / 2 - i) - 1] = '*';
}
 
void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna)
{
    if(pantalla[fila][columna] == '*' || fila < 0 || fila >= MAX_FILAS || columna < 0 || columna >= MAX_COLUMNAS)
        return;
 
    pantalla[fila][columna] = '*';
 
    rellenar(pantalla, fila - 1, columna);
    rellenar(pantalla, fila + 1, columna);
    rellenar(pantalla, fila, columna - 1);
    rellenar(pantalla, fila, columna + 1);
}
 
void imprimir(char pantalla[][MAX_COLUMNAS])
{
    int i;
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}
 
void rombo_2(int n_filas)
{
    char pantalla[MAX_FILAS][MAX_COLUMNAS];
    int i;
 
    if(!(n_filas & 1))
        return;
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        memset(pantalla[i],' ',MAX_COLUMNAS);
 
    dibujar_borde(pantalla,n_filas);
    rellenar(pantalla , n_filas / 2 , n_filas / 2);
    imprimir(pantalla);
}
 
int main(int argc, char *argv[])
{
    rombo_2(11);
 
    return 0;
}
 

No es tan corta como las otras pero bueno, primero dibuja el perimetro y luego rellena el interior. Si rellenais el exterior tendreis el dibujo en "negativo".

¡Saludos!

Y ahora complicandolo un poco mas:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_FILAS 20
#define MAX_COLUMNAS 80
 
int correcto(int fila,int columna)
{
    return fila >= 0 && fila < MAX_FILAS && columna >=0 && columna < MAX_COLUMNAS;
}
 
void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas , int fila_centro, int columna_centro)
{
    int i;
 
    for(i = 0 ; i < n_filas ; i++)
    {
        if(correcto(fila_centro - n_filas / 2 + i , columna_centro - n_filas / 2 + abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro - n_filas / 2 + abs(n_filas / 2 - i)] = '*';
 
        if(correcto(fila_centro - n_filas / 2 + i , columna_centro + n_filas / 2 - abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro + n_filas / 2 - abs(n_filas / 2 - i)] = '*';
    }
}
 
void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna)
{
    if(pantalla[fila][columna] == '*' || fila < 0 || fila >= MAX_FILAS || columna < 0 || columna > MAX_COLUMNAS)
        return;
 
    pantalla[fila][columna] = '*';
 
    rellenar(pantalla, fila - 1, columna);
    rellenar(pantalla, fila + 1, columna);
    rellenar(pantalla, fila, columna - 1);
    rellenar(pantalla, fila, columna + 1);
}
 
void imprimir(char pantalla[][MAX_COLUMNAS])
{
    int i;
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}
 
void rombo_3(char pantalla[][MAX_COLUMNAS], int n_filas, int fila_centro, int columna_centro)
{
    int i;
 
    if(!(n_filas & 1))
        return;
 
    dibujar_borde(pantalla , n_filas, fila_centro , columna_centro);
    rellenar(pantalla , fila_centro, columna_centro);
}
 
int main(int argc, char *argv[])
{
    char pantalla[MAX_FILAS][MAX_COLUMNAS];
    int i;
    char cad[] = "QUEDA BONITO";
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        memset(pantalla[i],' ',MAX_COLUMNAS);
 
    rombo_3(pantalla, 11 , 10, 11/2);
    rombo_3(pantalla, 17 , 10 , 11 + 17/2);
    rombo_3(pantalla, 19 , 10 , 28 + 19 / 2);
 
    for(i = 0 ; cad[i] ; i++)
        pantalla[5 + i][50] = cad[i];
 
    imprimir(pantalla);
}
 

¡Saludos!

Y en esta tercera versión, podéis jugar con los caracteres que forman el borde y los rellenos.

 
 
int correcto(int fila,int columna)
{
    return fila >= 0 && fila < MAX_FILAS && columna >=0 && columna < MAX_COLUMNAS;
}
 
void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas , int fila_centro, int columna_centro,char ch)
{
    int i;
 
    for(i = 0 ; i < n_filas ; i++)
    {
        if(correcto(fila_centro - n_filas / 2 + i , columna_centro - n_filas / 2 + abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro - n_filas / 2 + abs(n_filas / 2 - i)] = ch;
 
        if(correcto(fila_centro - n_filas / 2 + i , columna_centro + n_filas / 2 - abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro + n_filas / 2 - abs(n_filas / 2 - i)] = ch;
    }
}
 
void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna, char relleno)
{
    char actual;
 
    if(!correcto(fila,columna))
        return;
 
    actual = pantalla[fila][columna];
 
    if(relleno == actual)
        return;
 
    pantalla[fila][columna] = relleno;
 
    if(correcto(fila - 1,columna) && actual == pantalla[fila - 1][columna])
        rellenar(pantalla, fila - 1, columna,relleno);
 
    if(correcto(fila + 1,columna) && actual == pantalla[fila + 1][columna])
        rellenar(pantalla, fila + 1, columna,relleno);
 
    if(correcto(fila,columna + 1) && actual == pantalla[fila][columna + 1])
        rellenar(pantalla, fila, columna + 1,relleno);
 
    if(correcto(fila,columna - 1) && actual == pantalla[fila][columna - 1])
        rellenar(pantalla, fila, columna - 1,relleno);
 
    pantalla[fila][columna] = relleno;
}
 
void imprimir(char pantalla[][MAX_COLUMNAS])
{
    int i;
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}
 
int main(int argc, char *argv[])
{
    char pantalla[MAX_FILAS][MAX_COLUMNAS];
    int i;
    char cad[] = "QUEDA BONITO",interior = '*', exterior = ' ';
 
    for(i = 0 ; i < MAX_FILAS ; i++)
        memset(pantalla[i],' ',MAX_COLUMNAS);
 
    dibujar_borde(pantalla, 11 , 10, 11/2 , interior);
    rellenar(pantalla,10,11/2,interior);
 
    dibujar_borde(pantalla, 17 , 10, 10 + 17/2, interior);
    rellenar(pantalla, 10 , 10 + 17 / 2, interior);
 
    dibujar_borde(pantalla, 11 , 10, 26 + 11 / 2, interior);
    rellenar(pantalla, 10 , 26 + 11 / 2 , interior);
 
    rellenar(pantalla,0,0,exterior);
 
    for(i = 0 ; cad[i] ; i++)
        pantalla[5 + i][50] = cad[i];
 
    imprimir(pantalla);
 
    return 0;
}
 

¡Saludos de nuevo!

¡Buenas!

Como aun no había ninguna solución recursiva, aquí os dejo una 

#include <stdio.h>
#include <stdio.h>
#include <string.h>
 
/* n == numero total de filas del rombo (no puede ser par) y el segundo parametro siempre es cero:
   ejemplos: rombo(3,0);
             rombo(11,0);
*/
void rombo(int n,int paso)
{
    char *str = malloc(n / 2 + paso + 4);
 
    if(!(n & 1))
        return;
 
    memset(str,' ',n / 2 - paso + 1);
    memset(str + n / 2 - paso + 1 , '*' , 2 * paso + 1);
    memcpy(str + n / 2 + paso + 2 ,"\n\0",2);
 
    printf("%s",str);
 
    if(paso == n / 2)
    {
        free(str);
        return;
    }
 
    rombo(n,paso+1);
 
    printf("%s",str);
 
    free(str);
}
 
int main(int argc, char *argv[])
{
    rombo(5,0);
    rombo(4,0);
    return 0;
}
 

Sobre la antigüedad, ni idea, nunca los he usado ni los conozco. Y manuales de estilo tampoco ni idea. Aplica sentido comun. Indenta los bloques de codigo, los cuerpos de los bucles, cuerpos de las funciones, los campos de los struct o miembros de clases... da nombres coherentes a las variables y funciones. Vamos, que mas que llamarlo estilo se debería de llamar sentido comun para que tu código se pueda leer y entender tanto por ti como por otros.

¡Saludos!

XD

Mira, haz este experimento:

string cad;
int n;
 
cin >> n;
 
getline(cin, cad);
 
cout << n << endl;
 
cout << cad;
 

Y cuando toque leer datos escribes un numero y una cadena con lo que se te ocurra.

Veras que te lee el número y luego la cadena. Es decir, después de leer el numero no descarta el resto de la linea que introduzcas, sino que solo descarta el número leído así que después de leer el numero no se quedará esperando a que introduzcas alguna cosa y pulses intro, sino que terminará de leer lo que había, que es lo que pasa en tu programa.

Lo mismo pasaría si utilizases cin para leer una cadena. Solo leería hasta el primer caracter en blanco (un espacio, un tabulador...) y dejaría el resto (esto creo que puedes modificarlo especificando otro delimitador para que cin termine de leer...).

Así que cuando utilices cin, acuérdate siempre de terminar de leer lo que pueda quedar en el flujo de entrada. Como ya sabes que la entrada termina con un \n, lo unico que tienes que hacer es while(cint.get() != '\n');

¡Saludos!

man gzip y para los tar: man tar

Dudo bastante de que esa distribución no tenga esas herramientas.

¡Saludos!

  puntero_db no era un dato de tipo puntero (a no se que DB sea un typedef de un puntero de algun tipo de dato), asi que para acceder a la función de puntero_db no puedes utilizar el operador flecha, tienes que utilizar el operador punto.

¡Saludos!

¡Buenas!

Tu no tienes un problema con GNU-Linux. El  problema lo tienes con la programación. Y el error te lo describe muy bien el compilador:
abrir_db2.c:37:5: error: expected identifier or ‘(’ before ‘->’ token

Eso mismo. Se espera un identificador antes de '->', y no miente, has puesto un tipo de dato, no el identificador de una variable.

Lee bien los mensajes de error.

¡Saludos!