Mensajes

En algún caso que no recuerdo me hubiera gustado haber tenido un reconocedor de diferencias entre 2 textos o códigos.

Pero tú no querías eso, ya habías identificado la diferencia, lo que preguntabas es la diferencia en las consecuencias...

Podrías agregar función, loop, iteración, y algo que es parecido a función.

Función tengo claro qué es, es como un subprograma al que se lo puede ejecutar repetidamente, la función es para eso, para definir algo una vez y luego usarlo repetidamente.
Lo que me confunde un poco es que hay funciones a las que se le pasan variables y otras no, o es que esas no son funciones.
Una vez alguien me preguntó qué diferencia hay entre una función y no recuerdo qué otra cosa.

Loops creo que son circulos, procesos que se repiten.
Iteraciones capaz que es como se tradujo, aunque parece más bien la cantidad de repeticiones.

La respuesta parece estar relacionada con lo que llaman "árboles de decisión".
https://es.wikipedia.org/wiki/%C3%81rbol_de_decisi%C3%B3n#Ejemplo
O algo similar.

Intento aplicarlo a una versión simplificada, en que el número sólo tiene 2 caracteres y pueden ser del 0 al 3.

El 1er número con el que se intenta acertar puede ser cualquiera (si el juego admitiese que contenga números repetidos entonces sí la eficiencia puede que varíe y por tanto este número importaría). Digamos 01.

A partir de ahí hay 4 posibles "ramas", según las 4 posibles pistas que se reciba:

Código [Seleccionar] Expandir


   /--> 0-0
  /--> 0-1
01
  \--> 0-2
   \--> 1-0
También existe la posibilidad de 2-0 pero en tal caso se entiende que se llegó al resultado así que no es necesario ver qué se hace después, pues si este método es aplicado por una persona la respuesta es nada, ya ganó.

Ahora a partir de cada posible pista ponemos otro número. Por ejemplo:

Código [Seleccionar] Expandir


   /--> 0-0 --> 02
  /--> 0-1 --> 02
01
  \--> 0-2 --> 02
   \--> 1-0 --> 02
Y el proceso se repite 1 vez más, porque según he visto en este caso simplificado hay un método que adivina el num en 3 "tiros".

Una vez hecho eso, se probaría dicho método para cada posible número y se contaría cuánto tardó en hallar los números, si es que los halló todos.

Luego, el método se variaría y se repetiría el paso anterior.

El programa terminaría cuando ya no sea posible variar el método, en cuyo caso diría cual fue el que halló los números en menos "tiros".

Esto daría el método que tiene el mejor promedio, es decir, si uds leen por ahí info de esto verán que se habla de métodos que no llegan a tardar X tiros, y otros que sí pero en promedio tardan menos. No sé realmente qué me sirve (en el modo difícil puede que el "mínimo máximo", porque si es posible saber que viene un caso de los que tardará podría cancelar el juego y de ese modo ganar más rápido (es un juego para ganar fichas), pero esto me parece poco probable (no creo que sea posible en general ganar tan rápido como para que convenga abandonar ciertas apuestas)), pero me parece que es eso, el mínimo promedio.


Bueno, el problema ahora es implementar eso.

El 1er número del método sería N1.
N1="01";
Nótese el problema de eso. No puedo poner 01. Tiene que ser "01". Pero si es texto es más difícil sustituir caracteres por otros (si fuese posible decir 01+1 y que quede 02, buenísimo, pero como es texto y no números hay que usar ifs y cosas...).
Otra opción sería poner 12 y que se interprete que el 0 representa al 1, el 1 al 2. etc. Y sí, voy a hacerlo así, porque es mucho más fácil aunque requiera una traducción humana (o más código al final).
Entonces N1=12

Luego vienen los otros números a los que no sé cómo llamarles porque debo referirme a ellos más adelante y no sé cual es la mejor forma. No se olvide que esto es una versión simplificada. Entiendo que no me esté explicando bien pero es que no sé, verán más adelante el problema.

Supongamos que les llamo así:

Código [Seleccionar] Expandir


   /--> 0-0 --> N2 -> (N3, N4, N5, N6)
  /--> 0-1 --> N7 -> (N8, N9, N10, N11)
N1
  \--> 0-2 --> N12 -> (N13, N14, N15, N16)
   \--> 1-0 --> N17 -> (N18, N19, N20, N21)


Entiéndase que lo que está entre paréntesis son los números de las 4 posibles ramas que salen de esos puntos, no me pidan que dibuje las ramas...

Y supongamos que todas esas variables son 13.

Probamos cuánto tarda en adivinar el número 34 (X). Lo principal es algo así:

Código [Seleccionar] Expandir

Si el 1er número de N1 es el 1er número de X
  Si el 2ndo número de N1 es el 2ndo número de X
     Acertó.
  sino
     Pista: 1-0
sino si el 1er número de N1 es el 2ndo número de X
  Si el 2ndo número de N1 es el 1er número de X
     Pista: 0-2
  sino
     Pista: 0-1
sino si el 2ndo número de N1 es el 1er número de X
  Pista: 0-1
sino
  Pista 0-0 Ahora dependiendo de qué pista sea chequearemos lo mismo pero cambiando N1 por el número que sea. Acá es donde viene lo difícil, hay que hacer referencia a ese número, yo no quiero hacer tantos ifs para eso. Además, como esto es una versión simplificada sólo hay que hacerlo 1 o 2 veces, pero en la versión normal serían digamos 7 tiros a decir y en la versión difícil unos 15. No tengo idea de cuántos, pero son bastantes.


Probablemente no se entienda lo que estoy diciendo pero bueno ¿alguna idea hasta ahí? ¿hay algo que me pueda simplificar la tarea? ¿quizá arrays? ¿nombrar las variables de otro modo?

----------------------------------------------------------------------------------------

Edit:
Olvidé unas cosas porque debía irme.

Hay basicamente 2 problemas.
1- Cuando se quiere ver cómo sigue el método, cual es la variable luego de la pista.
2- Cuando se quiere variar el método, qué variable se variará, y en caso de llegar al límite cual es la siguiente, etc.

Con los nombres que les puse, el 2 está solucionado. Porque, imaginen que en 7285, 7=V1, 2=V2, etc.
O sea, cada posición está marcada por una variable. El número se podría variar haciendo V5+1, cuando llegue a 9 pasa a 0 y se hace V4+1 y así sucesivamente. Bueno, el método es parecido, está hecho de unos números representados con variables, variamos desde la 21 hasta la 1.
Pero el 1 no sé cómo arreglarlo.

Otro modo de nombrar las variables sería algo así:

Código [Seleccionar] Expandir


   /--> N1 --> (N11, N12, N13, N14)
  /--> N2 --> (N21, N22, N23, N24)
N
etc.
Entonces si obtengo la pista 1, para ver cual número probar luego busco la variable cuyo nombre es igual a la anterior pero agregando 1.
Esto resuelve el problema 2 pero el 1 se complica. Aún así me parece suficientemente viable... Lo probaré.

Estom... lo más fácil es crear otra variable.
V = Num1
Num1 = Num2
Num2 = V

Quisiera probarlo por las dudas, pero si hay algo mal es cambiar algunas variables por otras o de orden.

Este post está dividido en 3 partes.
La 1era es esta aclaración, la 2nda es la clave y la 3era es info extra a quien requiera o le interese.
Además en café puse lo menos importante.

--------------------------------------------------------------------------------------------

El juego es así:
1- Se genera un número al azar de 3 cifras usando números enteros del 0 al 5, sin repetir. Yo no sé el número que se genera (a menos que haga trampa, pero no quiero).
2- Yo elijo un número de dichas condiciones (excepto el ser por azar).
3- El juego informa cuántos números bien colocados (considerando el número elegido por la computadora) puse, y cuántos números están mal colocados.
El paso 2 y 3 se repiten hasta digamos decir 6 códigos fallidos o hasta que yo acierte el número elegido por la compu.

Cuando digo hacer fuerza bruta me refiero a hacer un "programa" (lo digo entre comillas porque más de uno dice que yo no programo, que hago otra cosa) que encuentre las mejores respuestas o algo que luego un humano pueda usar para ganar rápido en el juego, digamos procesos a seguir. Y que además dicho "programa" sea lo más fácil posible de hacer sin importar lo poco eficiente que sea. Pero que además esté hecho en un lenguaje "normal", no en lenguaje máquina.

Bueno, yo hice algunas cosas así, pero esto la verdad me sobrepasa por el tema de las pistas creo (entiendo que es muy vago decirlo así, pero no lo entiendo más que eso), por ahora no sé hacerlo, por eso hago este tema para pedir ayuda.

Lo que hice hace años fue algo así:
Hay un objeto en el punto 0 del eje de las X.
El objetivo es que llegue al 10 en la menor cantidad de movimientos posibles teniendo estos 2:
1: Moverse +1 a la derecha (hacia el 10).
2: Moverse -1 a la izquierda.
Es obvio que conviene usar la acción 1 10 veces, pero mi idea era que el programa lo descubriera sin que yo le diera pistas como "te estás acercando", no me gusta hacer eso porque uno no siempre sabe cuando una acción es buena o mala, prefiero evaluar "desde el final". Mi programa realizaba una acción, si llegaba a una situación nueva generaba un archivo cuyo nombre la describía y el contenido marcaba cual fue la anterior y qué hizo en ella, y se generaba otro archivo que marcaba que esa situación aún no había sido analizada. Tras probar todas las acciones en una situación (reseteándola luego de cada una), se hacía lo mismo pero desde una de esas situaciones no analizadas. El resultado básicamente son archivos así:
1.txt que tiene X=0; Action=1
2.txt que tiene X=1; Action=1
3.txt que tiene X=2; Action=1
etc, hasta
10.txt que tiene X=9; Action=1
Y por supuesto los otros archivos de situaciones por acciones estúpidas como -1.txt por haberse movido hacia atrás.
Cuando el programa llegaba a colocar el objeto en el punto 10, decía la acción que realizó, cargaba la situación anterior, decía la acción que se realizó en ella, y así sucesivamente hasta llegar a la situación inicial.

Eso me parece que es aplicable a "todo":
Hacer un jaque mate, hallar la cura a una enfermedad o a un país mal gobernado, etc.
Si no se puede es porque hay variables desconocidas por ejemplo, pero quizá el mismo método con los ajustes necesarios las puede averiguar, al fin y al cabo es un método para averiguar cosas.
En un foro me plantearon un problema del que sin embargo no podía: Hacer la serie de fibonacci con alguna condición que no creo venga al caso. Quizá no pude porque no lo apliqué bien, pero tampoco creo que venga mucho al caso, aunque por decir algo...:
Si se genera una serie a comprobar si sirve o no, necesito la serie verdadera para hacer esa comprobación. Si no sé cómo es ("variable desonocida") no puedo hacer la comprobación, y si sé cómo es y la voy a usar para hacer comprobaciones entonces qué sentido tiene buscarla.
Es un caso distinto de lo que yo plantee, en que se puede saber qué se quiere pero no cómo conseguirlo, saber el final de una serie pero no la serie en sí que además es irrelevante (pueden ser cualquier números, simplemente dependen de las acciones/situaciones posibles). Sólo porque un número esté bien ya tengo "la serie" (los movimientos para llegar a dicho número), pero en el caso de la serie de fibonacci es necesario que estén bien todos sus números y si no tengo la serie (o no la genero a propósito) no puedo. En fin, no tengo mucha idea de eso (quizá hay una ecuación matemática para saber si un número está en la serie, aunque no se tenga la serie, pero ni idea tampoco, no sé hallar condiciones o efectos aún, sólo hallé series de números basados en el último principalmente).

Y aquí estoy de nuevo con un problema que ese método supuestamente "todo terreno" no sé cómo puede solucionar esto, y si es que no puede, por qué no.

¿Cual sería el método más parecido al mío, que solucionaría el problema?

¿Cómo deben ser los archivos?
Se me ocurre por ejemplo esto:
012,00_345,03_453,03_534.txt
El nombre contiene las acciones realizadas y las pistas recibidas (el contenido en sí del archivo no se me ocurre). ¿pero cómo se generaría eso?

¿Cual es la situación inicial, debo mencionar el número que yo en teoría no conozco? El resultado sería este:
Para el 012 conviene usar 012
Para el 013 conviene usar 013
Inútil.

Necesito que se generen los procesos y contar la cantidad de pasos que requieren en cada caso, o al menos la máxima cantidad de pasos que requiere en un caso.

¿Esos procesos no se pueden describir mediante una línea?

Pero a ver, por ejemplo me serviría que exista un archivo
012,01_304,01_135,02_253,01_541.txt
y otro:
012,01_304,02etc.txt
Suponiendo que iniciar con 012 y luego 304 (si la pista es 01) fuese uno de los procesos que mejor funciona en general. O sea, no necesito que un proceso con todas sus variaciones esté en 1 línea, pueden ser muchas líneas/archivos indicando las diferentes variaciones según las pistas.

Luego de algún modo buscaría los archivos más cortos, de hecho podría ponerles LX al inicio y sustituir X por la cantidad de números que tienen luego.
Entonces si jugando al juego pongo 012 y obtengo 11 busco el proceso 012,11, veo qué dice después, y así sucesivamente.


Algo que se me ocurrió es generar un proceso, que puede ser 012,013,014etc, y contar en todos los casos cuánto tardaría en averiguarlos. Es decir, ignora las pistas. ¿Será esa la respuesta? No creo, sin pistas cualquier proceso puede tardar mucho.

¿Pistas en los nombres de archivos y acciones dentro? No sabría bien cómo contar qué tarda más. Podría eliminar los archivos más largos y ver cual proceso se repite más ¿?
Creo que esto no serviría, iguales pistas pueden obtenerse por distintas situaciones, los archivos serían sustituidos por otros.

Af. dado un número N el proceso P1 tarda 1 paso.
No, tampoco, porque cuando digo proceso me refiero a una línea y si me basara sólo en los que tardan menos obtendría los que por suerte aciertan de una.

En fin, como ven le doy vueltas pero no me sale.

--------------------------------------------------------------------------------------------

MasterMind:
https://es.wikipedia.org/wiki/Mastermind
Más info aquí:
https://en.wikipedia.org/wiki/Mastermind_(board_game)#Algorithms

Ejemplo del juego que dije:
1- Se genera el número 210
2.1- Digo 012
3.1- Me dice 1-2, lo cual significa que hay 1 número bien colocado (el 1, pero yo eso en realidad no puedo saberlo en este punto porque en el caso real no sé el número generado) y 2 mal colocados.
2.2- Debido a que en este caso habría tenido bastante suerte porque acerté cuales números son los presentes, sólo me queda averiguar el orden correcto. Sé que el número es alguno de estos 3: 021, 210 o 102. A partir de ahora es cuestión de probar esos 3, no sé si hay un orden de pruebas mejor que otro.

Búsqueda de modos de ganar antes de hacer este tema:
Quería tener un diagrama de flujo o algo similar:

Dado que habría muchas flechas en cada caso, pensé en hacer algo así:
012__0-0__345__0-3__453__0-3__534
_______________1-2__354__0-3__435__0-3__543
_____0-1

Por otro lado, pensando una explicación para un ejemplo en que me equivoqué, se me ocurrió un método que no me interesa usar en programación pero es interesante:
En cada columna de la siguiente "tabla" están los posibles números de cada cifra:
000
111
222
333
444
555
La mayoría de las posibles pistas nos permiten tachar algunos números.

El ejemplo siempre será 012.

0-1 o 0-2:
_00
1_1
22_
333
444
555

0-3:
_00
1_1
22_
___
___
___

1-0 o 2-0:
0__
_1_
__2
333
444
555

0-0:
___
___
___
333
444
555

1-2:
000
111
222
___
___
___

1-1:
Creo que esta no.

Tu dí lo que quieras, pero no puedes poner un "etc..." como dando a entender que continúa sin fin. Hay que ser discreto, porque el tamaño de la memoria es discreto lo mismo que el tamaño en los discos.

Vale, pero en estos casos nunca tuve necesidad de poner un límite.

Digamos que el límite es largo 30.

No sé si te tomaste la molestia de leer el hilo al que te derivé...

No le vi suficiente relación y me pareció muy largo.

aparte que tras esto, será conveniente que reescribas el resto, porque sigue sin entenderse adónde quieres llegar.

¿No entiendes el por qué planteo los retos o no entiendes alguno de ellos? Si por el final, te acabo de decir uno como pediste: Largo 30.

Esta función calcula el número de permutaciones para el caso específico que se invoque.
La llama la función bajo esta...

Código [Seleccionar] Expandir

entero = funcion NumPermutaciones(byte SizeAlfabeto, byte Largo)
   entero j, k

   j = 1
   bucle para k desde 1 hasta Largo
       j = (j * Sizealfabeto)
   siguiente en bucle

   devolver j
fin funcion

¿k es Largo? ¿el cálculo no es alfabeto^Largo? Por ejemplo si alfabeto fuese 4 y lago 3:
111
112
113
114
121
122
123
124
131
132
133
134
141
142
143
144
Y eso (16) se multiplica por 4.
Es lo mismo que 4*4*4, o 4^3. Pareces calcularlo de otro modo, no entiendo.

Bueno otro día continuaré intentando entender pero la verdad me cuesta mucho entender las funciones, estoy acostumbrado a flujos.

Ahora generamos las permutaciones para dicho alfabeto:

Código [Seleccionar] Expandir

funcion Permutar(String Alfabeto, byte LargoPalabra)
   entero i, j, k
   string palabra
   entero SizeAlfabeto = Alfabeto.Length  // vamos, la cantidad de caracteres del string,

   i= NumPermutaciones(sizealfabeto, LargoPalabra)

   bucle para k desde 0 hasta i-1
       palabra = PermutacionKaesima(Alfabeto, LargoPalabra, k)
       imprimir palabra
   siguiente en bucle
fin funcion Calculas el nro de permutaciones.
Comienzas un bucle.
Llamas a una función que aún no has definido (o sea no entiendo cómo uds leen esto, van más adelante en el texto, y luego vuelven, y luego se saltean lo antes leído que está después).
Creo que entendí lo que puede entenderse, lo que no no está explicado/definido aún.

Ahora obtenemos la permutación enésima ordenada, aplicando el alfabeto de entrada.

¿Qué es eso de "enésima ordenada"? ¿es lo que antes llamaste Kaesima? Pero no entiendo lo de ordenada. Es la última del Largo ¿no?

Esta función puede en realidad ponerse como un bucle interno en el lugar desde donde se la llama. Sería más eficiente, pero lo dejo así por claridad...

Para mí creo que sería más claro si estaba definida antes xD

j = (permutacion modulo Sizealfa)   //modulo es el resto de una división. Algo que tú horrorosamente llamas
                                                          // 'resetearse' y te cito: ("Si le aumentamos 1 a 9, queda en 0, eso es resetearse."

Bien por aclararme lo de modulo ¿"permutacion" es algo nuevo, definido como k también?

En cuanto a lo que me citas, recordaba haberlo escrito pero no el contexto, eso de 0 no me sonaba, olvidé que había hecho eso, está en otro tema, me autocito:

Código [Seleccionar] Expandir

actions for fotograma 4
      // El char no es aumentable, ergo Se resetea.
      set ("Char"+Cursor, 0);
      if (0<Cursor) {
         // Si Cursor puede bajar, baja.
         Cursor = Cursor-1;
      } else {
         // Sino (el cursor no puede bajar), se agrega un char.
         set ("Char"+Chars, 0);
         Chars = Chars+1;
         Concatenarytrace();
         gotoAndPlay (2);
      }
"Si le aumentamos 1 a 9, queda en 0, eso es resetearse." (...)

Yo ahí no estoy calculando el resto de una división (tampoco en la función que se llama), quizá te has confundido. Y resetearse significa volver al valor común, inicial, no sé qué tiene de malo esa expresión.

Código [Seleccionar] Expandir


string = Funcion PermutacionKaesima(string Alfabeto, byte LargoP, entero Permutacion)
   entero  k    
   entero SizeAlfa = Alfabeto.Length  // vamos, la cantidad de caracteres del string,
   string Permuta = espacios(LargoP)  // esto es creamos una cadena de texto del largo del alfabeto.
   byte j
   char c

   Bucle para k desde 0 hata LargoP-1
      j = (permutacion modulo Sizealfa)   //modulo es el resto de una división. Algo que tú horrorosamente llamas
                                                          // 'resetearse' y te cito: ("Si le aumentamos 1 a 9, queda en 0, eso es resetearse."
      c = alfabeto.Getchar(j)  // Esto es, obtener el carácter en la posición 'j' del alfabeto que se quiere usar.
                                        // Alfabeto: en tu caso, creo que sería = "123456", o quizás "654321", o quizás "012345", o los caracteres que se te antojen...
      permuta.SetChar( c, k)  // esto es, colocar el carácter 'c' en la posición 'k' del string permuta... Cada lenguaje tiene su propia función para el caso....
                                       // también puede usarse un array de chars, y al devolverlo convertirlo en string... etc, etc...
                                       // Igualmente el alfabeto puede ser un array de chars, se gana en velocidad usando arrays...
      permutacion = (permutacion \ sizealfa)  // es una división entera, si el lenguaje usado no tiene un operador, habrá que usar división y luego una función que elimine los decimales.
   Siguiente en bucle
   
   devolver Permuta
Fin funcion
En el bucle obtienes el resto de dividir permutación ¿k? entre Sizealfa, o viceversa, no sé cómo se interpreta.
Obtienes un caracter usando eso. No entiendo cómo haces ¿qué es permutación? ¿cómo es que el resto de una división está relacionada siempre con el caracter que necesitas?
Colocas el caracter en la cadena permuta.
Haces una división que elimina los decimales del resultado.

Lo reeleré otro día pero ya te digo que no entendí. Considerando que esto funciona a partir de otra cosa (si mal no recuerdo), a lo mejor es por eso. Sigo.

Código [Seleccionar] Expandir

   bucle para k desde 1 hasta  LargoPalabrasAGenerar
       imprimir "Permutaciones para un largo de " + k + " símbolos/caracteres de largo, con el alfabeto: " + Alfabeto   //simbolos=caracteres
       SubAlfa = Alfabeto.Substring(0, k)  // Esto es, toma los 'k' caracteres de la izquierda del string 'Alfabeto'...
       Permutar(subAlfa, k)
   siguiente en bucle No entiendo lo de
"SubAlfa = Alfabeto.Substring(0, k)  // Esto es, toma los 'k' caracteres de la izquierda del string 'Alfabeto'..."
Por ejemplo la 1er vuelta (creo que le llaman iteración) ¿toma 1 caracter de la izquierda? 6 izquierda-derecha ¿no? Por las dudas. ...ya entendí, pero en tu impresión has definido los caracteres al revés, por eso no entendía.

Bueno, otro día releo qué hace la función Permuta.

El pecado de esto, es que como cuento al hilo al que te derivé, es el algoritmo más sencillo de implementar para mostrar todas las permutaciones posibles dados un alfabeto específico, y de una 'palabra' de salida de largo específico... pero no es el algoritmo más óptimo cara a la velocidad. Pero si no lo entiendes allí, tendrás que apañarte con esto...

No te preocupes, soy ateo, jajaja. Hablando en serio, si este el más sencillo me resulta tan complicado, el otro prefiero ni verlo, sigamos con este.

Otro pecado, es en realidad te basta ejecutar el ´último ciclo, el de 6, pués todos los anteriores se entienden subsumidos en el siguyiente. Esto es... 'todas la permutaciones de 4 elementos', existen en 'todas las permutaciones de 5 elementos', y todas las permutaciones de 5 elementos', existen en 'todas las permutaciones de 6 elementos'.

Entiendo, bastaría con mantener guardadas las permutaciones hechas y para generar un largo mayor simplemente agregarle por separado los diferentes caracteres. Pero creo que es más complicado de programar.

Y es fácil entenderlo, pués el número 1, 2, 3 , 4 ,5 ,6  son lo mismo que 00º1, 002, 003, 004, 004, 006 si la cuenta la llevas hasta el 999... pero allá tú...

Esto no lo entendí.


Lo que más me gustó (de lo que entendí) es calcular el total de permutaciones. Yo en este caso no lo necesito, porque cuando el 1er caracter es 6 y debe aumentar entonces ya se sabe que se hizo todas. Pero cuando las quiero en un orden raro, como en el Reto 2, lo que hago es grabar cómo será la última, y "predecirla" da ciertos problemas (ya estoy medio oxidado, pero creo que el principal problema que tengo es precisamente ese de "predecir"). Pero si sé cuántas permutaciones son y las voy contando, no tengo que predecir.
El pecado de eso, como tú dirías, es que se tiene una variable cambiando a cada rato, y que puede ser alto... pero yo tengo una variable más larga, de texto, dudo mucho que sea mejor.
Me va a servir tu idea, creo. La voy a probar.

Lo demás me da curiosidad de cómo lo haces, aunque bueno, ahora me voy a descansar un rato, estas cosas me cuestan.

¿Los fundamentos se aplican a todas las formas de programar o cada diferente lenguaje o forma tiene sus propios fundamentos? ¿han demostrado digamos científicamente que contradecir alguno de esos fundamentos es un error?

Yo nunca he programado algo impresionante o realmente útil, y mis códigos creo que la gente no los entiende y yo más o menos, pero nunca estudié los fundamentos y aún así programo. Es más, si hubiera que memorizar mucho para programar, probablemente no programaría. ODIO memorizar, si algo no queda en mi mente es porque no me interesa y si no me interesa para qué lo quiero. A ver, si quiero denunciar a un vecino porque su perro no me deja caminar tranquilo, y no recuerdo el número de su casa, vale, digamos que soy tonto, pero ese tipo de cosas las anoto en un papel, y sí me acuerdo de en cual.

Si lo necesitas para aprobar un examen, muchos lo que suelen hacer (aunque no sé si en programación sirve) es memorizar sólo un par de letras iniciales o sólo algunas palabras clave de cada punto o lo que sea. Teniendo eso, el resto lo recuerdas (aunque es posible olvidarlo) o armas (en caso de tener las palabras) en el momento.

A ver cuan útiles son esos fundamentos.
http://www.areatecnologia.com/TUTORIALES/FUNDAMENTOS%20DE%20PROGRAMACION.htm
¿Es lo que está en negrita o qué? Que aprendan los "fundamentos de la redacción" antes de escribir semejante caos.

https://www.fdi.ucm.es/profesor/luis/fp/fp.pdf
¿Desde la página 16? Pero no entiendo ¿existe algo como "fundamentos de la física", "fundamentos de la matemática"? (*) Se supone que un fundamento es como una regla que se cumpla, el libro más bien parece decir información sobre cómo funcionan las computadoras y algunos significados. Yo esperaba reglas numeradas, de hecho no me queda claro ni cual sería la 1era. El libro comienza con esto:
"Informática (Ciencia de la computación)
Conjunto   de   conocimientos   científicos   y   técnicas   
que   hacen   posible   el   tratamiento   automático   
de   la   información   por   medio   de   ordenadores"

Está muy bonito pero no sé si es un fundamento o no. ¿Qué relación hay entre la informática y los fundamentos de la programación? ¿qué fue 1ero, la programación, o sus fundamentos, o la informática? ¿la programación es parte de la informática o la informática es el resultado de programación?

(*): Vaya, veo que sí hay fundamentos de la matemática, pero que yo sepa nunca los estudié y aún así sé bastante de matemática.

"Fundamento: Principio u origen en que se asienta una cosa."
Bueno, entonces a los libritos agreguen cómo están compuestos los ordenadores, qué son los átomos, qué es el espacio... así hasta la metafísica, pero bueno, uno puede saber correr aunque no tenga idea de cómo le funcionan las piernas, lo mismo con programar.

Nunca entendí cómo se lee for. A ver:

Código [Seleccionar] Expandir

       for(i=1;i<=6;i++)
        {
            System.out.println(i);
        }
"Para/por i que es 1, mientras sea menor que 6: Sumarle 1 y mostrar i en pantalla."
¿Es como esto?

Código [Seleccionar] Expandir

i = 1
si i<=6
   mostrar i en pantalla
   i++
repetir Eso muestra los números del 1 al 6, bien.

Luego dices:

Código [Seleccionar] Expandir

        for(i=1;i<=6;i++)
        {
            for(j=1;j<=6;j++)
            {
                System.out.println(i+" "+j);
            }
        }
Bien creo, eso muestra todos los números del 1 1 al 6 6.

Está bien, pero la idea era que muestre números hasta que el usuario lo detenga (dije "etc", pensé que se entendería), o sea, luego de 6 6 debe venir 1 1 1, luego 1 1 2, y así sucesivamente hasta que llega al 6 6 6 y luego pasa a 1 1 1 1 y así sucesivamente. Supongo que se entiende.

Yo lo haría así:
La parte1 es 1.
La combinación tiene 1 parte (partes=1).
El cursor está en la última parte, o sea 1 (cursor=partes).
Si la parte indicada por el cursor es < 6,
   aumentarla 1, concatenar las partes, mostrar eso en pantalla, y volver a "El cursor...".
Sino
   La parte indicada por el cursor es 1
   Si el cursor es mayor que 1,
      bajarlo 1 y volver "Si la parte...".
   sino
      La parte nro (cursor) es 1.
      Crear otra parte (partes+1), que sea 1.
      partes++
      Concatenar las partes y mostrar eso en pantalla
      Ir a "El cursor está..."

La concatenación la haría con un do while.

Código [Seleccionar] Expandir

En otras palabras:
Etapa 1:
La parte1 es 1.
La combinación tiene 1 parte (partes=1).
Etapa 2:
Poner el cursor en la última parte (partes)
Etapa 3:
Si la parte indicada por el cursor es aumentable,
   aumentarla, concatenar las partes, mostrar eso en pantalla, y volver a la etapa 2.
Etapa 4:
La parte indicada por el cursor es 1
Si el cursor puede bajar,
   bajarlo 1 y volver a la etapa 3
Etapa 5:
   Resetear la parte que indica el cursor.
   Crear parte (partes+1), que sea 1.
   Partes++
   Concatenar las partes y mostrar eso en pantalla
   Ir a etapa 2

Estaría bueno hacer una tabla o un gif o algo que vaya mostrando cómo se va ejecutando el código, porque por más que lo escriba de 3 formas distintas (aunque sin mucho esfuerzo), me cuesta entenderlo. De hecho no estoy seguro de que funcione (como comenté estoy con otra cosa, no tengo ganas de andar probando esto).

Reto 1:
Genera una lista así:
1
2
3
4
5
6
1 1
1 2
1 3
1 4
1 5
1 6
2 1
etc
Es como contar pero sólo se usan los números del 1 al 6 y además van separados.


Reto 2:
Genera una lista así:
1
2
3 4
3
3 5
6 7 8
4
3 6
6 7 9
10 11 12 13
etc
La 1era combinación está compuesta de 1 número.
Luego hay otra de 1 número y otra de 2.
Luego otra de 1, de 2, y de 3.
Luego 1, 2, 3, 4.
etc.
En cuanto qué números van en cada una, depende de si el largo de la combinación ya existía o no. Si existía, simplemente se le suma 1 al número final. Si no existía, el 1er número será el mayor que se haya alcanzado hasta ahora, +1.


Reto 3:
Genera una lista así:
1
2
3 4
3
3 5
6 1 2
4
3 6
6 1 3
4 5 6 1
etc
Es como la anterior pero los números van del 1 al 6. Cuando alguno se pasa de 6 vuelve a 1. El considerado máximo número es el último de la combinación que tenga más largo (y se modifica también cuando se está creando una combinación más larga, claro).


Reto 4:
Genera una lista como la anterior pero en la que luego de hacer una combinacion con el método "clásico" (como la lista anterior) se pregunte al usuario si quiere una de un largo aún no alcanzado (método "creativo"). Ej:
1
¿Creativo? Sí. 2 3
2
¿Creativo? No.
2 4
¿Creativo? No.
3
¿Creativo? Sí. 5 6 1.
2 5
etc
El máximo largo del proceso clásico no aumenta porque se creen mayores largos con el proceso creativo, pero si están creados el proceso clásico usa sus números en vez de crearlos.


Reto 5:
Genera una lista como la anterior pero en la cual el máximo de números sea 100 y en los momentos de crear una combinación de nuevo largo no se use el máximo+1 sino... no sé explicarlo pero básicamente el más alejado considerando todos los usados y considerando que forman un circulo (1 está luego de 100, el más alejado de 1 es 50 aproximadamente). Ejemplo aproximado:
1
¿Creativo? Sí. 50 51
2
¿Creativo? Sí. 25 26
25 27
¿Creativo? Sí. 75 76 77
etc
O sea, inicialmente se usa 1 como siempre. Luego lo que esté en medio de 2 y 100, que aproximadamente es 50. Luego 2, clásico. Luego, si se pide creativo o cuando haya que crear, se usa de 3 a 49, o sino de 52 a 100, lo que tenga más cantidad de números. Así sucesivamente. La cantidad de "fragmentos" va aumentando, o sea, 1ero tenemos de 2 a 100. Luego aproximadamente de 2 a 49 y de 51 a 100. Luego de un par de veces tendremos aproximadamente de 1 a 24, de 26 a 49, de 51 a 74, y de 76 a 100.


Yo estoy haciendo algo un poquitito más complicado que el 4. Tengo otro tema creado al respecto, en esta misma sección. Ver cómo harían estas cosas uds me ayudaría. Gracias.

Yo sólo confío en algo cuando me parece que está equivocado y tras un tiempo de analizarlo veo que el equivocado soy yo. Me pasa mucho con mis programas, tienen errores, los voy corrigiendo, y en eso de repente hay veces que me parece están fallando y me doy cuenta que no.

Pero bueno, generalmente hay que desconfiar, puede haber un error que aún no detectamos.