Mensajes

Bien, pero este tipo de 'predicciones' se ciñen exclusivamente al cálculo matemático... a la estadística... al presente inmediato. A esto primero lo llamo especulación.

Es decir, no tiene nada que ver, con (por ejemplo) soñar días-semanas antes que un familiar va a tener un accidente con bastantes detalles de los mismos. Que es una predicción totalmente distinta. A esto segundo lo llamo predicción.

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.

Luego procede... esto es, es obligado señalar un punto final. Un límite razonablemente práctico. Luego...  al implementarlo cada uno puede modificarlo a su antojo y necesidades, haciendo los cambios que procedan derivados de las circunstancias.

No sé si te tomaste la molestia de leer el hilo al que te derivé... pero bueno, tu problema 1 te lo resumo, fácilmente en 3-4 funciones... Si resulta que fueras incapaz de entender y aplicar esto, no vale lapena seguir dando más explicaciones, aparte que tras esto, será conveniente que reescribas el resto, porque sigue sin entenderse adónde quieres llegar.


- SizeAlfabeto: Cantidad de caracteres distintos que entran en juego, en tu caso 1-6, luego =6
- Largo: Cómode largo han de ser las permutaciones, si 1, solo genera 1,2,3,4,5,6, si 2, genera desde 11 hasta 66, si 8 genera desde 11111111 hasta 66666666
- Evidentemente si pones valores grandes podría desbordar, así que usa el tipo de datos adecuado...
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

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

Ahora obtenemos la permutación enésima ordenada, aplicando el alfabeto de entrada.
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...

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


El código para usar las funciones, vendría a ser:

Código [Seleccionar] Expandir


Funcion Main
   string Alfabeto = "654321"
   byte SizeAlFa = Alfabeto.Size // .Length, etc...
   byte LargoPalabrasAGenerar = 6   // esto es por ejemplo: "555436"  = 6 caracteres.

   entero k  
   string SubAlfa =""
   // como no quieres generar una sola lista sino  diferentes listas cada una con su largo, este  bucle es preciso, si no sería suficiente la última iteración...
   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  
   
   imprimeir "Fin de todas las permutaciones:"
Fin funcion


En realidad todo el código de estas 4 funciones es mucho más breve, la 'verbosidad' añadida para dejar claridad, es lo que lo abulta, solo porque comparten la misma ventana... y conviene para dejar el comentario oportuno, en el sitio requerido.

...Y tendrías las salidas, siguientes... las meto en una cita, para que se vea más claro... losp untos suspensivos, imagino que sabrás entenderlos como que ahí encajan todas las que no comparecen entre la secuencia previa y posterior...

Para el primer ciclo:
Permutaciones para un largo de 1 símbolos/caracteres de largo, con el alfabeto: 123456"
1
2
3
4
5
6

Para el 2º ciclo:
Permutaciones para un largo de 2 símbolos/caracteres de largo, con el alfabeto: 123456"
11
12
13
...
21
22
23
...
...
...
64
65
65

............................
............................
............................


Para el 6º ciclo:
Permutaciones para un largo de 6 símbolos/caracteres de largo, con el alfabeto: 123456"
111111
111112
111113
...
111116
....
611111
611112
611113
...
611116
...
...
...
666664
666665
666666
Fin de todas las permutaciones:

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

Lo peor de todo, es que si por ejemplo una persona tuviera que tomar una decisión y luego esa decisión le cuesta la vida a una persona, sin duda esa problema pasará por un análisis interior y probablemente una autoculpa, de lo que salga un mayor esmero en no errar en lo sucesivo... es decir tiene consciencia del daño que resulta de su error, en cambio para un algoritmo, todo ese proceso resulta inexistente... lo mismo da que sea un algoritmo que falle en como hacer churros más sabrosos, que en derivar tráfico por una carretera que va hacia un precipicio... no hay consciencia, autoculpa, ni sufre si "los demás te señalan con el dedo portu mala gestión"... ergo, la posibilidad de avanzar, mejorar y autocorregirse que es lo más elemental buscado en la IA, falla estrepitosamente.

Hoy día la IA, no aprende, porque no comprende, solo memoriza y da como aprendido, lo que estadísticamente parece resultar mejor... y además probablemente sin excepciones. Mientras que un humano, incluso en leyes perfectamente claras, no paramos de hacer excepciones, precisamente porque comprendemos que la "ley sagrada" refrendada por todos, falla para ese caso al conocer sus detalles...

Lo entiendo... pero, también hay un chorro de empresas estadounidenses con los mismos problemas y no recuerdo que jamás se haya lanzado mensajes de veto contra ellas... sin ir más lejos la propia "Intel Corporation".

No deja de ser un lammer. Todo sabio que luego resulta ser tonto, demuestra seguir siendo un lammer.
En este caso es además patético, porque no solo no se lleva el dinero, pero si una condena, y nada pequeña imagino.

Menudo delito... pasará a todos los libros de la ciencia criminalista: "Señora cruza la calle fuera del paso de peatones"... se recordará los próximos 1000 años... los museos colgarán cuadros de su rostro: "La maja delincuente". Para colmo, ni siquiera la denunciada era la que "cometió el delito".

...de los delitos reales, en cambio, nada que hacer... Es mejor perseguir al ciudadano de a pie, para que entre ellos se encaren y no se les ocurra pensar cosas más elevadas.

Los chinos siempre han sido como hormigas: mafiosos, sumisos, pisoteados... pero finalmente parece que entrarán en la autoesclavitud resignada.

Luego parte d ela noticia, habla de lo absurdo por sí mismo:

una ciudad como Shenzhen, por ejemplo, asegura que ha avergonzado a casi 14.000 peatones imprudentes en diez meses y solamente en una intersección.

Hagamos cuentas: 10 meses por 30 días= 300 días... ; 14.000 peatones imprudentes avergonzados / 300 días = 46 peatones impridentes avergonzados por día... en resumen tocan a media hora, si estuvieren proporcionalmente repartidos a lo largo del día. Ridículo... pero qué cabe esperar de países con regímenes absolutistas...

La relación, en bases de datos implica dependencia...

Es decir es como si tienes una estructura, y un campo de ellos refiere a su vez a otra estructura...

La dependencia (relación) puede ser tambien inversa, es decir el destino (la segunda estructura) contener un campo para referirse a la estructura inicial (vamos un puntero a la primera estructura).

No lo he revisado a fondo...
Aseguraría que tu fallo consiste en tus bucles While... ya que los condicionas para acabar cuando alcancen el valor de 't', pero anterior al bucle no verificas si el 'barco' cabe a partir de ahí. Tu sumas filas o columnas hasta que posiblemente desborde el array...

   While b<>t do begin
       if (((Tablero[f+1,c]<>'B') and (Tablero[f,c-1]<>'B')) and (Tablero[f,c+1]<>'B')) then begin
           f:=f+1;

Tendrías que revisar varios bucles.

La lógica es que crees algunas funciones de revisión...
Te aclaro un poco por encima, bueno las 3 funciones principales del tema que te trae...

- Primero creamos el mapa, además cuando se inicie una nueva partida, también se invoca.
- Básicamente borramos el mapa, marcando cada casilla con 'agua', vacía, un valor 0 si usas bytes,o un char "0"...

Código [Seleccionar] Expandir


funcion GenerarBorrarMapa(integer Filas, integer Columnas)
   integer j, k
   MAXCOLUMNA = (columnas-1)   //Maxcolumna y maxfila se DEBEN declarar a nivel de modulo... lo mismo que los arrays de Mapa (tableros).
   MAXFILA = (filas-1)

   // Hay 2 mapas el propioy el del enemigo...
   Dimensionar array MapaA(0 a MAXFILA , 0 a MAXCOLUMNA ) //es el array de las casillas, el tablero...
   Dimensionar array MapaB(0 a MAXFILA , 0 a MAXCOLUMNA )

   Bucle para j desde 0 a MAXFILA
       bucle para k desde 0 hasta MAXCOLUMNA
           MapaA(j,k) = 0 // marcamos la casilla como vacía
           MapaB(j,k) = 0 // marcamos la casilla como vacía
       siguiente
   siguiente
fin funcion

- Ahora se posicionan todos los barcos en un mapa  (MapaA o MapaB)
- Es decir se debe invocar dos veces cada vez con un mapa distinto.
- Hemos supuesto que la flota se compone de (por ejemplo); Un barco de 5 casillas, 2 de 4, 3 de 3 y 1 de 2 casillas... total la flota tiene 7 barcos... (24 casillas)

Código [Seleccionar] Expandir


funcion PosicionarFlota(array Mapa)
    PosicionarBarco(5, Mapa)  // es preferible posicionar primero los barcos más grandes,
      //los pequeños luego caben mejor en medias que si se hace al revés...
     // por eso los vamos colocando en este orden de mayor a menor...

    PosicionarBarco(4, Mapa)
    PosicionarBarco(4, Mapa)
    PosicionarBarco(3, Mapa)
    PosicionarBarco(3, Mapa)
    PosicionarBarco(3, Mapa)
    PosicionarBarco(2, Mapa)
fin funcion

- Aquí la función que reposiciona un solo barco... nota que se elige si colocarlo vertical u horizontal
- Luego se elige al azar la fila donde ponerlo, después se verifica si cabe en dicha fila, si no cabe se busca otra... Se supone que el mapa es lo suficientemente grande para que quepan todos los barcos holgadamente... si no es así... fallará.
- Al comprobar que un barco cabe en una fila, devuelve la posición donde cabe... pero intentamos colocarlo al azar, solo si tras 5 intentos al azar no fue osible ubicarlo, usamos la posición devuelta.
- Notar que la misma función para verificar si cabe el barco se usa dos veces, perimero recorriendo toda la fila, luego solo desde la posición elegida al azar.
- Solo se pone el pseudocódigo para el caso horizontal, el vertical es solo cambiar donde proceda...

Código [Seleccionar] Expandir


funcion PosicionarBarco( integer piezas , array Mapa)
   buleano b = random(entre 0 y 1)
   integer cabe, pos, n, k
 
   Si b=1 // elegimos ponerlo en horizontal
       Hacer
           fila = random(entre 0 y MAXFILA)
           cabe = BarcoCabeEnFila(piezas, fila, 0, TRUE)
       Repetir mientras (cabe= -1)

       hacer   // haremos 5 reintentos de ubicalro al azar, si fallan, se posicionará en 'cabe'.
           pos = Random(entre 0 y MAXCOLUMNA)
           pos = BarcoCabeEnFila(Piezas, Fila, pos, FALSO)
           n = (n+1)    
       Repetir mientras ((pos=-1) y (n < 5))

       // si se intentó 5 veces al azar y no encajó, lo posicionamos donde se encontró en la fila
       Si (pos= -1) luego pos = cabe
       
       // Finalmente marcamos las casillas donde se colca el barco, con el valor del barco.
       bucle para k desde pos hasta (pos + piezas-1)    
           Mapa(fila, k) = piezas  // una casilla ocupada la marcamos con el número de piezas que tiene ese barco... un barco de 2, con el valor-char 2, uno de 4 con valor o char 4, etc... la vacía tiene valor 0.
       fin si
   Sino // b=0 , se coloca en vertical
        // similar a lo de horizontal, cambiando donde proceda.
   fin si
fin funcion


- Esta función trata de ver si un barco de x piezas de tamaño, cabe en la fila dada... a partir de la posición que se pide. Para ello basta saber si tiene el números de casillas consecutivas libres que tiene 'piezas' de barco.
- La fila ya puede tener casillas ocupadas... cuando se vaya a colocar el barco, primero lo intentará al azar, tras x intentos fallidos, se tomaría el hueco encontrado y devuelto por esta funcion.
- La función se usa con dos usos bien diferenciados al inicio, se recorre la fila entera si es necesario... buscando que quepa. En la otra funcionalidad solo se recorre hasta encontrarlo o se sale... es decir no comprueba más alla de la posición de inicio recibida si se haya alguna ocupada. El parámetro 'Reubicable' se encarga de esto... fíjate en la llamada quien lo llama con TRUE y quien con FALSE
- La función Gemela- BarcoCabeEnColumna, es casi idéntica, cambia solo la comprobación del mapa: If Mapa(k, Columna)  ... MAXCOLUMNA

Código [Seleccionar] Expandir


integer = funcion BarcoCabeEnFila(integer Piezas, integer Fila, Integer Pos, buleano Reubicable)
   integer k, n

   Bucle para k desde Pos hasta MAXFILA
       If Mapa(fila, k) = 0  // " " "Agua" , casilla no ocupada actualmente.
            n = (n+1)
            Si n=Piezas devolver (k-piezas)  // devuelve el punto donde comienza a estar libre
       sino
           si Reubicable=FALSO salir del bucle // o devolver -1 saliendo de la funcion.
           n = 0
       fin si        
   fin bucle

   devolver -1  // no cabe un barco de ese tamaño.
fin funcion

Listo... ya tienes por donde seguir...

Es que hay que cerrarlo si vas a llamar a otro metodo que te hace una busqueda secuencial en el mismo bebe, saludos

No necesariamente. Basta que cambies el puntero al punto deseado, habitualmente al comienzo del fichero.

Piensa que a veces es más útil utilizar varios canales para un mismo fichero, que saltar entre punteros o que andar cerrando y abriendo el mismo fichero...

A mi también me vino en un CD, que aún conservo y el manual (in Spanish, of course).

Yo sí instalé el win-95 desde el CD, creo recordar aún su etiqueta "Win95prod". No lo adquirí para un nuevo equipo, si no para un viejo 486Dx. a 33Ghz. y funcionaba con mucha fluidez...