Unit1.cpp

// ---------------------------------------------------------------------------

#include <vcl.h>
#include <cmath>

#pragma hdrstop

#include "Unit1.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

// ---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
}

Cardinal factorial(byte n) {
	Cardinal f;
	if (n == 0) {
		f = 1;
	}
	else {
		f = n * factorial(n - 1);
	}
	return f;
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::factorialn1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("Factorial", "nro", ""));
	Cardinal f = factorial(n);
	ShowMessage(f);
}

// ---------------------------------------------------------------------------

/*
 0 < n < 10
 auxPotencia(2) => 22
 auxPotencia(3) => 333
 auxPotencia(4) => 4444
 */
Cardinal auxPotencia(byte n) {
	return (int)(pow(10, n) - 1) / 9 * n;
}

Cardinal potencia(Cardinal n) {
	Cardinal p;
	if (n < 10) {
		p = auxPotencia(n);
	}
	else {
		p = potencia(n / 10);
		Cardinal d = auxPotencia(n % 10);
		p = p * (int)pow(10, n % 10) + d;
	}
	return p;
}

void __fastcall TForm1::potencian1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Potencia", "nro", ""));
	Cardinal f = potencia(n);
	ShowMessage(f);
}

byte digitoMayorMenor(Cardinal n) {
	byte m;
	if (n < 10) {
		m = n * 11;
	}
	else {
		m = digitoMayorMenor(n / 10);
		byte d = n % 10;
		if (d < m % 10) {
			m = (m / 10) * 10 + d;
		}
		if (d > m / 10) {
			m = d * 10 + m % 10;
		}
	}
	return m;
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::mayorMenorn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("DigitoMayorMenor", "nro", ""));
	byte m = digitoMayorMenor(n);
	ShowMessage(m);
}

// ---------------------------------------------------------------------------

byte cantidadDigitos(Cardinal n) {
	byte c;
	if (n == 0) {
		c = 1;
	}
	else {
		c = (int)log10(10 * n);
	}
	return c;
}

void invertir(Cardinal &n) {
	if (n > 9) {
		Cardinal d = n % 10;
		n /= 10;
		invertir(n);
		n = d * (int)pow(10, cantidadDigitos(n)) + n;
	}
}

void __fastcall TForm1::invertirn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("invertir", "nro", ""));
	invertir(n);
	ShowMessage(n);
}

// ---------------------------------------------------------------------------
void moverMayorFinal(Cardinal &n) {
	if (n > 9) {
		byte d = n % 10;
		n /= 10;
		moverMayorFinal(n);
		if (n % 10 > d) {
			n = (n / 10) * 100 + d * 10 + n % 10;
		}
		else {
			n = n * 10 + d;
		}
	}
}

byte digitoMayor(Cardinal n) {
	byte d;
	if (n < 10) {
		d = n;
	}
	else {
		d = digitoMayor(n / 10);
		if (n % 10 > d) {
			d = n % 10;
		}
	}
	return d;
}

void eliminarDigito(Cardinal &n, byte d, bool &elimino) {
	if (n > 0) {
		byte p = n % 10;
		n /= 10;
		eliminarDigito(n, d, elimino);
		if (elimino) {
			n = n * 10 + p;
		}
		else {
			if (p == d) {
				elimino = true;
			}
			else {
				n = n * 10 + p;
			}
		}
	}
}

byte sumaDigitosBinarios(byte a, byte b) {
	return (a + b) / 2 * 10 + (a + b) % 2;
}

Cardinal sumaBinaria(Cardinal a, Cardinal b, byte c = 0) {
	Cardinal s;
	byte d = sumaDigitosBinarios(a % 10, b % 10);
	d = (d / 10) * 10 + sumaDigitosBinarios(d % 10, c);
	if (a < 2 && b < 2) {
		s = d;
	}
	else {
		s = sumaBinaria(a / 10, b / 10, d / 10);
		s = s * 10 + d % 10;
	}
	return s;
}

void __fastcall TForm1::moverMayorFinal1Click(TObject * Sender) {
	Cardinal n = StrToInt(InputBox("invertir", "nro", ""));
	byte d = digitoMayor(n);
	bool elimino = false;
	eliminarDigito(n, d, elimino);
	n = n * 10 + d;
	// moverMayorFinal(n);
	ShowMessage(n);
}

// ---------------------------------------------------------------------------
void __fastcall TForm1::sumaBinariaab1Click(TObject *Sender) {
	Cardinal a = StrToInt(InputBox("Suma Binario", "A :", ""));
	Cardinal b = StrToInt(InputBox("Suma Binario", "B :", ""));
	Cardinal s = sumaBinaria(a, b);
	ShowMessage(s);
}
// ---------------------------------------------------------------------------

String w = "0123456789ABCDEF";

String DecimalBaseK(Cardinal n, byte k) {
	String s;
	if (n < k) {
		s = String(w[n + 1]);
	}
	else {
		s = DecimalBaseK(n / k, k) + w[n % k + 1];
	}
	return s;
}

void __fastcall TForm1::toBinn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Decimal", "nro :", ""));
	byte k = StrToInt(InputBox("Base", "nro :", ""));
	String s = DecimalBaseK(n, k);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
void moverMenorFinal(Cardinal &n) {
	if (n > 9) {
		byte d = n % 10;
		n /= 10;
		moverMenorFinal(n);
		if (n % 10 < d) {
			n = (n / 10) * 100 + d * 10 + n % 10;
		}
		else {
			n = n * 10 + d;
		}
	}
}

void ordenar(Cardinal &n) {
	if (n > 9) {
		moverMenorFinal(n);
		byte d = n % 10;
		n /= 10;
		ordenar(n);
		n = n * 10 + d;
	}
}

void __fastcall TForm1::ordenarn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Ordenar", "nro :", ""));
	ordenar(n);
	ShowMessage(n);
}

// ---------------------------------------------------------------------------
void invertir(String &x) {
	int n = x.Length();
	if (x != "") {
		if (n > 1) {
			wchar_t a = x[1];
			wchar_t b = x[n];
			x.Delete(n, 1);
			x.Delete(1, 1);
			invertir(x);
			x = String(b) + x + a;
		}
	}
}

void __fastcall TForm1::invertirn2Click(TObject *Sender) {
	/*
	 ""  =>      ""
	 a   =>      a
	 ab  =>      ba
	 abc =>      cba


	 x = abcd
	 a,d
	 x = cb
	 =>  d-cb-a
	 --------
	 x = bc
	 b,c
	 => c-""-b
	 --------
	 x = ""
	 x = "a"
	 */
	String x = InputBox("Invertir", "cad :", "");
	invertir(x);
	ShowMessage(x);
}

// ---------------------------------------------------------------------------
byte contarPalabras(String x) {
	byte c;
	if (x == "") {
		c = 0;
	}
	else if (x.Length() == 1) {
		c = 0;
		if (x[1] != ' ') {
			c++;
		}
	}
	else {
		c = 0;
		if (x[1] != ' ' && x[2] == ' ') {
			c++;
		}
		x.Delete(1, 1);
		c += contarPalabras(x);
	}
	return c;
}

void __fastcall TForm1::cantidadPalabrasx1Click(TObject *Sender) {
	/*
	 if (x[i] != ' ' y x[i+1] == ' ')
	 c++
	 x = hola_mundo_ ?? => 2
	 */
	String x = InputBox("ContarPalabras", "cad :", "");
	byte c = contarPalabras(x);
	ShowMessage(c);
}

// ---------------------------------------------------------------------------
bool esVocal(wchar_t z) {
	/*
	 z = m   >> w.Pos(z) = 0
	 z = p   >> w.Pos(z) = 0
	 z = A   >> w.Pos(z) = 6
	 z = a   >> w.Pos(z) = 1
	 */
	String w = "aeiouAEIOU";
	return w.Pos(z) > 0;
}

void eliminarVocales(String &x) {
	if (x != "") {
		wchar_t z = x[1];
		x.Delete(1, 1);
		eliminarVocales(x);
		if (!esVocal(z)) {
			x = String(z) + x;
		}
	}
}

void __fastcall TForm1::eliminarVocalesx1Click(TObject *Sender) {
	/*
	 ""  ==>     ""
	 "a" ==>     ""
	 "hola " =>   "hl "

	 x = ho_
	 c = h
	 c??esVocal
	 x=h_
	 ----------------
	 x = o_
	 c = o
	 c??esVocal
	 => x=_
	 ----------------
	 x = _
	 c = _
	 c??esVocal
	 => x=_
	 ----------------
	 x = ""
	 */
	String x = InputBox("EliminarVocales", "cad :", "");
	eliminarVocales(x);
	ShowMessage(x);
}

// ---------------------------------------------------------------------------
String palabraMasLarga(String x) {
	int n = x.Length();
	String palMax = "";
	if (n > 0) {
		int p = x.LastDelimiter(" ");
		String pal = x.SubString(p + 1, n - p);
		x.SetLength(p - 1);
		palMax = palabraMasLarga(x);
		if (pal.Length() > palMax.Length()) {
			palMax = pal;
		}
	}
	return palMax;
}

void __fastcall TForm1::palabraMasLargax1Click(TObject *Sender) {
	/*
	 ""      =>  ""
	 hola    =>  hola
	 pedro mundo  =>  mundo
	 //
	 n = 10
	 p = 5
	 x = hola_mundo
	 p+1 = 6
	 n-p = 5
	 pal = mundo

	 x.setLength(4);
	 => x = hola
	 n = 4
	 x = hola mundo
	 x.setLength(3)  =>  x = hol
	 x.setLength(2)  =>  x = ho
	 x.setLength(1)  =>  x = h
	 x.setLength(0)  =>  x =
	 */
	String x = InputBox("Palabra+Larga", "cad :", "");
	String p = palabraMasLarga(x);
	ShowMessage(p);
}

// ---------------------------------------------------------------------------
bool estaOrdenadoAsc(Cardinal n) {
	bool h;
	if (n < 10) {
		h = true;
	}
	else {
		byte d = n % 10;
		n /= 10;
		// h = estaOrdenadoAsc(n) && !(n%10 > d);
		h = estaOrdenadoAsc(n);
		if (n % 10 > d) {
			h = false;
		}
	}
	return h;
}

bool estaOrdenadoDesc(Cardinal n) {
	bool h;
	if (n < 10) {
		h = true;
	}
	else {
		byte d = n % 10;
		n /= 10;
		// h = estaOrdenadoAsc(n) && !(n%10 > d);
		h = estaOrdenadoDesc(n);
		if (n % 10 < d) {
			h = false;
		}
	}
	return h;
}

void __fastcall TForm1::estaOrdenadon1Click(TObject *Sender) {
	/*
	 1234
	 1   =>  true
	 213 =>  false
	 123 =>  true
	 12  => true

	 n = 123
	 ---------------
	 n = 12
	 d = 3
	 h = true
	 if  d >= n %10
	 h = true
	 else
	 false
	 ---------------
	 n = 1   => true

	 */
	Cardinal n = StrToInt(InputBox("EstaOrdenado", "cad :", ""));
	bool ordenado = estaOrdenadoAsc(n) || estaOrdenadoDesc(n);
	ShowMessage(ordenado ? "true" : "false");
}
// ---------------------------------------------------------------------------

void eliminarPrimerLetra(String &x) {
	byte n = x.Length();
	if (x != "") {
		byte p = x.LastDelimiter(" ");
		String w = x.SubString(p + 1, n - p);
		x.SetLength(p - 1);
		eliminarPrimerLetra(x);
		if (w != "") {
			w.Delete(1, 1);
		}
		x = x + " " + w;
	}
}

void __fastcall TForm1::eliminarPrimerLetrax1Click(TObject *Sender) {

	String x = InputBox("Eliminar1erLetra", "cad :", "");
	eliminarPrimerLetra(x);
	ShowMessage(x);
}
// ---------------------------------------------------------------------------

void invertirPalabras(String &x) {
	byte n = x.Length();
	if (n > 0) {
		byte p = x.LastDelimiter(" ");
		String w = x.SubString(p + 1, n - p);
		x.SetLength(p - 1);
		invertirPalabras(x);
		invertir(w);
		x = x + " " + w;
	}
}

void __fastcall TForm1::invertirPalabras1Click(TObject *Sender) {
	String x = InputBox("Invertir Palabras", "cad :", "");
	invertirPalabras(x);
	ShowMessage(x);
}

// ---------------------------------------------------------------------------
Cardinal fibonacci(Word n) {
	Cardinal t;
	if (n < 2) {
		t = n;
	}
	else {
		t = fibonacci(n - 1) + fibonacci(n - 2);
	}
	return t;
}

void __fastcall TForm1::fibonaccit1Click(TObject *Sender) {
	Word t = StrToInt(InputBox("Invertir Palabras", "cad :", ""));
	Cardinal fibo = fibonacci(t);
	ShowMessage(fibo);
}
// ---------------------------------------------------------------------------

Cardinal serie1(Word n) {
	Cardinal t;
	if (n < 2) {
		t = n;
	}
	else {
		t = serie1(n - 1);
		if (n % 2 == 0) {
			t *= 2;
		}
		else {
			t++;
		}
	}
	return t;
}

void __fastcall TForm1::serie1t1Click(TObject *Sender) {
	Word n = StrToInt(InputBox("Serie 1", "term :", ""));
	Cardinal t = serie1(n);
	ShowMessage(t);
}

// ---------------------------------------------------------------------------
Cardinal sumaSerie(Word n) {
	Cardinal s;
	if (n == 1) {
		s = 0;
	}
	else {
		s = sumaSerie(n - 1);
		s += 2*(n - 1);
	}
	return s;
}

void __fastcall TForm1::sumaSerien1Click(TObject *Sender) {
	Word n = StrToInt(InputBox("Suma Serie", "term :", ""));
	Cardinal s = sumaSerie(n);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
Cardinal serie2(Word n) {
	Cardinal t;
	if (n < 2) {
		t = n;
	}
	else {
		t = serie2(n - 1) * 2 + 1;
	}
	return t;
	// return (int)pow(2, n)-1;
}

void __fastcall TForm1::serie2n1Click(TObject *Sender) {
	Word n = StrToInt(InputBox("SERIE 2", "term :", ""));
	Cardinal s = serie2(n);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
Cardinal sumaSerie2(Word n, Cardinal &s) {
	Cardinal t;
	if (n < 2) {
		t = n;
	}
	else {
		t = sumaSerie2(n - 1, s);
		if (n % 3 == 0) {
			t += 2;
		}
		else if (n % 3 == 1) {
			t++;
		}
		else {
			t *= 2;
		}

		if (t % 2 == 0) {
			s += t;
		}
	}
	return t;
}

void __fastcall TForm1::sumaSerie2n1Click(TObject *Sender) {
	Word n = StrToInt(InputBox("Suma Serie2", "cad :", ""));
	Cardinal s = 0;
	Cardinal t = sumaSerie2(n, s);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
byte cantidadPares(Cardinal n) {
	byte c;
	if (n < 10) {
		c = (n % 2 == 0) ? 1 : 0;
	}
	else {
		c = cantidadPares(n / 10) + cantidadPares(n % 10);
	}
	return c;
}

void __fastcall TForm1::DigitosParesn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Cantidad Digitos Pares", "cad :", ""));
	byte c = cantidadPares(n);
	ShowMessage(c);
}

// ---------------------------------------------------------------------------
Word sumaPares(Cardinal n) {
	Word s;
	if (n < 10) {
		s = (n % 2 == 0) ? n : 0;
	}
	else {
		s = sumaPares(n / 10) + sumaPares(n % 10);
	}
	return s;
}

void __fastcall TForm1::SumaDigitosParesn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Cantidad Digitos Pares", "cad :", ""));
	Word s = sumaPares(n);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
byte parAntesImpar(Cardinal n) {
	byte c;
	if (n < 10) {
		c = 0;
	}
	else if (n < 100) {
		if ((n / 10) % 2 == 0 && (n % 10) % 2 == 1) {
			c = 1;
		}
		else {
			c = 0;
		}
	}
	else {
		c = parAntesImpar(n / 10) + parAntesImpar(n % 100);
	}
	return c;
}

void __fastcall TForm1::parAntesImparn1Click(TObject *Sender) {
	Cardinal n = StrToInt(InputBox("Par antes Impar", "cad :", ""));
	byte c = parAntesImpar(n);
	ShowMessage(c);
}

// ---------------------------------------------------------------------------
float sumaSerie3(Word n) {
	float s;
	if (n < 2) {
		s = n;
	}
	else {
		s = sumaSerie3(n - 1);
		float p = pow(2, n);
		s += p / (p - 1);
	}
	return s;
}

void __fastcall TForm1::sumaSerie3n1Click(TObject *Sender) {
	Word n = StrToInt(InputBox("SumaSerie3", "term :", ""));
	float s = sumaSerie3(n);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
void cargarVector(TStringGrid *v, byte n) {
	if (n > 0) {
		v->Cells[n - 1][0] = Random(20);
		cargarVector(v, n - 1);
	}
}

void __fastcall TForm1::cargarn1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("Longitud", "nro :", ""));
	StringGrid1->ColCount = n;
	cargarVector(StringGrid1, n);
	// cargar vector randomicamente
}
// ---------------------------------------------------------------------------

Cardinal sumaPares(TStringGrid *v, byte n) {
	Cardinal s;
	if (n == 1) {
		s = StrToInt(v->Cells[0][0]);
		if (s % 2 == 1) {
			s = 0;
		}
	}
	else {
		s = sumaPares(v, n - 1);
		byte k = StrToInt(v->Cells[n - 1][0]);
		if (k % 2 == 0) {
			s += k;
		}
	}
	return s;
}

void __fastcall TForm1::sumaPares1Click(TObject *Sender) {
	// suponemos que el vector esta cargado
	Cardinal s = sumaPares(StringGrid1, StringGrid1->ColCount);
	ShowMessage(s);
}

// ---------------------------------------------------------------------------
void invertir(TStringGrid *v, byte a, byte b) {
	byte n = b - a + 1;
	if (n > 0) {
		String va = v->Cells[a][0];
		String vb = v->Cells[b][0];
		v->Cells[a][0] = vb;
		v->Cells[b][0] = va;
		invertir(v, a + 1, b - 1);
	}
}

void __fastcall TForm1::invertir1Click(TObject *Sender) {
	byte n = StringGrid1->ColCount;
	invertir(StringGrid1, 0, n - 1);
}

// ---------------------------------------------------------------------------
void cargarVectorCadena(TStringGrid *v, byte n, String x) {
	byte nx = x.Length();
	if (n > 0) {
		int p = x.LastDelimiter(" ");
		String pal = x.SubString(p + 1, nx - p);
		x.SetLength(p - 1);
		v->Cells[n - 1][0] = pal;
		cargarVectorCadena(v, n - 1, x);
	}
}

void __fastcall TForm1::cargarPalabrasx1Click(TObject *Sender) {
	String x = InputBox("cadena", "cad :", "");
	byte n = contarPalabras(x);
	StringGrid1->ColCount = n;
	cargarVectorCadena(StringGrid1, n, x);
	ShowMessage(n);
}
// ---------------------------------------------------------------------------

void cargarVector100(TStringGrid *v, byte n, Cardinal x) {
	if (n > 0) {
		v->Cells[n - 1][0] = x % 100;
		cargarVector100(v, n - 1, x / 100);
	}
}

void __fastcall TForm1::cargarVector1001Click(TObject *Sender) {
	Cardinal nro = StrToInt(InputBox("Nro", "nro :", ""));
	byte c = cantidadDigitos(nro);
	c = (c - 1) / 2 + 1;
	StringGrid1->ColCount = c;
	cargarVector100(StringGrid1, c, nro);
}
// ---------------------------------------------------------------------------

String generarCadenaNroInv(TStringGrid *v, byte a, byte b) {
	String x;
	byte n = b - a + 1;
	if (n < 1) {
		x = "";
	}
	else {
		x = v->Cells[a][0];
		invertir(x);
		x = x + generarCadenaNroInv(v, a + 1, b);
	}
	return x;
}

void __fastcall TForm1::cadenaNroInv1Click(TObject *Sender) {
	byte n = StringGrid1->ColCount;
	String x = generarCadenaNroInv(StringGrid1, 0, n - 1);
	ShowMessage(x);
}
// ---------------------------------------------------------------------------

Cardinal CargarSerie(TStringGrid *v, byte n) {
	Cardinal t;
	if (n < 2) {
		t = n * 2;
	}
	else {
		t = CargarSerie(v, n - 1);
		if (n % 2 == 0) {
			t += (n - 1)*2;
		}
		else {
			t *= (n - 1)*2;
		}
	}

	if (n > 0) {
		v->Cells[n - 1][0] = t;
	}
	return t;
}

void __fastcall TForm1::cargarSerie1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("Longitud", "nro: ", ""));
	StringGrid1->ColCount = n;
	Cardinal t = CargarSerie(StringGrid1, n);
	ShowMessage(t);
}
// ---------------------------------------------------------------------------

Cardinal suma(TStringGrid *v, byte n) {
	Cardinal s = 0;
	if (n > 0) {
		s = StrToInt(v->Cells[n - 1][0]);
		s += suma(v, n - 1);
	}
	return s;
}

void __fastcall TForm1::suman1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("SUMA", "nro: ", ""));
	Cardinal s = suma(StringGrid1, n);
	ShowMessage(s);
}
// ---------------------------------------------------------------------------

void columnaSerpiente(TStringGrid *v, byte fa, byte fb, byte ca, byte cb,
	byte &k) {
	byte n = cb - ca + 1;
	if (n > 0) {
		if (fa % 2 == 1) {
			v->Cells[ca][fa] = k++;
			columnaSerpiente(v, fa, fb, ca + 1, cb, k);
		}
		else {
			v->Cells[cb][fa] = k++;
			columnaSerpiente(v, fa, fb, ca, cb - 1, k);
		}
	}
}

void filaSerpiente(TStringGrid *v, byte fa, byte fb, byte ca, byte cb, byte &k)
{
	byte m = fb - fa + 1;
	if (m > 0) {
		columnaSerpiente(v, fa, fb, ca, cb, k);
		filaSerpiente(v, fa + 1, fb, ca, cb, k);
	}
}

void __fastcall TForm1::serpiente1Click(TObject *Sender) {
	byte m = StrToInt(InputBox("FILS", "nro: ", ""));
	byte n = StrToInt(InputBox("COLS", "nro: ", ""));
	byte k = 1;
	StringGrid2->RowCount = m;
	StringGrid2->ColCount = n;
	filaSerpiente(StringGrid2, 0, m - 1, 0, n - 1, k);
}
// ---------------------------------------------------------------------------

void colTriangular1(TStringGrid *v, byte fa, byte fb, byte ca, byte cb) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][fa] = fa + 1;
		colTriangular1(v, fa, fb, ca + 1, cb);
	}
}

void filaTriangular1(TStringGrid *v, byte fa, byte fb, byte ca, byte cb) {
	byte m = fb - fa + 1;
	if (m > 0) {
		colTriangular1(v, fa, fb, ca, cb);
		filaTriangular1(v, fa + 1, fb, ca + 1, cb);
	}
}

void __fastcall TForm1::triangular1n1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
//
	StringGrid2->RowCount = 0;
	StringGrid2->ColCount = 0;
//
	StringGrid2->ColCount = n;
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	filaTriangular1(StringGrid2, 0, n - 1, 0, n - 1);
}
// ---------------------------------------------------------------------------

void colTriangular2(TStringGrid *v, byte fa, byte fb, byte ca, byte cb, byte &k)
{
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][fa] = 2 * k++ - 1;
		colTriangular2(v, fa, fb, ca + 1, cb, k);
	}
}

void filaTriangular2(TStringGrid *v, byte fa, byte fb, byte ca, byte cb,
	byte &k) {
	byte m = fb - fa + 1;
	if (m > 0) {
		colTriangular2(v, fa, fb, ca, cb, k);
		filaTriangular2(v, fa + 1, fb, ca - 1, cb, k);
	}
}

void __fastcall TForm1::triangular2n1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	byte k = 1;
	filaTriangular2(StringGrid2, 0, n - 1, n - 1, n - 1, k);
}
// ---------------------------------------------------------------------------

void rellenarFila(TStringGrid *v, byte fa, byte fb, byte ca, byte cb) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][fa] = fa + 1;
		v->Cells[ca][fb] = fa + 1;
		rellenarFila(v, fa, fb, ca + 1, cb);
	}
}

void rellenarCol(TStringGrid *v, byte ca, byte cb, byte fa, byte fb) {
	byte m = fb - fa + 1;
	if (m > 0) {
		v->Cells[ca][fa] = ca + 1;
		v->Cells[cb][fa] = ca + 1;
		rellenarCol(v, ca, cb, fa + 1, fb);
	}
}

void cargarCuadrado(TStringGrid *v, byte fa, byte fb, byte ca, byte cb) {
	byte m = fb - fa + 1;
	byte n = cb - ca + 1;
	if (m * n != 0) {
		if (m * n == 1) {
			v->Cells[ca][fa] = ca + 1;
		}
		else {
			rellenarFila(v, fa, fb, ca, cb);
			rellenarCol(v, ca, cb, fa, fb);
			cargarCuadrado(v, fa + 1, fb - 1, ca + 1, cb - 1);
		}
	}
}

void __fastcall TForm1::cuadrado1n1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	cargarCuadrado(StringGrid2, 0, n - 1, 0, n - 1);
}
// ---------------------------------------------------------------------------

void cargarFilD1(TStringGrid *v, byte f, byte ca, byte cb, byte k) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][f] = k;
		cargarFilD1(v, f, ca + 1, cb, k + 1);
	}
}

void cargarD1(TStringGrid *v, byte fa, byte fb, byte ca, byte cb, byte k) {
	byte m = fb - fa + 1;
	if (m > 0) {
		cargarFilD1(v, fb, ca, cb, k);
		cargarD1(v, fa, fb - 1, ca, cb, k + 1);
	}
}

void __fastcall TForm1::re1Click(TObject *Sender) {
	byte m = StrToInt(InputBox("FILS", "nro: ", ""));
	byte n = StrToInt(InputBox("COLS", "nro: ", ""));
	StringGrid2->RowCount = m;
	StringGrid2->ColCount = n;
	cargarD1(StringGrid2, 0, m - 1, 0, n - 1, 1);
}
// ---------------------------------------------------------------------------

void abajo(TStringGrid *v, byte fa, byte fb, byte c, byte &k) {
	byte m = fb - fa + 1;
	if (m > 0) {
		v->Cells[c][fa] = k++;
		abajo(v, fa + 1, fb, c, k);
	}
}

void derecha(TStringGrid *v, byte ca, byte cb, byte f, byte &k) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][f] = k++;
		derecha(v, ca + 1, cb, f, k);
	}
}

void arriba(TStringGrid *v, byte fa, byte fb, byte c, byte &k) {
	byte m = fb - fa + 1;
	if (m > 0) {
		v->Cells[c][fb] = k++;
		arriba(v, fa, fb - 1, c, k);
	}
}

void izquierda(TStringGrid *v, byte ca, byte cb, byte f, byte &k) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[cb][f] = k++;
		izquierda(v, ca, cb - 1, f, k);
	}
}

void cargarCaracol(TStringGrid *v, byte fa, byte fb, byte ca, byte cb, byte &k)
{
	byte m = fb - fa + 1;
	byte n = cb - ca + 1;
	if (m * n != 0) {
		if (m * n == 1) {
			v->Cells[ca][fa] = k;
		}
		else {
			abajo(v, fa, fb - 1, ca, k);
			derecha(v, ca, cb - 1, fb, k);
			arriba(v, fa + 1, fb, cb, k);
			izquierda(v, ca + 1, cb, fa, k);
			cargarCaracol(v, fa + 1, fb - 1, ca + 1, cb - 1, k);
		}
	}
}

void __fastcall TForm1::caracoln1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	byte k = 1;
	cargarCaracol(StringGrid2, 0, n - 1, 0, n - 1, k);
}
// ---------------------------------------------------------------------------
void cargarColTri3(TStringGrid *v, byte f, byte ca, byte cb, byte k) {
	byte n = cb - ca + 1;
	if (n > 0) {
		v->Cells[ca][f] = k;
		if (k == 1) {
			cargarColTri3(v, f, ca+1, cb, k);
		}else {
			cargarColTri3(v, f, ca+1, cb, k-1);
		}
	}
}

void cargarFilaTri3(TStringGrid *v, byte fa, byte fb, byte ca, byte cb, byte k)
{
	byte m = fb - fa + 1;
	if (m > 0) {
		cargarColTri3(v, fa, ca, cb, k);
		cargarFilaTri3(v, fa + 1, fb, ca, cb, k - 1);
	}
}

void __fastcall TForm1::triangular3n1Click(TObject *Sender) {
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	cargarFilaTri3(StringGrid2, 0, n - 1, 0, n - 1, n);
}
// ---------------------------------------------------------------------------

void filSerpiente2(TStringGrid *v, byte c, byte fa, byte fb) {
	byte M = v->RowCount;
	byte m = fb -fa +1;
	if (m > 0) {
		if (c % 2 == 0) {
			v->Cells[c][fa] = (c * M + (fa + 1)) * (c * M + (fa + 1));
			filSerpiente2(v, c, fa+1, fb);
		}else {
			v->Cells[c][fb] = ((c+1) * (M) - (fb))*((c+1) * (M) - (fb));
			filSerpiente2(v, c, fa, fb-1);
		}
	}
}

void colSerpiente2(
	TStringGrid *v,
	byte fa, byte fb, byte ca, byte cb
){
	byte n = cb -ca +1;
	if (n > 0) {
		filSerpiente2(v, ca, fa, fb);
		colSerpiente2(v, fa, fb, ca+1, cb);
	}
}

void __fastcall TForm1::serpiente2mn1Click(TObject *Sender)
{
	byte m = StrToInt(InputBox("FILS", "nro: ", ""));
	byte n = StrToInt(InputBox("COLS", "nro: ", ""));
	StringGrid2->RowCount = m;
	StringGrid2->ColCount = n;
	colSerpiente2(StringGrid2, 0, m - 1, 0, n - 1);
}
//---------------------------------------------------------------------------

void cargarFilCad1(TStringGrid *v, byte c, byte fa, byte fb, String &x
){
	byte m = fb -fa +1;
	if (m > 0) {
		if (x != "") {
			v->Cells[c][fa] = x.SubString(1,1);
			x.Delete(1, 1);
		}else {
			v->Cells[c][fa] = "";
		}
		cargarFilCad1(v, c, fa+1, fb, x);
	}
}

void cargarColCad1(
	TStringGrid *v,
	byte fa, byte fb, byte ca, byte cb, String &x
) {
	byte n = cb -ca +1;
	if (n > 0) {
		cargarFilCad1(v, ca, fa, fb, x);
		cargarColCad1(v, fa, fb, ca+1, cb, x);
	}
}

void __fastcall TForm1::cargarcadena1mn1Click(TObject *Sender)
{
	byte m = StrToInt(InputBox("FILS", "nro: ", ""));
	byte n = StrToInt(InputBox("COLS", "nro: ", ""));
	StringGrid2->RowCount = m;
	StringGrid2->ColCount = n;
	String x = InputBox("CADENA", "cad:", "");
	if (x.Length() <= m*n) {
		cargarColCad1(StringGrid2, 0, m-1, 0, n-1, x);
	}else {
		ShowMessage("No carga la cadena");
	}
}
//---------------------------------------------------------------------------
void cargarCadena2(TStringGrid *v, byte a, byte b, String x)
{
	byte N = v->ColCount;
	byte n = b -a +1;
	if (n > 0) {
		if (x != "") {
			v->Cells[a%N][a/N] = String(x[1]);
			cargarCadena2(v, a+1, b, x.Delete(1,1));
		}else {
			v->Cells[a%N][a/N] = "";
			cargarCadena2(v, a+1, b, x);
		}
	}
}

void __fastcall TForm1::cargarCadena2mn1Click(TObject *Sender)
{
	byte m = StrToInt(InputBox("FILS", "nro: ", ""));
	byte n = StrToInt(InputBox("COLS", "nro: ", ""));
	StringGrid2->RowCount = m;
	StringGrid2->ColCount = n;
	String x = InputBox("CADENA", "cad:", "");
	if (x.Length() <= m*n) {
		cargarCadena2(StringGrid2, 0, m*n -1, x);
	}else {
		ShowMessage("No carga la cadena");
	}
}
//---------------------------------------------------------------------------

void triangularFila3(TStringGrid *v, byte c, byte m, byte &k)
{
	if (m > 0) {
		if (c % 2 == 1) {
			v->Cells[c][m-1] = k++;
			triangularFila3(v, c, m-1, k);
		}else {
			triangularFila3(v, c, m-1, k);
			v->Cells[c][m-1] = k++;
		}
	}
}

void triangular3(TStringGrid *v, byte m, byte n, byte &k)
{
	if (n > 0) {
		triangular3(v, m+1, n-1, k);
		triangularFila3(v, n-1, m, k);
	}
}

void __fastcall TForm1::triangular11Click(TObject *Sender)
{
	byte n = StrToInt(InputBox("ORDEN", "nro: ", ""));
	byte k = 1;
	StringGrid2->RowCount = n;
	StringGrid2->ColCount = n;
	triangular3(StringGrid2, 1, n, k);
}
//---------------------------------------------------------------------------
void cargarCadenaMatrizVector(
	TStringGrid *v,
	byte a, byte b, String x
){
	byte N = v->ColCount;
	byte n = b -a +1;
	if (n > 0) {
		if (x != "") {
			v->Cells[a%N][a/N] = String(x[1]);
			x.Delete(1,1);
			cargarCadenaMatrizVector(v, a+1, b, x);
		}
	}
}

void __fastcall TForm1::cargarCadenaVectorMatrizx1Click(TObject *Sender)
{
	String x = InputBox("Cadena", "String: ", "");
	if (x != "") {
		byte n = (int)sqrt(x.Length() -1 ) +1;
		StringGrid2->ColCount = n;
		StringGrid2->RowCount = n;
		cargarCadenaMatrizVector(
			StringGrid2,
			0, n*n -1, x
		);
	}else{
		ShowMessage("Cadena Vacia -> Matriz []");
	}
}
//---------------------------------------------------------------------------