using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace palindrome
{
class palindrome
{
static void Main(string[] args)
{
//Aqui empieza el programa

string pal1 = "", pal2 = "";

string le = "";
int i = 0, tl = 0;
Console.Write("Ingrese una palabra: ");
pal1 = Console.ReadLine();
tl = pal1.Length;
for (i = tl - 1; i >= 0; i--)
{
le = pal1.Substring(i, 1);
pal2 = pal2 + le;
}
Console.Write("\nPalabra invertida : " + pal2);
if (pal1.Equals(pal2))
{
Console.WriteLine("\nComo al invertirlas son iguales por lo tanto es
palindrome");
}
else
{
Console.WriteLine("\nNo es palindrome");
}

Console.ReadKey();

}
}
}

using System;
using System.Collections.Generic;
using System.Text;
namespace palindrome
{
class Program
{
//variables para derterminar si la palabra es palindrome o no
//son constantes, porque la funcion verificar es de tipo entero
// y retornara un 0 o 1 respectivamente.
const int palindrome = 1;
const int nopalindrome = 0;
static void Main(string[] args)
{
//este es un arreglo de tipo char, que contendra la letra a
introducir
char[] carateres;
//pedimos al usuario que introduzca una palabra
Console.WriteLine("Ingrese una palabra: ");
//asignamos lo que teclea el usuario a la variable "s"
string s = Console.ReadLine();
//instanceamos la var "caracteres" indicando el tamao de el arreglo
//que en este caso es el tamao de la palabra introducida.
carateres = new char[s.Length];
//saber cuantos caracteres tienes nuestra cadena
//esto lo hacemos copiando los caracteres de una subcadena
especificada
//esto lo hace el metodo ToCharArray
carateres = s.ToCharArray(0, s.Length);
//Console.WriteLine(s.Length);

//comparamos si lo que nos regresa la funcin es un 1

//si es as la palabra es palindrome, sino pues no lo es
if (verificar(0, carateres, s.Length) == palindrome)
Console.WriteLine("la palabra es palindrome...");
else
Console.WriteLine("La palabra no es palindrome...");
}
//aqu es donde comparamos las letras de inicio a fin
static int verificar(int pos, char[] palabra, int largo)
{
//primera condicin, si la palabra en su posicin 0 es igual a la
ultima,
//por ejemplo "ojo", verifica si la pos 0 ('o') es igual a la ultima
(3-0-1= 2) que tambin es una 'o'
if (palabra[pos] == palabra[largo - pos - 1])
{
//aqu solo nos indica que si las pos es menor que largo - pos
entra e incrementa pos
//cuando llega al centro de la palabra, nos indica que es un
palindrome
if (pos < largo - pos)
return (verificar(++pos, palabra, largo));
else
return (palindrome);
}
//si no entra al if en donde se comaparan los caracteres
return (nopalindrome);
}
}
}

Este post en respuesta aun comentario en el post de palindrome en C# explicacin. Tengo que
mencionar que cualquier otro da (es decir; un fin de semana o un da que no sea lunes xD) no
hubiera contestado este comentario con un post, solo hubiera dicho, amigo pinsale un poco y
seguro encuentras la respuestas, pero esta vez he llegado al trabajo y como no tengo mucho
que hacer aqu rpido la solucin a su tarea, solo espero que su profesor no vea este post xD.
El comentario lo pueden revisar aqu:

https://mspnor.wordpress.com/2008/08/10/palindrome-en-c-explicacin/#comment-330
Y aqu la mi pequeo programa que espero que funcione y les sirva (lo pongo por partes para
que se entienda):
Main:

static void Main(string[] args)

{
//variables
StringBuilder frase = new StringBuilder();
//Men
Menu:
Menu();
int opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1:
Console.Clear();
goto Leer;
case 2:
Console.Clear();
MostrarFrase(frase);
Console.ReadLine();
goto Menu;
case 3:
Console.Clear();
MostrarTotalLetras(frase);
Console.ReadLine();
goto Menu;
case 4:
Console.Clear();
FraseInvertida(frase);
Console.ReadLine();
goto Menu;
case 5:
Console.Clear();
EsPalindrome(frase);
Console.ReadLine();
goto Menu;
default:
break;
}

Leer:
try
{
Console.WriteLine("Cantidad de Palabras que tendr la frase?");
int totalPalabras = int.Parse(Console.ReadLine());

Repetir:
Console.Clear();
Console.WriteLine("Introduce Frase: ");

string[] frase1 = Console.ReadLine().Split(' ');

for (int i = 0; i < frase1.Length; i++)

{
if (totalPalabras == frase1.Length)
{
if (i == (frase1.Length - 1))
frase.Append(frase1[i]);
else
frase.Append(frase1[i] + " ");
}
else if (totalPalabras < frase1.Length)
{
Console.Clear();
Console.WriteLine("Te excediste en el total de palabras!");
Console.WriteLine("Solo se aceptan {0} palabras para esta frase y
escribiste {1}", totalPalabras, frase1.Length);
Console.WriteLine("Intntalo de nuevo..");
Console.ReadLine();
goto Repetir;
}
else
{
break;
}
}
Console.ReadLine();
goto Menu;
}
catch (Exception ex)
{
Console.Clear();

Console.WriteLine("Debes seleccionar una opcin, escribe un nmero");

Console.ReadLine();
goto Leer;
}
}

Men:

private static void Menu()

{
Console.Clear();
Console.WriteLine("");
Console.WriteLine("1 Ingresar una nueva frase.");
Console.WriteLine("2 Mostrar la frase actual.");
Console.WriteLine("3 Contar la cantidad de letras de la frase actual.");
Console.WriteLine("4 Invertir frase actual.");
Console.WriteLine("5 Es la frase actual un palndromo?");
Console.WriteLine("6 Terminar el programa.");
Console.WriteLine("");
Console.Write("Elige una Opcin: ");
}

Mostrar Totales Letras:

private static void MostrarTotalLetras(StringBuilder frase)

{
Console.WriteLine("El total de letras en la frase es:
{0}",frase.ToString().Length);
}

Frase Invertida:

private static void FraseInvertida(StringBuilder frase)

{
Console.WriteLine("Frase Invertida: {0} ",invertir(frase.ToString()));
}

Funcin Invertir:

private static string invertir(string frase)

{
string invertido = "";
for (int i = frase.Length - 1; i >= 0; i--)

invertido = invertido + frase.Substring(i, 1);

return invertido;
}

Determinar si es Palndromo la frase:

private static void EsPalindrome(StringBuilder frase)

{
string[] palabras = frase.ToString().Split(' ');
if(verificar(0,palabras, palabras.Length) == 1)
Console.WriteLine("la frase es palindrome...");
else if(verificar(0,palabras, palabras.Length) == 3)
Console.WriteLine("Intntalo de nuevo...");
else
Console.WriteLine("La frase no es palindrome...");
}

Funcin Verificar:

public static int verificar(int pos, string[] palabra, int largo)

{
try
{
//primera condicin, si la palabra en su posicin 0 es igual a la ultima,
//por ejemplo "ojo", verifica si la pos 0 ('o') es igual a la ultima (30-1= 2) que tambin es una 'o'
if (palabra[pos] == palabra[largo - pos - 1])
{
//aqu solo nos indica que si las pos es menor que largo - pos entra
e incrementa pos
//cuando llega al centro de la palabra, nos indica que es un
palindrome
if (pos < largo - pos)
return (verificar(++pos, palabra, largo));
else
return (1);
}
//si no entra al if en donde se comaparan los caracteres
return (0);
}
catch (Exception ex)
{

Console.WriteLine("Aun no existe una frase para verificar. Primero debes

ingresar una frase");
return 3;
}
}

Creo que la explicacin esta de ms, ademas se pueden dar una idea de que hace cada funcin o
mtodo si revisan el comentario del otro post.
Aqu pueden descargar el cdigo fuente:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Palindrome
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("\t\t\tPalindrome");
Console.Write("Ingrese una frase: ");
string cadena = Console.ReadLine();
cadena = cadena.Trim();
Palindrome p = new Palindrome(cadena);
Console.WriteLine("La cadena invertida es '" + p.Invertir() + "'");
p.esPalindrome();
Console.WriteLine("La cadena tiene {0} palabras palindromes", p.tienePalindromos());
Console.ReadLine();
}
}
class Palindrome
{

string Texto = "";

public Palindrome(string texto)
{
this.Texto = texto;
}
public string Invertir()
{
string aux = "";
//Recorremos el string en orden inverso
for (int i = Texto.Length - 1; i >= 0; i--)
{
aux += Texto[i];
}
//retornamos la nueva cadena
return aux;
}
public string Invertir(string palabra)
{
string aux = "";
//Recorremos el string en orden inverso
for (int i = palabra.Length - 1; i >= 0; i--)
{
aux += palabra[i];
}
//retornamos la nueva cadena
return aux;
}
public void esPalindrome()
{
if (Texto != Invertir())
{
Console.WriteLine("La frase invertida No es palindrome");
}
else
{
Console.WriteLine("La frase invertida Si es palindrome");
}
}
public int tienePalindromos()
{
int palindromos = 0;
string[] arrayCadena = Texto.Split(' ');

for (int i = 0; i < arrayCadena.Length; i++)

{
string Palabra = Convert.ToString(arrayCadena[i]);
string invertido = Invertir(Palabra);
if (Palabra.Equals(invertido))
{
palindromos++;
}
}
return palindromos;
}
}
}
Fuente(s):Yop!

Comprobar si una palabra es un palndromo en C

Publicado por gorkau

Con este sencillo programa escrito en C podemos comprobar si una palabra es un

palndromo (una palabra que se lee igual tanto del derecho como del revs). Esta
versin la he hecho usando punteros para el acceso a los elementos de la cadena:
#include <stdio.h>
#include <string.h>
int main()
{
char palabra[20];
int i, j;
int palindromo = 1;
printf("Escribe una cadena: ");
fflush(stdout);
gets(palabra);
j=strlen(palabra)-1;
for(i=0; i<strlen(palabra)/2; i++, j--) {
printf("Comprobando %c==%c\n", *(palabra+i), *(palabra+j));
if (*(palabra+i)!=*(palabra+j)) {
palindromo = 0;
break;
}
}
if (palindromo)
printf("\nEs un palndrimo.\n");
else
printf("\nNo es un palndrimo.\n");
return (0);
}

Muchas gracias por todo

Cdigo: [Seleccionar]
// Ejercicio 6.33: Palndromos //

#include <stdio.h>

int pruebaPalindromo(char palabra[], int longitud );

main()
{
int palindromo;
char palabra[20];
int longitud = 0;

printf("Por favor, introduzca una palabra: ");

scanf("%s", palabra);

while(palabra[longitud] != '\0' )
{
longitud++;
}

palindromo = pruebaPalindromo(palabra, longitud - 1 );

printf("\npalindromo %d\n\n",palindromo);

if(palindromo == 1)
printf("\nLa palabra introducida ES un pal%cndromo\n\n", 161);

if(palindromo == 0)
printf("\nLa palabra introducida NO ES un pal%cndromo\n\n", 161);

system("pause");
return 0;
}

int pruebaPalindromo (char palabra[], int longitud )

{
static int letra = 0;

printf("%d\n", letra);

if (palabra[letra] != palabra[longitud-letra] || letra > longitud/2 )

{
printf("Longitud es %d\n", longitud);
printf("La letra es %d\n", letra);
if(letra <= longitud / 2 )
return 1;
else
return 1; // Debera de ser 0, pero puse 1 para ver si an as segua
devolviendo 0//
}

else
{

printf("'%c' es igual a '%c'\n", palabra[letra],palabra[longitud - letra] );

letra++;
pruebaPalindromo(palabra, longitud );

#include
#include
using namespace std;
char cadenaf[50]={0}; int len, n=0;

string chk4palindrosity(int c)
{
if(cadenaf[c] == cadenaf[len-1-c])
{
n++;
if(n == len/2)
return "Si es palindromo!";
return chk4palindrosity(c+1);
}
else
return "No es palindromo";

int main()
{
char cadena[50],*parte;
cout<<"Introduce un palindromo: "; cin.getline(cadena,50,'n');

parte = strtok(cadena," ");

strcat(cadenaf,parte);

//
//

while((parte = strtok(NULL," ")) != NULL) //

strcat(cadenaf,parte);

// quitar espacios del

string

len = strlen(cadenaf);
cout << chk4palindrosity(0);
cin.get();
}

La verdad es que es la funcin es recursiva de puro milagro. Lo que hice fue

transformar el ciclo que checaba que los caracteres fueran iguales en una funcin
en la que se aumenta una variable cada vez que se llama a s misma.
El cdigo ahora es ms eficiente por dos simples razones:
1.

Se detiene y da el resultado a la primera comparacin de caracteres que no

sean iguales. Si el primer y el ltimo caracter no son iguales, no es palndromo y
ya no sigue analizando los dems.

2.

Slo checa la mitad de los caracteres. Si la mitad de los caracteres

corresponden a la configuracin de un palndromo, ya no hay porqu seguir
analizando la otra mitad.
Tal vez una mejor manera de hacerlo sera con una funcin que recibiera el string
a analizar, comparar el primer y ltimo caracter: si no, no es; si si, eliminar el
primer y ltimo caracter y volver a llamar a la funcin. Esto hasta que el numero de
comparaciones ciertas sea igual a la mitad de la longitud inicial del string. Alguien
se anima a hacerlo?

Bueno, seguimos con algunos ejercicios resueltos en

C#. Esta vez implementamos algunos mtodos un poco
ms complejos, pero muy tiles para resolver distintos
problemas. Empezamos desde lo ms sencillo hasta lo
ms complejoAunque no son muy complicados los
ejercicios, te aconsejo que leas primero estos tres:
Arrays en C# (Para que veas bien que es un array)
Ejercicios resueltos de arrays en C# (Primera parte)
Ms ejercicios resueltos de arrays en C# (Segunda parte)
1- Saber si una cadena es palndromo o no.
Una cadena es palndromo si se puede leer igual de
derecha a izquierda que de izquierda a derecha, por ej:
otto, sacas, etc. El mtodo, que en este caso sera
recursivo tendra la siguiente signatura:
public bool EsPalindromo(string s). Vamos a la
implementacin:

Como vemos, es un mtodo muy sencillo haciendo uso de

la recursividad, teniendo en cuenta que una cadena es
palndromo si al quitar los extremos del texto, este sigue
siendo palndromo, y as sucesivamente hasta que quede
de longitud 1, que por supuesto es palndromo. De todas
formas traten de hacerlo iterativo, para que vean como se
extiende un poco ms el cdigo jjeje. Si quieren,
pueden ver un poco ms sobre recursividad aqu.
Invertir un array es algo que puede que hagamos muy
seguido en nuestros programas, a travs del siguiente
mtodo vemos como invertir un array de nmeros
enteros, de tal forma que si nos pasan un array de
enteros con 1,2,3,4,5, este mtodo devuelva 5,4,3,2,1
vamos al cdigo:

Como vemos, lo nico que va a tener este mtodo que

puede no entiendas esnmeros[numeros.Lenght-i-1]. Si
le vamos dando valores a la i a partir de 0, vemos como a
medida que aumenta i, nos movemos un paso antes en el
array numeros. Recuerden tambin que la ultima posicin
de un array es array[array.Lenght-1], que es cuando
la i vale 0.
Buscar un elemento en un array bidimensional (tabla)
Mtodo muy sencillo que nos muestra como movernos
por un array bidimensional buscando si contiene un
elemento dado. Veamos este ejemplo rpidamente:

Vemos como con dos ciclos for nos podemos mover

fcilmente por todas las posiciones de la tabla. El mtodo
retornar true solamente si encuentra el elemento nen la
tabla. Aclarar que la propiedad GetLenght(int

dimension), nos da el ancho o el alto dependiendo de la

dimensin. 1 es para el alto, y 0 es para el ancho.
Rotar un array
Entenderemos por rotar un array n veces, trasladar el
elemento de la primera posicin n veces a la derecha si
n>0 o a la izquierda si n<0. Por ejemplo, si rotamos 3
veces el array 1,3,2,4,5 devolvera 2,4,5,1,3. Esto se
puede lograr de varias formas, pero proponemos una muy
poco costosa, calculando la posicin del array donde
debera caer el primer elemento del array que se desea
rotar. Bueno, vamos a la prctica, el cdigo es:

Vemos que es un poquito complicado esto de rotar un

array calculando la posicin a partir del resto de n con la

longitud del array, pero si se ponen a analizar linea por

lnea se darn cuenta que no es tan difcil. Haciendo n
%array.Lenght, calculamos la nueva posicin donde
quedara el primer elemento del array. Interesante verdad?
Ya veremos prximamente como armar un diccionario
donde poder agregar y leer datos fcilmente sin necesidad
de buscar por todos sus elementos utilizando mucho este
operador % para el resto. Entonces practiquen con estos
mtodos, hagan modificaciones, busquen otras ideas,
traten de mejorarlos y todo lo que se les ocurra.
Para aprender a programar hay que leer y escribir
cdigo. Si tienen alguna duda, dejen un
comentario. Prximamente estaremos viendo la clase
Matriz con todos sus mtodos y propiedades.
Determinante, multiplicacin escalar, multiplicacin por
otra matriz, suma, resta, etc

PALNDROMO CON RECURSIVIDAD EN C

Minuto Sapiens 12:32

Este divertido programa creado en C nos verifica si una palabra o

frase

es

palndromo

no.

Para

entrar

en

contexto

primero

explicaremos que es palndromo.

Segn Wikipedia la

palabra

"palndromo

viene

del

griego palin

dromein(volver a ir hacia atrs) y hace referencia a una palabra, nmero o

frase que se lee igual hacia adelante que hacia atrs". Por ejemplo:

"Anita lava la tina"

4125214

Para lograr verificar si una palabra cumple con nuestro requisito

lo que vamos a hacer es usar la recursividad.

Estos son los pasos a seguir:

1. Nos vamos a situar en el inicio y en el final de la frase o

nmero. Ejemplo:

*FRASE: "Anita

lava

la

tina";

*TAMAO: 15(no se toma en cuenta el espacio en blanco entre

cada palabra ni el carcter finalizador de cadena);

*INICIO: 0;

*FINAL: TAMAO - 1;

*FRASE[INICIO]: A;

*FRASE[FINAL]: a;
*FUNCION_PALINDROMO(FRASE, INICIO, FINAL - 1);

2. Comparamos los dos caracteres para comprobar si son iguales. Recordad

que en cdigo ASCII no es lo mismo la letra 'A' que la letra 'a'.

SI coinciden
entonces
continuamos
"recorriendo"
nuestro
nmero o frase tanto para adelante como para atrs. Para ir
adelante usamos INICIO + 1, y para ir hacia atrs FINAL - 1, con
esto llamaremos recursivamente a nuestra funcin.
EN CASO CONTRARIO retornar que la frase no es palndromo.

-Pero

entonces

sencillo,

para

cuando
poder

sabremos

hacer

un

si

es

algoritmo

palndromo
recursivo

no?.

tenemos

Es
que

especificar siempre un caso base que nos permitir detener nuestro

algoritmo una vez lleguemos a el de manera recursiva. Para nuestro
caso

haremos

que

el

caso

base

sea

cuando

las

posiciones

sean

iguales o la posicin que va hacia adelante sea mayor que la va

hacia atrs.

No

siendo

ms

aqu

os

compartimos

un

screenshot

del

corriendo, el link de descarga como siempre est al final:

LINK: Palindromo.c
#include <stdio.h>
#include <iostream.h>
int main () {
int j,i;
char frase[50],cadena [50]];
bool temp = false;
printf ("Introduzca una cadena: ");
scanf("%s",&cadena);
for(i=0;i<strlen(cadena);i++) {

j = (strlen(cadena)-1)-i;

programa

frase[i] = cadena[j];

if(frase[i] == cadena[j]) {
temp = true;
}
else {
temp = false;
}
}
if(temp == true) {
cout << "la palabra es palindromo";
}
else {
cout << "La palabra no es palindromo";
}
cout << "\n";
return 0;
}
la logica del programa es sencilla lo que hago es tomar la palabra escrita por el usuario e
invertirla y guardarla en otro array de caracteres para luego hacer la comparacion para ver si
las palabras son identicas de derecha a izquierda y de izquierda a derecho luego en una
variable del tipo bool guardo true si son identicas y false si no lo son pero por algun motivo
que aun desconozco siempre me dice que es palindromo

ltima modificacin: 13 Agosto 2008, 06:22 por darkxxx

CamaleonB
Desconectado
Mensajes: 92

Re: ayuda en codigo de palindromo

Respuesta #1 en: 13 Agosto 2008, 06:01
ahi te lo dejo... La verdad das muchas vueltas para llegar al mismo lugar y
combinas mucho c con c++
Ahi te queda, aunque creo que se puede simplificar mas
Cdigo

Chameleon
Rock's

En lnea

1. #include <iostream>
2. #include <string.h>
3.

4. using namespace std;

5. int main () {
6.

char frase[50],cadena [50] ;

7.
8.

cout << "Introduzca una cadena: ";

9.

cin.get(cadena,50);

10.
11.

for(int i=strlen(cadena)-1;i>=0;i--) {

12.
13.

frase[strlen(cadena)-1-i] = cadena[i];
}

14. if(*frase == *cadena) {

15.

cout << "la palabra es palindromo\n";

16. }
17. else {
18.

cout << "La palabra no es palindromo\n";

19. }
20.
21. }
22.

return 0;