Xwork's Blog

La última vez que vimos un post sobre programación, vimos la conjetura de los números palíndrómicos e hicimos un programa en C# para windows. Hoy y cómo en ocasiones anteriores, vamos a ver cómo hacer una versión para android.

El código en java que hace funcionar las cosas es el siguiente:

package com.mdev.numerospalindromos;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;
import java.lang.String;
import java.math.BigInteger;
import android.widget.ArrayAdapter;
import java.util.ArrayList;
public class MainActivity extends Activity {
	Button BtnCalculate;
	TextView TxtNumberIn;
	TextView TxtIterations;
	ListView LVResultados;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		BtnCalculate = (Button)findViewById(R.id.BtnCalculate);
		TxtNumberIn = (TextView)findViewById(R.id.TXTNumberIn);
		TxtIterations = (TextView)findViewById(R.id.TxtIterations);
		LVResultados = (ListView)findViewById(R.id.LVResults);
		BtnCalculate.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				GetNumber(TxtNumberIn.getText().toString(), Integer.parseInt(TxtIterations.getText().toString()));
			}
		});
	}
	private boolean IsPalindrome(String Number)
	{
		String Value = ReverseNumber(Number);
		if (Number.equals(Value))
			return true;
		else
			return false;
	}
	private String ReverseNumber(String NumberIn)
	{
		char[] charArray = NumberIn.toCharArray();
		char[] OutArray = new char[charArray.length];
		for (int i = charArray.length-1; i >= 0 ; i--){
			OutArray[charArray.length - 1 - i] = charArray[i];
		}
		return new String(OutArray);
	}
	private void GetNumber(String Number1, Integer MaxIterations)
	{
		ArrayList Items = new ArrayList();
		int Iterator = 1;
		if (IsPalindrome(Number1))
		{
			Items.add("0 iteraciones " + Number1 + " cumple la conjetura");
		}
		else
		{
			BigInteger Result = new BigInteger(Number1);

			while (!IsPalindrome(Result.toString()))
			{
				BigInteger NewNumber = new BigInteger(ReverseNumber(Result.toString()));
				Result = Result.add(NewNumber);
				if (Iterator >= MaxIterations)
				{
					break;
				}
				Iterator += 1;
				Items.add(Iterator + " iteraciones " + Result);
			}

			if (IsPalindrome(Result.toString()))
				Items.add("La conjetura se cumple");
			else
				Items.add("La conjetura no se cumple.");
		}
		final ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1,Items);
		LVResultados.setAdapter(adapter);
	}
}

El código consta de 3 funciones. La primera de ellas en orden de aparición, es: IsPalindrome y aunque su nombre lo diga o lo haga parecer, esta función no es la encargada de hacer los cálculos. La función simplemente comprueba que el valor que se pasa cómo parámetro, cumpla con la condición: "es igual si se lee al derecho que al revés", usando la función "ReverseNumber". Si la condición se cumple, la función regresa un valor booleano "true" en caso contrario regresa "false".

La función "ReverseNumber", sirve para invertir el orden de los dígitos de un número, es decir; el primer número pasa a ser el último y viceversa. hay que recordar que la conjetura nos dice que se debe de obtener un palíndromo si se suma un número que sea el mismo número pero invertido. Esta función recibe un parámetro del tipo "String" que representa el número que queremos invertir. La función usa dos "Arrays" que contienen los dígitos almacenados como caracteres, por lo que "2" es algo totalmente diferente a 2, el parámetro de entrada, es el primero en separarse, con eso obtenemos el tamaño que tendrá el otro "Array" y lo asignamos al momento de crearlo. Para formar el valor de salida, simplemente recorremos en orden inverso el "Array" que contiene los digitos del valor de entrada. La función regresa un valor del tipo "String" que representa el parámetro  de entrada en orden inverso.

Finalmente el procedimiento que se encarga de comprobar la conjetura es "GetNumber". Este procedimiento hace todos los pasos.  El procedimiento recibe dos parámetros, el primero del tipo "String", es el número al cual le queremos aplica la conjetura, el segundo, es in valor del tipo "Integer" que contiene el valor máximo de la iteraciones. Antes de si quiera empezar con los cálculos, comprobamos que el valor que se ingresa  cumpla la conjetura, si lo hace, simplemente informamos que el  número es palíndromo y terminamos el procedimiento. En  caso contrario, empezamos convirtiendo el valor de "String " a "BigInteger". Luego iniciamos un bucle "while" en el cual haremos uso de la función "IsPalindrome" mientras está sea falsa  o mientras el valor de la variable "Iterator" sea menor que  el parámetro "MaxIterations". Cuando cualquiera de las condiciones es verdadera, salimos del bucle; si salimos debido a que la función "IsPalindrome" resulta verdadera,  mostramos un mensaje indicando que el número cumplió con la conjetura; pero si la salida del bucle se debe a que el número de iteraciones alcanzo el máximo indicado por el usuario, mostramos un  mensaje que la conjetura no se cumplió. En este caso, que un número no cumpla la conjetura en X numero de iteraciones, no quieres decir que por ello este exento, algunas veces bastará con aumentar el número de iteraciones.

Y bien, por ahora es todo, al igual que las otra aplicaciones, el código fuente pronto la publicaré en la sección de descargas, el APK ya compilado, lo puedes descargar de mi dropbox.

Antes de terminar, debo aclarar que la aplicación aun no es a prueba de errores, y peor aun, no es a prueba de si misma. Todo es meramente ilustrativo, porque la aplicación va a hacer lo que el usuario le diga y por el momento no es recomendable pasar de las 1000 iteraciones; aunque la mayoría de los numero comprendidos entre 1 y 1000 la cumplen en unos cuantos pasos, puede pasar que haya un número que ni con 20000 iteraciones la cumpla, al hacer 20000 pasos la aplicación demandará memoria y capacidad de procesamiento por lo que las cosas se pueden volver inestables, además como todas las comprobaciones se hacen en el hilo principal, la aplicación se bloqueará hasta que termine (cualquiera de los dos casos, si se cumple o si se llego al limite establecido), en los siguiente post veremos cómo usar "threads" (C# y Java) y cómo manejarlas un poco, para; si por ejemplo; comenzamos un proceso largo, lo podamos detener en cualquier momento (si aun así quieres probar los alcances de tu dispositivo, puedes probar el número 196 con el límite que más gustes, pero quedas advertido que ni con 24000 iteraciones se cumple la conjetura).

Por ahora es todo. Los leo luego.

El código en c# que prueba la conjetura de los números palindrómicos es el siguiente.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Numerics;

namespace NumerosPalindromicos
{
	public partial class FrmMain : Form
	{
		private bool IsPalindrome(string Number)
		{
			if (Number.ToString() == ReverseNumber(Number.ToString()))
				return true;
			else
				return false;

		}
		private string ReverseNumber(string NumberIn)
		{
			char[] charArray = NumberIn.ToCharArray();
			Array.Reverse(charArray);
			return new string(charArray);
		}

		private void GetNumber(string Number1, decimal MaxIterations)
		{
			int Iterator = 1;
			if (IsPalindrome(Number1) == true)
				LBResults.Items.Add("0 iteraciones "+ Number1 +" cumple la conjetura");
			else
			{
				BigInteger Result;
				BigInteger.TryParse(Number1,out Result);
				while (IsPalindrome(Result.ToString()) == false)
				{
					Result += BigInteger.Parse(ReverseNumber(Result.ToString()));
					LBResults.Items.Add(Iterator + " iteraciones "+ Result);
					if (Iterator >= MaxIterations)
					{
						break;
					}
					Iterator += 1;
				}

				if (IsPalindrome(Result.ToString()) == true)
					LBResults.Items.Add("La conjetura se cumple");
				else
					LBResults.Items.Add("La conjetura no se cumple.");
			}

		}
		public FrmMain()
		{
			InitializeComponent();
		}
		private void BtnDo_Click(object sender, EventArgs e)
		{
			LBResults.Items.Clear();
			GetNumber(TxtNumberIn.Text, NUDIterator.Value);
		}
	}
}

El código anterior consta de tres funciones, la primera de ellas (en orden de aparición) es "IsPalindrome". Está función del tipo "boolean" y recibe un parámetro del tipo "string"; se encarga de comprobar si el parámetro que se ingresa cumple con la condición que sea un palíndromo, para eso, simplemente invierte el orden de los número del parámetro de entrada usando la función "ReverseNumber".
La funcion "ReverseNumber, al igual que la funcion "IsPalindrome", recibe un parametro del tipo "string", este lo convierte en una matriz del tipo "char" y luego coloca el primer elemento al final y viceversa, con esto obtenemos el parametro de entrada invertido. La funcion regresa un valor del tipo "string".
Finalmente la función "GetNumber", es la que se encarga de hacer los cálculos. Esta función, recibe dos parámetros, el primero del tipo "string" que es la representación del número al cual queremos comprobar la conjetura. El segundo parámetro, es un valor del tipo "decimal" que se usará para determinar cuantas ciclos deben de hacerse antes de que se diga que la conjetura no se cumple.
En la función, lo primero que hacemos, es comprobar si el número no es ya un palíndromo, si lo es solamente agregamos en la lista de resultados que el número ya es palíndromo y que no se hizo ninguna iteración.
Si no es el caso, creamos una variable del tipo "BigInteger" en la que almacenaremos el resultado de la suma.
Luego creamos el bucle principal, la condición para que este siga activo, es que al llamar a la función "IsPalindrome" esta devuelva false.  Luego a la variable "Result" le sumará el resultado de la función "ReverseNumber", luego agregará el resultado a la lista de resultados  y después comprobará que la iteración actual, este dentro de los limites establecidos en el parámetro "MaxIterations"; si no es así, el bucle se interrumpirá y terminará la prueba de la conjetura declarando que no se cumple en el limite establecido (pero eso no significa que no tenga solución); en caso contrario, se incrementará el valor de la variable "Iterator" en uno y el bucle volvería al inicio.

Con el código anterior, podemos probar que el número 28,121,993 no cumple la conjetura, o no dentro de las primeras mil iteraciones (tampoco en 10,000).
Al código anterior, al igual que a varios de los otros proyectos, le faltan algunas optimizaciones (correrlo en un thread diferente para no bloquear la interfaz principal), pero por ahora sirve para dejar la idea en claro, cómo siempre, el código completo lo puedes descargar de mi dropbox para revisarlo.

Por ahora es todo, los leo luego.