Foro de elhacker.net

Buenas noches.. Espero puedan ayudarme o prestarme alguna idea. Mi duda surge cuando al generar una cierta cantidad de arrays de tipo char de forma iterativa (obtengo los resultados esperados), cumpliendo ciertas condiciones de ordenamientos entre sus componentes

for(i=l1; i<=l3-1; i++){ 
t=0;
for(j=i-1; j>=0; j--){
   s++;
   aux1=S3[j];
   S3[j]=S3[j+1];
   S3[j+1]=aux1;
   arreglo[s]=S3;
   printf("\n\n Permuta %i en ciclo %i es:%s y Arreglo es %s",s,t,S3,arreglo[s]); 
} 
}
 

Pero al terminas  e  imprimirlos nuevamente de esta forma

for(j=0;j<=cant;j++){
   printf("\n\n Permuta %i es:%s",j, arreglo[j]);
}
 

solo arroja en las tantas iteraciones el ultimo arrays generado, y requiero guardar todos los resultados para generar otras permutaciones. Nota:

char *arreglo, S3, aux1;
 

Gracias

Si he entendido bien... lo que necesitas es guardar los resultados intermedios... cierto??

Si es así necesitarás crear tantos arrays como resultados intermedios quieras guardar ... lo suyo entonces es meter tu algoritmo en una función que admita dos arrays... uno que contiene los valores iniciales y otro para almacenar los resultados tras la permutación. Lo único que tienes que hacer entonces es ir pasando los arrays de forma ordenada para almacenar los resultados intermedios.

void permutacion( char* origen, char* destino );
 
// Lo de void main () lo pongo para escribir menos, al fin y al cabo es solo
// un ejemplo
void main( )
{
  char* inicio;
  char* permutacion1;
  char* permutacion2;
  char* permutacion3;
  char* final;
 
  // Inicializacion de los arrays
  // ...
 
  permutacion( inicio, permutacion1 );
  permutacion( permutacion1, permutacion2 );
  permutacion( permutacion2, permutacion3 );
  permutacion( permutacion3, final );
 
  // Liberación de recursos
  // ...
}

Con esta sentencia:

char *arreglo, S3, aux1;

El otro fragmento que pones no es valido, supongo en realidad la declaracion de las variables es:

char **arreglo, *S3, *aux1;

Para evitar confusiones mejor publica el código fuente completo.

Un saludo

Para ayudarte mejor creo que debes darnos más información sobre el contexto de tu trabajo. Pareciera que quisieras ordenar un arreglo de cadenas, .... ahora no le veo sentido a guardar los resultados de las permutaciones.

Ten en cuenta que el número de permutaciones puede ser mayor a la cantidad de elementos del arreglo, o sea que no sabrás de antemano cuántas cadenas intermedias debes guardas. Quizá se requiera dimensionamiento dinámico (aumento de la longitud del vector en tiempo de ejecución).

Por otra parte, si tratas de implementar un algoritmo de ordenamiento, ¿por qué la permutación de los elementos se realiza incondicionalmente, es decir, sin verificar ninguna condición de orden entre los elementos?

Debes aclararnos mejor sobre el trabajo que se quiere realizar ...

Holaaaa. Gracias!
Seré más claro... Supongamos que abc y wz son dos palabras o cadenas de eventos generados por dos componentes independientes de un Sistema (respectivamente). Según las condiciones del sistemas el ordenamiento no es cualquier ordenamiento... Al comenzar con la concatenacion abcwz yo espero esto.
abwcz
awbcz
wabcz
wabzc
wazbc
wzabc
guardando los resultados anteriores para reusarlos podría generar estos otros (pero los pierdo, y me imprime wzabc)
awbzc
awzbc
abwzc
Algo de memoria perdida... El código es este

#include <stdio.h>
#include <stdlib.h>
int l3,l1,l2,i,j,s,k,t;
 
int main(void){
printf("Programa que concatena dos segmentos\n\n");  
printf("Introduzca la longitud del primer segmento:"); 
scanf("%i",&l1);/*Se piden los datos*/
printf("Introduzca el primer segmento:");
char S1[l1];
scanf("%s", S1);
printf("\nIntroduzca la longitud del segundo segmento:"); 
scanf("%i", &l2);
char S2[l2];
printf("Introduzca  segundo segmento:");
scanf("%s",S2);
l3=l1+l2;  
int cant; 
cant=factorial(l3)/(factorial(l2)*factorial(l1));
printf("\n\n El numero de permutaciones es:%d",cant);
char S3[l3];
for(i=0; i<l1; i++){
  S3[i]=S1[i];
} 
j=0;
for(i=l1; i<l3; i++){
  S3[i]=S2[j];
   j++;
}
printf("\n\n El segmento es:%s",S3);
 
fflush(stdin); 
 
//dato = (char*)malloc(cant);
 
char aux1; /*Tamaño maximo de 100*/
char *arreglo[cant];  
//char* dato;    
s=0;
arreglo[0]=S3; 
printf("\n\n OjO es:%s",arreglo[s]);
for(i=l1; i<=l3-1; i++){ 
   t=0;
   for(j=i-1; j>=0; j--){
     s++;
     aux1=S3[j];
     S3[j]=S3[j+1];
     S3[j+1]=aux1;
     arreglo[s]=S3;
     printf("\n\n Permutacion %i en ciclo %i es:%s y Arreglo es %s",s,t,S3,arreglo[s]); 
//   t=0;
//   while(abs(i+1-j)>1){
//	aux1=S3[j+1];		
//      S3[j+1]=S3[i+1];
//      S3[i+1]=aux1;
//      s++; t++;
//	arreglo[s]=S3;
//	printf("\n\n Permutacion %i en ciclo %i es:%s y arreglo es %s",s,t,S3,arreglo[s]);
//   }      
   }        
} 
//printf("\n\n Permuta DOS es:%s",arreglo[2]);
for(j=0;j<=cant;j++){
   printf("\n\n Permuta %d es:%s",j,arreglo[j]);
}
 
return EXIT_SUCCESS;
}
 
 

Eso es irrelevante al problema.. puede estar afuera o adentro...  Te entiendo!  Es una función y por ende puede ser usado por otros programas. Porque? Para su mejor  aprovechamiento es recomendable que este afuera.

No se ponen funciones dentro de otras funciones.

PD:

for(i=0; i<=l1; i++){
 
  S3[i]=S1[i];
 
}
 
j=0;
 
for(i=l1; i<l3; i++){
 
  S3[i]=S2[j];
 
   j++;
 
}

Después de eso, en el caso de por ejemplo, l1=2 y l2=3, sobrarán 5 caracteres en l3.

es cierto lo que comenta ivancea96, estás generando una alta dependencia, aparte que el código se transforma poco a poco en un delirio; es uno de los puntos centrales del paradigma de la programación estructurada, separar código en funciones cortas y auto suficentes, que hagan una sola tarea, y que te permita abstraer el problema de "como lo hace" (se inicia el concepto de encapsulación).

en este momento no encuentro un buen link para orientarte sobre el concepto de la programación estructurada o modular, y formas de crear un función de manera correcta, pero con más o menos detalles en cualquier buen libro de lenguaje C se explica lo anteriormente dicho, igualmente ya te han indicado ese punto ivancea96 como leosansan.

Holaaa.... Nunca he dicho lo contrario Gh057, pero creo que era necesario fomentar este punto ( Porque no se debe colocar funciones dentro del programa principal?). Es distinto decir, no se debe a no se puede!

Efectivamente, se estaba contando de más. Si las longitudes L1 y L2 son 3 y 2 respectivamente. El contador i va de 0 a 2 (antes de 0 a 3) y el otro i de 3 a 4.

for(i=0; i<l1; i++){
     S3[i]=S1[i];
}
j=0;
for(i=l1; i<l3; i++){
    S3[i]=S2[j];
    j++;
 }
 

Ahora, no se a que te refieres ivancea96,  con que sobran 5 caracteres en L3 (longitud del string 5).

es por el segundo for, estás iniciando desde la longitud de l1... si tiene 3, recorrerías un par de posiciones solamente.

(agrego) otro tema que veo es que declaras los arreglos justo cuando los vas a llenar... eso en c++ está permitido, pero en ansi c, no es aconsejable. por lo cual deberías o bien pasar el código a c++ o bien (yo aunque sea en c++ lo prefiero así) declararlas al inicio...

básicamente es asignarles a los tres arreglos la memoria a ocupar dinámicamente en ejecución; luego agregarlos al tercero para efectuar la permutación, mediante alguna regla impuesta en tu algoritmo con una variable auxiliar local por ejemplo. (aunque según lo primero que posteas, esas permutaciones puedes lograrlas modificando el algoritmo de ordenamiento de burbuja, que utiliza dos variables en cada extremo, van intercambiando los valores mientras se aproximan).

resumiendo, el código puede quedarte funcional, pero te recomiendo que lo reescribas tanto para tomar buenos hábitos, como para solucionar más rápidamente los problemas que se te vayan presentando al generar código. saludos

 

Okey, perfecto ya te entiendo.  Tomare tu consejo en C e intentare modificar el algoritmo de Ordenamiento de Burbuja. Gracias... Saludos...

Me parecen suficientes razones.