1) Aumento infinito de 2 variables. 2) De más de 2.

[Tachikomaia]

Son 2 códigos distintos, aunque obviamente el 2ndo implicaría al 1ero, así que si sólo quieren hacer uno hagan ese.

En cuanto al significado, es que quiero un código que haga algo así:
(output)
V1=1, V2=1, V3=1
V1=1, V2=1, V3=2
V1=1, V2=2, V3=1
V1=1, V2=2, V3=2
V1=2, V2=1, V3=1
V1=2, V2=1, V3=2
V1=2, V2=2, V3=2
V1=1, V2=1, V3=3
Y siga

Es decir, hacer combinatoria implicando un número máximo, que aumenta cuando cada variable alcanza ese máximo.

Gracias.

[Usuario887]

Hola. Esto puedes lograrlo con clases o funciones recursivas (o redundantes, como les llamo yo)...

Un ejemplo en ASM:

Código (asm) [Seleccionar] Expandir

proc numericalIncrement
   
   push bp
   push si
   push di
   push bx
   ;addr at        bp+18
   ;cnt init at    bp+16
   ;cnt max at     bp+14
   ;min at         bp+12
   ;max at         bp+10  
   mov bp, sp
   ;addr starts at  bp-2
   sub sp, 2
   
   mov si, ss:[bp+18]
   mov bx, ss:[bp+16]
   
   mov ax, ss:[bp+14]
   cmp ax, bx
   jz numericalIncrement_err0
   jmp numericalIncrement_stepOver0
   numericalIncrement_err0:
   
   mov ax, 0
   jmp numericalIncrement_return
   
   numericalIncrement_stepOver0:
   
   mov ax, ss:[bp+10]
   cmp al, byte ptr ss:[si+bx]
   jnz numericalIncrement_skip0
   
   mov al, byte ptr ss:[bp+12]
   mov byte ptr ss:[si+bx], al
   
   mov ax, ss:[bp+18]
   push ax
   mov ax, ss:[bp+16]
   inc ax ;next ch  
   push ax
   mov ax, ss:[bp+14]
   push ax
   mov ax, ss:[bp+12]
   push ax
   mov ax, ss:[bp+10]
   push ax
   call numericalIncrement
   pop ax
   jmp numericalIncrement_return
   
   numericalIncrement_skip0:
   
   mov al, byte ptr ss:[si+bx]
   inc al
   mov byte ptr ss:[si+bx], al
   mov ax, 1
   
   numericalIncrement_return:
   mov ss:[bp+18], ax
   mov sp, bp
   pop bx
   pop di
   pop si
   pop bp
   
   ret 2*4
endp


la funcion toma como parametros la cadena de variables, el valor minimo de la combinatoria, el valor maximo de la misma, el contador inicial en la cadena y el contador final de la misma respectivamente. Tambien la tengo en C; te la muestro en ASM porque fue la forma mas eficiente para mi de escribir el algoritmo...

Saludos.


Ah, y retorna en la pila 1 si fue efectiva o 0 si hubo un error (numericalIncrement_err0). Mas que incremento numerico creo que seria mejor llamada incremento combinatorial, pero el punto es el punto.

Aqui un ejemplo utilizando Windows, con una cadena de 4 variables byte (char) inicializada como 'a','a','a','a'. el minimo es el codigo ASCII del caracter 'a' y el maximo el respectivo al caracter 'z'; el inicio del contador es 0 y el maximo del mismo es 3:

https://i.imgur.com/k8EIqjG.png
https://i.imgur.com/WYk2uax.png

[Tachikomaia]

Gracias pero no entiendo el code.

[Usuario887]

Dices; primero, aumento infinito de dos variables; luego, aumento de mas de dos. No son dos preguntas diferentes, es lo mismo; por tanto se aplica en este caso una funcion recursiva, es decir, que se llama a si misma, porque su "metodo" yace en si misma.

Supone una cadena de valores con un sistema numerico en base 3.
Supone una combinacion de tales cifras asi:

1,1,1

Aumento se define asi:

aumento (cadena_de_valores, valor_inicial, valor_final, contador_actual, contador_final)
{
si (cadena_de_valores[contador_actual] es menor o igual que valor_final) entonces
{
incrementar cadena_de_valores[contador_actual]
retornar contador_actual;
}
si no
{
aumento (cadena_de_valores, valor_inicial, valor_final, contador_actual+1, contador_final)
}
}

si ejecutas aumento con la cadena antes mencionada una vez (llamemosle a esas "veces" instantes), la cadena resultaria:

1,1,2

luego, entonces, de cada instante:

1,1,3
1,2,1
1,2,2
1,2,3
1,3,1
...

si ejecutas aumento con la cadena antes mencionada

Por cierto, la llamada a la funcion del pseudocodigo seria de esta forma:

...
cadena=1,2,3
...
aumento (cadena, 1, 3, 0, 2)