¿Creacion de ciclos dinamicos?

Primero, que tal a todos espero estén bien; me han dejado una tarea donde me surgió una duda algo extraña que no sé si se pueda realizar algo así, lo que pasa que me dejaron un ejercicio donde en un momento de lapsus brutus, pensé:

¿Se podrán crear ciclos anidados dinámicamente?, es decir, si yo tengo un arreglo de tamaño n, para visitar cada una de sus posiciones necesito un ciclo, ¿cierto?; bueno pero que tal si necesito tambien m ciclos anidados para hacer alguna operacion con ese arreglo (no importa qué operacion); la duda es esa, ¿Cómo hago para tomar m ciclos anidados según se vayan necesitando? digo espero haberme explicado, sino, pues diganme y me motivo a ponerles un ejemplo detallado...

Sin más que decir, de antemano gracias.

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Pues de principio sí, tienes

Pues de principio sí, tienes que poner una condición en la cual se repetirá la acción y controlar el incremento tu mismo.

Pero sí, creo que sería mejor tener un ejemplo porque lo que yo me estoy imaginando es un while donde el código se repite varias veces hasta que la condición de parar sea true

Imagen de isorxp

Ejemplo del tema

hola OscarRyz, gracias por responder, mira a continuación pongo un ejemplo (no código) para explicarme mejor:

| 1 | 2 | 3 | 4 | 5 | 6 | <--Esto representa un array de enteros

¿Cuales combinaciones sin repetirse puedes obtener? PERO formando grupos de 3 numeros... hice esto en una calculadora de internet y los conjuntos son:

{1,2,3} {1,2,4} {1,2,5} {1,2,6} {1,3,4}
{1,3,5} {1,3,6} {1,4,5} {1,4,6} {1,5,6}
{2,3,4} {2,3,5} {2,3,6} {2,4,5} {2,4,6}
{2,5,6} {3,4,5} {3,4,6} {3,5,6} {4,5,6}

Para el ejemplo anterior, si hacemos un programa que genere esos conjuntos, tendriamos que utilizar 3 ciclos anidados for o while (rudimentariamente haciendolo) un ciclo por cada indice, osea uno para i, otro para j y otro para k... son 3 indices porque hay que formar grupos de 3 numeros.

Pero ¿qué pasa? si dicho programita es interactivo y en vez de ser 6 numeros ahora son 10 y formando grupos de 4 numeros?? O.O osea ya no nos servirian los 3 ciclos anidados, obvio ya tienen que ser mas para poder generar los conjuntos como los siguientes:

{1,2,3,4} {1,2,3,5} {1,2,3,6} {1,2,3,7} {1,2,3,8} {1,2,3,9} {1,2,3,10} {1,2,4,5} {1,2,4,6} {1,2,4,7}
{1,2,4,8} {1,2,4,9} {1,2,4,10} {1,2,5,6} {1,2,5,7} {1,2,5,8} {1,2,5,9} {1,2,5,10} {1,2,6,7} {1,2,6,8}
{1,2,6,9} {1,2,6,10} {1,2,7,8} {1,2,7,9} {1,2,7,10} {1,2,8,9} {1,2,8,10} {1,2,9,10} {1,3,4,5}
{1,3,4,6} {1,3,4,7} {1,3,4,8} {1,3,4,9} {1,3,4,10} {1,3,5,6} {1,3,5,7} {1,3,5,8} {1,3,5,9} {1,3,5,10}

Bueno, no les puse todos los conjuntos porque salen muchos... siendo todo lo anterior en tiempo de ejecucion.

La verdad ahora si espero haberme explicado mejor sino pues igual trato de buscar un mejor ejemplo... ok es todo.

Recursion

La recursion es la respuesta,pero lo que muestras es un algoritmo de permutaciones.

Y sobre mas sobre recursivadad hay un post aqui mismo Recursividad

Aqui dejo un algoritmo parecido al que quieres.

public class Recursion {
        public static void inter(int [] arr,int i,int j){//solo es un intercambio de valores
                int t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;      
                }
               
        public static void perm(int [] arr,int n,int lim){//funcion que hace las permutaciones n es la profundidad inicial,lim el limite de numero a tomar
               
                if(n<lim){                     
                        for(int i=n;i<arr.length;i++){
                                inter(arr,n,i);
                                perm(arr,n+1,lim);
                                inter(arr,n,i);                        
                                }              
                        }
                else{
                        for(int i=0;i<lim;i++)
                                System.out.print(arr[i]+" ");  
                        System.out.println("");
                }              
        }              

        public static void main(String [] args){                       
                perm(new int[]{1,2,3,4,5,6},0,3);      
        }
}

Imagen de ezamudio

Programación funcional

http://www.javamexico.org/foros/java_standard_edition/%C2%BFcreacion_de_...

En programación funcional no sólo es posible sino sencillo y natural hacer lo que dices. Es común que los iteradores de colecciones en programación funcional reciban como parámetro una función, la cual ejecutan con cada elemento de la colección; si la función que pasas contiene un ciclo entonces ya tienes ciclos anidados.

El ejemplo que pones de hecho es un problema común al trabajar con colecciones de elementos, tanto así que por ejemplo Scala ya contiene un método combinations y un permutations para hacer precisamente lo que ilustras. 1 to 6 combinations 3 toList te devuelve esto:

List(Vector(1, 2, 3), Vector(1, 2, 4), Vector(1, 2, 5), Vector(1, 2, 6), Vector(1, 3, 4),
     Vector(1, 3, 5), Vector(1, 3, 6), Vector(1, 4, 5), Vector(1, 4, 6), Vector(1, 5, 6),
     Vector(2, 3, 4), Vector(2, 3, 5), Vector(2, 3, 6), Vector(2, 4, 5), Vector(2, 4, 6),
     Vector(2, 5, 6), Vector(3, 4, 5), Vector(3, 4, 6), Vector(3, 5, 6), Vector(4, 5, 6))

Y 1 to 10 combinations 4 toList nos da la otra lista que mencionas. Pero bueno, si fueran problemas que no te resuelven ya las colecciones, tienes varias maneras de resolverlos, gracias a los métodos de las colecciones que iteran sobre sus elementos ejecutando distintas funciones:

foreach
Espera una función con un parámetro; le pasan cada elemento y se ignora el resultado.
map
Espera una función con un parámetro y que devuelva algo; le pasan cada elemento y con los resultados se genera una nueva colección.
filter
Espera una función con un parámetro y que devuelva un boolean; se genera una nueva colección que sólo contiene los elementos para los que la función devolvió true.
foldLeft
Espera una función que recibe dos parámetros y devuelva un valor. Uno de los parámetros debe ser del mismo tipo que los elementos de la colección y el otro parámetro debe ser del mismo tipo del retorno. foldLeft también espera un valor inicial, del mismo tipo que el retorno de la función. Por cada elemento, se invoca la función con el elemento actual y el valor devuelto por la invocación anterior (o el valor inicializador en la primera invocación).

Y hay un montón más de cosas que puedes hacer con las colecciones: reduceLeft, reduceRight, foldRight, mapRight, minBy, maxBy, groupBy, etc. No me clavo mucho en el ejemplo de las combinaciones porque creo que la pregunta original era cómo ejecutar un número variable de ciclos según se necesiten. Mi respuesta es que con programación funcional sí se puede y no es complicado. Con Java 8 también será realizable gracias a las expresiones lambda, aunque no tan sencillo como lo es hoy en Scala o Groovy.

Imagen de isorxp

Hola BT

Que tal, gracias por tomarse un momento para responderme. Me ha servido mucho tu informacion, es excelente y muy buen ejemplo el del algoritmo recursivo.

Saludos, que estés bien.

Imagen de isorxp

Hola ezamudio

Primero gracias por responder... No tenía ni la más mínima idea de existe la programación "funcional", me he documentado y la encuentro muy interesante, excelente dato ezamudio. Creo que acertaste al 100% a la disipación de mi duda y hasta tú mismo lo mencionaste: "No me clavo mucho en el ejemplo de las combinaciones porque creo que la pregunta original era cómo ejecutar un número variable de ciclos según se necesiten.".

Bueno una vez más le sigo agradeciendo a esta gran comunidad.

Les deseo lo mejor y hasta luego. Saludos.