Beruflich Dokumente
Kultur Dokumente
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 );
}
}
//------------------------------------------------------------------------------
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 );
}*/
//------------------------------------------------------------------------------
}
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;
}
}
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 );
}*/
//------------------------------------------------------------------------------
if ( n == 0 )
s = 0;
else {
a = n % 10;
s = SumaN( n / 10 ) + a;
}
return ( s );
}
//-----------------------------------------------------------------------------// 30) PROGRAMA QUE MUESTRA LOS DGITOS DE UN NMERO
void 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 PAR
void 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 <= 1 )
e = true;
else {
n--;
e = EstaOrdenado( v, n );
n++;
if ( e ) {
if ( v[ n - 1 ] < v[ n - 2 ] )
e = false;
}
}
return ( e );
}
bool enOrdenVec( int v[], int n ) {
bool bb = false;
if ( n == 1 )
bb = true;
else {
bb = enOrdenVec( v, n - 1 );
if ( bb && ( v[ n - 1 ] >= 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 <= 1 )
e = true;
else {
n--;
e = EstaOrdenado1( v, n );
n++;
if ( e ){
if ( v[ n - 1 ] > 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 );
}
//------------------------------------------------------------------------------
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 );
}
}
}
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;
}
}
}
//------------------------------------------------------------------------------
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 ) );
}
// 50) PROGRAMA QUE SEPARA LOS DGITOS PARES DE LOS IMPARES DE UN VECTOR DE N
ELEMENTOS
void rota( int v[], Word n );
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 VECTOR
int 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 VECTOR
void 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 VECTOR
int 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 VECTOR
bool hallado( int v[], int x, Cardinal n ) {
Cardinal a, b, c;
bool bb;
a = 0;
b = n - 1;
bb = false;
while ( ( a <= b ) && ( !bb ) ) {
c = ( a + b ) / 2;
if ( v[ c ] == x )
bb = true;
else
if ( x < v[ c ] )
b = c - 1;
else
a = c + 1;
}
return ( bb );
}
///----------------------------------------------------------------------------// 57) FUNCIN QUE MUESTRA LA SUMA DE LAS CASILLAS PARES
int sumCasillaPar( int v[], int n ) {
int sum = 0;
if ( n == 1 )
sum = v[ 0 ];
else {
sum = sumCasillaPar( v, n - 1 );
if ( ( n - 1 ) % 2 == 0 )
sum = sum + v[ n - 1 ];
}
return ( sum );
}
///**************************************************************************///
///**************************************************************************///
void intercambiar( int v[], int v1[], short n, short m ) {
int i = 0;
int aux, x;
while ( ( i < n ) || ( i < m ) ) {
aux = v[ i ];
//x = v[ i ];
//v1[ i ] = aux;
v[ i ] = v1[ i ];
v[ i ] = x;
i++;
}
}
///**************************************************************************///
///************* EJERCICIOS DEL PRCTICO # 1 DEL CURSO DE VERANO ************///
///**************************************************************************///
float promedio( int v[], int n ) {
int sum = 0;
int i = 0;
float prom = 0;
while ( i < n ) {
sum = sum + v[ i ];
i++;
}
prom = sum / n;
return ( prom );
}
//------------------------------------------------------------------------------
void concatenar( int v[], int v1[], int n, int m, int vx[], int &k ) {
for ( int k = 0; k < n; k++ ) {
vx[ k ] = v[ k ];
}
for ( int i = 1; i <= n; i++ ) {
vx[ k + 1 ] = v1[ i - 1 ];
}
k += m + 1;
}
//-----------------------------------------------------------------------------bool repetidos( int v[], int n ) {
bool bb = false;
int k = 0;
while( ( k < n ) && ( !bb ) ) {
int i = k + 1;
while ( ( i < n ) && ( !bb ) ) {
if ( v[ k ] == v[ i ] ) {
bb = true;
i++;
}
}
k++;
}
}
//-----------------------------------------------------------------------------int prodMaxMin( int v[], int n ) {
int i = 1;
int max = v[ 0 ];
int min = v[ 0 ];
while ( i < n ) {
if ( v[ i ] > max )
max = v[ i ];
if ( v[ i ] < min )
min = v[ i ];
i++;
}
return ( max * min );
}
//-----------------------------------------------------------------------------void prodCartesiano( int v[], int v1[], int n, int m, int vx[] ) {
int i = 0;
int k = 0;
while ( i < n ) {
int j = 0;
while ( j < m ) {
vx[ k ] = v[ i ];
k++;
vx[ k ] = v1[ j ];
k++;
j++;
}
i++;
}
}
//-----------------------------------------------------------------------------int hamming( int v[], int v1[], int n, int m ) {
if ( n == m ) {
int c = 0;
for ( int i = 0; i < n; i++ ) {
if ( v[ i ] != v1[ i ] )
c++;
}
return ( c );
}
}
//-----------------------------------------------------------------------------int Pro1( int n ) {
int x, y, z;
x = n; y = 0; z = 0;
while ( y < x - 1 ) {
y = y + 1; z = z + y;
}
return ( z );
}
//-----------------------------------------------------------------------------int Pro2( int n ) {
int i, j, c;
c = 0;
for ( i = 1; i <= n; i++ ) {
for ( j = 1; j <= i; j++ ) {
c = c + j;
}
}
return ( c );
}
//-----------------------------------------------------------------------------int Pro3( int v[], int n ) { // OJO : CICLO INFINITOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
int p, i, j, s;
p = 1;
i = 1;
while ( i <= n ) {
s = 0;
j = 1;
while ( j < i ) {
s = v[ j ] - s;
j = j + 1;
}
p = p * s;
}
return ( p );
}
//-----------------------------------------------------------------------------// # 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 SUMAS
int 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
//-------------------------------------------------------------------------------
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 OK
int 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;
}
}
}
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 Inversa
void 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 );
}
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 );
}
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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 );
}
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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 );*/
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);
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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 )*/
f++;
k--;
if ( f == A->ColCount ) {
f = A->ColCount - 1;
c++;
}
}
llenMat6( A, f, c, k );
}
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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(f<0)
{c--; f++;}
}
else
{ f++;
if(f==m)
{ c--; f--;}
}
}
else
{ if(c%2==0)
{
f--;
if(f<0)
{ c--; f++;}
}
else
{ f++;
if(f==m)
{ c--; f--;}
}
}
Vivora(A,m,n,f,c,k+1);
}
}
void Vivora(TStringGrid *A,short m,short n)
{ short a=1;
Vivora(A,m,n,m-1,n-1,a);
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*int m=StrToInt(InputBox("","",""));
int n=StrToInt(InputBox("","",""));
Matrix->ColCount=n;
Matrix->RowCount=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])<StrToInt(A->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);
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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(f<0) {
f++;
c++;
}
}
else {
f++;
if(f==m) {
f--;
c++;
}
}
LlenarDesdeAvajo(A,m,n,f,c,k+1);
}
}
void LlenarDesdeAvajo(TStringGrid *A,short m,short n) {
LlenarDesdeAvajo(A,m,n,m-1,0,1);
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*int m=StrToInt(InputBox("","",""));
int n=StrToInt(InputBox("","",""));
M->ColCount=n;
m->RowCount=m;
LlenarDesdeAvajo(M,m,n);*/
//-----------------------------------------------------------------------------//-----------------------------------------------------------------------------void CargarTri(TStringGrid *A,short m,short n,short &f,short &c) {
if(f<m)
{ A->Cells[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);
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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;
}
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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
//-----------------------------------------------------------------------------//------------------------------------------------------------------------------
n++;
}
A->Cells[ m ][ n ] = a;
}
else {
m=0;
n=f/2;
A->Cells[ m ][ n ] = 1;
}
}
// <SU LLAMADA ES DE LA SGTE. MANERA: > //
/*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 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 ORDENADA
bool 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;
}*/
//-----------------------------------------------------------------------------//------------------------------------------------------------------------------
///**************************************************************************///
///******************************* CADENAS ******************************///
///**************************************************************************///
//-----------------------------------------------------------------------------// 1) PROGRAMA QUE VERIFICA SI ES CONSONANTE
bool 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 VOCAL
bool 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 CADENA
void 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 CADENA
String 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 CADENA
int 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
//------------------------------------------------------------------------------
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 CADENA
void 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 CADENA
void 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;
}
}
//------------------------------------------------------------------------------
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 <= n ) && ( sw == false ) ) {
if ( s1[ i ] == 'a' ) {
sw = true;
c++;
}
i++;
}
}
return ( c );
}
//------------------------------------------------------------------------------
s.Delete( n, 1 );
sw = esta( s );
if ( x == 'a' )
sw = true;
}
return ( sw );
}
//-----------------------------------------------------------------------------// 14) PROCEDIMIENTO QUE ELIMINA LAS VOCALES DE UNA CADENA
void elimVocales( String &s ) {
int n;
char x;
String vocal = "aeiouAEIOU";
n = s.Length( );
if ( n > 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)));*/
//------------------------------------------------------------------------------
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 );
}
//------------------------------------------------------------------------------
y = StrToInt( InputBox( "* SEPARAR PAR - IMPAR", "* INGRESE OTRO NMERO: ", "0" ) );
Edit1->Text = x;
Edit2->Text = y;
juntar( x, y, z );
if ( z <= 999999999 ) {
EditMostrar->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 ] );
}
}
//------------------------------------------------------------------------------
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 ) );
}
//------------------------------------------------------------------------------
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 =(" );
}
}
///**************************************************************************///
///******************* 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 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 SUMAS
/*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)
/*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 );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------// 5) MOSTRAR ELEMENTOS DEL VECTOR DE LAS CASILLAS PARES
/*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
/*int v[ 50 ], i;
int n;
String s;
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 ] );
}
casillaPar( v, n, s );
EditMostrar->Text = EditMostrar->Text + "," + s;*/ // OK OK OK OK OK OK
//------------------------------------------------------------------------------
int v2[ 3 ] = { 4, 5, 6 };
int m = 3;
int prod = proEscalar( v1, v2, n );
ShowMessage( prod );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------// 8)
/*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 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)
//ShowMessage(sumMayUlt(Vextor,Vextor->ColCount));// // OK OK OK OK OK OK
/*int v[ 50 ], i;
int n, sum;
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 ] );
}
sum = sumMayUlt( v, n);
EditMostrar->Text = EditMostrar->Text +IntToStr( sum );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------// 12)
/*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
//-----------------------------------------------------------------------------// 14)
/*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)
/*int a,b,v[ 7 ] = { 1, 3, 5, 8, 9, 10, 6 };
int n = 7;
MergeSort( v, a, b );
ShowMessage( "[" + VecToStr( v, n ) + "]" );*/ //malllllllllllllllllllllllllllll
///**************************************************************************///
///******************************* CADENAS ******************************///
///**************************************************************************///
//-----------------------------------------------------------------------------/*String s = "Homero raro";
ShowMessage(palExt(s));*/ //OK
/*String s=EditMostrar->Text;
s = ( InputBox("CADENAXXX","* DIGITE UNA CADENA :", "" ) );
palExt( s ); //MUESTRA LA PALABRA MAS LARGA DE UNA CADENA ojoooooooooooooo
EditMostrar->Text = EditMostrar->Text+(s);*/ //OK OK OK OK OK OK
//-----------------------------------------------------------------------------/* int v[5]={9,2,3,4,5};
int max,min; mallllllllllllllllllllllllllll
MaxMin(v,max,min,5);
ShowMessage(IntToStr(max)+"/"+IntToStr(min)); */
//-----------------------------------------------------------------------------/*String s = "adf dba bfei";
ElimVoc(s);
ShowMessage(s);*/ //OK
/*String s=EditMostrar->Text;
s = ( InputBox("CADENAXXX","* DIGITE UNA CADENA :", "" ) );
ElimVoc(s); //ELIMINA LAS VOCALES DE UNA CADENA
EditMostrar->Text = EditMostrar->Text+(s);*/ //OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*String s = "hola a todos";
String s1,s2;
separaVocCon(s,s1,s2);
ShowMessage(s1+"-"+s2);*/ //OK
/*String s,s1,s2=EditMostrar->Text;
s = ( InputBox("CADENAXXX","* DIGITE UNA CADENA :", "" ) );
separaVocCon(s,s1,s2); //SAPARA LAS VOCALES DE LAS CONSONANTES DE UNA CADENA
//-----------------------------------------------------------------------------/*Cardinal x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ",
"0" ) );
ShowMessage( SumaDigitosPares( x ) );*/ // 5) MOSTRAR SUMA DE DIGITOS PARES DE UN NRO
OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*Cardinal x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ",
"0" ) );
ShowMessage( CantidadPar( x ) );*/ // 6) MOSTRAR CANTIDAD DE DIGITOS PARES DE UN NRO
OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*byte n = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ", "0" ) );
MostrarImpares( n );*/ // 7) MOSTRAR N PRIMEROS NUMEROS IMPARES OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*Cardinal n = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ",
"0" ) );
ShowMessage( SumaDigitos( n ) );*/ // 11) MOSTRAR SUMA DE LOS DIGITOS OK OK OK OK OK
OK
//-----------------------------------------------------------------------------/*Cardinal x, p, i;
x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ", "0" ) );
Sep_Imp_Par( p, i, x ); // 12) SEPARA LOS DIGITOS PARES E IMPARES DE UN NRO OK OK OK OK
OK OK
ShowMessage( " [ " +IntToStr( p ) +'|'+ IntToStr( i ) + " ] " );*/
//-----------------------------------------------------------------------------/*Cardinal x,y,z; malllllllllllllllllllllllllllllllllllllllllllllllllllllll
x = 3745;
y = 1234;
SepararParImpar( z, x, y ); // 8) SEPARA LOS DIGITOS PARES E IMPARES DE DOS NRO
ShowMessage( " [ " +IntToStr( x ) +'|'+ IntToStr( y ) + " ] " ); */
//-----------------------------------------------------------------------------/*Cardinal x, y, z;
x = StrToInt(InputBox("** NMEROS NATURALES **", "* DIGITE UN NMERO: ", "0" ) );
y = StrToInt(InputBox("** NMEROS NATURALES **", "* DIGITE OTRO NMERO: ", "0" ) );
juntar( x, y, z ); // 15) JUNTAR LOS DIGITOS DE 2 NMEROS EN UNO SOLO OK OK OK OK OK OK
ShowMessage( z );*/
//-----------------------------------------------------------------------------/*Cardinal z; //malllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
z = 98713;
Ordenar( z ); // 16) ORDENAR DIGITOS DE UN NRO
ShowMessage( z );*/
//-----------------------------------------------------------------------------/*Cardinal x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ",
"0" ) );
ShowMessage( MenorDigito( x ) );*/ // 17) MOSTRAR EL MENOR DIGITO DE UN NRO
//8451962 MAAAAAAAAAAAAAAAAALLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
//--------------------------------------------------------------------------/*Cardinal x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ",
"0" ) );
x = Fibo( x ); // 20)MUESTRA EL N-SIMO TRMINO DE LA SERIE FIBONACCI OK OK OK OK OK
OK
ShowMessage( x );*/
//-----------------------------------------------------------------------------/*float p, x, n;
x = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE UN NMERO: ", "0" ) );
n = StrToInt( InputBox( "** NMEROS NATURALES **", "* DIGITE POTENCIA: ", "0" ) );
/*int v[ 50 ], i;
int n;
Edit1->Clear( );
EditMostrar->Clear( );
Edit2->Clear( );
n = StrToInt( InputBox( "VEXXXTOR", "* INGRESE DIMENSIN: ", "0" ) );
for ( i = 0; i < n; i++ ) {
v[ i ] = StrToInt( InputBox( "VEXXXTOR", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] );
} // ) Pro4 //
EditMostrar->Text = IntToStr( Pro4( v, n ) );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------///**************************************************************************///
///******************************* VECTORES *******************************///
///**************************************************************************///
//-----------------------------------------------------------------------------/*int x,v[7]={2,5,6,8,6,1,10};
byte z = 7;
x = SumaV( v, z ); // 13)MUESTRA LA SUMA DE LOS ELEMENTOS DE UN VECTOR //
ShowMessage( x );*/ //OK
//-----------------------------------------------------------------------------/*int x,v[7]={3,5,6,8,6,1,1};
byte z = 7;
x = SumaImpares( v, 7 ); // 14)MUESTRA LA SUMA DE LOS ELEMENTOS IMPARES DE UN
VECTOR //
ShowMessage( x );*/
//OK
//-----------------------------------------------------------------------------/*int x,v[7]={3,7,14,5,2,16,15};
Word n = 7;
x = sumParImp( v, n ); // X)MUESTRA LA SUMA DE LOS ELEMENTOS PARES CON IMPARES DE UN
VECTOR //
ShowMessage( x );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*int v[7]={3,7,14,5,2,16,15};
short n = 7;
int v1[8]={1,2,3,4,5,6,7,9};
short m = 8;
intercambiar( v, v1, n, m );
ShowMessage( "[" + VecToStr( v, n) + "]" );
ShowMessage( "[" + VecToStr( v1,m) + "]" );*/
/*int v[5]={1,2,3,4,5};
int n = 5;
float x;
x = promedio( v, n ); // 15)MUESTRA EL PROMEDIO DE LOS ELEMENTOS DE UN VECTOR //
ShowMessage( x );*/
/*int v[ 50 ], i;
int n, x;
Edit1->Clear( );
EditMostrar->Clear( );
Edit2->Clear( );
n = StrToInt( InputBox( " EJERCICIO DE VERANO ", "* INGRESE DIMENSIN: ", "0" ) );
for ( i = 0; i < n; i++ ) {
v[ i ] = StrToInt( InputBox( " EJERCICIO DE VERANO ", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] );
} // ) PROMEDIO DE LOS DGITOS DE UN VECTOR //
x = promedio( v, n );
EditMostrar->Text = IntToStr( x );*/ // OK OK OK OK OK OK
/*int v[4]={3,7,14,5};
int n = 4;
int v1[4]={1,2,8,4};
int m = 4;
int vx[ 50 ] = { 50 };
int k = 50;
concatenar( v, v1, n, m, vx, k );
ShowMessage( "[" + VecToStr2( v, v1, n, m ) + "]" );*/ // OK OK OK OK OK OK
/*int v[4]={3,7,14,5};
int n = 4;
int v1[3]={1,2,8};
int m = 4;
int vx[ 50 ] = { 50 };
int k = 50;
prodCartesiano( v, v1, n, m, vx );
//concatenar( v, v1, n, m, vx, k );
ShowMessage( "[" + VecToStr2( v, v1, n, m ) + "]" );*/
/*int x, v[ 6 ] = { 1, 2, 3, 4, 5, 5 };
short n = 6;
if ( repetidos( v, n ) )
// 24)BUSQUEDA BINARIA //
ShowMessage( "SI HAY DOS NMEROS REPETIDOS =)" );
else
// OK
ShowMessage( "NO HAY DOS NMEORS REPETIDOS =(" );*/
/*int v[7]={3,7,9,5,2,10,8};
int n = 7;
int x;
x = prodMaxMin( v, n );
ShowMessage( x );*/ //OK OK OK OK OK OK
/*int v[ 50 ], i;
int n,x;
Edit1->Clear( );
EditMostrar->Clear( );
Edit2->Clear( );
n = StrToInt( InputBox( "VEXXXTOR", "* INGRESE DIMENSIN: ", "0" ) );
for ( i = 0; i < n; i++ ) {
v[ i ] = StrToInt( InputBox( "VEXXXTOR", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] );
} // ) PRODUCTO DEL VALOR MAXIMO POR EL MINIMO //
x = prodMaxMin( v, n );
EditMostrar->Text = IntToStr( x );*/ // OK OK OK OK OK OK
/*int v[ 3 ] = { 1, 1, 1 };
int n = 3;
int v1[ 3 ] = { 0, 1, 0 };
int m = 3;
int x;
x = hamming( v, v1, n, m ); // OK OK OK OK OK OK
ShowMessage( x );*/
//-----------------------------------------------------------------------------/*int v[ 50 ], i;
Word n;
Edit1->Clear( );
EditMostrar->Clear( );
Edit2->Clear( );
n = StrToInt( InputBox( "VEXXXTOR", "* INGRESE DIMENSIN: ", "0" ) );
for ( i = 0; i < n; i++ ) {
v[ i ] = StrToInt( InputBox( "VEXXXTOR", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] );
} // 32)MUESTRA LA SUMA DE LOS ELEMENTOS PARES DE UN VECTOR //
EditMostrar->Text = IntToStr( sumaPares( v, n ) );*/ // OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*int v[7]={2,6,8,16,7,1,1};
int z = 7;
float x;
x = PromedioV( v, z ); // 15)MUESTRA EL PROMEDIO DE LOS ELEMENTOS DE UN VECTOR //
ShowMessage( x );*/ //OK
//-----------------------------------------------------------------------------/*int v[7]={3,7,4,5,1,13,2};
Rotar(v,7);
// 16)ROTAR UNA CASILLA A LA DERECHA ELEMENTOS DEL VECTOR //
ShowMessage( "[" + VecToStr( v, 7 ) + "]" );*/ //OK OK OK OK OK OK
//rotarDer( Vextor, Vextor->ColCount ); // OK OK OK OK OK OK
// rotarIzq1( Vextor, Vextor->ColCount ); // OK OK OK OK OK OK
/*int v[ 50 ], i;
Word n;
Edit1->Clear( );
EditMostrar->Clear( );
Edit2->Clear( );
n = StrToInt( InputBox( "VEXXXTOR", "* INGRESE DIMENSIN: ", "0" ) );
for ( i = 0; i < n; i++ ) {
v[ i ] = StrToInt( InputBox( "VEXXXTOR", "* VALOR: ", "0" ) );
Edit1->Text = Edit1->Text + "-" + IntToStr( v[ i ] );
}
//Rotar( v, n ); // 16)ROTAR UNA CASILLA A LA DERECHA ELEMENTOS DEL VECTOR //
rotarIzq( v, n );// xxxxx)ROTAR UNA CASILLA A LA IZQUIERDA ELEMENTOS DEL VECTOR //
EditMostrar->Text = ( "[" + VecToStr( v, n ) + "]" );*/ //OK OK OK OK OK OK
//-----------------------------------------------------------------------------/*int v[ 7 ] = { 1, 3, 5, 8, 9, 10, 6 };
InsertarX(v,7);
// 16.1)INSERTAR UN ELEMENTO A SU LUGAR //
ShowMessage( "[" + VecToStr( v, 7 ) + "]" );*/ //OK
//-----------------------------------------------------------------------------/*int x,v[10]={2,8,-5,10,15,4,6,9,2,7};
short int n = 1;
/*int v[ 50 ], i;
int n, 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 ] );
}
x = StrToInt( InputBox( "VEXXXTOR", "* DIGITE NMERO A ELIMINAR: ", "0" ) );
EliminarElemento( v, n, x ); // eliminar dato //
for ( i = 0; i < n; i++ ) {
EditMostrar->Text = EditMostrar->Text +","+IntToStr( v[ i ] );
}*/ // OK OK OK OK OK OK
/*int x;
x = StrToInt( InputBox( "VEXXXTOR", "* DIGITE NMERO A ELIMINAR: ", "0" ) );
elimDato( Vextor, Vextor->ColCount, x );*/ //MALLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
//-----------------------------------------------------------------------------/*int v[7]={7,4,1,8,5,3,6};
Burbu( v, 7 ); // 19)LLEVA EL MAYOR DIGITO A LA LTIMA CASILLA DEL VECTOR //
ShowMessage( VecToStr( v, 7 ) );*/ //OK OK OK OK OK OK
//burbujita( Vextor, Vextor->ColCount ); //mallllllllllllllllllllllllllll
//-----------------------------------------------------------------------------/*bool v[6]={7,1,5,8,6,4};
Ordenar( v, 6 ) // 20)VERIFICA SI LOS ELEMENTOS DEL VECTOR EST ORDENADO//
ShowMessage( VecToStr( v, 6 ) ); */
//-----------------------------------------------------------------------------/*int v[6]={1,3,8,9,10,7};
short n = 6;
Invertir( v, n );
// 23)INVERTIR LOS ELEMENTOS DE UN VECTOR //
ShowMessage( "[" + VecToStr( v, n ) + "]" );*/ //OK
//-----------------------------------------------------------------------------/*int x, v[ 12 ] = {1, 2, 4, 6, 9, 10, 11, 12, 20, 30, 31, 35 };
short n = 12;
if ( BusBin( v, n, 10 ) )
// 24)BUSQUEDA BINARIA //
ShowMessage( "SE ENCUENTRA EL VALOR =)" );
else
// OK
ShowMessage( "NO SE ENCUENTRA EL VALOR =(" );*/
//-----------------------------------------------------------------------------/*int v[ 8 ] = {4, 1, 5, 8, 6, 3, 2, 9 };
Word n = 8;
if ( EstaAntes( v, n, 3, 5 ) )
// 26)EST ANTES X DE Y EN UN VECTOR //
ShowMessage( "SE ENCUENTRA ANTES =)" );
else
// OK
ShowMessage( "NO SE ENCUENTRA ANTES =(" );*/
//------------------------------------------------------------------------------
}
//--------------------------------------------------------------------------void __fastcall TForm1::matrizAuxClick(TObject *Sender) {
int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE DIMENSIN: ", "0" ) );
int f = 0;
int c = m - 1;
int dato = limiteM( m );
matriztri( Matrix, m, f, c, dato ); //OK OK OK OK OK OK
}
//--------------------------------------------------------------------------void __fastcall TForm1::matrizElementalClick(TObject *Sender) {
int m = StrToInt( InputBox( "MATRIXXX", "* DIGITE DIMENSIN: ", "0" ) );
int f = m - 1;
int c = m - 1;
espiral( Matrix , m , f , c , m*m ); //OK OK OK OK OK OK
}
//--------------------------------------------------------------------------void __fastcall TForm1::estaOrdenMatrizClick(TObject *Sender) {
/*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 );*/
/*int f = m;
int c = n;
if ( estaOrdenada( Matrix , m , n , f ,c ) )
ShowMessage ("true");
else
ShowMessage ("false");*/
}
//--------------------------------------------------------------------------void __fastcall TForm1::BTNCARGAVECTORESClick(TObject *Sender) {
Word i, n ;
n = StrToInt( InputBox( "VEXXXTOR", "* INGRESE DIMENSIN: ", "0" ) );
Vextor->ColCount = n;
Randomize( );
for ( i = 0; i < n; i++ ) {
Vextor->Cells[ i ][ 0 ] = random( 20 );
}
}
void __fastcall TForm1::Par_ImpClick(TObject *Sender)
{
Cardinal p = 0, i = 0;
Cardinal n = StrToInt(InputBox("","cvjyuht",""));
Sep_Imp_Par(p,i,n);
ShowMessage(p);
ShowMessage(i);
}
// -------------------------------------------------------------------------