///**************************************************************************//////*****************************
NATURALES
******************************//////**************************************************************************///
//------------------------------------------------------------------------------//
1) PROGRAMA QUE MUESTRA LOS PRIMEROS N NMEROS NATURALES //void
Mostrar( byte n ) { if ( n == 0 ) { } else { Mostrar( n - 1 );
ShowMessage( n );
}}//------------------------------------------------------------------------------//
2) PROGRAMA QUE MUESTRA LOS PRIMEROS N NMEROS NATURALES INVERTIDOS
//void Mostrar1( byte n ) { if ( n == 0 ) { } else { ShowMessage( n
); Mostrar1( n - 1 );
}}//------------------------------------------------------------------------------//
3) PROGRAMA QUE MUESTRA LOS PRIMEROS N NMEROS PARES //void
MostrarPares( byte n ) { if ( n == 0 ) { } else { MostrarPares( n -
1 ); ShowMessage( n * 2 - 2 );
}}//------------------------------------------------------------------------------//
4) PROGRAMA QUE ELIMINA LOS DGITOS PARES DE UN NMERO //void
EliminarPares( Cardinal &n ) { if ( n < 10 ) { if ( n % 2 ==
0 ) n = 0; } else { byte d; d = n % 10; n = n / 10; EliminarPares(
n ); if ( d % 2 == 1 ) n = n * 10 + d;
}}//------------------------------------------------------------------------------
// 5) PROGRAMA QUE MUESTRA LA SUMA DE LOS DGITOS PARES DE UN
NMERO //byte SumaDigitosPares( Cardinal x ) { byte sum; if ( x <
10 ) { if ( x % 2 == 0 ) sum = x; else sum = 0; } else { sum =
SumaDigitosPares( x / 10 ); if ( ( ( x % 10 ) % 2 ) == 0 ) sum =
sum + ( x % 10 ); } return ( sum
);}//------------------------------------------------------------------------------//
6) PROGRAMA QUE MUESTRA LA CANTIDAD DE DGITOS PARES DE UN NMERO
//byte CantidadPar( Cardinal x ) { byte c; if ( x < 10 ) { if (
x % 2 == 0 ) c = 1; else c = 0; } else { c = CantidadPar( x / 10 );
if ( x % 2 == 0 ) c++; } return ( c
);}//------------------------------------------------------------------------------//
7) PROGRAMA QUE MUESTRA LOS PRIMEROS N NMEROS IMPARES //void
MostrarImpares( byte n ) { if ( n == 0 ) { } else { MostrarImpares(
n - 1 ); ShowMessage( n * 2 - 1 );
}}//------------------------------------------------------------------------------
// 8) PROGRAMA QUE ELIMINA LOS DGITOS IMPARES DE UN NMERO //void
elimImpares( Cardinal &n ) { if ( n < 10 ) { if ( n % 2 == 1
) n = 0; } else { byte d; d = n % 10; n = n / 10; elimImpares( n );
if ( ( d % 2 ) == 0 ) n = n * 10 + d;
}}//------------------------------------------------------------------------------//
9) PROGRAMA QUE MUESTRA LA SUMA DE LOS DGITOS IMPARES DE UN NMERO
///*byte SumaDigitosImpares( Cardinal x ) { byte sum; if ( x <
10 ) { if ( x % 2 == 1 ) sum = x; else sum = 0; } else { sum =
SumaDigitosImpares( x / 10 ); if ( ( ( x % 10 ) % 2 ) == 1 ) sum =
sum + ( x % 10 ); } return ( sum
);}*///------------------------------------------------------------------------------//
10) PROGRAMA QUE MUESTRA LA CANTIDAD DE DGITOS IMPARES DE UN NMERO
///*byte CantidadImpar( Cardinal x ) { byte c; if ( x < 10 ) {
if ( x % 2 == 1 ) c = 1; else c = 0; } else { c = CantidadImpar( x
/ 10 ); if ( x % 2 == 1 ) c++; } return ( c
);}*///------------------------------------------------------------------------------
// 11) PROGRAMA QUE MUESTRA LA SUMA DE LOS DGITOS DE UN NMERO
//byte SumaDigitos( Cardinal n ) { byte s; if ( n < 10 ) { s =
n; } else { s = SumaDigitos( n / 10 ); s = s + n % 10; } return ( s
);}//------------------------------------------------------------------------------//
12) PROGRAMA QUE SEPARA LOS DGITOS PARES E IMPARES DE UN NMERO
//void Sep_Imp_Par( Cardinal &par, Cardinal &imp, Cardinal
n ) { if ( n < 10 ) { if ( ( n % 2 ) == 0 ) { par = n; imp = 0;
} else { imp = n; par = 0; } } else { byte d = ( n % 10 );
Sep_Imp_Par( par, imp, n / 10 ); if ( ( d % 2 ) == 0 ) par = ( par
* 10 ) + d; else imp = ( imp * 10 ) + d;
}}//------------------------------------------------------------------------------//
13) PROGRAMA QUE SEPARA DGITOS PARES E IMPARES DE DOS NMEROS //void
SepararNro( int &x, int &y ) { int a, b; a = 0; b = 0;
Sep_Imp_Par( x, a, b ); Sep_Imp_Par( y, a, b ); x = a; y =
b;}//------------------------------------------------------------------------------
// 14) PROGRAMA QUE ORDENA LOS ELEMENTOS DE UN NMERO POR EL
MTODO DE BURBUJA //void Burbuja( Cardinal &x );void OrdenarX(
Cardinal &x ) { if ( x >= 10 ) { Burbuja( x ); byte d; d = x
% 10; x = x / 10; OrdenarX( x ); x = x * 10 + d; }}void Burbuja(
Cardinal &x ) { byte d, d2; if ( x >= 10 ) { d = x % 10; x =
x / 10; Burbuja(x); d2 = x % 10; x = x / 10; if ( d < d2 ) x = (
x * 10 + d ) * 10 + d2; else x = ( x * 10 + d2 ) * 10 + d;
}}//------------------------------------------------------------------------------//
15) PROGRAMA QUE JUNTA LOS DGITOS DE 2 NMEROS EN UN SOLO NMERO
//void juntar( Cardinal x, Cardinal y, Cardinal &z ) { if ( y
< 10 ) { z = ( x * 10 ) + y; } else { byte d = y % 10; juntar(
x, y / 10, z ); z = ( z * 10 ) + d;
}}//------------------------------------------------------------------------------//
16) PROGRAMA PARA ORDENAR UN NMERO POR EL MTODO INSERTAR //void
Insertar( Cardinal &x, byte d );void Ordenar( Cardinal &x )
{ if ( x >= 10 ) { byte d; Insertar( x, d ); d = x % 10; d = x /
10; Ordenar( x ); }}
void Insertar( Cardinal &x, byte d ) { if ( x < 10 ) { if
( x < d ) x = x * 10 + d; else x = d * 10 + x; } else { byte d2;
d2 = x % 10; x = x / 10; Insertar( x, d ); if ( d2 >= ( x % 10 )
) x = x * 10 + d2; else { d = x % 10; x = x / 10; x = x * 10 + d2;
x = x * 10 + d; }
}}//------------------------------------------------------------------------------//
17) PROGRAMA QUE MUESTRA EL MENOR DGITO DE UN NMERO //byte
MenorDigito( Cardinal x ) { byte d, men = 9; if ( x >= 10 ) { d
= x % 10; x = x / 10; MenorDigito( x ); if ( d < men ) men = d;
} return ( men
);}//------------------------------------------------------------------------------//
18) PROGRAMA QUE MUESTRA EL MAYOR DGITO DE UN NMERO ///*byte
MayorDigito( Cardinal x ) { byte d, may = 0; if ( x >= 10 ) { d
= x % 10; x = x / 10; MayorDigito( x ); if ( d > may ) may = d;
} return ( may
);}*///------------------------------------------------------------------------------
// 19) PROGRAMA QUE DEVUELVE TRUE SI UN NMERO EST ORDENADO
//bool EstaOrdenado( Cardinal &x ) { bool b; if ( x < 10 ) b
= true; else { byte d; d = x % 10; x = x / 10; b = EstaOrdenado( x
); if ( d >= ( x % 10 ) ) b = true; else b = false; }}// 9.2)
HACER UN PROGRAMA QUE DEVUELVA TRUE SI UN NMERO EST ORDENADO// EJ:
X = 12379 -> TRUE// EJ: X = 489 -> TRUE// EJ: X = 74512 ->
FALSE// EJ: X = 123450 -> FALSE
bool estaOrden( int n ) { bool bb; int d; if ( n < 10 ) bb =
true; else { d = n % 10; n = n / 10; bb = estaOrden( n ); if ( bb )
{ if ( d >= ( n % 10 ) ) bb = true; else bb = false; } } return
( bb
);}//------------------------------------------------------------------------------
// 20) PROGRAMA QUE DEVUELVE EL N-SIMO TRMINO DE LA SERIE DE
FIBONACCI //Cardinal Fibo( byte n ) { Cardinal f; if ( n < 1 )
throw new Exception( "ERROR" ); else { if ( n == 1 ) f = 0; else if
( n == 2 ) f = 1; else f = Fibo( n - 2 ) + Fibo( n - 1 ); } return
( f
);}//------------------------------------------------------------------------------//
21) PROGRAMA QUE ELEVA UN NMERO X A LA N //float Potencia( Word x,
Word n ) { float p; if ( ( x == 0 ) && ( n == 0 ) ) throw
new Exception( "ERROR" ); else if ( n == 0 ) p = 1; else { p =
Potencia( x, n / 2 ); p = p * p; if ( ( n % 2 ) == 1 ) p = p * x; }
return ( p
);}//------------------------------------------------------------------------------//
22) PROGRAMA QUE DEVUELVE TRUE SI UN NMERO ES PAR //bool EsImpar(
Cardinal x );bool EsPar( Cardinal x ) { bool p; if ( x == 0 ) p =
true; else p = EsImpar( x - 1 ); return ( p );}bool EsImpar(
Cardinal x ) { bool i; if ( x == 0 ) i = false; else i = EsPar( x -
1 ); return ( i
);}//------------------------------------------------------------------------------//
23) PROGRAMA QUE MUESTRA N VECES HOLA Y UNA VEZ CHAU //void
MostrarHola( Word n ) { if ( n == 0 ) ShowMessage(" JEJE CHAU ");
else { ShowMessage( " HOLA " ); MostrarHola( n - 1 );
}}//------------------------------------------------------------------------------//
24) PROGRAMA QUE MUESTRA EL FACTORIAL DE UN NMERO //Cardinal
Factorial( byte n ) { Cardinal f; if ( n == 0 ) f = 1; else f =
Factorial( n - 1 ) * n; return ( f
);}//------------------------------------------------------------------------------//
25) PROGRAMA QUE MUESTRA EL N-SIMO TRMINO DE LA SERIE:
0.1.3.7.15.31.63..N //Word Nesimo( byte n ) { Word t; if ( n == 0 )
throw new Exception( "ERROR" ); else { if ( n == 1 ) t = 0; else t
= Nesimo( n - 1 ) * 2 + 1; } return ( t
);}//------------------------------------------------------------------------------//
26) PROGRAMA QUE MUESTRA LA SERIE: 1.2.3.6.7.14.15.30...n //int
GenerarSerie ( byte n ) { int t; if ( n == 1 ) t = 1; else { if ( (
n % 2 ) == 0 ) t = GenerarSerie( n - 1 ) * 2; else t =
GenerarSerie( n - 1 ) + 1; } return ( t
);}//------------------------------------------------------------------------------
// 27) PROGRAMA QUE MUESTRA LA SUMA DE LA SERIE:
1.2.3.6.7.14.15.30...n //int SumaSerie( byte n ) { int s; if ( n ==
0 ) s = 0; else { s = SumaSerie( n - 1 ) + GenerarSerie( n ); }
return ( s
);}//------------------------------------------------------------------------------//
28) PROGRAMA QUE SEPARA LOS DGITOS DE UN NMERO: X=34876
SALIDA:6,7,8,7,6 //byte SepararDigito( Cardinal x ) { byte d; if (
x < 10 ) ShowMessage( x ); else { d = x % 10; x = x / 10;
ShowMessage( d ); SepararDigito( x );
}}//------------------------------------------------------------------------------//
29) PROGRAMA QUE MUESTRA SUMA N...int SumaN( int n ) { int s,a; if
( n == 0 ) s = 0; else { a = n % 10; s = SumaN( n / 10 ) + a; }
return ( s
);}//------------------------------------------------------------------------------//
30) PROGRAMA QUE MUESTRA LOS DGITOS DE UN NMEROvoid mostrarDigitos(
int n ) { int x; if ( n < 10 ) ShowMessage( n ); else {
mostrarDigitos( n / 10 ); ShowMessage( n % 10 );
}}//------------------------------------------------------------------------------
// 31) PROGRAMA QUE MUESTRA LOS DGITOS QUE ESTN AL LADO DERECHO
DE UN DGITO PARvoid mostrarDerecho( int n ) { int s; if ( n > 10
) { s = n / 10; mostrarDerecho( n / 10 ); if ( ( s % 10 ) % 2 == 0
) ShowMessage( n % 10 ); }}
///**************************************************************************//////******************************
VECTORES
******************************//////**************************************************************************///
//------------------------------------------------------------------------------//
30) PROGRAMA QUE DEVUELVE TRUE SI UN VECTOR EST ORDENADO DE MENOR A
MAYOR //bool EstaOrdenado( int v[], Cardinal &n ) { bool e; if
( n = v[ n - 2 ] ) ) //>= o == bb = true; else bb = false; }
return ( bb
);}//------------------------------------------------------------------------------
// 31) PROGRAMA QUE DEVUELVE TRUE SI UN VECTOR EST ORDENADO DE
MAYOR A MENOR //bool EstaOrdenado1( int v[], Cardinal &n ) {
bool e; if ( n v[ n - 2 ] ) e = false; } } return ( e
);}//------------------------------------------------------------------------------//
32) PROGRAMA QUE MUESTRA LA SUMA DE LOS DGITOS PARES DE UN VECTOR
//int sumaPares ( int v[], Word n ) { int s; if ( n == 0 ) { s = 0;
} else { s = sumaPares( v, n - 1 ); if ( ( v[ n - 1 ] % 2 ) == 0 )
s = s + v[ n - 1 ]; } return ( s
);}//------------------------------------------------------------------------------//
33) PROGRAMA QUE MUESTRA LA SUMA DE LOS DGITOS IMPARES DE UN VECTOR
//int SumaImpares ( int v[], byte n ) { int s; if ( n == 0 ) { s =
0; } else { s = SumaImpares( v, n - 1 ); if ( ( v[ n - 1 ] % 2 ) ==
1 ) s = s + v[ n - 1 ]; } return ( s
);}//------------------------------------------------------------------------------
// 34) PROGRAMA QUE MUESTRA LA SUMA DE LOS ELEMENTOS DE UN
VECTOR //int SumaV( int v[], Word n ) { int s; if ( n == 0 ) { s =
0; } else { s = SumaV( v, n - 1 ); s = s + v[ n - 1 ]; } return ( s
);}//------------------------------------------------------------------------------//
X) PROGRAMA QUE MUESTRA LA SUMA DE DGITOS PARES Y SUMA DE IMPARES
DE UN VECTOR //int sumParImp ( int v[], Word n ) { int s; if ( n ==
0 ) { s = 0; } else { s = sumParImp( v, n - 1 ); if ( ( v[ n - 1 ]
% 2 ) == 0 ) s = s + v[ n - 1 ]; if ( ( v[ n - 1 ] % 2 ) == 1 ) s =
s + v[ n - 1 ]; } return ( s
);}//------------------------------------------------------------------------------//
XX) PROGRAMA QUE MUESTRA SUMA DE DGITOS PARES - SUMA DE IMPARES DE
LOS ELEM DE UN VECTOR
////------------------------------------------------------------------------------//
35) PROGRAMA QUE MUESTRA EL PROMEDIO DE LOS ELEMENTOS DE UN VECTOR
//float PromedioV( int v[], int n ) { float p = 0; if ( n > 0 )
{ p = PromedioV( v, n - 1 ); p = ( ( n - 1 ) * p + v[ n - 1 ] ) /
n; } return ( p
);}//------------------------------------------------------------------------------//
36) PROGRAMA PARA ROTAR LOS ELEMENTOS DE UN VECTOR UNA CASILLA A LA
DERECHA //void Rotar( int v[], byte n ) { byte aux; if ( n > 1 )
{ Rotar( v, n - 1 ); aux = v[ 0 ]; v[ 0 ] = v[ n - 1 ]; v[ n - 1 ]
= aux; }}
void rotarDer( TStringGrid *v, byte n ) { String x; if ( n >
1 ) { rotarDer( v, n - 1 ); x = v->Cells[0][0];
v->Cells[0][0] = v->Cells[ n - 1 ][ 0 ]; v->Cells[ n - 1
][ 0 ] = x;
}}//------------------------------------------------------------------------------//
xxxxxX) PROGRAMA PARA ROTAR LOS ELEMENTOS DE UN VECTOR UNA CASILLA
A LA IZQUIERDA //void rotarIzq( int v[], byte n ) { byte aux; if (
n > 1 ) { rotarIzq( v, n - 1 ); aux = v[ n - 1 ]; v[ n - 1 ] =
v[ n - 2 ]; v[ n - 2 ] = aux; }}
void rotarIzq1( TStringGrid *v, byte n ) { String x; if ( n >
1 ) { rotarIzq1( v, n - 1 ); x = v->Cells[ n - 1 ][ 0 ];
v->Cells[ n - 1 ][ 0 ] = v->Cells[ n - 2 ][ 0 ]; v->Cells[
n - 2 ][ 0 ] = x;
}}//------------------------------------------------------------------------------//
37) PROGRAMA PARA MOVER EL LTIMO ELEMENTO AL LUGAR QUE LE
CORRESPONDA //void InsertarX( int v[], Word n ) { int aux; if ( n
> 1 ) { if ( v[ n - 2 ] > v[ n - 1 ] ) { aux = v[ n - 2 ]; v[
n - 2 ] = v[ n - 1 ]; v[ n - 1 ] = aux; InsertarX( v, n - 1 ); }
}}
void inserccion( int v[], int &n, int x ) { if ( n == 0 ) {
n++; v[ n - 1 ] = x; } else { if ( x > v[ n - 1 ] ) { n++; v[ n
- 1 ] = x; } else { int aux = v[ n - 1 ]; n--; inserccion( v, n, x
); n++; v[ n - 1 ] = aux; }
}}//------------------------------------------------------------------------------//
38) PROGRAMA QUE MUESTRA EL MAYOR DE LOS ELEMENTOS DE UN VECTOR
//byte Mayor( int v[], Word n ) { int may; if ( n == 0 ) { throw
new Exception( "ERROR" ); } else { if ( n == 1 ) { may = v[ 0 ]; }
else { may = Mayor( v, n - 1 ); if ( ( v[ n - 1 ] ) > may ) may
= v[ n - 1 ]; } return ( may );
}}//------------------------------------------------------------------------------
// 39) PROGRAMA QUE MUESTRA EL MENOR DE LOS ELEMENTOS DE UN
VECTOR //byte Menor( int v[], Word n ) { int men; if ( n == 0 ) {
throw new Exception( " ERROR" ); } else { if ( n == 1 ) { men = v[
0 ]; } else { men = Menor( v, n - 1 ); if ( ( v[ n - 1 ] ) < men
) men = v[ n - 1 ]; } return ( men );
}}//------------------------------------------------------------------------------//
40) PROGRAMA QUE ORDENA LOS ELEMENTOS DE UN VECTOR POR MTODO DE LA
BARAJA //void InsertionSort( int v[], Word n ) { if ( n > 1 ) {
InsertionSort( v, n - 1 ); InsertionSort( v, n );
}}//------------------------------------------------------------------------------//
41) PROGRAMA QUE ELIMINA UN ELEMENTO DEL VECTOR //void
EliminarElemento( int v[], int &n, int x ) { if ( n > 0 ) {
int aux; aux = v[ n - 1 ]; n--; EliminarElemento( v, n, x ); if ( x
!= aux ) { v[ n ] = aux; n++; } }}
void elimDato( TStringGrid *v, int &n, int x ) { if ( n >
0 ) { String aux; aux = v->Cells[ n - 1 ][ 0 ]; n--; elimDato(
v, n, x ); if ( x != aux ) { v->Cells[ n ][ 0 ] = aux; n++; }
}}//------------------------------------------------------------------------------String
VecToStr( int v[], int n ) { String s; if( n == 0 ) s = " "; else s
= VecToStr( v, n - 1 ) + ";" + IntToStr( v[ n - 1 ] ); return ( s
);}
String VecToStr2( int v[], int v1[], int n, int m ) { String s;
if ( ( n == 0 ) && ( m == 0 ) ) s = " "; else s =
VecToStr2( v, v1, n-1, m-1 ) + ";" + IntToStr( v[ n - 1 ] ) +
IntToStr( v1[ m - 1 ] ); //s = VecToStr2( v, v1, n-1, m-1 ) + ";" +
IntToStr( v[ n - 1 ] ) + ";" + IntToStr( v1[ m - 1 ] ); return ( s
);}//------------------------------------------------------------------------------//
42) PROGRAMA QUE EMPUJA EL MAYOR DGITO DEL VECTOR A LA LTIMA
CASILLA //void Burbu( int v[], int n ) { byte aux; if ( n > 1 )
{ Burbu( v, n - 1 ); if ( v[ n - 2 ] > v[ n - 1 ] ) { aux = v[ n
- 1 ] ; v[ n - 1 ] = v[ n - 2 ]; v[ n - 2 ] = aux; } }}
void burbujita( TStringGrid *v, int n ) { String aux; if ( n
> 1 ) { burbujita( v, n - 1 ); if ( v->Cells[ n - 2 ][0] >
v->Cells[ n - 1 ][0] ) { aux = v->Cells[ n - 1 ][0];
v->Cells[ n - 1 ][0] = v->Cells[ n - 2 ][0]; v->Cells[ n -
2 ][0] = aux; }
}}//------------------------------------------------------------------------------//
43) PROGRAMA QUE ORDENA UN VECTOR POR EL MTODO DE BURBUJEAR //void
OrdenarBurbu( Word n, int v[] ) { if ( n > 1 ) { Burbu( v, n );
OrdenarBurbu( n - 1, v );
}}//------------------------------------------------------------------------------//
44) PROGRAMA QUE INVIERTE LOS ELEMENTOS DE UN VECTOR //void
Invertir( int v[], Word a, Word b ) { //Proceso Privado WORD =
SHORT Word n; int aux; n = b - a + 1; if ( n > 1 ) { aux = v[ a
]; v[ a ] = v[ b ]; v[ b ] = aux; Invertir( v, a + 1, b - 1 );
}}void Invertir( int v[], Word n ) { //Proceso Pblico Invertir( v,
0, n - 1 ); //Mscara}
void invVector( TStringGrid *v, int a, int b ) { int n; String
x; n = b - a + 1; if ( n > 1 ) { x = v->Cells[ b ][ 0 ];
v->Cells[ b ][ 0 ] = v->Cells[ a ][ 0 ]; v->Cells[ a ][ 0
] = x; invVector( v, a + 1, b - 1 ); }}void invert( TStringGrid *v
) { invVector( v, 0, v->ColCount - 1
);}//------------------------------------------------------------------------------//
45) PROGRAMA QUE DEVUELVE TRUE SI EL DATO X EXISTE DENTRO DE UN
VECTOR ORDENADO //bool BusBin( int v[], Word a, Word b, int x ) {
bool bb; Word c; //v[1,2,4,6,9,10,11,12,20,30,31,35] Word n; //
a=1; c=10; b=35; n = b - a + 1; if ( n == 0 ) bb = false; else { c
= ( a + b ) / 2; if ( v[ c ] == x ) bb = true; else if ( x < v[
c ] ) bb = BusBin( v, a, c - 1, x ); else bb = BusBin( v, c + 1, b,
x ); } return ( bb );}
bool BusBin( int v[], Word n, int x ) { return ( BusBin( v, 0, n
- 1, x ) );}
bool busBinaria( TStringGrid *v, int x, int a, int b ) { bool h;
int c; //v[1,2,4,6,9,10,11,12,20,30,31,35] int n; // a=1; c=10;
b=35; n = b - a + 1; if ( n == 0 ) h = false; else { c = ( a + b )
/ 2; if ( x == StrToInt( v->Cells[ c ][ 0 ] ) ) h = true; else
if ( x > StrToInt( v->Cells[ c ][ 0 ] ) ) h = busBinaria( v,
x, c + 1, b ); else h = busBinaria( v, x, a, c - 1 ); } return ( h
);}bool busBinaria( TStringGrid *v, int x, int n ) { return (
busBinaria( v, x, 0, n - 1 )
);}//------------------------------------------------------------------------------//
46) PROGRAMA QUE ORDENA LOS ELEMENTOS DE UN VECTOR POR EL MTODO
QUICKSORT //void Pivotear( int v[], short a, short b, int &c
);void QuickSort( int v[], short a, short b ) { short n; short c; n
= b - a + 1; if ( n > 1 ) { Pivotear( v, a, b, c ); QuickSort(
v, a, c - 1 ); QuickSort( v, c + 1, b ); }}void QuickSort( int v[],
short n ) { return ( QuickSort( v, 0, n - 1 ) );}
void Pivotear( int v[], short a, short b, int &c, int sw ) {
short n; n = b - a + 1; if ( n < 2 ) c = a; else { if ( v[ a ]
> v[ b ] ) { int x = v[ a ]; v[ a ] = v[ b ]; v[ b ] = x; sw = -
sw; } if ( sw == 1 ) Pivotear( v, a + 1, b, c, sw ); else Pivotear(
v, a, b - 1, c, sw ); }}void Pivotear( int v[], short a, short b,
int &c ) { return ( Pivotear( v, a, b, c, 1 )
);}//------------------------------------------------------------------------------//
47) PROGRAMA QUE DEVUELVE TRUE SI X EST ANTES QUE Y EN UN VECTOR
//bool EstaAntes( int v[], Word n, int x, int y ) { bool e; int z;
if ( n < 2 ) e = false; else { if ( v[ n - 1 ] == y ) { if ( v[
n - 2 ] == x ) e = true; else { z = v[ n - 2 ]; e = EstaAntes( v, n
- 1, x, z ); } } else e = EstaAntes( v, n - 1, x, y ); } return ( e
);}//------------------------------------------------------------------------------
// 48) PROGRAMA QUE DEVUELVE TRUE SI X EST DESPUS QUE Y EN UN
VECTOR //// EJ: V[1,5,8,7,3,2,6] X=2 y Y=8 -> TRUEbool
estaDespues( int v[], Word n, int x, int y ) { bool e; int z; if (
n 0 ) { if ( v[ i ] < v[ i - 1 ] ) { x = v[ i ]; v[ i ] = v[ i -
1 ]; v[ i -1 ] = x; i--; } else i = 0;
}}//------------------------------------------------------------------------------
// 50) PROGRAMA QUE SEPARA LOS DGITOS PARES DE LOS IMPARES DE UN
VECTOR DE N ELEMENTOSvoid rota( int v[], Word n );
void sepParImp( int v[], Word n ) { if ( n > 1 ) { int x ; x
= v[ n - 1 ]; sepParImp( v, n - 1 ); if ( ( x % 2 ) == 0 ) rota( v,
n ); }}void rota( int v[], Word n ) { if ( n > 1 ) { rota( v, n
- 1 ); int x; x = v[ n - 1 ]; v[ n - 1 ] = v[ 0 ]; v[ 0 ] = x;
}}
void rotax( int v[], int n );void separart( int v[], int n ) {
if ( n > 1 ) { separart(v,n-1); if ( v[n-1]%2==0) rotax(v,n);
}}void rotax(int v[], int n ) { if ( n > 1 ) { rotax( v, n - 1
); int x; x = v[ 0 ]; v[ 0 ] = v[ n - 1 ]; v[ n - 1 ] = x;
}}///-----------------------------------------------------------------------------
// 51) CARGAR UN VECTOR CON LOS N PRIMEROS TRMINOS DE LA SERIE
DE FIBONACCIvoid CargarFibo( int v[], Word n ) { if ( ( n < 3)
&& ( n > 0 ) ) { if ( n < 2 ) v[ n - 1 ] = 1; else {
v[ n - 2 ] = 1; v[ n - 1 ] = 1; } } else { CargarFibo( v, n - 1 );
v[ n - 1 ] = v[ n - 2 ] + v[ n - 3 ];
}}//------------------------------------------------------------------------------//
52) MUESTRA LA SUMA DE LOS DGITOS EN LAS POSICIONES PARES DE UN
VECTORint sumaPosPares( int v[], int n ) { int s = 0; int d = 0; if
( n > 1 ) { d = v[ n ]; s = sumaPosPares( v, n - 1 ); if ( d % 2
== 0 ) { s = s + d; } } return ( s
);}//------------------------------------------------------------------------------//
53) MUESTRA SI EL VECTOR EST ORDENADO CON UNA CTTE EXTRA 1=ASC;
2=DESC (m)bool EstaOrdenadovector( int v[], int n, int &m ) {
bool e; if ( n == 1 ) { e = true; m = m; } else { if ( m ==1 ) { if
( v[ n - 1 ] < v[ n - 2 ] ) e = EstaOrdenadovector( v, n - 1, m
); e = false; } else { if ( m == 2 ) { e = EstaOrdenadovector( v, n
- 1, m ); e = false; } else throw new Exception( "ERROR" ); } }
return ( e
);}///-----------------------------------------------------------------------------//
54) MUESTRA EL VALOR MXIMO Y MNIMO DE LOS ELEMENTOS DE UN
VECTORvoid MaxMin( int v[], int n,int &Max, int &Min ) { if
( n > 1 ) { MaxMin( v, n - 1, Max, Min ); if ( v[ n - 1 ] >
Max ) Max = v[ n - 1 ]; else { if ( v[ n - 1 ] < Min ) Min = v[
n - 1 ]; } } if ( n == 1 ) { Max = v[ n - 1 ]; Min = v[ n - 1 ];
}}///-----------------------------------------------------------------------------//
55) MUESTRA LA POSICIN DEL ELEMENTO DE UN VECTORint posi( int v[],
int x, Word n ) { int i, p; p = - 1; i = 0; while ( ( i < n )
&& ( p == - 1 ) ) { if ( x == v[ i ] ) p = i; i++; } return
( p
);}///-----------------------------------------------------------------------------//
56) MUESTRA HALLADO DE UN VECTORbool hallado( int v[], int x,
Cardinal n ) { Cardinal a, b, c; bool bb; a = 0; b = n - 1; bb =
false; while ( ( a Clear( ); Edit2->Clear( ); n = StrToInt(
InputBox( "VEXXXTOR", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0;
i < n; i++ ) { v[ i ] = StrToInt( InputBox( "VEXXXTOR", "*
VALOR: ", "0" ) ); Edit1->Text = Edit1->Text + "-" +
IntToStr( v[ i ] ); } if( SumaMitades( v, n ) ) ShowMessage( " SON
IGUALES " ); else ShowMessage( "No son Iguales" );*/ //OK OK OK OK
OK
OK//------------------------------------------------------------------------------//
# 2)bool existe( int v[], int n, int x ) { bool bb = false; if ( n
> 0 ) { bb = existe( v, n - 1, x ); if ( v[ n - 1 ] == x ) bb =
true; } return ( bb );}
bool contenido( int v[], int v1[], int n, int m ) { int a; bool
sw = true; if ( n > 0 ) { sw = contenido(v,v1,n-1,m); if ( sw )
{ a = v[n-1]; if ( existe(v1,m,a)) { sw = true; } else { sw =
false; } } } return ( sw );}
// < AQU EST SU LLAMADA AL MTODO > // /*int v[ 3 ] = { 2,
3, 4 }; int n = 3; int v1[ 6 ] = { 1, 2, 3, 4, 5, 6 }; int m = 6;
if ( contenido( v, v1, n, m ) ) ShowMessage( "EL VECTOR A EST EN EL
VECTOR B" ); else ShowMessage( "EL VECTOR A NO EST EN EL VECTOR B"
);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
# 3) MUESTRA EL PRODUCTO DE DOS NMEROS POR SUMASint producto( int a
, int b ) { int p; if ( b == 0 ) p = 0; else p = producto( a, b - 1
) + a; return ( p );}// < AQU EST SU LLAMADA AL MTODO >
///*int a, b; a = StrToInt(InputBox("** XXX VERANO XXX **", "*
DIGITE UN NMERO: ", "0" ) ); b = StrToInt(InputBox("** XXX VERANO
XXX **", "* DIGITE OTRO NMERO: ", "0" ) ); int prod = producto( a,
b ); ShowMessage( prod );*/ //OK OK OK OK OK
OK//-------------------------------------------------------------------------------//
# 4) // ELEVA UN NRO X A LA N POR MEDIO DE MULTIPLICACINfloat
potencia( Word x, Word n ) { float p; if ( ( x == 0 ) && (
n == 0 ) ) throw new Exception( "ERROR" ); else if ( n == 0 ) p =
1; else { p = potencia( x, n / 2 ); p = p * p; if ( ( n % 2 ) == 1
) p = p * x; } return ( p );}// < AQU EST SU LLAMADA AL MTODO
> // /*float p, x, n; x = StrToInt( InputBox( "** NMEROS
NATURALES **", "* DIGITE UN NMERO: ", "0" ) ); n = StrToInt(
InputBox( "** NMEROS NATURALES **", "* DIGITE POTENCIA: ", "0" ) );
p = potencia( x, n ); ShowMessage( p
);*///------------------------------------------------------------------------------//
# 5)
void casillaPar( int v[], int n, String &x ) { if ( n == 1 )
x = IntToStr( v[ 0 ] ); else { casillaPar( v, n-1, x ); if ( ( n -
1 ) % 2 == 0 ) x = x + "," + IntToStr( v[ n - 1 ] ); }}// < AQU
EST SU LLAMADA AL MTODO > ///*int v[ 5 ] = { 0, 1, 2, 3, 4 };
int n = 5; String s; casillaPar( v, 5, s ); ShowMessage( s );*/ //
OK OK OK OK OK
OK//------------------------------------------------------------------------------//
# 6)int cantRepite( int v[], int n, int a ) { int c; if ( n == 0 )
c = 0; else { c = cantRepite( v, n - 1, a ); if ( v[ n -1 ] == a )
c++; } return ( c );}int contar(TStringGrid *v, int n, int x ) {
int c = 0; if ( n > 0 ) { c = contar( v, n - 1, x ); if (
v->Cells[ n - 1 ][ 0 ] == x ) c++; } return ( c );}// < AQU
EST SU LLAMADA AL MTODO > ///*int v[ 5 ] = { 2, 3, 4, 5, 5 };
int n = 5; int x = 5, c; c = cantRepite( v, n, x ); ShowMessage( c
);*/ //OK OK OK OK OK
OK//------------------------------------------------------------------------------//
# 7)int proEscalar( int v1[], int v2[], int n ) { int prod; if( n
== 0 ) prod = 0; else { prod = proEscalar( v1, v2, n - 1 ) + v1[ n
- 1 ] * v2[ n - 1 ]; } return ( prod );}// < AQU EST SU LLAMADA
AL MTODO> ///*int v1[ 3 ] = { 1, 2, 3 }; int n = 3; int v2[ 3 ]
= { 4, 5, 6 }; int m = 3; int prod = proEscalar( v1, v2, n );
ShowMessage( prod );*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
# 8)bool esPalindrome( String s, int x ) { bool bb; char c,e; int n
= s.Length( ) - x + 1; if ( ( n == 0 ) || ( n == 1 ) || ( n == 2 )
) { if ( n == 2 ) { c = s[ n ]; e = s[ n - 1 ]; bb = ( c == e ); }
else bb = true; } else { c = s[ n ]; e = s[ x ]; s = s.SetLength( 1
); bb = esPalindrome( s, x + 1 ); if ( bb ) bb = ( c == e ); }
return ( bb );}bool esPalindrome( String s ) { bool sw; sw =
esPalindrome( s, 1 ); return ( sw );}// < AQU EST SU LLAMADA AL
MTODO> ///*String s = EditMostrar->Text; s = InputBox(
"CADENAXXX","* DIGITE UNA CADENA :", "hola" ); if ( esPalindrome( s
) ) ShowMessage("TRUE"); else ShowMessage("FALSE");*/ // OK OK OK
OK OK
OK//------------------------------------------------------------------------------
// # 10)int ackerman( int M, int N ) { int res; if ( M == 0 ) {
res = N + 1; } else { if ( N == 0 ) { res = ackerman( M - 1, 1 ); }
else { res = ackerman( M - 1, ackerman( M, N - 1 ) ); } } return (
res );}// < AQU EST SU LLAMADA AL MTODO> ///*int M, N; M =
StrToInt(InputBox("** XXX VERANO XXX **", "* DIGITE UN NMERO: ",
"0" ) ); N = StrToInt(InputBox("** XXX VERANO XXX **", "* DIGITE
OTRO NMERO: ", "0" ) ); int res = ackerman(M,N); ShowMessage( res
);*/ //OK OK OK OK OK
OK//------------------------------------------------------------------------------//
# 11)int sumMayUlt( TStringGrid *v, int n ) { int a,s=0; int x;
x=StrToInt(v->Cells[n-1][0]); if(n>1){
a=StrToInt(v->Cells[n-2][0]); s=sumMayUlt(v,n-1); if(a>x)
s=s+a; } return s;}// < AQU EST SU LLAMADA AL MTODO>
////ShowMessage(sumMayUlt(Vextor,Vextor->ColCount)); // OK OK OK
OK OK OKint sumMayUlt( int v[], int n ) { int a,s=0; int x; x=
v[n-1]; if(n>1){ a=v[n-2]; s=sumMayUlt(v,n-1); if(a>x) s=s+a;
} return
s;}//------------------------------------------------------------------------------
// # 12)void BurbuVer( int v[], int n ) { byte aux; if ( n >
1 ) { BurbuVer( v, n - 1 ); if ( v[ n - 2 ] > v[ n - 1 ] ) { aux
= v[ n - 1 ] ; v[ n - 1 ] = v[ n - 2 ]; v[ n - 2 ] = aux; } }}
void OrdenBurbuVer( Word n, int v[] ) { if ( n > 1 ) {
BurbuVer( v, n ); OrdenBurbuVer( n - 1, v ); }}// < AQU EST SU
LLAMADA AL MTODO> // /*int v[ 50 ], i; Word n; Edit1->Clear(
); EditMostrar->Clear( ); Edit2->Clear( ); n = StrToInt(
InputBox( "** VERANO **", "* DIGITE DIMENSIN: ", "0" ) ); for ( i =
0; i < n; i++ ) { v[ i ] = StrToInt( InputBox( "** VERANO **",
"* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text + "-" +
IntToStr( v[ i ] ); } OrdenBurbuVer( n, v ); for ( i = 0; i < n;
i++ ) { EditMostrar->Text = EditMostrar->Text + "-" +
IntToStr( v[ i ] ); }*/ // OK OK OK OK OK OK
void burbujitaVer( TStringGrid *v, int n ) { String aux; if ( n
> 1 ) { burbujita( v, n - 1 ); if ( v->Cells[ n - 2 ][0] >
v->Cells[ n - 1 ][0] ) { aux = v->Cells[ n - 1 ][0];
v->Cells[ n - 1 ][0] = v->Cells[ n - 2 ][0]; v->Cells[ n -
2 ][0] = aux; } }}
void OrdenBurbujitaVer( int n, TStringGrid *v ) { if ( n > 1
) { burbujitaVer( v, n ); OrdenBurbujitaVer( n - 1, v ); }}
//------------------------------------------------------------------------------//
14)int posMayor( int v[], Word n ) { int pos = 0; if ( n == 1 )
return ( n ); else { pos = posMayor( v, n - 1 ); if( v[ pos - 1 ]
< v[ n - 1 ] ) pos = n; } return ( pos );}
void selection( int v[], Word n ) { if ( n > 1 ) { int pos =
posMayor( v, n ); int x = v[ pos - 1 ]; v[ pos - 1 ] = v[ n - 1 ];
v[ n - 1 ] = x; selection( v, n - 1 ); }}// < AQU EST SU LLAMADA
AL MTODO> ///*int v[] = { 8, 4, 2, 5, 6, 1, 3, 9 }; Word n = 8;
int t = posMayor( v, n ); ShowMessage( t ); selection( v, t ); for(
int i = 0; i < n; i++ ) { ShowMessage( v[ i ] ); // OK OK OK OK
OK OK
}*///------------------------------------------------------------------------------//
15)
void Merge ( int v[], Word a, Word c, Word f ) { int b[ 100 ],
i, j; if ( f > a ) { c = ( a + f ) / 2 ; for ( i = c + 1; i >
a; i-- ) b[ i - 1 ] = v[ i - 1 ]; for ( j = c; j < f; j++ )b[ f
+ c - j ] = v[ j + 1 ];for ( int k = a; k a ) { Word c = ( a + b )
/ 2 ; MergeSort( v, a, c ); MergeSort( v, c + 1, b ); Merge( v, a,
c + 1, b );
}}//------------------------------------------------------------------------------//
17)void ordenCol( TStringGrid *A, int f, int c, int cont ) { if ( (
A->ColCount*A->RowCount ) >= cont ) { //25 20 15 10 5
A->Cells[ c ][ f ] = cont; // 24 19 14 9 4 f--; // 23 18 13 8 3
cont++; // 22 17 12 7 2 if ( f < 0 ) { // 21 16 11 6 1 c--; f =
A->RowCount - 1; } ordenCol( A, f, c, cont ); }}void ordenCol(
TStringGrid *A ) { ordenCol( A, A->RowCount - 1, A->ColCount
- 1, 1 );}// < AQU EST SU LLAMADA AL MTODO> ///*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
ordenCol( Matrix );*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
18)void matrixFila( TStringGrid *A, short m, short n, short f,
short c );void matrixFila( TStringGrid *A, short m, short n ) {
matrixFila( A, m, n, m - 1, n - 1 );}
void matrixFila( TStringGrid *A, short m, short n, short f,
short c ) { int k; short fa,ca; k = f * n + c + 1; //1 2 3 4 5 if (
k > 0 ) { // 6 7 8 9 10 if ( c == 0 ) { // 11 12 13 14 15 fa = f
- 1; // 16 17 18 19 20 ca = n - 1; // 21 22 23 24 25 } else { ca =
c - 1; fa = f; } matrixFila( A, m, n, fa, ca ); A->Cells[ c ][ f
] = k; }}// < AQU EST SU LLAMADA AL MTODO> ///*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
matrixFila( Matrix, m, n );*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
19)void matrixColumna( TStringGrid *A, short m, short n, short f,
short c );void matrixColumna( TStringGrid *A, short m, short n ) {
matrixColumna( A, m, n, m - 1, n - 1 );}void matrixColumna(
TStringGrid *A, short m, short n, short f, short c ) { int k; short
fa,ca; //1 6 11 16 21 k = f * n + c + 1; // 2 7 12 17 22 if( k >
0 ) { // 3 8 13 18 23 if ( c == 0 ) { // 4 9 14 19 24 fa = f - 1;
// 5 10 15 20 25 ca = n - 1; } else { ca = c - 1; fa = f; }
matrixColumna( A, m, n, fa, ca ); A->Cells[ f ][ c ] = k; }}//
< AQU EST SU LLAMADA AL MTODO> ///*int m = StrToInt(
InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) ); int n =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" )
); Matrix->ColCount = n; Matrix->RowCount = m; matrixColumna(
Matrix, m, n );*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
21)void triSupIzq( TStringGrid *A, int f, int c, int k ) { if (
A->RowCount > f ) { A->Cells[c][f] = k; c++; k++; if ( c
>= f ) { f++; c = 0; } triSupIzq(A,f,c,k); }}void triSupIzq(
TStringGrid *A ) { triSupIzq( A, 1, 0, 1 ) ;}// < AQU EST SU
LLAMADA AL MTODO> ///*int m = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE FILAS: ", "0" ) ); int n = StrToInt( InputBox(
"MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) );
Matrix->ColCount = n; Matrix->RowCount = m;
triSupIzq(Matrix);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------void
llenar8( TStringGrid *A, int f, int c, int k ) { int n =
A->ColCount*( A ->ColCount+1)/2 - k; A->Cells[c][f] = k;
if ( n > 0 ) { if ( f == 0 ) { f = c + 1; c = 0; } else { f--;
c++; } llenar8(A,f,c,k+1); }}
// # 20)//Su Inversavoid llenar8_1( TStringGrid *A, int f, int
c, int k ) { if ( A->RowCount > f ) { A->Cells[c][f] = k;
c++; k++; if ( c >= A->ColCount ) { f++; c = f; }
llenar8_1(A,f,c,k); }}void llenar8_1( TStringGrid *A ) { llenar8_1(
A, 0, 0, 1 ) ;}// < AQU EST SU LLAMADA AL MTODO> // /*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
llenar8_1(Matrix);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//
22)void magicVer( TStringGrid *A, short m, short n, short f, short
c, short k ) { if( k == m * n ) { //caso base A->Cells[ c ][ f ]
= k; //17 24 1 8 15 } // 23 5 7 14 16 else { // 4 6 13 20 22
A->Cells[ c ][ f ] = k; // 10 12 19 21 3 if ( k % m == 0 ) // 11
18 25 2 9 f++; else { f--; c++; if ( f == - 1 ) f = m - 1; if ( c
== n ) c = 0; } magicVer( A, m, n, f, c, k + 1 ); }}// < AQU EST
SU LLAMADA AL MTODO> ///*int m = StrToInt( InputBox( "MATRIXXX",
"* DIGITE NRO DE FILAS: ", "0" ) ); int n = StrToInt( InputBox(
"MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) );
Matrix->ColCount = n; Matrix->RowCount = m; magicVer( Matrix,
m, m, 0, m / 2, 1 );*/ // OK OK OK OK OK
OK********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
///**************************************************************************//////******************************
MATRICES
******************************//////**************************************************************************///const
max =
20;//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
LlenarMatriz1( TStringGrid *A, short m, short n, short f, short c
);void LlenarMatriz1( TStringGrid *A, short m, short n ) {
LlenarMatriz1( A, m, n, m - 1, n - 1 );}void LlenarMatriz1(
TStringGrid *A, short m, short n, short f, short c ) { int k; short
fa,ca; //1 2 3 4 5 k = f * n + c + 1; // 6 7 8 9 10 if ( k > 0 )
{ // 11 12 13 14 15 if ( c == 0 ) { // 16 17 18 19 20 fa = f - 1;
// 21 22 23 24 25 ca = n - 1; } else { ca = c - 1; fa = f; }
LlenarMatriz1( A, m, n, fa, ca ); A->Cells[ c ][ f ] = k; }}//
// /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; LlenarMatriz1( Matrix, m, n );*/ //OK OK
OK OK OK OK
//OTRA FORMA:void llenarMatrix1( TStringGrid *A, int m, int n,
int f, int c, int k ) { int z; z = m * n - k; if ( z == 0 )
A->Cells[ n - 1 ][ m - 1 ] = k; else { A->Cells[ c ][ f ] =
k; c++; if ( c == n ) { c = 0; f++; } llenarMatrix1( A, m, n, f, c,
k + 1 );
}}//------------------------------------------------------------------------------//------------------------------------------------------------------------------
void llenarMatrix2( TStringGrid *A, int f, int c, int k ) { int
n; n = A->ColCount*A->RowCount-k; //1 2 3 4 5
A->Cells[c][f] = k; //10 9 8 7 6 if ( n > 0 ) { // 11 12 13
14 15 if ( ( f % 2 ) == 0 ) { // 20 19 18 17 16 c++; if ( c ==
A->ColCount ) { f++; c = A->ColCount-1; } } else { c--; if (
c == - 1 ) { c = 0; f++; } } llenarMatrix2( A, f, c, k + 1 ); }}//
///*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS:
", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO
DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; llenarMatrix2(Matrix, 0, 0, 1 );*/ // OK
OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenarMatrix3( TStringGrid *A, int f, int c, int k ) { int n; n =
A->ColCount*A->RowCount-k; //1 8 9 16 A->Cells[c][f] = k;
// 2 7 10 15 if ( n > 0 ) { // 3 6 11 14 if ( ( c % 2 ) == 0 ) {
// 4 5 12 13 f++; if ( f == A->ColCount ) { c++; f =
A->ColCount-1; } } else { f--; if ( f == - 1 ) { f = 0; c++; } }
llenarMatrix3( A, f, c, k + 1 ); }}
// // /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; llenarMatrix3(Matrix, 0, 0, 1
);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenarMatrix4( TStringGrid *A, int f, int c, int k ) { int n; n =
A->ColCount*(A->ColCount+1)/2-k; //1 3 6 10 15
A->Cells[c][f] = k; // 2 5 9 14 if ( n > 0 ) { // 4 8 13 if (
f == 0 ) { // 7 12 f = c + 1; // 11 c = 0; } else { f--; c++; }
llenarMatrix4(A,f,c,k+1); }}// // /*int m = StrToInt( InputBox(
"MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) ); int n = StrToInt(
InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) );
Matrix->ColCount = n; Matrix->RowCount = m;
llenarMatrix4(Matrix, 0, 0, 1
);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenarMatrix5( TStringGrid *A, int f, int c, int k ) { int n; if (
f < A->RowCount ) { //1 2 3 4 A->Cells[ c ][ f ] = k; // 2
3 4 if ( f == 0 ) { // 3 4 f = c + 1; // 4 c = 0; k++; } } /////
OOOOOOOOOOOOOOOOOOJJJJJJJJJJJJJJJOOOOOOOOOOOOO ///// else { f--;
c++; } llenarMatrix5(A,f,c,k);}
void llenarMatrix5(TStringGrid *A,short m,short n) {
llenarMatrix5(A,0,0,1);}
// // /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; llenarMatrix5(Matrix, 0, 0, 1
);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenarMatrix6( TStringGrid *A, int f, int c, int k ) { if ( k >=
0 ) { A->Cells[ c ][ f ] = k; if ( c % 2 == 0 ) {
//SUPUESTAMENTE HACE ESTA MATRIZ PERO LLAMAR BIEN f--; k--; // 13
12 5 4 if ( f == - 1 ) { // 14 11 6 3 f = 0; // 15 10 7 2 c++; //
16 9 8 1 } } else { f++; k--; if ( f == A->ColCount ) { f =
A->ColCount - 1; c++; } } llenarMatrix6( A, f, c, k );
}}//llenarMatrix6( Matrix, Matrix->RowCount-1, 0,
Matrix->ColCount*Matrix->RowCount);
// // /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; llenarMatrix6( Matrix, m-1, 0, n*m- 1
)*/
void llenMat6( TStringGrid *A, int f, int c, int k ) { if ( k
>= 0 ) { A->Cells[ f ][ c ] = k; if ( c % 2 == 0 ) { f--;
k--; if ( f == - 1 ) { f = 0; c++; } } else { f++; k--; if ( f ==
A->ColCount ) { f = A->ColCount - 1; c++; } } llenMat6( A, f,
c, k ); }}// // /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE
NRO DE FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX",
"* DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; llenMat6( Matrix, m-1, 0, n*m- 1 )*/
void Vivora(TStringGrid *A,short m,short n,short &f,short
&c,short &k) { int p=m*n-k+1; // 13 12 5 4 ok ok ok ok ok
ok if(p>0) // 14 11 6 3 { A->Cells[c][f]=k; // 15 10 7 2
if(n%2==0) // 16 9 8 1 { if(c%2!=0) { f--; if(fRowCount=m;
Vivora(Matrix,m,n);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
Ord(TStringGrid *A,short m,short n, short &f,short &c,short
&f1,short &c1) { int k=c*m+f+1; int j=c1*m+f1+1; //ORDENAR
UNA MATRIZ POR COLUMNA if(k>1) { if(j>0) {
if(StrToInt(A->Cells[c][f])Cells[c1][f1])) { String
aux=A->Cells[c][f]; A->Cells[c][f]=A->Cells[c1][f1];
A->Cells[c1][f1]=aux; } if(f1==0) {f1=m-1; c1--;} else f1--;
Ord(A,m,n,f,c,f1,c1); } else {if(f==0) { f=m-1; c--; } else f--;
if(f==0) {f1=m-1; c1=c-1;} else { f1=f-1;c1=c; }
Ord(A,m,n,f,c,f1,c1); } }}
void Ord(TStringGrid *A,short m,short n) {
Ord(A,m,n,m-1,n-1,m-2,n-1);}// // /*int m=Matrix->ColCount; int
n=Matrix->RowCount;
Ord(M,m,n);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
LlenarDesdeAvajo(TStringGrid *A,short m,short n,short f,short
c,short k) { int p=m*n-k+1; if(p>0) { //4 5 12 13
A->Cells[c][f]=k; // 3 6 11 14 if(c%2==0) { // 2 7 10 15 f--; //
1 8 9 16 if(fColCount=n; m->RowCount=m;
LlenarDesdeAvajo(M,m,n);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
CargarTri(TStringGrid *A,short m,short n,short &f,short &c)
{ if(fCells[c][f]=m*f+c+1; //1 2 3 4 if(c==(m-f-1)) // 5 6 7 { c=0;
f++; // 9 10 } // 13 else c++; CargarTri(A,m,n,f,c); }}
void CargarTri(TStringGrid *A,Word n) { int a=0,b=0;
CargarTri(A,n,n,a,b);}// // /*int n = StrToInt( InputBox(
"MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) ); CargarTri(
Matrix, n
);*///------------------------------------------------------------------------------//------------------------------------------------------------------------------void
LlenarMatriz2( TStringGrid *A, short m, short n, short f, short c
);void LlenarMatriz2( TStringGrid *A, short m, short n )
{LlenarMatriz2( A, m, n, m - 1, n - 1 );}void LlenarMatriz2(
TStringGrid *A, short m, short n, short f, short c ) { int k; //1 6
11 16 21 short fa,ca; // 2 7 12 17 22 k = f * n + c + 1; // 3 8 13
18 23 if( k > 0 ) { // 4 9 14 19 24 if ( c == 0 ) { // 5 10 15
20 25 fa = f - 1; ca = n - 1; } else { ca = c - 1; fa = f; }
LlenarMatriz2( A, m, n, fa, ca ); A->Cells[ f ][ c ] = k; }}//
// /*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
FILAS: ", "0" ) ); int n = StrToInt( InputBox( "MATRIXXX", "*
DIGITE NRO DE COLUMNAS: ", "0" ) ); Matrix->ColCount = n;
Matrix->RowCount = m; LlenarMatriz2( Matrix, m, n );*/ // OK OK
OK OK OK OK
//------------------------------------------------------------------------------//------------------------------------------------------------------------------
void Magico( TStringGrid *A, short m, short n, short f, short c,
short k ) { if( k == m * n ) { //caso base A->Cells[ c ][ f ] =
k; //17 24 1 8 15 } // 23 5 7 14 16 else { // 4 6 13 20 22
A->Cells[ c ][ f ] = k; // 10 12 19 21 3 if ( k % m == 0 ) // 11
18 25 2 9 f++; else { f--; c++; if ( f == - 1 ) f = m - 1; if ( c
== n ) c = 0; } Magico( A, m, n, f, c, k + 1 ); }}// // /*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
Magico( Matrix, m, m, 0, m / 2, 1 );*/ //OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
magico( TStringGrid *A, int f, int c, int &m, int &n, int
a);void magico( TStringGrid *A,int f,int c, int ){ int x,y; magico(
A, f, c, x, y, f*c );}void magico( TStringGrid *A, int f, int c,
int &m, int &n, int a) { if(a>1) {
magico(A,f,c,m,n,a-1); //15 16 22 3 9 if(((a-1)%f)==0) // 8 14 20
21 2 m++; // 1 7 13 19 25 else { // 24 5 6 12 18 if(m==0) // 17 23
4 10 11 m=f-1; else m--; if(n==0) n=f-1; else n--; } A->Cells[ m
][ n ] = a; } else { m=0; n=f/2; A->Cells[ m ][ n ] = 1; }}// //
/*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS:
", "0" ) ); Matrix->ColCount = m; Matrix->RowCount = m;
magico( Matrix, m, m, 0 );*/ //OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
magico21( TStringGrid *A , int f, int c, int &m, int&n, int
a );void magico21( TStringGrid *A ,int f,int c, int ){ int x,y;
magico21(A,f,c,x,y,f*c);}void magico21( TStringGrid *A ,int f,int
c,int &m,int&n,int a) { if(a>1) {
magico21(A,f,c,m,n,a-1); //17 23 4 10 11 if((a-1)%f==0) // 24 5 6
12 18 m++; // 1 7 13 19 25 else { // 8 14 20 21 2 if(m==0) // 15 16
22 3 9 m=f-1; else m--; if(n==f-1) n=0; else n++; } A->Cells[ m
][ n ] = a; } else { m=0; n=f/2; A->Cells[ m ][ n ] = 1; }}//
///*int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS:
", "0" ) ); Matrix->ColCount = m; Matrix->RowCount = m;
magico21(Matrix,m,m,1);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------
void llenar_1( TStringGrid *A , int fila, int col ) {
if(fila>0) { //1 2 3 4 5 llenar_1(A,fila-1,col); // 2 3 4 5 for
(int j=0;jCells[ fila - j - 1 ][ j ] = fila;// 4 5 } // 5 }}/*int m
= StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" )
); int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE
COLUMNAS: ", "0" ) ); Matrix->ColCount = n; Matrix->RowCount
= m; llenar_1(Matrix,m,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------void
llenar_2( TStringGrid *A, int fila, int col ) { if(fila>0) { //1
2 3 4 5 llenar_2(A,fila-1,col); // 2 2 3 4 5 for (int j=0;jCells[ j
][ fila - 1 ] = fila; // 4 4 4 4 5 A->Cells[ fila - 1 ][ j ] =
fila; // 5 5 5 5 5 } }}// ///*int m = StrToInt( InputBox(
"MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) ); int n = StrToInt(
InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) );
Matrix->ColCount = n; Matrix->RowCount = m;
llenar_2(Matrix,m,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenar_3(TStringGrid *M,int n,int m) { if (n > 0) { //4 4 4 4
llenar_3(M,n-1,m); // 4 3 3 3 for (int j = 0; j < n; j++ ) { //
4 3 2 2 M->Cells[j][n - 1]= IntToStr(m - j); // 4 3 2 1
M->Cells[n - 1][j]= IntToStr(m - j); } }}// ///*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
llenar_3(Matrix,m,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------
void llenar_4(TStringGrid *M,int n,int m) { //1 2 3 4 5 if (n
> 0) // 2 1 2 3 4 llenar_4(M,n-1, m); // 3 2 1 2 3 for (int j =
0; j < n; j++ ) { // 4 3 2 1 2 M->Cells[j][n - 1]= IntToStr(n
- j); // 5 4 3 2 1 M->Cells[n - 1][j]= IntToStr(n - j); }}void
llenar_4(TStringGrid *M,int n) { llenar_4(M,n,3);}// ///*int m =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE FILAS: ", "0" ) );
int n = StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS:
", "0" ) ); Matrix->ColCount = n; Matrix->RowCount = m;
llenar_4(Matrix,m,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenar_5(TStringGrid *M,int n) { //1 2 3 4 5 if (n > 0) // 2 3 4
5 6 llenar_5(M,n-1); // 3 4 5 6 7 for (int j = 0; j < n; j++ ) {
// 4 5 6 7 8 M->Cells[j][n - 1]= IntToStr(n + j); // 5 6 7 8 9
M->Cells[n - 1][j]= IntToStr(n + j); }}// ///*int n = StrToInt(
InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" ) );
Matrix->ColCount = n; llenar_5(Matrix,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
llenar_6(TStringGrid *M,int n) { //1 2 3 4 5 if (n > 0) // 2 3 4
5 llenar_6(M,n-1); // 3 4 5 for (int i = 0; i < n; i++ ) { // 4
5 M->Cells[i][n - 1 - i ] = IntToStr( n ); // 5 }}// ///*int n =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" )
); Matrix->ColCount = n; llenar_6(Matrix,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------
void llenar_7(TStringGrid *M,int n) { //1 2 3 4 if (n > 0) //
2 3 4 5 llenar_7(M,n-1); // 3 4 5 6 for (int j = 0; j < n; j++ )
{ // 4 5 6 7 M->Cells[j][n - 1] = IntToStr( n + j );
M->Cells[n - 1][j] = IntToStr( n + j ); }}// ///*int n =
StrToInt( InputBox( "MATRIXXX", "* DIGITE NRO DE COLUMNAS: ", "0" )
); Matrix->ColCount = n; llenar_7(Matrix,n);*/ // OK OK OK OK OK
OK//------------------------------------------------------------------------------//------------------------------------------------------------------------------/*void
revesColumna( TStringGrid *A, short m, short n, short &f, short
&c, short dato ) { if ( dato > 1 ) {
revesColumna(A,m,n,f,c,dato-1); if ( f == m -1) { c++; f = 0; }
//NO SE COMO SE LO LLAMA A LA FUNCI YA QUE ME APARECE CON POCOS
PARMETROS else { f++; } A->Cells[f][c]=dato; } else { f = 0; c =
0; A->Cells[ f ][ c ] = dato;
}}*///------------------------------------------------------------------------------//------------------------------------------------------------------------------/*void
inversa( TStringGrid *A, short m, short n, short &f, short
&c, short a );void inversa( TStringGrid *A, short m, short n )
{ inversa( A, m, n, m - 1, n - 1 );}
void inversa( TStringGrid *A, short m, short n, short &f,
short &c, short a ) { if ( a > 1 ) { inversa(A,m,n,f,c,a-1);
if ( f > 0 ) f--; else { f = m -1; c++; } //NO SE COMO SE LO
LLAMA A LA FUNCI YA QUE ME APARECE CON POCOS PARMETROS
A->Cells[f][c]=a; } else { f = m - 1; c = 0;
A->Cells[f][c]=1;
}}*///------------------------------------------------------------------------------//------------------------------------------------------------------------------//
DEVUELVE TRUE SI LA MATRIZ M*N EST ORDENADAbool estaOrden(
TStringGrid *A, int m, int n ) { bool bb; if ( m == 0 ) bb = true;
else { bb = estaOrden(A,m-1,n); if ( bb ) { bb =
estaOrden(A,m-1,n); if ( bb ) bb = A->Cells[ m - 2 ][ n - 1 ]
< A->Cells[ m - 1 ][ 0 ]; } } return ( bb );}
bool estaOrdenada( TStringGrid *A, int m, int n, int f, int c )
{ bool bb; int ne,c2,f2; ne = f * n + c + 1; if ( ne < 2 ) bb =
true; else { if ( c == 0 ) { c2 = n - 1; f2 = f - 1; } else { f2 =
f; c2 = c - 1; bb = estaOrdenada(A,m,n,f2,c2); if ( bb ) bb =
A->Cells[ f2 ][ c2 ] < A->Cells[ f ][ c ]; } } return ( bb
);}//------------------------------------------------------------------------------//------------------------------------------------------------------------------/*void
Magico1( TStringGrid *A, short m, short n, short f, short c ) { if(
n == 1 ) { //caso base f = 2; c = (A->ColCount+1)/2-1;
A->Cells[ c ][ f ] = n; } else { ESTA MALLLLLLLLLLLLLLLLLL SALE
OVERFLOW Magico1( A, m, n-1, f, c); if ( ( n-1 ) % m == 0 ) f++;
else { if ( f == 0 ) f = m - 1; else f--; if ( c == ( m-1) ) c = 0;
else c++; } A->Cells[ f ][ c ] = n;
}}*///------------------------------------------------------------------------------//------------------------------------------------------------------------------/*void
Magic( TStringGrid *A, short n, short f, short c ) { if ( n == 1 ){
f = 0; c = (A->ColCount+1)/2-1; A->Cells[ c ][ f ] = n; }
else { //ESTA MALLLLLLLLLLLLLLLLLL SALE SATCK OVERFLOW Magic( A,
n-1, f, c); if ( ( n-1 ) % n == 0 ) if ( f == 0 ) f =
A->ColCount-1; else f--; } A->Cells[ c ][ f ] =
n;}*///------------------------------------------------------------------------------//------------------------------------------------------------------------------
void llenarReves( TStringGrid *A, int m , int n , int f , int c)
{ int ne; ne = ( n * m ) - ( n * f ) - c; if ( ne Cells[ c ] [ f ]
= IntToStr( ne ); if ( c == 0 ) { f--; c = n - 1; } else { c--; }
llenarReves( A , m ,n, f, c );
}}//------------------------------------------------------------------------------//------------------------------------------------------------------------------void
magico2( TStringGrid *A, int m , int &f , int &c, int dato)
{ if (dato > 1) { magico2(A,m,f,c,dato-1); if ( ((dato-1)% m) ==
0) f++; else { if ( f==0 ) f = m-1; else f--; if ( c==0 ) c = m-1;
else c--; } A->Cells[c][f]= IntToStr(dato); } else { f = 0; c =
m / 2; A->Cells[c][f]= IntToStr(dato);
}}//------------------------------------------------------------------------------//------------------------------------------------------------------------------int
limiteM( int x ) { int r = 0; for ( int i = 0; i < x ; i++ ) { r
= r + ( x - i); } return r;}
/*********modoto del llenadon sespiral***************/
void matriztri( TStringGrid *A, int m, int &f, int &c,
int dato) { if ( dato == 1 ) { A->Cells[ c ][ f ] =
IntToStr(dato); } else { A->Cells[c][f]= IntToStr(dato); if ( c
== 0 ) { c = f-1; f = 0; } else { c--; f++; } matriztri( A, m, f,
c, dato-1 ); }}/********************* Proceso
Principal********************************/void espiral( TStringGrid
*A, int m, int &f, int &c, int dato) { int lim = limiteM( m
); if ( dato > lim ) { A->Cells[c][f]= IntToStr(dato); if ( f
== m-1 ) { f = c-1; c++; } else { f++; c--; } if ( c == m ) c--; if
( f == 1 ) c = m-1; espiral( A, m, f, c, dato-1 ); } else { c = m -
1; dato = dato + 1; matriztri( A , m , f , c , dato - 1 ); }}
///**************************************************************************//////*******************************
CADENAS
******************************//////**************************************************************************///
//------------------------------------------------------------------------------//
1) PROGRAMA QUE VERIFICA SI ES CONSONANTEbool esConsonante( char x
) { bool sw = false; if ( ( x == 'b' ) || ( x == 'c' ) || ( x ==
'd' ) || ( x == 'f' ) || ( x == 'g' ) || ( x == 'h' ) || ( x == 'j'
) || ( x == 'k' ) || ( x == 'l' ) || ( x == 'm' ) || ( x == 'n' )
|| ( x == 'p' ) || ( x == 'q' ) || ( x == 'r' ) || ( x == 's' ) ||
( x == 't' ) || ( x == 'v' ) || ( x == 'w' ) || ( x == 'x' ) || ( x
== 'y' ) || ( x == 'z' ) ) sw = true; return ( sw
);}//------------------------------------------------------------------------------//
2) PROGRAMA QUE VERIFICA SI ES VOCALbool esVocal( char x ) { bool
sw = false ; if ( ( x == 'a' ) || ( x == 'e' ) || ( x == 'i' ) || (
x == 'o' ) || ( x == 'u' ) || ( x == 'A' ) || ( x == 'E' ) || ( x
== 'I' ) || ( x == 'O' ) || ( x == 'U' ) ) sw = true; return ( sw
);}//------------------------------------------------------------------------------//
3) PROGRAMA QUE ELIMINA LAS VOCALES DE UNA CADENAvoid ElimVoc(
String &s ) {int n = s.Length( ); char ch; if( n > 0 ) { ch
= s[ n ]; s.Delete( n, 1 ); ElimVoc( s ); if( !esVocal( ch ) ) s +=
ch;
}}//------------------------------------------------------------------------------//
4) PROGRAMA QUE INVIERTE UNA CADENAString invertirCad( String
&s ) { int n = s.Length(); if( n > 0 ) { char x = s[ n ];
s.Delete( n, 1 ); invertirCad( s ); s.Insert( x, 1 ); } return ( s
);}//------------------------------------------------------------------------------//
5) PROGRAMA QUE CUENTA LA CANTIDAD DE PALABRAS DE UNA CADENAint
contarPal( String &s ) { int n, c; s = s.Trim( ); n = s.Length(
); s = s + ' '; if ( n == 0 ) c = 0; else { int pos = s.Pos( ' ' );
s.Delete( 1, pos ); c = contarPal( s ); c++; } return ( c );}
int contPalabras( String s ) { int c, n; char x; n = s.Length(
); if ( n == 0 ) //Primer Caso Base c = 0; else if ( n == 1 ) {
//Segundo Caso Base if ( s[ 1 ] == ' ' ) c = 0; else c = 1; } else
{ x = s[ n ]; s.SetLength( n - 1 ); c = contPalabras( s ); if ( ( x
!= ' ' ) && ( s[ n - 1 ] == ' ' ) ) c++; } return ( c );}//
< AQU EST SU LLAMADA AL MTODO > // /*String s =
EditMostrar->Text; s = ( InputBox( "CADENAXXX","* DIGITE UNA
CADENA :", "" ) ); int x = contPalabras( s ); //CONTAR LA CANTIDAD
DE PALABRAS QUE TENGAN LA LETRA 'A' EditMostrar->Text =
EditMostrar->Text + ( x );*/ //OK OK OK OK OK
OK//------------------------------------------------------------------------------
// 6) PROGRAMA QUE SEPARA LAS VOCALES Y CONSONANTES DE UNA
CADENAvoid separaVocCon( String s, String &s1, String &s2 )
{ int n = s.Length( ); char ch; s.Trim( ); if ( n > 0 ) { ch =
s[ n ]; s.Delete( n, 1 ); separaVocCon( s, s1, s2 ); if ( esVocal(
ch ) ) { s1 += ch; } else if ( ch != ' ' ) { s2 += ch; }
}}//------------------------------------------------------------------------------//
7) PROGRAMA QUE CUENTA LAS VOCALES QUE ESTN DELANTE DE UNA
CONSONANTEint contVocCon( String s ) { int n = s.Length( ); int c =
0; if ( n < 2 ) c = 0; else { char x = s[ n ]; s.Delete( n, 1 );
c = contVocCon( s ); if ( ( esVocal( s[ n - 1 ] ) ) && (
esConsonante( x ) ) ) c++; } return ( c
);}//------------------------------------------------------------------------------//
8) PROGRAMA QUE CUENTA LA CANTIDAD DE VOCALES DE UNA CADENAint
contVocales( String s ) { int a = 0; int n = s.Length( ); if ( n
> 0 ) { char ch = s[ n ]; s.Delete( n, 1 ); a = contVocales( s
); if ( esVocal( ch ) ) a++; } return ( a );}
int cantidadVocales( String s ) { int c, n; char x; n =
s.Length( ); if ( n == 0 ) c = 0; else { x = s[ n ]; s.SetLength( n
- 1 ); c = cantidadVocales( s ); if ( esVocal( x ) ) c++; } return
( c
);}//------------------------------------------------------------------------------//
9) PROGRAMA QUE ELIMINA LOS ESPACIOS DE UNA CADENAvoid ElimEsp(
String &s ) { int n = s.Length( ); String x = ' '; if ( n >
0 ) { x = s[ n ]; s.Delete( n, 1 ); ElimEsp( s ); if ( x != ' ' ) s
= s + x;
}}//------------------------------------------------------------------------------//
10) PROGRAMA QUE ELIMINA UN CARACTER DE UNA CADENAvoid ElimCar(
String &s, char c ) { int n = s.Length( ); char x = ' '; if ( n
> 0 ) { x = s[ n ]; s.Delete( n, 1 ); ElimCar( s, c ); if ( x !=
c ) s = s + x;
}}//------------------------------------------------------------------------------
// 11) PROGRAMA QUE MUESTRA LA PALABRA LARGA DE UNA CADENAString
palExt( String &s ) { int n; String b, c; s = s.Trim( ); n =
s.Length( ); s = s + ' '; if ( n == 0 ) { return ( "" ); } else {
int pos = s.Pos( ' ' ); c = s.SubString( 1, pos - 1 ); s.Delete( 1,
pos ); b = palExt( s ); if ( c.Length( ) >= b.Length( ) ) b = c;
} return ( b
);}//------------------------------------------------------------------------------//
12) PROGRAMA QUE CUENTA CANTIDAD DE PALABRAS QUE TENGA LA LETRA
'A'int contarPalabras( String &s ) { int n, c; String s1; s =
s.Trim( ); n = s.Length( ); s = s + ' '; if ( n == 0 ) return ( 0
); else { int pos = s.Pos( ' ' ); s1 = s.SubString( 1, pos - 1 );
s.Delete( 1, pos ); c = contarPalabras( s ); n = s1.Length( ); int
i = 1; bool sw = false; while ( ( i 0 ) { x = s[ n ]; s.SetLength(
n - 1 ); elimVocales( s ); if ( vocal.Pos( x ) == 0 ) s = s + x;
}}// < AQU EST SU LLAMADA AL MTODO > ///*String
s=EditMostrar->Text; s = ( InputBox("CADENAXXX","* DIGITE UNA
CADENA :", "" ) ); elimVocales( s ); //ELIMINAR LAS VOCALES DE UNA
CADENA EditMostrar->Text = EditMostrar->Text+( s );*/ //OK OK
OK OK OK
OK//------------------------------------------------------------------------------
// 15) FUNCIN QUE MUESTRA LA CANTIDAD DE PALABRAS QUE TENGAN AL
MENOS UNA LETRA 'A'void contPar( String s, int &c, bool hay ) {
int n; char x; n = s.Length( ); if ( n == 0 ) { c = 0; hay = false;
} else { x = s[ n ]; s.SetLength( n - 1 ); contPar( s, c, hay ); if
( ( x == 'a' || x == 'A') && ( !hay ) ) { c++; hay = true;
} else if ( x == ' ' ) { hay = false; } }}/*int contarPalA( String
s ) { int c; bool sw; contarPalA( s,c,sw ); //
OOOOOOOOOOOOOOOOJJJJJJJJJJJJJJJJJJJJJJOOOOOOOOOO return ( c );}
*///------------------------------------------------------------------------------bool
Palin(String s,int a,int b){ int n=(b-a+1)/2; bool f; Char x,y;
if(n==0) f=true; else { x=s[a]; y=s[b];
if(Palin(s,a+1,b-1)&&x==y) f=true; else f=false;
}return f;}bool Palin(String s){ int a,b; bool f; b=s.Length();
if(Palin(s,1,b)) f=true; else f=false; return f;}
// < AQU EST SU LLAMADA AL MTODO > // /*String
cad=InputBox("",""," "); if(Palin(cad)) ShowMessage("Es
Palindrome"); else ShowMessage("No es
Palindrome");*///------------------------------------------------------------------------------bool
EstalaVoc(String s){ bool b; char p; String voc="aeiouAEIOU"; int
n=s.Length(); if(n==0) b=false; else { p=s[n]; s=s.SetLength(n-1);
if(voc.Pos(p)>0) b=true; else b=EstalaVoc(s); } return b;}int
ContarPal(String s) // CONTAR LAS PALABRAS SIN VOCALES{ int c; int
n=s.Length(); if(n==0) c=0; else { char p=s.Pos(' '); if(p==0) p=n;
String aux=s.SubString(1,p); s=s.SubString(p+1,n-p);
c=ContarPal(s); if(!EstalaVoc(aux)) c++; } return c;}// < AQU
EST SU LLAMADA AL MTODO > // /*String s=InputBox("","","");
ShowMessage("Las Palabras sin vocal son:
"+IntToStr(ContarPal(s)));*///------------------------------------------------------------------------------
// EST LA LETRA 'A'bool estaVoc(String s){ int n; char p; bool
b; n=s.Length(); if(n==0) b=false; else { p=s[n]; s.SetLength(n-1);
if(estaVoc(s)||p=='a') b=true; else b=false; }return b;}// < AQU
EST SU LLAMADA AL MTODO > // /*String cad=Edit1->Text;
if(estaVoc(cad)) ShowMessage("Esta"); else ShowMessage("No
esta");*///------------------------------------------------------------------------------//
CONTAR LAS PALABRAS QUE TENGAN LA LETRA 'A'int
ContarPalconVoc(String s){ int c,n; char p; n=s.Length(); if(n==0)
c=0; else { if(n==1) { if(s[1]=='a') c=1; else c=0; } else { int
a=s.Pos(' '); if(a==0) a=n; String cad=s.SubString(1,a-1);
s=s.SubString(a+1,n-a); c=ContarPalconVoc(s); if(estaVoc(cad)) c++;
} } return c;}// < AQU EST SU LLAMADA AL MTODO > //
//ShowMessage(IntToStr(ContarPalconVoc(Edit1->Text)));
///**************************************************************************//////************
DESDE AQU EMPIEZO A LLAMAR A TODAS MIS FUNCIONES ***********///
///********** POR AQU ACCEDO DIRECTO A LAS FUNCIONES DESDE EL
MEN
*********//////**************************************************************************///
//------------------------------------------------------------------------------void
__fastcall TForm1::Fibonacci1Click(TObject *Sender) { short a; a =
StrToInt( InputBox( "* SERIE FIBONACCI", "* INGRESE UN NMERO: ",
"0" ) ); EditMostrar->Text = Fibo( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Ascendentes1Click(TObject *Sender) { byte a; a =
StrToInt( InputBox( "* PRIMEROS N NMEROS NATURALES", "* INGRESE UN
NMERO: ", "0" ) ); Mostrar( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Descendentes1Click(TObject *Sender) { byte a; a
= StrToInt( InputBox( "* PRIMEROS N NMEROS NATURALES", "* INGRESE
UN NMERO: ", "0" ) ); Mostrar1( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Pares1Click(TObject *Sender) { byte a; a =
StrToInt( InputBox( "* PRIMEROS N NMEROS PARES", "* INGRESE UN
NMERO: ", "0" ) ); MostrarPares( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Impares1Click(TObject *Sender) { byte a; a =
StrToInt( InputBox( "* PRIMEROS N NMEROS IMPARES", "* INGRESE UN
NMERO: ", "0" ) ); MostrarImpares( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Digitos1Click(TObject *Sender) { int a; a =
StrToInt( InputBox( "* SUMA DE LOS DGITOS DE UN NMERO", "* INGRESE
UN NMERO: ", "0" ) ); ( *EditMostrar ).Text = SumaDigitos( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::DigitoPares1Click(TObject *Sender) { Cardinal a;
a = StrToInt( InputBox( "* ELIMINAR DGITOS PARES DE UN NMERO", "*
INGRESE UN NMERO: ", "0" ) ); EliminarPares( a ); ShowMessage( a
);}//------------------------------------------------------------------------------
void __fastcall TForm1::Pares2Click(TObject *Sender) { int a; a
= StrToInt( InputBox( "* SUMA DE LOS DGITOS PARES DE UN NMERO", "*
INGRESE UN NMERO: ", "0" ) ); ( *EditMostrar ).Text =
SumaDigitosPares( a
);}//------------------------------------------------------------------------------void
__fastcall TForm1::ParesImpares1nro1Click(TObject *Sender) {
Cardinal x,p,i; x = StrToInt( InputBox( "* SEPARAR DGITOS
PARES-IMPARES DE UN NMERO", "* INGRESE UN NMERO: ", "0" ) );
Sep_Imp_Par( p, i, x ); ShowMessage( " [ " +IntToStr( p ) +'|'+
IntToStr( i ) + " ] "
);}//------------------------------------------------------------------------------void
__fastcall TForm1::BtnSepararClick(TObject *Sender) { Cardinal x,
y, z; EditMostrar->Clear( ); x = StrToInt( InputBox( "* SEPARAR
PAR - IMPAR", "* INGRESE UN NMERO: ", "0" ) ); y = StrToInt(
InputBox( "* SEPARAR PAR - IMPAR", "* INGRESE OTRO NMERO: ", "0" )
); Edit1->Text = x; Edit2->Text = y; juntar( x, y, z ); if (
z Text = z; Sep_Imp_Par( x, y, z ); } Edit1->Text = x;
Edit2->Text =
y;}//------------------------------------------------------------------------------void
__fastcall TForm1::BurbujaClick(TObject *Sender) { int v[ 50 ], i;
Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* ORDENAR UN VECTOR
POR BURBUJA", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i <
n; i++ ) { v[ i ] = StrToInt( InputBox( "* ORDENAR UN VECTOR POR
BURBUJA", "* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text +
"-" + IntToStr( v[ i ] ); } OrdenarBurbu( n, v ); for ( i = 0; i
< n; i++ ) { EditMostrar->Text = EditMostrar->Text + "-" +
IntToStr( v[ i ] );
}}//------------------------------------------------------------------------------
void __fastcall TForm1::Juntar2Nro1Click(TObject *Sender) {
Cardinal x, y, z; EditMostrar->Clear( ); x=StrToInt( InputBox(
"* JUNTAR LOS DGITOS DE DOS NMEROS", " * INGRESE UN NMERO: ", "0" )
); y=StrToInt( InputBox( "* JUNTAR LOS DGITOS DE DOS NMEROS", " *
INGRESE OTRO NMERO: ", "0" ) ); Edit1->Text = x; Edit2->Text
= y; juntar( x, y, z ); if ( z Text = z; else EditMostrar->Text
= "NO SE PUDO
JUNTAR";}//------------------------------------------------------------------------------void
__fastcall TForm1::Potenciaxn1Click(TObject *Sender) { Word x, n; x
= StrToInt( InputBox( "* POTENCIA X ^ N", "* INGRESE UN NMERO: ",
"0" ) ); n = StrToInt( InputBox( "* POTENCIA X ^ N", "* INGRESE
POTENCIA: ", "0" ) ); EditMostrar->Text = FloatToStr( Potencia(
x, n )
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Burbuja1Click(TObject *Sender) { int v[ 50 ], i;
Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* ORDENAR UN VECTOR
POR BURBUJA", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i <
n; i++ ) { v[ i ] = StrToInt( InputBox( "* ORDENAR UN VECTOR POR
BURBUJA", "* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text +
"-" + IntToStr( v[ i ] ); } OrdenarBurbu( n, v ); for ( i = 0; i
< n; i++ ) { EditMostrar->Text = EditMostrar->Text + "-" +
IntToStr( v[ i ] );
}}//------------------------------------------------------------------------------void
__fastcall TForm1::SumaDgitosPares1Click(TObject *Sender) { int v[
50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* SUMA DE LOS DGITOS
DE UN VECTOR", "* INGRESE DIMENSIN: ", "0" ) ); for ( i = 0; i <
n; i++ ) { v[ i ] = StrToInt( InputBox( "* SUMA DE LOS DGITOS DE UN
VECTOR", "* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text +
"-" + IntToStr( v[ i ] ); } EditMostrar->Text = IntToStr( SumaV(
v, n )
);}//------------------------------------------------------------------------------
void __fastcall TForm1::SumaDgitos1Click(TObject *Sender) { int
v[ 50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* SUMA DE LOS DGITOS
PARES DE UN VECTOR", "* INGRESE DIMENSIN: ", "0" ) ); for ( i = 0;
i < n; i++ ) { v[ i ] = StrToInt( InputBox( "* SUMA DE LOS
DGITOS PARES DE UN VECTOR", "* VALOR: ", "0" ) ); Edit1->Text =
Edit1->Text + "-" + IntToStr( v[ i ] ); } EditMostrar->Text =
IntToStr( sumaPares( v, n )
);}//------------------------------------------------------------------------------void
__fastcall TForm1::SumaDgitosImpares1Click(TObject *Sender) { int
v[ 50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* SUMA DE LOS DGITOS
IMPARES DE UN VECTOR", "* INGRESE DIMENSIN: ", "0" ) ); for ( i =
0; i < n; i++ ) { v[ i ] = StrToInt( InputBox( "* SUMA DE LOS
DGITOS IMPARES DE UN VECTOR", "* VALOR: ", "0" ) ); Edit1->Text
= Edit1->Text + "-" + IntToStr( v[ i ] ); } EditMostrar->Text
= IntToStr( SumaImpares( v, n )
);}//------------------------------------------------------------------------------void
__fastcall TForm1::PromedioDgitos1Click(TObject *Sender) { int v[
50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* PROMEDIO DE LOS
DGITOS DE UN VECTOR", "* INGRESE DIMENSIN: ", "0" ) ); for ( i = 0;
i < n; i++ ) { v[ i ] = StrToInt( InputBox( "* PROMEDIO DE LOS
DGITOS DE UN VECTOR", "* VALOR: ", "0" ) ); Edit1->Text =
Edit1->Text + "-" + IntToStr( v[ i ] ); } EditMostrar->Text =
FloatToStr( PromedioV( v, n )
);}//------------------------------------------------------------------------------
void __fastcall TForm1::MayorDgito1Click(TObject *Sender) {int
v[ 50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* MAYOR DGITO DE UN
VECTOR", "* INGRESE DIMENSIN: ", "0" ) ); for ( i = 0; i < n;
i++ ) { v[ i ] = StrToInt( InputBox( "* MAYOR DGITO DE UN VECTOR",
"* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text + "-" +
IntToStr( v[ i ] ); } EditMostrar->Text = IntToStr( Mayor( v, n
)
);}//------------------------------------------------------------------------------void
__fastcall TForm1::Clear1Click(TObject *Sender) { Edit1->Clear(
); Edit2->Clear(
);}//------------------------------------------------------------------------------void
__fastcall TForm1::OrdenarBurbuja1Click(TObject *Sender) { Cardinal
a; a = StrToInt( InputBox( "* ORDENAR DGITOS DE UN NMERO POR
BURBUJA", "* INGRESE UN NMERO: ", "0" ) ); OrdenarX( a );
ShowMessage( a
);}//------------------------------------------------------------------------------/*void
__fastcall TForm1::OrdenarInsertar1Click(TObject *Sender) {
Cardinal a; a = StrToInt(InputBox("* ORDENAR LOS DGITOS DE UN NMERO
POR INSERCIN","* INGRESE UN NMERO: "," ")); Ordenar( a );
ShowMessage( a ); //ALGO ESTA MALLLLLLLLLLLLLLL}
*///------------------------------------------------------------------------------void
__fastcall TForm1::Exit1Click(TObject *Sender) {
Application->Terminate(
);}//---------------------------------------------------------------------------void
__fastcall TForm1::BtnSalirClick(TObject *Sender) {
Application->Terminate(
);}//------------------------------------------------------------------------------void
__fastcall TForm1::TimerAutorTimer(TObject *Sender) {
LbAutor->Visible =!LbAutor->Visible; ImgCamba->Visible =
!ImgCamba->Visible; ImgkoRn->Visible =
!ImgkoRn->Visible;}//------------------------------------------------------------------------------void
__fastcall TForm1::TimerResultadoTimer(TObject *Sender) {
LblResultado->Visible = !LblResultado->Visible;}
//------------------------------------------------------------------------------void
__fastcall TForm1::TimerTituloTimer(TObject *Sender) { String x, s
= ""; s = Caption; char ch = s[ 1 ]; s.Delete( 1, 1 ); s.Insert(
ch, s.Length( ) ); Caption = s; x += 11;/// ESTE CDIGO ME PERMITIR
MOVER EL TTULO DE LA VENTANA FORM1 ////*String cad, aux; //var
cad,aux:string; cad = Form1->Caption;
//cad:=FrmExplorador.Caption; aux = cad[cad.Length()];
//aux:=cad[length(cad)]; delete(cad,
cad.Length(),1);//Delete(cad,length(cad),1); cad = aux + cad;
//cad:=aux+cad; Form1->Caption = cad;*/
//FrmExplorador.Caption:=cad;}//------------------------------------------------------------------------------void
__fastcall TForm1::InvertirElementos1Click(TObject *Sender) { int
v[ 50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* INVERTIR ELEMENTOS
DE UN VECTOR", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i <
n; i++ ) { v[ i ] = StrToInt( InputBox( "* INVERTIR ELEMENTOS DE UN
VECTOR", "* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text +
"-" + IntToStr( v[ i ] ); } Invertir( v, n ); for ( i = 0; i <
n; i++ ) { EditMostrar->Text = EditMostrar->Text + "-" +
IntToStr( v[ i ] ); }
//v[6]={1,3,8,9,10,7};}//------------------------------------------------------------------------------void
__fastcall TForm1::BusquedaBinaria1Click(TObject *Sender) { int v[
50 ], i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* BUSQUEDA BINARIA",
"* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i < n; i++ ) { v[ i
] = StrToInt( InputBox( "* BUSQUEDA BINARIA", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] ); }
BusBin( v, n, 10 ); for ( i = 0; i < n; i++ ) { if ( BusBin( v,
n, 10 ) ) // OJO MUESTRA LAS VECES DE DIGITOS DEL VECTOR //
ShowMessage( "SE ENCUENTRA EL VALOR =)" ); else ShowMessage( "NO SE
ENCUENTRA EL VALOR =(" );
}}//------------------------------------------------------------------------------void
__fastcall TForm1::BusBinariaClick(TObject *Sender) { int v[ 50 ],
i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* BUSQUEDA BINARIA",
"* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i < n; i++ ) { v[ i
] = StrToInt( InputBox( "* BUSQUEDA BINARIA", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] ); }
BusBin( v, n, 10 ); for ( i = 0; i < n; i++ ) { if ( BusBin( v,
n, 10 ) ) // OJO MUESTRA LAS VECES DE DIGITOS DEL VECTOR //
ShowMessage( "SE ENCUENTRA EL VALOR =)" ); else ShowMessage( "NO SE
ENCUENTRA EL VALOR =(" );
}}//-----------------------------------------------------------------------------void
__fastcall TForm1::QuickSort1Click(TObject *Sender) { int v[ 50 ],
i; Word n; Edit1->Clear( ); EditMostrar->Clear( );
Edit2->Clear( ); n = StrToInt( InputBox( "* ORDENAR UN VECTOR
POR QUICKSORT", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0; i <
n; i++ ) { v[ i ] = StrToInt( InputBox( "* ORDENAR UN VECTOR POR
QUICKSORT", "* VALOR: ", "0" ) ); Edit1->Text = Edit1->Text +
"-" + IntToStr( v[ i ] ); } QuickSort(v,n); //OrdenarBurbu( n, v );
for ( i = 0; i < n; i++ ) { EditMostrar->Text =
EditMostrar->Text + "-" + IntToStr( v[ i ] );
}}//---------------------------------------------------------------------------void
__fastcall TForm1::CargaRandomizeClick(TObject *Sender) { Word i, n
; n = StrToInt( InputBox( "* CARGA RANDOMIZE", "* INGRESE DIMENSIN:
", "0" ) ); Vextor->ColCount = n; Randomize( ); for ( i = 0; i
< n; i++ ) { Vextor->Cells[ i ][ 0 ] = random( 20 );
}}//------------------------------------------------------------------------------
///**************************************************************************//////*******************
LLAMADOS A LOS MTODOS RECURSIVOS
********************//////**************************************************************************///
void __fastcall TForm1::BTNRECURSIVOClick(TObject *Sender) {
//****************************************************************************////*********
LLAMADOS A TODOS LOS MTODOS DEL PRCTICO # 2 DE VERANO
**********////****************************************************************************//
//------------------------------------------------------------------------------//
1) /*int v[ 8 ] = { 8, 2, 3, 1, 3, 5, 6 }, n = 8; if( SumaMitades(
v, n ) ) ShowMessage( " SON IGUALES " ); else ShowMessage( "No son
Iguales" );*/ //OK OK OK OK OK OK
/*int v[ 50 ], i; int n; String x; Edit1->Clear( );
EditMostrar->Clear( ); Edit2->Clear( ); n = StrToInt(
InputBox( "VEXXXTOR", "* DIGITE DIMENSIN: ", "0" ) ); for ( i = 0;
i < n; i++ ) { v[ i ] = StrToInt( InputBox( "VEXXXTOR", "*
VALOR: ", "0" ) ); Edit1->Text = Edit1->Text + "-" +
IntToStr( v[ i ] ); } if( SumaMitades( v, n ) ) ShowMessage( " SON
IGUALES " ); else ShowMessage( "No son Iguales" );*/ //OK OK OK OK
OK
OK//------------------------------------------------------------------------------//
2) /*int x = StrToInt(InputBox("","","")); if ( existe(v,n,x))
ShowMessage("SI"); else ShowMessage("NO");*/ //
/*int v[ 3 ] = { 2, 3, 4 }; int n = 3; int v1[ 6 ] = { 1, 2, 3,
4, 5, 6 }; int m = 6; if ( contenido( v, v1, n, m ) ) ShowMessage(
"EL VECTOR A EST EN EL VEC