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
...

---

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

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

Hola,

He buscado y rebuscado la respuesta por Internet y lo unico que encuentro es si es malo hacer ejercicio de noche. Mi pregunta es: ¿cual es la relacion entre el mal sueño y el ejercicio fisico?
Cuando duermo "muy mal" (menos de seis horas, cosa que se esta convirtiendo en algo un poco usual en mi vida, lo cual ha de tomarse en cuenta para responder mi pregunta) evito seguir mi rutina de una hora y quince minutos y la reduzco a cuarenta y cinco minutos o incluso treinta si me mareo (o tal vez me auto-sugestiono). En definitiva, ¿es malo hacer ejercicio mas o menos "intenso" diariamente tomando en cuenta un mal sueño paulatino -quiero decir, digamos, tres veces a la semana? ¿sigo reduciendo el tiempo con la misma intensidad cuando considere que he dormido mal, da igual, o es incluso mejor? ¿contrarresta de alguna forma el ejercicio los perjuicios del mal sueño?

Saludos y muchas gracias de antemano por la respuesta.

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

Un ejemplo en ASM:

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

Pareces referirte a la directiva #include del preprocesador de C++... ¿a que te refieres exactamente con «agregar»?

Como los accesos a memoria pueden ser de 8, 16 y 32 bits, y una direccion limite es especifica, podria establecerse, para un programa:

direccion base de su unica pagina (usando este modelo descriptivo de paginacion): 0
direccion limite: 0a

Si, por ejemplo, un programa accede, de esta forma, al byte que se encuentra en la direccion de memoria 0b:

mov al, [0b]

El sistema operativo pude indentificar que es un acceso a memoria ilegal. Sin embargo, ¿y en este caso?:

mov eax, [08]

Se esta accediendo a la direccion 0b, sin embargo, la direccion que se esta especificando es 08. Se que Windows detecta este acceso a memoria ilegal porque lo acabo de intentar, sin embargo, ¿alguien sabe como lo hace? se que nadie es ingeniero de Microsoft pero me pregunto si existe una aplicacion general en sistemas operativos y asi...

Saludos y gracias de antemano por la respuesta.

Gracias por sus respuestas.

Like.


Incluso mas eficiente que los libros, es que programes. Aprendes mejor programando que aprendiendo. Por ejemplo, ¿sabrias hacer el sistema operativo de un cajero? si la respuesta es no ¿por que no lo intentas? lograrlo implicaria conocer estructuras de datos, listas enlazadas, entre otras cosas interesantes. Si lo logras, entonces plantea un sistema para guardar en el disco los datos de los usuarios del cajero (si lo haces multi-usuario), tal vez con algo de alineamiento o criptografia... depende de tu creatividad aunque, claro, no te apures.

Saludos.

Bien, pero supone que tales procesos no tienen el mismo nivel de privilegio, ¿que es exactamente lo que evita que se acceda a la memoria? ¿algun algoritmo especifico en la deduccion de la direccion?

Para ser exacto, ese mismo evento es el que intento deducir.


¿con elevando tus permisos te refieres a elevar el nivel de privilegio? porque yo hablo de dos procesos con el mismo nivel de privilegio (ring3).

Hola,
Segun entiendo, la memoria se divide en los segmentos que describe la GDT y en ellos los desplazamientos que se especifican en la PDE y respectivas PTEs pero si, por ejemplo, un proceso A tiene asignado el segmento 0001 en la GDT mapeado como datos/lectura-escritura, y un proceso B accede a la dirrecion 0001:0  con intencion de escribir, ¿que lo detiene, si el DPL del proceso B es el mismo cual del proceso A?, quiero decir, ¿como el sistema operativo detecta un acceso a memoria que no corresponde a su memoria, si es un acceso a memoria al fin y al cabo? ¿hace el sistema operativo pruebas en cada acceso a memoria?

Saludos.