//vaciar una matriz // Jose Daniel Soliz

void eliminarf(TStringGrid *v,byte fa, byte fb, byte ca,byte cb)

{ byte n= cb-ca+1;

if (n>0){

v->Cells[ca][fa]="";

eliminarf(v,fa,fb,ca+1,cb);}

void eliminarc(TStringGrid *v,byte fa, byte fb, byte ca,byte cb)

{ byte m=fb-fa+1;

if (m>0){

eliminarf(v,fa,fb,ca,cb);

eliminarc(v,fa+1,fb,ca,cb);}

void __fastcall TForm1::Button3Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

StringGrid1->ColCount =1;

StringGrid1->RowCount =1;

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

//ejer1

//cargar 123 12

// 456 34

void cargarcol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb){

byte n=cb-ca+1;

//N=v->colcount =cb+1

if (n>0) {

if (fa%2==0) { //cambiar la condicion para inverso

v->Cells[ca][fa]=fa*(cb+1) + ca +1;

else {

v->Cells[ca][fa]=(fa+1)*(cb+1) - ca;
 }

cargarcol(v,fa,fb,ca+1,cb);

void cargar1(TStringGrid *v,byte fa,byte fb,byte ca,byte cb){

byte m=fb-fa+1;

if (m>0) {

cargarcol(v,fa,fb,ca,cb);

cargar1(v,fa+1,fb,0,cb);

void __fastcall TForm1::ejer11Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

cargar1(StringGrid1,0,m-1,0,n-1);

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

void cargar(TStringGrid *v,byte n )

byte i=v->ColCount ;

if (n>0) {

//j , i

v->Cells[(n-1)%i][(n-1)/i]=Random(20);

cargar(v,n-1);

void __fastcall TForm1::Button1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

 StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

cargar(StringGrid1,m*n);

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

void llenarf(TStringGrid *a,byte f,byte n, byte k)

if (n>0) {

llenarf(a,f,n-1,k);

a->Cells [n-1][f]=k;

void llenarc(TStringGrid *a,byte c,byte n, byte k)

if (n>0) {

llenarc(a,c,n-1,k);

a->Cells [c][n-1]=k;

void cargarclas(TStringGrid *a, byte m, byte n)

if (m*n>0) {

cargarclas(a,m-1,n-1);

llenarf(a,m-1,n,n);

llenarc(a,m-1,n,n);

void __fastcall TForm1::cargarclas11Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

byte n=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =n;
cargarclas(StringGrid1,m,n);

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

// CARGAR UNA MATRIZ EN FORMA DE ESPIRAL

//

void llenarf1(TStringGrid *a,byte fa,byte ca,byte cb,byte &k)

if (cb>=ca) {

a->Cells [ca][fa]=k++;

llenarf1(a,fa,ca+1,cb,k); }

void llenarc2(TStringGrid *a,byte cb,byte fa,byte fb,byte &k)

if (fb>=fa) {

a->Cells [cb][fa]=k++;

llenarc2(a,cb,fa+1,fb,k); }

void llenarf2(TStringGrid *a,byte fb,byte ca,byte cb,byte &k)

if (cb>ca) {

a->Cells [cb][fb]=k++;

llenarf2(a,fb,ca,cb-1,k); }

void llenarc1(TStringGrid *a,byte ca,byte fa,byte fb,byte &k)

if (fb>fa) {

a->Cells [ca][fb]=k++;

llenarc1(a,ca,fa,fb-1,k); }

typedef TStringGrid mat;

void cargarespi(mat *a,byte fa, byte fb, byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;
byte n=cb-ca+1;

if (m*n>0) {//caso base m=0 o n=0

if (m*n==1) //2do caso base

a->Cells[ca][fb]=k;

else {//caso general

llenarf1(a,fa,ca,cb,k);//k= dato inicial

llenarc2(a,cb,fa+1,fb,k);

llenarf2(a,fb,ca,cb-1,k);

llenarc1(a,ca,fa,fb,k);

cargarespi(a,fa+1,fb-1,ca+1,cb-1,k);

void __fastcall TForm1::cargarespiral1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

byte k=1;

cargarespi(StringGrid1,0,m-1,0,m-1,k);

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

//auxiliatura

//ejer2

void cargarfil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa +1;

if (m>0) {

v->Cells [ca][fa]=k;

k++;

cargarfil(v,fa+1,fb,ca,cb,k);

}
}

void triangulari(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n= cb-ca +1;

if (n>0) {

cargarfil(v,fa,fb,ca,cb,k);

triangulari(v,fa+1,fb,ca+1,cb,k);

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

void __fastcall TForm1::cargartriangularinferior1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

triangulari(StringGrid1,0,m-1,0,m-1,k);

//ejer3

void cargarfilasda(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n= cb-ca +1;

if (n>0) {

v->Cells [cb][fb]=k;

k++;

cargarfilasda(v,fa,fb,ca,cb-1,k);

void ejerda(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa +1;

if (m>0) {

cargarfilasda(v,fa,fb,ca,cb,k);
 ejerda(v,fa,fb-1,ca,cb-1,k);

void __fastcall TForm1::ejer31Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

ejerda(StringGrid1,0,m-1,0,m-1,k);

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

//cargar matriz triangular superior

void cargarf(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [ca][fa]=k;

k++;

cargarf(v,fa,fb,ca+1,cb,k);

void triangulars(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n=fb-fa +1;

if (n>0) {

cargarf(v,fa,fb,ca,cb,k);

triangulars(v,fa+1,fb,ca+1,cb,k);

void __fastcall TForm1::cargartriangularsuperior1Click(TObject *Sender)

{eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

triangulars(StringGrid1,0,m-1,0,m-1,k);

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

void cargcol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n=cb -ca+1;

if (n>0) {

v->Cells [ca][fb]=k;

k++;

cargcol(v,fa,fb,ca+1,cb,k);

void cargfil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb -fa +1;

if (m>0) {

cargcol(v,fa,fb,ca,cb,k);

cargfil(v,fa,fb-1,ca+1,cb,k);

void __fastcall TForm1::cargartriangularderecha1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

cargfil(StringGrid1,0,m-1,0,m-1,k);

//---------------------------------------------------------------------------
//cargar triangular superior 2.0

void cargarfil3(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb -fa+1;

if (m>0) {

v->Cells [cb][fb]=k;

k++;

cargarfil3(v,fa,fb-1,ca,cb,k);

void cargarfil22(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n=cb -ca +1;

if (n>0) {

cargarfil3(v,fa,fb,ca,cb,k);

cargarfil22(v,fa,fb-1,ca,cb-1,k);

void __fastcall TForm1::triangularsuperior201Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

cargarfil22(StringGrid1,0,m-1,0,m-1,k);

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

String helloworld(byte i){

String s;

if (i>0) {

s=helloworld(i-1);

s="Hola Mundo";}

return s;
}

void __fastcall TForm1::holamundo1Click(TObject *Sender)

ShowMessage(helloworld(1));

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

// 001

// 024

// 356

void inser(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

if (fa<=fb) {

v->Cells [cb][fa]=k++;

inser(v,fa+1,fb,ca,cb-1,k);

void modex1(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

inser(v,fa,fb,ca,cb,k);

modex1(v,fa+1,fb,ca,cb,k);

void __fastcall TForm1::modeex11Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

modex1(StringGrid1,0,m-1,0,m-1,k);

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

//inversa de mode ex 2

void inser3(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

if (cb<=fb) {

v->Cells [cb][fa]=k--;

inser3(v,fa,fb,ca,cb+1,k);

void modex3(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

inser3(v,fa,fb,ca,cb,k);

modex3(v,fa+1,fb,ca,cb-1,k);

void __fastcall TForm1::modex2inversa1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=(((m*m)-m)/2)+m;

modex3(StringGrid1,0,m-1,0,m-1,k);

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

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

//clase - vector a Matriz

void cargarV(TStringGrid*M, byte N){

if (N>0) {

byte n=M->ColCount ;
 cargarV(M,N-1);

M->Cells [(N-1)%n][(N-1)/n]= 2*N-1; }

void __fastcall TForm1::cargarvectorimpares1Click(TObject *Sender)

byte m=StrToInt(InputBox("","","5"));

byte n=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

cargarV(StringGrid1,m*n);

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

//de una cadena insertar en una matriz solo las consonantes

//hola que hace

//h l q

//h c

bool consonante(wchar_t ele){

String cad="BCDFGHJKLMNÑPQRSTVWXYZ";

return cad.Pos(UpperCase(ele))>0;

void soloconsonante(String &cad){

byte l=cad.Length();

if (l>0) {

wchar_t ele=cad[l];

cad.Delete(l,1);

soloconsonante(cad);

if (consonante(ele))

cad=cad+ele;

void __fastcall TForm1::soloconsonante1Click(TObject *Sender)

String cad=Edit1->Text ;
 soloconsonante(cad);

ShowMessage(cad);

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

void cfilas(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,String &cad)

byte n=cb-ca +1;

if ((n>0)&&(cad.Length() >0)) {

char ele=cad[1];

v->Cells [ca][fa]=ele;

cad.Delete(1,1);

cfilas(v,fa,fb,ca+1,cb,cad);

void modex5(TStringGrid *v,byte fa, byte fb, byte ca, byte cb, String &cad)

byte l=cad.Length();

if (l>0) {

cfilas(v,fa,fb,ca,cb,cad);

modex5(v,fa+1,fb,ca,cb,cad);

void __fastcall TForm1::vocalesenmatriz1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount,0,StringGrid1->ColCount);

String cad=Edit1->Text;

soloconsonante(cad);

byte n=(cad.Length() % 2)+2;

byte m=(cad.Length() %2!=0)?(cad.Length()-1) /2:cad.Length() /2;

StringGrid1->RowCount = m;

StringGrid1->ColCount = n;

modex5(StringGrid1,0,m-1,0,n-1,cad);

//---------------------------------------------------------------------------
void modex6_1(TStringGrid *v,byte fa,byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0){

v->Cells[cb][fa]=k;

k=k+2;

modex6_1(v,fa+1,fb,ca,cb,k);

void modex6(TStringGrid *v,byte fa,byte fb,byte ca, byte cb,byte &k)

{ byte n=cb-ca+1;

if (n>0){

modex6_1(v,fa,fb,ca,cb,k);

modex6(v,fa,fb,ca,cb-1,k);

void __fastcall TForm1::modex61Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

byte n=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

byte k=2;

modex6(StringGrid1,0,m-1,0,n-1,k);

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

//cargar matriz triangular superior

void modex7_1(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fb]=k++;
 modex7_1(v,fa,fb,ca+1,cb,k);

void modex7_2(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [cb][fb]=k++;

modex7_2(v,fa,fb,ca,cb-1,k);

void modex7(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

modex7_1(v,fa,fb,ca,cb,k);

modex7_2(v,fa,fb-1,ca,cb-1,k);

modex7(v,fa,fb-2,ca,cb-2,k);

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

void Llenarfila(TStringGrid *v, int fa, int fb, int ca, int cb, int k){

if (cb>=ca){

Llenarfila(v,fa,fb,ca+1,cb,k+1);

v->Cells[ca][fb]=k;

void Llenarfila2(TStringGrid *v, int fa, int fb, int ca, int cb, int k){

if (cb>=ca){

Llenarfila2(v,fa,fb,ca,cb-1,k+1);

v->Cells[cb][fb]=k;

void preguntamatriz(TStringGrid *v, int fa, int fb, int ca, int cb, int k, int x){
int n=fb-fa+1;

if (n>0){

if (fb==1){

preguntamatriz(v,fa,fb-1,ca,cb,k+n*2-1,x+2);

else{

preguntamatriz(v,fa,fb-2,ca,cb,k+n*2-1,x+2);

Llenarfila(v,fa,fb,ca,cb-x,k);

Llenarfila2(v,fa,fb-1,ca,cb-x-1,k+n);

void __fastcall TForm1::amanecitrisupvibora1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

byte k=1;

preguntamatriz(StringGrid1,0,m-1,0,m-1,k,0);

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

//matriz simetrica

//123

//212

//321

void modex8_1(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

v->Cells [ca][fa]=k;

v->Cells [fa][ca]=k;

modex8_1(v,fa+1,fb,ca+1,cb,k);

}
}

void modex8(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

modex8_1(v,fa,fb,ca,cb,k);

k++;

modex8(v,fa+1,fb,ca,cb,k);

void __fastcall TForm1::matrizsimetricasuperior1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

byte k=1;

modex8(StringGrid1,0,m-1,0,m-1,k);

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

//matriz simetrica trnaspuesta

//321

//212

//123

void modex9_1(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

v->Cells [fa][cb]=k;

modex9_1(v,fa+1,fb,ca,cb-1,k);

void modex9(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{
 byte m=fb-fa+1;

if (m>0) {

modex9_1(v,fa,fb,ca,cb,k);

k++;

modex9(v,fa+1,fb,ca,cb,k);

k=1;

void modex10_1(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

v->Cells [ca][fb]=k;

modex10_1(v,fa,fb-1,ca+1,cb,k);

void modex10(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

modex10_1(v,fa,fb,ca,cb,k);

k++;

modex10(v,fa,fb-1,ca,cb,k);

void __fastcall TForm1::matrizsimetrica11Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

byte k=1;

modex9(StringGrid1,0,m-1,0,m-1,k);

modex10(StringGrid1,0,m-1,0,m-1,k);
}

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

//

//

//

//editar -------------------------------------------------------------

void modex11_1(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

v->Cells [fa][cb]=k;

modex11_1(v,fa+1,fb,ca,cb-1,k);

void modex11_2(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

v->Cells [ca][fa]=k;

v->Cells [fa][ca]=k;

modex11_2(v,fa+1,fb,ca+1,cb,k);

void mode11(TStringGrid* v,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

modex11_1(v,fa,fb,ca,cb,k);

modex11_2(v,fa,fb,ca,cb,k);

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

void retocarlo_1(TStringGrid *v,byte fa,byte ca,byte cb,byte &k)

{

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fa]=pow(k,fa);

retocarlo_1(v,fa+1,ca+1,cb,k);

void retocarlo(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca+1;

if (m>0) {

retocarlo_1(v,fa,ca,cb,k);

k++;

retocarlo(v,fa,fb,ca+1,cb,k);

void __fastcall TForm1::retodecarlo1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

byte k=1;

retocarlo(StringGrid1,0,m-1,0,m-1,k);

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

void derecha(TStringGrid *a,byte fa,byte ca,byte cb,byte &k)

if (cb>=ca) {

a->Cells [ca][fa]=k;
 derecha(a,fa,ca+1,cb,k); }

void abajo(TStringGrid *a,byte cb,byte fa,byte fb,byte &k)

if (fb>=fa) {

a->Cells [cb][fa]=k;

abajo(a,cb,fa+1,fb,k); }

void izquierda(TStringGrid *a,byte fb,byte ca,byte cb,byte &k)

if (cb>ca) {

a->Cells [cb][fb]=k;

izquierda(a,fb,ca,cb-1,k); }

void arriba(TStringGrid *a,byte ca,byte fa,byte fb,byte &k)

if (fb>fa) {

a->Cells [ca][fb]=k;

arriba(a,ca,fa,fb-1,k); }

//CODIGO M.ESP

typedef TStringGrid mat;

void cargarespi2(mat *a,byte fa, byte fb, byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

byte n=cb-ca+1;

if (m*n>0) {//caso base m=0 o n=0

if (m*n==1) //2do caso base

a->Cells[ca][fb]=k;

else {//caso general

derecha(a,fa,ca,cb,k); //k= dato inicial

abajo(a,cb,fa+1,fb,k);

izquierda(a,fb,ca,cb-1,k);

arriba(a,ca,fa,fb,k);

//k--; //de n a 1
 k++;

cargarespi2(a,fa+1,fb-1,ca+1,cb-1,k);

void __fastcall TForm1::matrizespiral201Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m;

StringGrid1->ColCount =m;

//byte k=m/2+m%2; //de n a 1

byte k=1;

cargarespi2(StringGrid1,0,m-1,0,m-1,k);

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

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

//matriz cargada en cortes

void cortes2(TStringGrid *v,byte fa,byte fb, int ca, byte cb, byte &k,byte &j)

if (ca>=0) {

v->Cells [ca][fa]=k++;

v->Cells [cb][fb]=j--;

cortes2(v,fa+1,fb-1,ca-1,cb+1,k,j);

void cortes(TStringGrid *v,byte fa,byte fb, byte ca, byte cb, byte &k,byte &j)

if (ca<=fb) {
 cortes2(v,fa,fb,ca,cb,k,j);

cortes(v,fa,fb,ca+1,cb-1,k,j);

void __fastcall TForm1::matrizencortes1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte j=m*m;

byte k=1;

cortes(StringGrid1,0,m-1,0,m-1,k,j);

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

void modex12_1(TStringGrid *v,byte fa,byte fb, byte ca, byte cb,byte k)

byte n=fb-fa+1;

if (n>0) {

v->Cells [ca][fb]=k;

modex12_1(v,fa,fb-1,ca,cb,k+1);

void modex12(TStringGrid *v,byte fa,byte fb, byte ca, byte cb,byte &k)

byte n=cb-ca+1;

if (n>0) {

modex12_1(v,fa,fb,ca,cb,k);

k++;

modex12(v,fa,fb,ca+1,cb,k);

}
}

void __fastcall TForm1::matrizascendentedeabajo1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

modex12(StringGrid1,0,m-1,0,m-1,k);

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

byte sumavec(TStringGrid *v,byte a, byte b,byte n)

{ byte s;

if (n>0) {

s=sumavec(v,a,b,n-1);

if ((n>=a)&&(n<=b))

s=s+ StrToInt(v->Cells [n][0]);

else s=0;

return s;

void __fastcall TForm1::sumadeelementosdeunvectorrangoayb1Click(TObject *Sender)

byte a=StrToInt(InputBox("","rango a",""));

byte b=StrToInt(InputBox("","rango a",""));

ShowMessage(IntToStr(sumavec(StringGrid1,a,b,StringGrid1->ColCount )));

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

// cadena a matriz

//editar

void modex13_1(TStringGrid *v,byte fa,byte fb, byte ca, byte cb,String &cad)

{ byte m=fb-fa+1;

if ((m>0)&&(cad.Length()>0)){
 v->Cells [ca][fa]=cad[1];

cad.Delete(1,1);

modex13_1(v,fa+1,fb,ca,cb,cad);}

void modex13(TStringGrid *v,byte fa,byte fb, byte ca, byte cb,String &cad)

if (cad.Length()>0 ){

modex13_1(v,fa,fb,ca,cb,cad);

modex13(v,fa,fb,ca+1,cb,cad);

void __fastcall TForm1::cadenaamatriz1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

String cad=Edit1->Text;

byte k=cad.Length() ;

byte m=floor(sqrt(k))+1;

byte n=(k%2!=0)?ceil(sqrt(k)):floor(sqrt(k));

StringGrid1->ColCount =m;

StringGrid1->RowCount =n;

modex13(StringGrid1,0,n-1,0,m-1,cad);

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

void modex14_1(TStringGrid *v,byte pos,byte n)

if (n>=pos) {

byte n2=(n==1)?0:n-2;

v->Cells [n-1][0]=v->Cells [n2][0];

modex14_1(v,pos,n-1);

void modex14(TStringGrid *v,String cad,byte pos)

{
 if (cad.Length()>0 ) {

v->ColCount ++;

modex14_1(v,pos,v->ColCount );

v->Cells [pos-1][0]=cad[1];

cad.Delete(1,1);

modex14(v,cad,pos+1);

void __fastcall TForm1::insertarunacadenaenunvectorapartirdeunapocicion1Click(TObject

*Sender)

String cad=Edit1->Text ;

byte pos=StrToInt(InputBox("","posicion?",""));

modex14(StringGrid1,cad,pos);

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

void modex15(TStringGrid*v,byte n,byte &s)

if (n>0) {

modex15(v,n-1,s);

v->Cells [n-1][0]=s;

if (n%2==0)

s=s+1;

else

s=s*2;

void __fastcall TForm1::serieenvector1Click(TObject *Sender)

{ byte s=1;

byte n=StrToInt(InputBox("","n?",""));

StringGrid1->ColCount =n;

modex15(StringGrid1,n,s);
}

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

//ex1

//achaaaaaaaa

//triangular superior vibora

void vibora2(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[ca][fa]=k--;

vibora2(v,fa,fb,ca+1,cb,k);

void vibora1(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[cb][fa]=k--;

vibora1(v,fa,fb,ca,cb-1,k);

void vibora(TStringGrid *v , int fa , byte fb, byte ca, byte cb, byte &k)

if (fa-1<fb) {

vibora1(v,fa,fb,ca,cb,k);

vibora2(v,fa+1,fb,ca+1,cb,k);

vibora(v,fa+2,fb,ca+2,cb,k);

void __fastcall TForm1::triangularsuperiorvibora1Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));
 StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=((m*m)-m)/2+m;

vibora(StringGrid1,0,m-1,0,m-1,k);

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

// 001

// 023

// 456

void inser2(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

if (cb<=fb) {

v->Cells [cb][fa]=k++;

inser2(v,fa,fb,ca,cb+1,k);

void modex2(TStringGrid *v,byte fa, byte fb,byte ca, byte cb,byte &k)

{ byte m=fb-fa+1;

if (m>0) {

inser2(v,fa,fb,ca,cb,k);

modex2(v,fa+1,fb,ca,cb-1,k);

void __fastcall TForm1::modeex21Click(TObject *Sender)

{ eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","","5"));

StringGrid1->RowCount =m ;

StringGrid1->ColCount =m;

byte k=1;

modex2(StringGrid1,0,m-1,0,m-1,k);

//examen verano 4/2019

// 001

// 032
// 456

//

void vibora23(TStringGrid *v , byte fa , byte fb, int ca, int cb, byte &k)

{ //byte n=cb-ca+1;

if (cb>=ca) {

v->Cells[cb][fb]=k--;

vibora23(v,fa,fb,ca,cb-1,k);

void vibora13(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (ca<=cb) {

v->Cells[ca][fb]=k--;

vibora13(v,fa,fb,ca+1,cb,k);

void vibora56(TStringGrid *v , byte fa , int fb, byte ca, byte cb, byte &k)

if (fb>=fa) {

vibora23(v,fa,fb,ca,cb,k);

vibora13(v,fa,fb-1,ca+1,cb,k);

vibora56(v,fa,fb-2,ca+2,cb,k);

void __fastcall TForm1::N11Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;
 StringGrid1->RowCount =m;

byte k=((m*m)-m)/2+m;

vibora56(StringGrid1,0,m-1,0,m-1,k);

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

//examen verano repechaje

void vibora24(TStringGrid *v , byte fa , byte fb, int ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[ca][fa]=k++;

vibora24(v,fa,fb,ca+1,cb,k);

void vibora14(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[cb][fa]=k++;

vibora14(v,fa,fb,ca,cb-1,k);

void vibora57(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

if (fa<=fb) {

vibora24(v,fa,fb,ca,cb,k);

vibora14(v,fa+1,fb,ca,cb-1,k);

vibora57(v,fa+2,fb,ca,cb-2,k);

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

void vibora25(TStringGrid *v , byte fa , byte fb, int ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[ca][fa]=k++;
 vibora25(v,fa,fb,ca+1,cb,k);

void vibora15(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[cb][fa]=k++;

vibora15(v,fa,fb,ca,cb-1,k);

void vibora58(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

if (fa<=fb) {

vibora25(v,fa,fb,ca,cb,k);

vibora15(v,fa+1,fb,ca+1,cb,k);

vibora58(v,fa+2,fb,ca+2,cb,k);

void __fastcall TForm1::N101Click(TObject *Sender)

//eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

vibora58(StringGrid1,0,m-1,0,m-1,k);

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

//algoritmo de warshall

byte buscarfil(TStringGrid *v , byte f,byte c)

{ byte i=0;

byte pos;

byte k;

bool b=true;

while ((i<=c)&&(b))

k=StrToInt(v->Cells [i][f]);

if (k>0) {

pos=i;

b=false;

i++;

return pos;

byte buscarcol(TStringGrid *v , byte f,byte c)

{ byte i=0;

byte pos;

byte k;

bool b=true;

while ((i<=f)&&(b))

k=StrToInt(v->Cells [c][i]);

if (k>0) {

pos=i;

b=false;

i++;

return pos;

void warshall(TStringGrid *v , byte fa,byte fb,byte ca,byte cb,byte n)

{ byte i=0;

byte pos;

bool b=true;

for (i = 0; i < fb; i++) {

byte f=buscarfil(v,i,i);

byte c=buscarcol(v,i,i);
 v->Cells [c][f]=1;

void __fastcall TForm1::algdewarshal1Click(TObject *Sender)

//eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte k=StrToInt(InputBox("","cuantas veces",""));

byte m= StringGrid1->ColCount;

byte n= StringGrid1->RowCount ;

warshall(StringGrid1,0,n-1,0,m-1,k);

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

void cargarm(TStringGrid *v,byte n )

byte i=v->ColCount ;

if (n>0) {

//j , i

v->Cells[(n-1)%i][(n-1)/i]=InputBox("","","");

cargarm(v,n-1);

void __fastcall TForm1::Button2Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

cargarm(StringGrid1,m*n);

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

//modelo de examen 1

void cargarfilasss(TStringGrid *m , byte fa , byte fb, byte ca, byte cb, byte &k)

byte n=cb-ca+1;

if (n>0){

m->Cells[ca][fa]=k;

k=k+2;

cargarfilasss(m,fa,fb,ca+1,cb,k);

void auxmod(TStringGrid *m , byte fa , byte fb, byte ca, byte cb, byte &k)

byte n=fb-fa+1;

if (n>0){

cargarfilasss(m,fa,fb,ca,cb,k);

auxmod(m,fa+1,fb,ca+1,cb,k);

void __fastcall TForm1::hola1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

byte k=1;

auxmod(StringGrid1,0,m-1,0,n-1,k);

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

//mod ex 2
void cargarfilassss(TStringGrid *m , byte fa , byte fb, byte ca, byte cb, byte &k)

byte n=cb-ca+1;

if (n>0){

m->Cells[cb][fa]=k++;

cargarfilassss(m,fa,fb,ca,cb-1,k);

void auxmod2(TStringGrid *m , byte fa , byte fb, byte ca, byte cb, byte &k)

byte n=fb-fa+1;

if (n>0){

cargarfilassss(m,fa,fb,ca,cb,k);

k=1;

auxmod2(m,fa+1,fb,ca,cb-1,k);

//rellenar con 1

void cargarfilassss2(TStringGrid *m , byte fa , byte fb, byte ca, byte cb)

byte n=cb-ca+1;

if (n>0){

m->Cells[ca][fb]=1;

cargarfilassss2(m,fa,fb,ca+1,cb);

void auxmod3(TStringGrid *m , byte fa , byte fb, byte ca, byte cb)

byte n=fb-fa+1;

if (n>0){

cargarfilassss2(m,fa,fb,ca,cb);

auxmod3(m,fa,fb-1,ca+1,cb);

}
void __fastcall TForm1::modex21Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

byte k=1;

auxmod2(StringGrid1,0,m-1,0,n-1,k);

auxmod3(StringGrid1,0,m-1,0,n-1);

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

//examen de prueba continuacion en vectores

void Exprueba3(TStringGrid *m , byte fa , byte fb, byte ca, byte cb,byte &k)

if (cb>=ca){

m->Cells[ca][fa]=k++;

Exprueba3(m,fa,fb,ca+1,cb,k);

void Exprueba3_1(TStringGrid *m , byte fa , byte fb, byte ca, byte cb,byte &k)

{ byte n=cb-ca+1;

if (n>0){

m->Cells[cb][fa]=k++;

Exprueba3_1(m,fa,fb,ca,cb-1,k);

void Exprueba3_2(TStringGrid *m , byte fa , byte fb, byte ca, byte cb,byte &k)

{ byte n=fb-fa+1;

if (n>0){

if (fa%2==0){

Exprueba3(m,fa,fb,ca,cb,k);}

else {

Exprueba3_1(m,fa,fb,ca,cb,k); }
 Exprueba3_2(m,fa+1,fb,ca,cb,k);

void __fastcall TForm1::exdeprueba31Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

byte k=1;

Exprueba3_2(StringGrid1,0,m-1,0,n-1,k);

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

//examen 1/2020

// 654

// 230

// 100

//

void viboraexamen(TStringGrid *v , byte fa , byte fb, int ca, int cb, byte &k)

{ //byte n=cb-ca+1;

if (cb>=ca) {

v->Cells[ca][fa]=k--;

viboraexamen(v,fa,fb,ca+1,cb,k);

void viboraexamen_1(TStringGrid *v , byte fa , byte fb, int ca, int cb, byte &k)

{ //byte n=cb-ca+1;

if (cb>=ca) {

v->Cells[cb][fa]=k--;

viboraexamen_1(v,fa,fb,ca,cb-1,k);
 }

void viboraexamen2(TStringGrid *v , byte fa , byte fb, byte ca, byte cb, byte &k)

{ byte n=cb-ca+1;

if (n>0) {

v->Cells[cb][fa]=k--;

viboraexamen2(v,fa,fb,ca,cb-1,k);

void viboraExamen(TStringGrid *v , byte fa , int fb, byte ca, byte cb, byte &k)

if (fb>=fa) {

if (fa%2==0) {

if (fb+1%2==1) {

viboraexamen(v,fa,fb,ca,cb,k);

}else{

viboraexamen_1(v,fa,fb,ca,cb,k);}

}else

viboraexamen2(v,fa,fb,ca,cb,k);

viboraExamen(v,fa+1,fb,ca,cb-1,k);

//

void paladerecha(TStringGrid *v ,byte ca, byte fb,int n,byte k,byte n2)

if (n>0) {

v->Cells[ca][fb]=(n2%2==1)?k--:k++;

paladerecha(v,ca+1,fb,n-1,k,n2);

}
void all(TStringGrid *v ,byte fb, byte ca, int &n, byte &k)

{ byte n2=fb+1;

if (n2>0) {

if (n%2==1){

paladerecha(v,ca,fb,n,k,n);

k++; }

else{

paladerecha(v,ca,fb,n,k,n);

k=k+(2*n); }

n++;

all(v,fb-1,ca,n,k);

void __fastcall TForm1::pregunta31Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m = StrToInt(InputBox("Filas", "nro",""));

byte n = StrToInt(InputBox("Columnas", "nro",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount =n;

// byte k=((m*m)-m)/2+m;

byte k=1;

int n2=1;

all(StringGrid1,m-1,0,n2,k);
}

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

//1111111

//244443

//25773

//2563

//253

//23

//2

void LlenaTriangEsp(TStringGrid *A, Word fa, Word fb, Word ca, Word cb, Word k){

byte n=cb-ca+1;

if (n>0) {

A->Cells[cb][fa]=k;

LlenaTriangEsp(A,fa,fb,ca,cb-1,k);

void Llena1TriangEsp(TStringGrid *A, Word fa, Word fb, Word ca, Word cb, Word k){

byte n=fb-fa+1;

if (n>0) {

A->Cells[ca][fa]=k;

Llena1TriangEsp(A,fa+1,fb,ca,cb,k);

void Llena2TriangEsp(TStringGrid *A, Word fa, Word fb, Word ca, Word cb, Word k){

byte n=cb-ca+1;

if (n>0) {

A->Cells[ca][fb]=k;

Llena2TriangEsp(A,fa,fb-1,ca+1,cb,k);

void TriangEsp(TStringGrid *A, Word fa, Word fb, Word ca, Word cb, Word &k){

byte n=(A->ColCount %2==0)?0:1;

if (fa<cb) {
LlenaTriangEsp(A,fa,fb,ca,cb,k);

k++;

Llena1TriangEsp(A,fa+1,fb,ca,cb,k);

k++;

Llena2TriangEsp(A,fa+1,fb-1,ca+1,cb-1,k);

k++;

TriangEsp(A,fa+1,fb-2,ca+1,cb-2,k);

void __fastcall TForm1::matrizcaracoltriangular1Click(TObject *Sender)

byte m=StrToInt(InputBox("","Inserte la cantidad de filas y columnas",""));

StringGrid1->RowCount=m;

StringGrid1->ColCount=m;

Word k=1;

TriangEsp(StringGrid1,0,m-1,0,m-1,k);

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

//practicando modelos de examenes 2/2020

//pregunta 1 matriz

//45678

//34567

//23456

//12345

void Cargar_Fila(TStringGrid*m,byte f,byte ca,byte cb,byte k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [ca][f]=k;

Cargar_Fila(m,f,ca+1,cb,k+1);

}
void Matrizmod1(TStringGrid*m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

Cargar_Fila(m,fb,ca,cb,k);

k++;

Matrizmod1(m,fa,fb-1,ca,cb,k);

void __fastcall TForm1::cargarmatrizcortesdiagonales1Click(TObject *Sender)

byte m=StrToInt(InputBox("","",""));

StringGrid1->ColCount =m;

StringGrid1->RowCount =m;

byte k=1;

Matrizmod1(StringGrid1,0,m-1,0,m-1,k);

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

//pregunta2 vector

//v(0,1,2,3,6,7,14.....)

void serieVector(TStringGrid*v,byte n,int &k){

if (n>0) {

serieVector(v,n-1,k);

v->Cells [n-1][0]=k;

k=(n%2!=0)?k+1:k*2;

void __fastcall TForm1::serievector012361Click(TObject *Sender)

{
byte n=StrToInt(InputBox("","inserte un nro",""));

int k=0;

StringGrid1->ColCount =n;

serieVector(StringGrid1,n,k);

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

//pregunta 3 vector suma de elementos en un rango del vector a,b

byte sumaEleVect(TStringGrid*v,byte a,byte b){

byte s;

if (b==a)

s=StrToInt(v->Cells [a][0]);

else{

s=sumaEleVect(v,a,b-1);

s=s+StrToInt(v->Cells [b-1][0]);

return s;

void __fastcall TForm1::sumarelementosdeunvectorentreab1Click(TObject *Sender)

byte a=StrToInt(InputBox("","inserte a",""));

byte b=StrToInt(InputBox("","inserte b",""));

ShowMessage(IntToStr(sumaEleVect(StringGrid1,a,b)));

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

//pregunta 4 insertar v2 en v1 apartir de una posicion

void recorrer(TStringGrid*v,byte n,byte p){

if (n>p+1) {

v->Cells [n-1][0]=v->Cells [n-2][0];

recorrer(v,n-1,p);

void insertarVect2(TStringGrid*v,TStringGrid*v2,byte k,byte p){

 if (k <v2->ColCount ) {

v->ColCount++;

recorrer(v,v->ColCount ,p+k);

v->Cells [p+k][0]=v2->Cells [k][0];

insertarVect2(v,v2,k+1,p);

void __fastcall TForm1::insertarv2env1apartisdepos1Click(TObject *Sender)

byte p=StrToInt(InputBox("","posicion",""));

byte n=StringGrid1->ColCount ;

byte k=0;

//StringGrid1->ColCount ++;

//recorrer(StringGrid1,n+1,p);

insertarVect2(StringGrid1,StringGrid2,k,p);

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

void __fastcall TForm1::Button4Click(TObject *Sender)

eliminarc(StringGrid2,0,StringGrid2->RowCount ,0,StringGrid2->ColCount );

byte n = StrToInt(InputBox("dimension", "cant de elementos",""));

StringGrid2->ColCount =n;

cargar(StringGrid2,n*n);

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

//1,2,3,4

//8,7,6,5

//8,10,11,12

//16,15,14,13

void izqDer(TStringGrid*m,byte f,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {
 m->Cells [ca][f]=k++;

izqDer(m,f,ca+1,cb,k);

void derIzq(TStringGrid*m,byte f,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [cb][f]=k++;

derIzq(m,f,ca,cb-1,k);

void princi(TStringGrid*m,byte fa,byte fb,byte ca,byte cb,byte &k){

if (fb>fa-1) {

izqDer(m,fa,ca,cb,k);

if (fa+1<=fb)

derIzq(m,fa+1,ca,cb,k);

princi(m,fa+2,fb,ca,cb,k);

void __fastcall TForm1::matrizviboritaenfilas1Click(TObject *Sender)

byte m=StrToInt(InputBox("","",""));

StringGrid1->ColCount =m;

StringGrid1->RowCount =m;

byte k=1;

princi(StringGrid1,0,m-1,0,m-1,k);

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

//

int IsDig(char c){

String cad="0123456789";

return cad.Pos(c);

}
void SoloNumeros(String &cad){

int L=cad.Length();

if (L>0) {

char UltCar=cad[L];

cad.Delete(L,1);

SoloNumeros(cad);

if (IsDig(UltCar)>0 ) {

cad=cad+UltCar;

}else

cad=cad+" ";

int preguntaCad(String &cad){

SoloNumeros(cad);

cad=cad.Trim() ;

int may;

if (cad=="") {

may=0;

else{

byte pos=cad.LastDelimiter(' ') ;

String nro=cad.SubString(pos+1,cad.Length() );

cad.Delete(pos+1,cad.Length());

may=preguntaCad(cad);

if (StrToInt(nro)>may)

may=StrToInt(nro);

return may;

void __fastcall TForm1::pregunta1Click(TObject *Sender)

String cad=Edit1 ->Text;

 ShowMessage(preguntaCad(cad));

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

//

void load(TStringGrid *v,int fa,byte fb, byte ca, byte cb, byte &k,byte &j)

if (fa>=0) {

v->Cells [ca][fa]=k++;

v->Cells [cb][fb]=j--;

load(v,fa-1,fb+1,ca+1,cb-1,k,j);

void cortesdiag(TStringGrid *v,byte fa,byte fb, byte ca, byte cb, byte &k,byte &j)

byte n=fb-fa+1;

if (fa<=cb) {

load(v,fa,fb,ca,cb,k,j);

cortesdiag(v,fa+1,fb-1,ca,cb,k,j);

void __fastcall TForm1::pregunta21Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte j=m*m;

byte k=1;

cortesdiag(StringGrid1,0,m-1,0,m-1,k,j);

}
//---------------------------------------------------------------------------

void cadVec(TStringGrid*v,String cad){

cad=cad.Trim() ;

int l=cad.Length() ;

if (l>0) {

int pos = cad.LastDelimiter(' ');

String pal=cad.SubString(pos+1,l-pos);

cad.Delete(pos+1,l-pos);

cadVec(v,cad);

v->Cells [v->ColCount -1][0]=pal;

v->ColCount ++;

void __fastcall TForm1::palabrasavector1Click(TObject *Sender)

cadVec(StringGrid1,Edit1->Text );

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

int fibo(int n){

int s;

if (n==0) {

s=0;

}else if (n==1) {

s=1;

else{

s=fibo(n-1)+fibo(n-2);

return s;

}
void __fastcall TForm1::fibonacci1Click(TObject *Sender)

ShowMessage(fibo(StrToInt(Edit1->Text)));

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

void aderecha(TStringGrid* m,byte fa,byte ca,byte cb,byte &k){

if (ca<cb) {

int n=k;

m->Cells [ca][fa]=fibo(n);

k++;

aderecha(m,fa,ca+1,cb,k);

void aabajo(TStringGrid* m,byte fa,byte fb,byte cb,byte &k){

if (fa<fb) {

int n=k;

m->Cells [cb][fa]=fibo(n);

k++;

aabajo(m,fa+1,fb,cb,k);

void aizquierda(TStringGrid* m,byte fb,byte ca,byte cb,byte &k){

if (cb>ca) {

int n=k;

m->Cells [cb][fb]=fibo(n);

k++;

aizquierda(m,fb,ca,cb-1,k);

void aarriba(TStringGrid* m,byte fa,byte fb,byte ca,byte &k){

if (fb>fa) {

int n=k;

m->Cells [ca][fb]=fibo(n);
 k++;

aarriba(m,fa,fb-1,ca,k);

void vibFibo(TStringGrid* a,byte fa,byte fb,byte ca,byte cb,byte &k){

byte m=fb-fa+1;

byte n=cb-ca+1;

if (m*n>0) {//caso base m=0 o n=0

if (m*n==1){ //2do caso base

int n=k;

a->Cells[ca][fb]=fibo(n);}

else {//caso general

aderecha(a,fa,ca,cb,k);//k= dato inicial

aabajo(a,fa,fb,cb,k);

aizquierda(a,fb,ca,cb,k);

aarriba(a,fa,fb,ca,k);

vibFibo(a,fa+1,fb-1,ca+1,cb-1,k);

void __fastcall TForm1::matrizviboracaracol1Click(TObject *Sender)

eliminarc(StringGrid1,0,StringGrid1->RowCount ,0,StringGrid1->ColCount );

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

vibFibo(StringGrid1,0,m-1,0,m-1,k);

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

int mayor(int n){

byte may;

if (n>0) {
 int dig=n%10;

may=mayor(n/10);

if (dig>may)

may=dig;

}else

may=0;

void movMayFinal(int n){

if (n>0) {

int dig=n%10;

movMayFinal(n/10);

void recorrer2(TStringGrid*v,byte n,byte p){

if (n>p+1) {

recorrer2(v,n-1,p);

v->Cells [n-2][0]=v->Cells [n-1][0];

void EliminarX(TStringGrid *v,byte n, int x){

if (n>0) {

int ele=StrToInt(v->Cells [n-1][0]);

if (x==ele) {

recorrer2(v,v->ColCount,n-1);

v->ColCount --;

EliminarX(v,n-1,x);

void __fastcall TForm1::pregunta11Click(TObject *Sender)

{
 EliminarX(StringGrid1,StringGrid1->ColCount ,StrToInt(Edit1->Text) );

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

void __fastcall TForm1::eliminareledeunapos1Click(TObject *Sender)

recorrer2(StringGrid1,StringGrid1->ColCount ,StrToInt(Edit1->Text) );

StringGrid1->ColCount --;

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

int serie(int n,int &k){

int s;

if (n>1) {

s=serie(n-1,k);

s=s+k;

k=k+2;

}else

s=2;

return s;

String Serie(int n,int &k){

String s;

String x;

if (n>0){

k=3;

x=IntToStr(serie(n,k));

s=Serie(n-1,k);

s=s+","+x;

}else

s="";

return s;

}
void __fastcall TForm1::serie14387sumatoria1Click(TObject *Sender)

int k=3;

Edit1->Text =Serie(StrToInt(InputBox("","n","")),k);

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

//600

//540

//321

void ejercicio1columnak(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [cb][fb]=k++;

ejercicio1columnak(m,fa,fb,ca,cb-1,k);

void ejercicio1k(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

ejercicio1columnak(m,fa,fb,ca,cb,k);

ejercicio1k(m,fa,fb-1,ca,cb-1,k);

void __fastcall TForm1::matriztriangular1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

ejercicio1k(StringGrid1,0,m-1,0,m-1,k);

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

//600

//540
//321

void ejercicio2columnak(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

m->Cells [ca][fa]=k++;

ejercicio2columnak(m,fa+1,fb,ca,cb,k);

void ejercicio2k(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

ejercicio2columnak(m,fa,fb,ca,cb,k);

ejercicio2k(m,fa+1,fb,ca+1,cb,k);

void __fastcall TForm1::matriztriangular21Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

ejercicio2k(StringGrid1,0,m-1,0,m-1,k);

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

void ejercicio3columnak(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

m->Cells [ca][fa]=k++;

ejercicio3columnak(m,fa+1,fb,ca,cb,k);

void ejercicio3columna2k(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

 byte n=fb-fa+1;

if (n>0) {

m->Cells [ca][fb]=k++;

ejercicio3columna2k(m,fa,fb-1,ca,cb,k);

void ejercicio3k(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

if (ca%2==0) {

ejercicio3columnak(m,fa,fb,ca,cb,k);

} else{

ejercicio3columna2k(m,fa,fb,ca,cb,k);

ejercicio3k(m,fa,fb,ca+1,cb,k);

void __fastcall TForm1::Matriz3k1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

byte n= StrToInt(InputBox("","dimencion",""));

StringGrid1->RowCount =m;

StringGrid1->ColCount = n;

byte k=1;

ejercicio3k(StringGrid1,0,m-1,0,n-1,k);

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

void ejercicio5filak(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

m->Cells [cb][fa]=k;

ejercicio5filak(m,fa+1,fb,ca,cb,k);
 }

void ejercicio5columnak(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [ca][fb]=k;

ejercicio5columnak(m,fa,fb,ca+1,cb,k);

void ejercicio5k(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

ejercicio5filak(m,fa,fb,ca,cb,k);

ejercicio5columnak(m,fa,fb,ca,cb,k);

k++;

ejercicio5k(m,fa,fb-1,ca,cb-1,k);

void __fastcall TForm1::Matriz51Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

ejercicio5k(StringGrid1,0,m-1,0,m-1,k);

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

void examencol(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [ca][fa]=k;

examencol(m,fa,fb,ca+1,cb,k+1);
 }

void examencol2(TStringGrid* m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

examencol(m,fa,fb,ca,cb,k);

k++;

examencol2(m,fa+1,fb,ca,cb,k);

//

void Ejercicio2(TStringGrid* a,byte za,byte zb,byte p,byte d,byte k){

byte n=d-p+1;

if (n>0) {

a->Cells [p][za]=k;

Ejercicio2(a,za,zb,p+1,d,k+1);

void Ejercicio21(TStringGrid* a,byte za,byte zb,byte p,byte d,byte &k){

byte n=zb-za+1;

if (n>0) {

Ejercicio2(a,za,zb,p,d,k);

k++;

Ejercicio21(a,za+1,zb,p,d,k);

void __fastcall TForm1::matrizcortes1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;
 byte k=1;

examencol2(StringGrid1,0,m-1,0,m-1,k);

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

double CantDig (int n) {

int c=0;

while (n>0){

n=n/10;

c++;

return c;

String examen12(int x, String s){

if(x>0) {

int z=pow(10,CantDig(x)-1);

int p=x/z;

int c=0;

String d="";

while (c<p){

d=d+p;

c++;

x=x%z;

s=d+examen12(x,s);

return s;

String digitos(byte d,byte d2){

String s;

if (d==0) {

s="";
 }else{

s=digitos(d-1,d2);

s=s+d2;

return s;

String examen112(int n){

String s;

if (n>0) {

byte d=n%10;

s=examen112(n/10);

s=s+digitos(d,d);

}else{

s="";

return s;

void __fastcall TForm1::ndigacadena1Click(TObject *Sender)

Edit3->Text =examen112(StrToInt(Edit2->Text));

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

void mesa1(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=cb-ca+1;

if (n>0) {

m->Cells[ca][fa]=k;

mesa1(m,fa,fb,ca+1,cb,k+1);

void mesa2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=cb-ca+1;

if (n>0) {

m->Cells[cb][fa]=k;
 mesa2(m,fa,fb,ca,cb-1,k+1);

void mesa(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;

if (n>0) {

if (fa%2==0) {

mesa2(m,fa,fb,cb,fb,k);

else {

mesa1(m,fa,fb,cb,fb,k);

mesa(m,fa+1,fb,ca,cb-1,k+fa+1);

void __fastcall TForm1::matriztriangular2Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

mesa(StringGrid1,0,m-1,0,m-1,1);

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

void mesa11(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;

if (n>0) {

m->Cells[cb][fa]=k;

mesa11(m,fa+1,fb,ca,cb,k+1);

void mesa22(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;
 if (n>0) {

m->Cells[cb][fb]=k;

mesa22(m,fa,fb-1,ca,cb,k+1);

void mesaa(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;

if (n>0) {

if (fa%2==0) {

mesa11(m,fa,fb,ca,cb,k);

else {

mesa22(m,fa,fb,ca,cb,k);

mesaa(m,fa+1,fb,ca,cb-1,k+fb-fa+1);

//cambiado

void llenarC(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;

if (n>0) {

m->Cells[cb][fa]=k;

llenarC(m,fa+1,fb,ca,cb,k+1);

void llenarC2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;

if (n>0) {

m->Cells[cb][fb]=k;

llenarC2(m,fa,fb-1,ca,cb,k+1);

void pregunta2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte k){

byte n=fb-fa+1;
 if (n>0) {

if (fa%2==0)

llenarC(m,fa,fb,ca,cb,k);

else

llenarC2(m,fa,fb,ca,cb,k);

k=k+fb-fa+1;

pregunta2(m,fa+1,fb,ca,cb-1,k);

void __fastcall TForm1::matriztriangularenbajada1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

pregunta2(StringGrid1,0,m-1,0,m-1,1);

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

void practejer2_1(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells[cb][fb]=k++;

practejer2_1(m,fa,fb,ca,cb-1,k);

void practejer2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

practejer2_1(m,fa,fb,ca,cb,k);

practejer2(m,fa,fb-1,ca,cb,k);

}
void __fastcall TForm1::viboraenfilasdesdeabajohacialaizquiera1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte k=1;

practejer2(StringGrid1,0,m-1,0,m-1,k);

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

void practejer3_1(TStringGrid *m,byte fa,byte fb,byte ca,byte cb){

byte n=cb-ca+1;

if (n>0) {

m->Cells[ca][fa]=1;

practejer3_1(m,fa,fb,ca+1,cb);

void practejer3(TStringGrid *m,byte fa,byte fb,byte ca,byte cb){

byte n=fb-fa+1;

if (n>0) {

m->Cells[ca][fa]=1;

practejer3(m,fa+1,fb,ca,cb);

void __fastcall TForm1::matrizcruz1Click(TObject *Sender)

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = m;

StringGrid1->RowCount =m;

byte fa=m/2;

practejer3_1(StringGrid1,fa,m-1,0,m-1);

practejer3(StringGrid1,0,m-1,fa,m-1);
}

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

void practejer1_1(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells[ca][fa]=k;

practejer1_1(m,fa,fb,ca+1,cb,k);

void practejer1(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

practejer1_1(m,fa,fb,ca,cb,k);

k++;

practejer1(m,fa+1,fb,ca+1,cb-1,k);

void __fastcall TForm1::matrizpuntadecarta1Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

byte m=(n/2)+1;

StringGrid1->ColCount = n;

StringGrid1->RowCount =m;

byte k=0;

practejer1(StringGrid1,0,m-1,0,n-1,k);

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

int suma_aux(TStringGrid *v,int n){

int s;

if (n==1) {

s=StrToInt(v->Cells [n-1][0]);

}else{

s=suma_aux(v,n-1);
 int ele=StrToInt(v->Cells [n-1][0]);

s=s+ele;

return s;

void __fastcall TForm1::sumdeelementosdeunvect1Click(TObject *Sender)

int n=StringGrid2->ColCount;

Edit2->Text = IntToStr(suma_aux(StringGrid2,n));

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

int mayor_aux(TStringGrid *v,int n){

int may;

if (n==1) {

may=StrToInt(v->Cells [n-1][0]);

}else{

may=mayor_aux(v,n-1);

//poner lo que iria dentro del while

int ele=StrToInt(v->Cells [n-1][0]);

if (ele>may) {

may=ele;

return may;

void __fastcall TForm1::mayordeunvector1Click(TObject *Sender)

int n=StringGrid2->ColCount;

Edit2->Text = IntToStr(mayor_aux(StringGrid2,n));
}

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

void numeroVector_aux(TStringGrid *v,int n){

if (n<10) {

v->Cells [v->ColCount-1][0]=n;

}else{

int ele=n%10;

v->Cells [v->ColCount-1][0]=ele;

numeroVector_aux(v,n/10);

void __fastcall TForm1::numeroavector1Click(TObject *Sender)

int n=StrToInt(InputBox("","",""));

numeroVector_aux(StringGrid2,n);

//StringGrid2->ColCount --;

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

void serie_aux(TStringGrid *v,int n,int n2){

if (n2==1) {

v->Cells [n2-1][0]=pow(n2,n-(n2-1));

}else{

serie_aux(v,n,n2-1);

v->Cells [n2-1][0]=pow(n2,n-(n2-1));

v->ColCount ++;

void __fastcall TForm1::serievector1Click(TObject *Sender)

{
 int n=StrToInt(InputBox("","",""));

serie_aux(StringGrid2,n,n);

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

void cargarFila_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [ca][fa]=k++;

cargarFila_aux(m,fa,fb,ca+1,cb,k);

void cargarFila2_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [cb][fb]=k++;

cargarFila2_aux(m,fa,fb,ca,cb-1,k);

void cargarCol_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

m->Cells [cb][fa]=k++;

cargarCol_aux(m,fa+1,fb,ca,cb,k);

void cargarCol2_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

m->Cells [ca][fb]=k++;

cargarCol2_aux(m,fa,fb-1,ca,cb,k);

void cargarCaracol_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;
byte m2=cb-ca+1;

if (m2*n>0) {//caso base m=0 o n=0

if (m2*n==1) //2do caso base

m->Cells[ca][fb]=k;

else {//caso general

cargarFila_aux(m,fa,fb,ca,cb-1,k);

cargarCol_aux(m,fa,fb-1,ca,cb,k);

cargarFila2_aux(m,fa,fb,ca+1,cb,k);

cargarCol2_aux(m,fa+1,fb,ca,cb,k);

cargarCaracol_aux(m,fa+1,fb-1,ca+1,cb-1,k);

void __fastcall TForm1::matrizcaracol1Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

cargarCaracol_aux(StringGrid1,0,n-1,0,n-1,k);

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

void cargarFila2_aux2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [ca][fa]=k++;

cargarFila2_aux2(m,fa,fb,ca+1,cb,k);

void cargarFila3_aux2(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=cb-ca+1;

if (n>0) {

m->Cells [cb][fa]=k++;
 cargarFila3_aux2(m,fa,fb,ca,cb-1,k);

void triangular_aux(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,byte &k){

byte n=fb-fa+1;

if (n>0) {

if (fa%2!=0) {

cargarFila2_aux2(m,fa,fb,cb,fb,k);

}else{

cargarFila3_aux2(m,fa,fb,cb,fb,k);

triangular_aux(m,fa+1,fb,ca,cb-1,k);

void __fastcall TForm1::formuladelultimoenmatriztriangular1Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

triangular_aux(StringGrid1,0,n-1,0,n-1,k);

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

bool verifprimo(Cardinal n,Cardinal n2,byte &i)

{bool b;

if (n<2){

if (n==1) {

b=true;

i=1;

}else{

b=false;
 i=1;

else{

b=verifprimo(n-1,n2,i);

if (n2%n==0)

i++;

b=(i==2)?true:false;

return b;

int cantPrimos(TStringGrid *v,int n){

int c;

int ele;

byte i=1;

if (n==1) {

ele=StrToInt(v->Cells [n-1][0]);

if (verifprimo(ele,ele,i)) {

c=1;

}else{

c=0;

}else{

c=cantPrimos(v,n-1);

ele=StrToInt(v->Cells [n-1][0]);

if (verifprimo(ele,ele,i)) {

c++;

return c;

int cantidadPrimos(TStringGrid *v,int n){

int c;

if (n==1) {
 int ele=StrToInt(v->Cells [n-1][0]);

byte i=1;

if (verifprimo(ele,ele,i))

c=1;

else

c=0;

}else{

c=cantidadPrimos(v,n-1);

int ele=StrToInt(v->Cells [n-1][0]);

byte i=1;

if (verifprimo(ele,ele,i))

c++;

return c;

void __fastcall TForm1::cantidaddeprimos1Click(TObject *Sender)

int n=StringGrid2->ColCount;

Edit2->Text = IntToStr(cantidadPrimos(StringGrid2,n));

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

Byte CantVoc(String n)

{byte c=0;

String vocales="aeiouAEIOUÁÉÍÓÚáéíóú";

if (!n.Length()==0 ) {

wchar_t car=n[1];

n.Delete(1,1);

c=CantVoc(n);

if (vocales.Pos((car))>0)

c++;

return c;

}
int cantidadVocales(TStringGrid *v,int n){

int c;

if (n==1) {

String ele=v->Cells [n-1][0];

c=CantVoc(ele);

}else{

c=cantidadVocales(v,n-1);

String ele=v->Cells [n-1][0];

c=c+CantVoc(ele);

return c;

int cantVocales(TStringGrid *v,int n){

int c;

if (n==1) {

c=CantVoc(v->Cells [n-1][0]);

}else{

c=cantVocales(v,n-1);

c=c+CantVoc(v->Cells [n-1][0]);

return c;

int cantidaVocales(TStringGrid *v,int num){

int c;

if (num==1) {

String ele=v->Cells [num-1][0];

c=CantVoc(ele);

}else{

c=cantidaVocales(v,num-1);

String ele=v->Cells [num-1][0];

c=c+CantVoc(ele);

return c;

}
void __fastcall TForm1::cantdevocales1Click(TObject *Sender)

int n=StringGrid1->ColCount;

Edit2->Text = IntToStr(cantidadVocales(StringGrid1,n));

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

void MinMaxFil(TStringGrid *m,byte ca,byte cb,byte fa,int &may,int &men){

byte n=cb-ca+1;

if(n>0) {

int ele = StrToInt(m -> Cells[ca][fa]);

if ((may==0)&&(men==0)) {

may = ele;

men = ele;

if (ele>may)

may = ele;

if(ele<men)

men=ele;

MinMaxFil(m,ca+1,cb,fa,may,men);

void MinMax(TStringGrid *m,byte fa,byte fb,byte ca,byte cb,int &may,int &men){

byte n = fb-fa+1;

if (n>0){

MinMaxFil(m,ca,cb,fa,may,men);

MinMax(m,fa+1,fb,ca,cb,may,men);

void __fastcall TForm1::maxymin1Click(TObject *Sender)

{
 byte n=StringGrid1->RowCount;

byte m=StringGrid1->ColCount;

int min=0;

int max=0;

MinMax(StringGrid1,0,n-1,0,m-1,max,min);

ShowMessage("Min= "+IntToStr(min)+" Max= "+IntToStr(max));

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

//cargar matriz triangular superior

void preguntamatriz2(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [ca][fa]=0;

preguntamatriz2(v,fa,fb,ca+1,cb,k);

void preguntamatriz22(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte n=fb-fa +1;

if (n>0) {

preguntamatriz2(v,fa,fb,ca,cb,k);

preguntamatriz22(v,fa+1,fb,ca,cb,k);

void preguntamatriz(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [ca][fa]=k;

preguntamatriz(v,fa,fb,ca+1,cb,k+2);

void preguntamatriz1(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

{

byte n=fb-fa +1;

if (n>0) {

preguntamatriz(v,fa,fb,ca,cb,k);

preguntamatriz1(v,fa+1,fb,ca+1,cb,k);

void __fastcall TForm1::matriztrisup1Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

preguntamatriz22(StringGrid1,0,n-1,0,n-1,k);

preguntamatriz1(StringGrid1,0,n-1,0,n-1,k);

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

void parcialfila(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [cb][fb]=k;

parcialfila(v,fa,fb,ca,cb-1,k);

void parcialfila2(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=cb-ca +1;

if (m>0) {

v->Cells [ca][fb]=k;

parcialfila2(v,fa,fb,ca+1,cb,k+1);

void parcialmatriz(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

{

byte n=fb-fa +1;

if (n>0) {

parcialfila(v,fa,fb,ca,cb,k);

parcialfila2(v,fa,fb,0,ca,1);

parcialmatriz(v,fa,fb-1,ca+1,cb,k+1);

void __fastcall TForm1::matriz1Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

parcialmatriz(StringGrid1,0,n-1,0,n-1,1);

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

//AUXILIATURA 1 2022

void aux_cargarCol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fa]=k++;

aux_cargarCol(v,fa,fb,ca+1,cb,k);

void aux_cargarFil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

aux_cargarCol(v,fa,fb,ca,cb,k);
 aux_cargarFil(v,fa+1,fb,ca,cb,k);

void __fastcall TForm1::ejercicio11Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =m;

byte k=1;

aux_cargarFil(StringGrid1,0,m-1,0,n-1,k);

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

void aux2_cargarCol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fb]=k++;

aux2_cargarCol(v,fa,fb,ca+1,cb,k);

void aux2_cargarFil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

aux2_cargarCol(v,fa,fb,ca,cb,k);

aux2_cargarFil(v,fa,fb-1,ca,cb-1,k);

}
void __fastcall TForm1::ejercicio21Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

aux2_cargarFil(StringGrid1,0,n-1,0,n-1,k);

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

void aux3_cargarCol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k,bool b)

byte m=cb-ca+1;

if (m>0) {

if (b) {

v->Cells [ca][fb]=k++;

aux3_cargarCol(v,fa,fb,ca+1,cb,k,b);

}else{

v->Cells [cb][fb]=k++;

aux3_cargarCol(v,fa,fb,ca,cb-1,k,b);

void aux3_cargarFil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k,bool b)

byte m=fb-fa+1;

if (m>0) {

aux3_cargarCol(v,fa,fb,ca,cb,k,b);

aux3_cargarFil(v,fa,fb-1,ca,cb-1,k,!b);

}
}

void __fastcall TForm1::ejercicio31Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

aux3_cargarFil(StringGrid1,0,n-1,0,n-1,k,true);

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

void aux4_cargarFil(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fa]=k;

aux4_cargarFil(v,fa,fb,ca+1,cb,k);

void aux4_cargarCol(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte k)

byte m=fb-fa+1;

if (m>0) {

v->Cells [ca][fa]=k;

aux4_cargarCol(v,fa+1,fb,ca,cb,k);

void aux4_cargarp(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

aux4_cargarCol(v,fa,fb,ca,cb,k);

aux4_cargarFil(v,fa,fb,ca,cb,k);

k++;
 aux4_cargarp(v,fa+1,fb,ca+1,cb,k);

void __fastcall TForm1::ejercicio41Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));

byte m=StrToInt(InputBox("","dimencion",""));

StringGrid1->ColCount = n;

StringGrid1->RowCount =m;

byte k=1;

aux4_cargarp(StringGrid1,0,m-1,0,n-1,k);

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

void aux5_cargarcorte(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=cb-ca+1;

if (m>0) {

v->Cells [ca][fb]=k++;

aux5_cargarcorte(v,fa,fb-1,ca+1,cb,k);

void aux5_cargarp(TStringGrid *v,byte fa,byte fb,byte ca,byte cb,byte &k)

byte m=fb-fa+1;

if (m>0) {

aux5_cargarcorte(v,fa,fa,ca,fa,k);

aux5_cargarp(v,fa+1,fb,ca,cb,k);

void __fastcall TForm1::ejercicio51Click(TObject *Sender)

byte n=StrToInt(InputBox("","dimencion",""));
 StringGrid1->ColCount = n;

StringGrid1->RowCount =n;

byte k=1;

aux5_cargarp(StringGrid1,0,n-1,0,n-1,k);

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