Mensajes

Lo que más falta hace a los que quieren ser buenos hackers?.... Paciencia.

Si eres hacker, ya está... para ser bueno, además... debes tener paciencia, porque nadie consigue ser bueno en nada en 2 días y sin ningún esfuerzo.

Así, que sí... paciencia leyendo libros (ni éste, ni aquél, sino éste y aquél) y aprendiendo a programar en x-Lenguaje.

La pila hay que tenerla retirada entre 10 y 60 segundos... ya que a menudo algún condensador podría aún estar suministrando corriente. Tras ese período, es factible que se hayan descargado...

Aparte, los BIOS de hoy día, tienen más seguridad que antes... Suele haber un jumper, de tres pines, y tras tener el equipo apagado y desconectado de la red, hay que mover el conector desde los pines 1-2, a los pines 1-3, ó al revés, incluso retirado el conector (esto es algo que depende de cada fabricante). A menudo ponerlo en la otra pareja de pines es para acceder a un modo especial de configuración de la BIOS y en tales casos, es retirando el conector de sus pines, que se resetea a valores de fábrica. La pila debe tener carga y estar puesta durante ese proceso... nuevamente pudieran haber hecho algún cambio nuevo y pudiera requerir que al tiempo esté quitada la pila del BIOS, aunque me extrañaría.
Luego conecta el equipo a la corriente y enciéndelo durante unos segundos (esto también varía según el fabricante, aunque cada vez el tamaño (en bytes) de los BIOS es mayor, también es cierto que son más veloces). ante la duda déjalo 1 minuto funcionando. Luego lo apagas y desconectas de nuevo de la red, vuelves a poner el conector en los pines que estaba y en teoría al conectar de nuevo la corriente y prender el equipo, la BIOS debería estar restaurada en modo de fábrica.

Si no sabes encontrar el conector y los pines indicados, mira el manual de la placa base... en la propia placa base, podrías buscarlo como JBatt  (Jumper Battery), pero no es universal, cada fabricante sigue sus propias convicciones a veces...

De hecho, lo más recomendable sería buscar el manual d ela placa base e informarse d ela operativa que debe seguirse para el modelo concreto de tu placa base. El manual si no te entró cuando adquiriste la placa, debes buscarlo en la página web del fabricante, usando el nombre de la marca y el modelo de la placa base

Dicho modelo deberías verlo escrito (impreso), con letras más o menos grandes, claras y vistosas sobre la propia placa base... mira alrededor del procesador, ente el procesador y la memoria y entre el procesador y los conectores PCI-XPress, incluso entre medias de estos conectores... por ahí suelen ponerlos todas las marcas.

Todo depende de la forma exacta en que se haga y si es algo automático o tienes control de ello. Supongamos que todo es asequible y que lo haces tú, sin requerir a librerías ajenas...

El modo más sencillo entonces es que cuando debas seleccionar las palabras que se están buscando según el filtro (etc...), las añadas a una colección explícita (quien dice una colección, dice una tabla hash, etc...).
A la colección colRojas, las palabras rojas y a la colección colAzules para las palabras azules, según el criterio seguido y acto seguido las coloreas sobre el texto (tal como vienes haciendo)...

Luego cuando se reclame contar las palabras, la propiedad Count de la colección te devuelve el total.
Luego también, si se reclama una búsqueda sobre esa selección, ahora puedes buscar en la colección las palabras específicas que se seleccionaron (en vez de hacerlo de nuevo cada vez sobre el texto).

Y por supuesto, cuando cambie el criterio de selección se debe destruir el contenido de las colecciones y crearlas de nuevo, exactamente igual que las palabras se volverían a colorear de la forma esperada...

p.d.: Si además de buscarla en la colección, tienes también que remarcarla en el texto, guarda también la posición de la palabra en el texto en la propia colección.

Así se explica como es la era de un presidente zoquete: Se elige cuando desean tener un muñeco al que torear y que no sepa ni luego por donde le vino la pelota ni a donde iba... Mejor si es un títere prepotente que cree mandar.

Yo soy partidario, de que cada país debería tener su propia industria de microchips y su marca propia (al menos una).
Y no necesariamente por negocio, creo que es una cuestión estratégica...
Ante cualquier eventualidad política, de esa forma, un país podría al menos nutrirse de su propia tecnología, más allá de que luego esa tecnología esté muy alejada de la más puntera en todo el mundo...

Sin embargo presenta una limitación importante, y es que sólo es capaz de almacenar un máximo de 4 bits de datos.

Sí, es una cifra muy pequeña, tanto que para un usuario normal no tendría utilidad alguna, pero es un primer paso a una innovación realmente prometedora que como dijimos podría marcar un punto de inflexión en el sector del almacenamiento.

De momento el principal desafío que enfrentan los expertos es aumentar su capacidad de almacenamiento...

mmmm... 4 bits bastan.
Superarlo es hacer códigos de barras, intercalando zonas de spray con zonas que no. Cada zona entonces delimita ese pequeño código de 4 bits, luego una zona sin bits, y luego otra con bits... etc... y en cada zona se continúa con otro nibble.

Pués si, le doy la razón a EleKtro... aunque yo como llevo poco tiempo en el foro (en la nueva andadura), no te conozco, así que tienes otra oportunidad de 'redimirte'  

A - Todo lo que tienes que hacer es meter tus 'códigos' en un array.
B - Y luego invocar una función pasando ese array.
C - En dicha función es un bucle quien recorre el array invocando a la función de ese 'código misterioso superlargo y supersecreto (que encontraste)' (la verdad que si es tan largo como dices, ni siquiera será muy bueno), pasándole como parámetro el 'código' actualmente en ciclo del bucle. Esto es, por cada índice en el array se invoca esa supersecretaFunciónQR(array(k)).
D - Finalmente supongo que devuelve algo, no sé si una imagen o si un fichero... si es un fichero, quizás debas pasarle también una ruta, si es una imagen la guardas tu mismo a fichero.

Tengo en un formulario un TextBox (oculto) un texto en el cual está correctamente escrito, sin errores. Y otro TextBox el cual se ve, en el cual debo intentar escribir lo que está en el TextBox oculto lo más correctamente posible.

De no estar correctamente escrito en este último, que me cuente la cantidad de errores existentes y si es posible, también marcar cuáles fueron los errores.

Básicamente eso es lo que hace el juego del Mastermind. Lo único que cambia es que en el mastermind, se usan bolas de colores y tu usas letras y bueno, como es un juego se da un límite máximo de intentos.
Guglea si qieres buscando código.

¿Es posible hacer esto desde VB.NET?

Qué, cómo.?????????

Vi en algunas páginas proyectos hechos donde implementan RichTextBox, y en otros casos algo relacionado con XAML, pero la verdad es que no he conseguido salir de este problema.

Se puede complicar uno la vida todo lo que quiera, pero basta con tu idea original, incluso sin siquiera ese textbox oculto, basta que esté en una variable del código.

PD: Mi idea es intentar hacer algo parecido a lo que es el programa de mecanografía Typing Master en una de sus funciones cuando compara y muestra los errores, como para que tengan una idea de lo que intento realizar.

Ahora mismo, no caigo en cual es es eprograma (hay tantos...). Pero ya te digo, que lo que quieres hacer es el típico mastermind, pero más simplificado aún.

Una idea aproximada de lo que tienes que hacer:

- Crear una propiedad que indique el tamaño (númeor de caracteres de la palabra). (esto puede ser una opción en un menú o bien con un control "slider", "scrollhorizontal", etc... siempre entre un rango mínimo y máximo (min=6, Máx=16, por ejemplo).
- Crear una función Nuevo: que genere una palabra al azar del tamaño indicado, y guardarla en un campo oculto, convertida en un array de caracteres.
- Crear una función Intento (llamada desde un botón y con un texto, que yace sobre un control de texto (textbox, es más que sufieciente, si quieres colorealo, para que sea más 'atractivo'...

--- Tu escribes en el texto, en el evento 'change' del textbox, miras si la palaba escrita tiene el largo (ni más ni menos) que se requiere y si es que sí, activas el botón para "Escrutar", si no, sigue desactivado.
--- También puedes dejar siempre activo el botón y no hacer nada en eventos del texto, y cuando se pulse el botón, miras si el texto contiene el númeor de caracteres concreto, si no es así, un mensaje al usuario de 'faltan/sobran letras'... el código del botón.

--- El botón, invoca la función Intento, pasándole el texto que contiene el control si devuelve false, pegar de nuevo el texto 'Palabra' en el textbox.
Y el código de la función lo que hará es:

Código [Seleccionar] Expandir

Funcion Intento(byref Palabra as string) as boolean
--- Recibir un texto del mismo largo que la palabra oculta.
--- Convertirlo a un array de caracteres.
--- Iniciar un bucle, que recorra desde 0 hasta el final del array.
--- Dentro del bucle:
---------- Si Oculto(k) <> TxtUser(k) luego
---------------   TxtUser(k)= "*"
---------------    n +=1
---------- Fin si
--- fin bucle
--- Si n> 0 entonces 'implica que no todos los caracteres fueron encontrados
-------- Convertir el array txtUser que ha sido modificado, indicando con *, cada carácter donde falló, a una cadena de texto, reescribiendo el parámetro: 'Palabra' (se devuelve por referencia).
------------ El botón que recibe de vuelta False, pega entonces el parámetro en el textbox.
--- Si no
-------  Devolver: True
-------  El botón que recibe el true saca un Mensaje: enhorabuena acertaste la palabra oculta...
fin función.

p.d.: Eso sí, antes de todo tú decides si se truncan mayúsculas a inúsculas o viceversa o no... Así :  ¿MARTE=MarTE???, y por tanto obra en consecuencia.
texto= texto.toupper ó texto= texto.ToLower, o nada si se distingue capitalización de caracteres.

[NombreArray = new TipoDato[tamaño];]

No has llegado a interpretarme correctamente. Te desgrano cada bucle, porque cometes errores en todos ellos...

Antes de nada te comento el punto final...

no he entendido lo de redimensionar cuenta desde 0 hasta max-min ... java me envia los array Cuenta y ValoresUnicos como null

Redimensionar = dimensionar = inicializar a un tamaño específico.
En java un array se inicializa a un amaño específico así:
NombreArray = new TipoDato[tamaño];
Sólo una vez que inicialices el array al tamaño deseado, estos podrán contener algo, si desde el comienzo están vacíos y siguen vaciós, al final también estarán vacíos. Inícialos, y luego ya en los bucles se irán rellenando con los valores adecuados. al iniciarlizarlos, se le da un tamaño al array (que luego puede consukltarse con: array.length) y cada valor del mismo se pone al valor 0.

y no se como devolver el array Valores unicos,

Bueno, esto ya es falta de conocimiento del lenguaje, es algo que pudes consultar perfectamente guglenado, si no tienes un libro a mano, o una web de referencia del lenguaje Java... No tiene caso preguntar cosas que están escritas en 1.000 partes desde hace 20 años o más... De entrada si no sabes devolverlos, al menos entrégalos por referencia como parámetro en la llamada de la función... de hecho mirando tu función:
- La declaras como void (sin devolución), yo devolvería el valor de 'Unicos'.
- Tienes dos arrays declarados en la entrada de la función: int x[], int y[] ...si el array x contiene los valores entre los que deseamos buscar, qué contiene el array y?... ese array podría ser el array Valoresunicos (da igual el nombre que le pongas, pero siempre mejor si es significativo).
- Supongo que 'n' es el tamaño del array x... puedes usar para el caso x.Length y así no es preciso en la función el parámetro n.

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

Empiezo comentando tu código, para señalarte las correccioes que necesita, bucle por bucle:
Cuando recorres el bucle para encontrar el valor menor (del PASO 1) en  tú codigo, pones:

Código (java) [Seleccionar] Expandir

for(j=0;j<n;j++)
   {
    if(y[j]<min)
    {
    min=y[j];
    }
    j++;
   }
...al mismo tiempo puedes ir hallando el mayor... imagina que tienes esta corta serie de valores: 7,17,3,15,21,2,9 ...al empezar el bucle tomamos como menor y mayor el primero de la serie, el valor 7...
Luego que entramos preguntamos si el siguiente ítem y(1)< min, esto es si 17 es menor que 7, no es menor, luego si no es menor, queda que : o es igual que siete o es mayor, luego, en la alternativa (al si) se pregunta si es mayor que 7 y si es así, asignamos el valor a mayor (si resulta serlo).
En definitiva nos basta un solo bucle para encontrar el menor y también el mayor de la serie.
Es más, es que no veo que busques el mayor de la serie, creí que lo hacías en otro bucle aparte más adelante..., pero mirando resulta que no, que te has olvidado de ello.

Código [Seleccionar] Expandir

   Si array(k) es menor que Min luego
         Min= array(k)
  [b] en otro caso[/b]  (lo desmonto en otra línea para que te quede más claro...)
        [b]si array(k) es mayor que Max luego
            Max = array(k)
        fin si[/b]
   fin si
Si no buscas el mayor, entonces el valor que usar más adelante para mayor, es que usamos al comienzo, el contenido del indice 0.

De igual modo, aunque de menor importancia, puesto que el primer elemento de la serie ya lo hemos asignado de entrada como el menor y el mayor, el bucle puede ser iniciado desde el siguiente elemtno, es decir el 1 y no volver al cero como haces en: "for(j=0", si hemos asignado ese valor ya, al preguntar 7 no será menor que 7, y 7 tampoco será mayor que 7.... pero bueno, es solo un ítem por el que s epregunta, no tiene más importancia. Tu deberías poner: "for(j=1"


Ahora vamos a repasar el bucle del PASO-2:

Código (java) [Seleccionar] Expandir


for(j=0;j<n;j++)
   {
    cuenta[y[j-min]]=cuenta[y[j-min]+1];
    j++;
   }

De entrada el array cuenta, aunque está declarado, no está inicializado, no se le ha asignado un tamaño. En Java, no se permite empezar en otro índice que no sea 0, así que el array debería desde 0 hasta Max-Min. Una vez redimensionado el array (inicializado, quizás te suene
En el código que pones para el segundo paso, no lo has interpretado correctamente ...
Yo puse:

Código [Seleccionar] Expandir

redimensionar cuenta desde 0 hasta max - min
Iniciar bucle para k y recorrer desde 0 hasta fin del array
   cuenta(Array(k)-min) = cuenta(Array(k)-min) +1
   incrementar k
fin bucle
Fíjate en lo que tu pones: cuenta[y[j-min]]
Y lo que yo te puse: cuenta(Array(k)-min)
Y no me refiero a las llaves y paréntesis (obviamente), si no a donde está el signo '-' y por tanto de qué se hace la resta... es decir no hacemos resta del índice, sino del valor que contiene ese índice.,... si te fijas, tu tienes 2 cierres de llave al final, yo solo 1, por que el otro cierre, el del índice está tras el índice mismo.

Ahora repaso el código del bucle del PASO-3, hay dos fallos, donde tu tienes:

Código (java) [Seleccionar] Expandir

for(j=min;j<max;j++)
   {
    if(cuenta[j]>0)
    {
    unicos=unicos+1;
    j++;
    }
   }

El código es casi correcto, pero contiene 2 fallos:
El primero está en la declaración del bucle, tu has puesto en tu código: for(j=min;j<max;j++)
Y yo puse: Iniciar bucle para K recorriendo desde 0 hasta Max - Min
Luego lo correcto sería poner: for(j=0;j<(max-min);j++)

El otro error lo cometes bucle tras bucle...
Verás cuando yo estructuro un bucle en pseudocódigo:

Código [Seleccionar] Expandir

Iniciar bucle para x desde y hasta z
   ...
  [b] Incrementar X[/b]
fin bucle
El punto de incrementar, es dependiente de qué tipo de bucle se use, si se usa un bucle for... ya lleva en el propio código, como se incrementa. ...en Java igual que en C, (señalado en negrita) es en la forma: for(x=y;x<z;x++)
Luego no hace falta que al finalizar el bucle vuelvas a incrementar el valor de la variable de control del bucle, porque entonces estás saltando en cada ciclo 2 unidades cada vez.
El 'incrementar x', debe interpretarse que es así, pero si el formato del bucle ya lo ofrece por sí mismo, ya está, no hay que añadirlo. ...pero en bucles de tipo While... no se 'autoincrementa' en el diseño del bucle de forma automática, luego ahí si sería preciso explicitarlo. En TODOS los bucles for que has puesto, por tanto están sobrando...

Por fin te comento el cuarto bucle de tu código, correspondiente al paso 4:

Código (java) [Seleccionar] Expandir

for(j=min;j<max;j++)
   {
    ValoresUnicos[n]=(j+min);
    n++;
    if(n==unicos)
    {
    }
    j++;
   }

De entrada no has inicializado el array ValoresUnicos (arriba del todo te comentaba si ese array podría ser el mismo que el array 'y', que entra en la función.

Luego la declaración del bucle, tampoco es correcta. Supongo que el error es porque no has trasladado mi declaración al caso de Java. En Java los arrays siempre empiezan en el índice 0, entonces debes hacer el cambio preciso.
Si yo puse esto: Iniciar bucle para K recorriendo desde Min hasta Max
Usando Java deberías poner: for(j=0;j<cuenta.length-1;j++)

el resto del bucle, también está muy desorientado:
Si o puse, en el cuerpo del bucle:

Código [Seleccionar] Expandir

  Si cuenta(k) es mayor que 0 luego
       ValoresUnicos(n) = (k+min)
       Incrementar n
       Si n es igual que unicos salir del bucle, ya no hay más...
   fin si
tu deberías poner:

Código (java) [Seleccionar] Expandir

if(cuenta[j]>0){
   ValoresUnicos[n]=(j+min);
   n++;
}
Solo dos cosas más... dado que la variable 'n', tu ya la traes con un valor en la entrada de la función, tienes que hacer una de dos cosas, o bien la pones a 0 antes del bucle, o bien creas una nueva variable que sirva de contador... en cualquier caso, no puedes usar una variable ya existente con un valor que tenga, tal cual... puedes reutilizar una variable muchas veces, pero poniendo a 0 su valor cuando antes de usarlo para otra cosa (a 0 o al valor inicial que debeiera tener, por supuesto).

Finalmente, puedes ignorar la línea: "Si n es igual que unicos salir del bucle", es sólo un ahorro para no recorrer todo el bucle si ya se asignaron todos los valores únicos. No es imprescindible, y probablemente no suponga una mejora en velocidad salvo que a priori se sepa por ejemplo, que hay 1 millón de elementos, pero sólo haya 5 únicos y que estén todos al principio... Este detalle si quieres lo pones en el código, pero lo dejas comentado, cuando tengas más conocimiento del lenguaje y sobreprogamar, lo entenderás claro.

p.d.: Tu último mensaje no lo comento. En este aún con tantos errores tiene mejor enfoque que aquél, que tienes bucles anidados...

[50 millones de combinaciones que son funcionales]

Te comento lo que busco es el el algoritmo generador de los codigos, pero que este dentro del parámetro de los 50 millones de combinaciones que son funcionales.

Bien, es posible hacerlo, pero necesitamos más datos para circunscribir el algoritmo a la exactitud de donde se pretende imitarlo...
Por ejemplo, no sé de donde sacas ese dato de 50 millones, ¿me lo puedes decir?.

Segui parte del codigo que dejaste y termine creando un generador que entregaba las 270 millones de combinaciones pero realmente no tuve un gran avance.

Vale, seguir cierta parte es razonable, ya que uno debe adaptarlo a lo que exactamente necesite... sin embargo, tampoco aclaras que límites impusiste (ni código ni explicaciones) para llegar a los 270 millones de combinaciones, cuando ya te expresé que todas las combinaciones posibles para secuancias de 10 caracteres con un alfabeto de 28 caracteres, se obtienen: 28 elevado a la 10 (28*28*28*28*28*28*28*28*28*28)= 296.196.766.695.424 = casi 300billones, no millones, de secuencias.

Analizando las muestras encontre este codigo que en especial me llamo mucho la atencion, ya que pinta para ser consecutivo y tiene una cadena muy similar al final.  

Nuevamente hay que basarse en hipótesis... ¿porqué sumas el valor de los caracteres de la secuencia?. ¿Hay algún sitio donde se use un algoritmo, que haya alguna simple explicación peregrina que diga algo al respecto, sobre como crearon esas secuencias y en ello verse tu empeño en sumarlas?.

3KL9MDV NFH  - 2+15+16+7+17+10+24+18+11+13 // 133  
72GDNZ7 NSH -  6+1+12+10+18+28+6+18+22+13 // 134  

Podría suceder que la secuencia de 10 caracteres, esté formada por la concatenación de dos generadores diferentes de secuencias... pongamos una de 7 caracteres y otra de 3. Pero es una teoría, y habría quye demostrar que fuere cierto, para ello, insisto en que, es preciso obtener más secuencias de las que poder hacer un análisis (incluso sencillo, no requiere que sea profundo) y deducir las reglas inferidas.
Quizás se pudiere sacar en concreto, que por ejemplo los 3 caracteres finales, tengan un alfabeto más reducido, o incluso que sean tan solo una suma de verificación (un hash de comprobación de la validez de las secuencias) de los otros 7 previos caracteres... que (ésto) tendría, incluso, más sentido.

Hay algún problema en que reveles de donde obtienes esas secuencias o datos de algún lugar donde se dé algún detalle de como se generan, por nimios que sean esos detalles???.

En fín se requieren más datos (si puedes conseguirlos) o como mínimo más muestras (del orden de centenares), para poder fijar el camino, la ruta a seguir en vez de ir a la deriva, movido por la imaginación...

Si no hay más datos con los que limitar el algoritmo, ni secuencias de las que se puedan deducir reglas tras unos análisis, no es posible avanzar de forma seria, sería una pérdida de tiempo.