Mensajes

Al darle a Reparar no me aparece la instalación de Windows 7.

Cuando debería verse algo así:


El disco si lo detecta (puedo acceder a él desde el cuadro de diagolo que aparece en "Cargar Controladores"), por lo que no creo que sea un tema de drivers.
El SSD es un Kingston ssdNOW UV300 120GB y la placa base MSI Z170A GAMING M3.

["Reservado para el sistema" 100MB NTFS Correcto (Sistema, Activo, Partición Primaria)]

Hola, tengo tres unidades de almacenamiento:

• SSD 120GB Sistema Operativo
• HDD 500GB (particion de 100MB Reservado para el sistema)
• HDD 1TB

¿Cómo puedo mover la particion: "Reservado para el sistema" 100MB NTFS Correcto (Sistema, Activo, Partición Primaria) del disco de 500GB a alguno de los otros sin tener que reinstalar el Sistema Operativo?

Puedo redimensionar los otros dos discos y formatear el de 1TB si fuera necesario, uso Windows 7 Ultimate SP1 y dispongo de la ISO.

El problema que tengo es que si quito el disco de 500GB me sale el siguiente mensaje luego de la BIOS:
"Reboot and Select proper Boot device or Insert Boot Media in selected Boot device and press a key"

Click en el icono de Windows
Selecciona "Configuración"
Click en "Cuentas"
Click en "Familia y otros usuarios"
Click en "Agregar a alguien más a este PC"
Seleccionar "No tengo la informacion de registro de esa persona"
Seleccionar "Agragar usuario sin cuenta de Microsoft"
Ingresar un nombre de usuario y escribir la contraseña dos veces, ingresar una pista y clickear siguiente.
Click en el icono de Windows
Seleccionar el icono de usuario de las esquina superior izquierda del Menú Inicio
Seleccionar el nuevo usuario.
Luego ingresa a la cuenta con la contraseña anterior.

Aprende a escribir.

Totalmente de acuerdo.

...pero qué se puede esperar?...después de todo, Zuckerberg, (parece que) es sólo un niñato malcriado, que tuvo una buena idea y consiguió el dinero necesario para llevarlo a cabo...

En realidad un millonario le pago para que deje de estudiar y creará Facebook. Y la idea era hacer un álbum de fotos de fin de curso. Así que sí, básicamente es un ***** con suerte.

Aquí lo tienes en C++ más reducido, este no muestra el historial de intentos.

También tengo una IA que busca las mejores combinaciones en base a los intentos anteriores.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>

const int MAXIMO_INTENTOS = 20;
const int LARGO_CODIGO = 6;
const char PRIMERA_LETRA = 'A';
const char ULTIMA_LETRA = 'H';

typedef char TipoCodigo[LARGO_CODIGO + 1];

bool EsValido(TipoCodigo codigo) {
// Devuelve true si el codigo es valido.
int i = 1;
while (i <= LARGO_CODIGO && codigo[i] >= PRIMERA_LETRA && codigo[i] <= ULTIMA_LETRA)
i++;
// Es valido si todos los elementos del codigo estan en el rango.
return i > LARGO_CODIGO;
}

void ObtenerNota(TipoCodigo propuesta, TipoCodigo codigo, unsigned int &buenos, unsigned int &regulares) {
// Obtener cantidad de buenos y regulares entre dos codigos.
TipoCodigo propuestacopia;
buenos = 0;
for (int i = 1; i <= LARGO_CODIGO; i++) {
if (propuesta[i] == codigo[i]) buenos++;
propuestacopia[i] = propuesta[i];
}
int max = 0;
// Hallar la "maxima" cantidad de buenos.
for (int i = 1; i <= LARGO_CODIGO; i++) {
int j = 1;
while (j <= LARGO_CODIGO && codigo[i] != propuestacopia[j]) j++;
if (j <= LARGO_CODIGO) {
// Borrar la letra para no volver a usar la misma.
propuestacopia[j] = ' ';
max++;
}
}
regulares = max - buenos;
}

void GenerarCodigo(TipoCodigo &codigo) {
// Generar codigo aleatorio
int ord_prim = (int)PRIMERA_LETRA;
int ord_ult = (int)ULTIMA_LETRA;
for (int i = 1; i <= LARGO_CODIGO; i++)
codigo[i] = ord_prim + rand() % (ord_ult - ord_prim + 1);
}

void LeerCodigo(TipoCodigo &codigo) {
char c;
for (int i = 1; i <= LARGO_CODIGO; i++) {
scanf("%c", &c);
codigo[i] = toupper(c);
}
do {
c = getchar();
} while (c != '\n');
}

int main() {
srand(time(NULL));
TipoCodigo secreto;
GenerarCodigo(secreto);
int intentos = 0;
bool exito = false;
bool fracaso = false;
printf("He pensado un codigo, intenta adivinarlo.\n");
printf("*Pista: tiene %d letras y estas estan entre la %c y la %c\n", LARGO_CODIGO, PRIMERA_LETRA, ULTIMA_LETRA);
printf("Las letras pueden repetirse o no aparecer en el codigo, y solo tienes %d intentos.\n\n", MAXIMO_INTENTOS);
do {
TipoCodigo codigo;
LeerCodigo(codigo);
while (!EsValido(codigo)) {
printf("El codigo no es valido, intentalo de nuevo.\n");
LeerCodigo(codigo);
}
intentos++;
unsigned int buenos, regulares;
ObtenerNota(codigo, secreto, buenos, regulares);
if (buenos == LARGO_CODIGO) exito = true;
else if (intentos == MAXIMO_INTENTOS) fracaso = true;
else {
printf("B: %d   R: %d", buenos, regulares);
printf("                      Te quedan %d intentos\n", MAXIMO_INTENTOS - intentos);
}
} while (!(exito || fracaso));

printf("\n\n");
if (exito) printf("***** FELICIDADES, has ganado. *****\n");
else {
printf("--- Demasiados intentos, perdiste. ---\n");
printf("El codigo secreto era: ");
for (int i = 1; i <= LARGO_CODIGO; i++) printf("%c", secreto[i]);
}
printf("\n");
}

Este es un codigo que hice hace varios años en Pascal, se puede pasar a C muy fácil.

"Regulares" es a lo que tu llamas heridos y "buenos" es muertos.
ObtenerNota haya dichos valores en el codigo, en este caso tiene un largo de seis letras que pueden ir de la A a la H

Código (pascal) [Seleccionar] Expandir

PROCEDURE ObtenerNota(propuesta, codigo: TipoCodigo; VAR buenos, regulares: RangoBR);

Código (cpp) [Seleccionar] Expandir

void ObtenerNota(TipoCodigo propuesta, TipoCodigo codigo, RangoBR &buenos, RangoBR &regulares) {

Código (pascal) [Seleccionar] Expandir

PROGRAM MasterMind (input, output);
CONST
MAXIMO_INTENTOS = 20;
LARGO_CODIGO = 6;
PRIMERA_LETRA = 'A';
ULTIMA_LETRA = 'H';
TYPE
RangoCodigo = 1..LARGO_CODIGO;
TipoCodigo = ARRAY [RangoCodigo] OF Char;

RangoBR = 0..LARGO_CODIGO;
TRegistroNota = RECORD
codigo: TipoCodigo;
buenos,
regulares: RangoBR
END;

   THistoria = RECORD
info: ARRAY [1..MAXIMO_INTENTOS] OF TRegistroNota;
tope: 0..MAXIMO_INTENTOS
END;

ListaNotas = ^CeldaNota;
CeldaNota = RECORD
codigo: TipoCodigo;
buenos,
regulares: RangoBR;
turno: 1..MAXIMO_INTENTOS;
siguiente: ListaNotas
END;
VAR
secreto, codigo: TipoCodigo;
historia: THistoria;
buenos, regulares: RangoBR;
i, intentos: Integer;
exito, fracaso: Boolean;
lista: ListaNotas;

FUNCTION EsValido(codigo: TipoCodigo): Boolean;
VAR
i: Integer;
BEGIN
i := 1;
WHILE (i <= LARGO_CODIGO) AND (codigo[i] >= PRIMERA_LETRA) AND (codigo[i] <= ULTIMA_LETRA) DO
i := i + 1;
EsValido :=  i > LARGO_CODIGO
END;

PROCEDURE ObtenerNota(propuesta, codigo: TipoCodigo; VAR buenos, regulares: RangoBR);
VAR
i, j, max: Integer;
propuestacopia: TipoCodigo;
BEGIN
buenos := 0;
FOR i := 1 TO LARGO_CODIGO DO
BEGIN
IF propuesta[i] = codigo[i] THEN
buenos := buenos + 1;
propuestacopia[i] := propuesta[i]
END;
max := 0;
FOR i := 1 TO LARGO_CODIGO DO
BEGIN
j := 1;
WHILE (j <= LARGO_CODIGO) AND (codigo[i] <> propuestacopia[j]) DO
j := j + 1;
IF j <= LARGO_CODIGO THEN
BEGIN
max := max + 1;
propuestacopia[j] := ' '
END
END;
regulares := max - buenos
END;

PROCEDURE IniciarHistoria(VAR historia: THistoria);
BEGIN
WITH historia DO
tope := 0
END;

PROCEDURE GuardarNota(VAR historia: THistoria;
codigo: TipoCodigo;
buenos, regulares: RangoBR);
VAR
i: Integer;
BEGIN
WITH historia DO
BEGIN
tope := tope + 1;
FOR i := 1 TO LARGO_CODIGO DO
info[tope].codigo[i] := codigo[i];
info[tope].buenos := buenos;
info[tope].regulares := regulares
END
END;

FUNCTION ListaOrdenada(historia: THistoria): ListaNotas;
VAR
i, j: Integer;
p, actual, anterior, lista: ListaNotas;
BEGIN
lista := NIL;
FOR i := 1 TO historia.tope DO
BEGIN
new(p);
FOR j := 1 TO LARGO_CODIGO DO
p^.codigo[j] := historia.info[i].codigo[j];
p^.buenos := historia.info[i].buenos;
p^.regulares := historia.info[i].regulares;
p^.turno := i;

actual := lista;
anterior := lista;
WHILE (actual <> NIL) AND (10 * actual^.buenos + actual^.regulares <= 10 * p^.buenos + p^.regulares) DO
BEGIN
anterior := actual;
actual := actual^.siguiente
END;
IF (anterior = NIL) OR (anterior = actual) THEN
BEGIN
p^.siguiente := anterior;
lista := p
END
ELSE
BEGIN
p^.siguiente := actual;
anterior^.siguiente := p
END
END;
ListaOrdenada := lista
END;

PROCEDURE GenerarCodigo(VAR codigo: TipoCodigo);
VAR
i: Integer;
ordprim, ordult: Integer;
BEGIN
ordprim := ord(PRIMERA_LETRA);
ordult  := ord(ULTIMA_LETRA);
FOR i := 1 TO LARGO_CODIGO DO
codigo[i] := chr(ordprim + random(ordult - ordprim + 1))
END;

PROCEDURE LeerCodigo(VAR codigo: TipoCodigo);
VAR
i: Integer;
BEGIN
FOR i := 1 TO LARGO_CODIGO DO
Read(codigo[i]);
ReadLn
END;

(* ------ Programa Principal ------ *)
BEGIN
Randomize;
IniciarHistoria(historia);
GenerarCodigo(secreto);
intentos := 0;
exito := false;
fracaso := false;
WriteLn('He pensado un codigo, intenta adivinarlo.');
WriteLn('*Pista: tiene ', LARGO_CODIGO, ' letras y estas estan entre la ', PRIMERA_LETRA, ' y la ', ULTIMA_LETRA);
WriteLn('Las letras pueden repetirse o no aparecer en mi codigo, y solo tienes ', MAXIMO_INTENTOS, ' intentos.');
WriteLn;
REPEAT
LeerCodigo(codigo);
WHILE NOT EsValido(codigo) DO
BEGIN
WriteLn('El codigo no es valido, intentalo de nuevo.');
LeerCodigo(codigo)
END;
intentos := intentos + 1;
ObtenerNota(codigo, secreto, buenos, regulares);
IF buenos = LARGO_CODIGO THEN
exito := true
ELSE IF intentos = MAXIMO_INTENTOS THEN
fracaso := true
ELSE
BEGIN
Write('B: ', buenos, '   R: ', regulares);
WriteLn('                      Te quedan ', MAXIMO_INTENTOS - intentos, ' intentos')
END;
GuardarNota(historia, codigo, buenos, regulares)
UNTIL exito OR fracaso;
WriteLn;
WriteLn;
IF exito THEN
WriteLn('***** FELICIDADES, has ganado. *****')
ELSE
BEGIN
WriteLn('--- Demasiados intentos, perdiste. ---');
Write  ('    El codigo secreto era: ');
FOR i := 1 TO LARGO_CODIGO DO
Write(secreto[i])
END;
WriteLn;
WriteLn;
lista := ListaOrdenada(historia);
WHILE lista <> NIL DO
BEGIN
FOR i := 1 TO LARGO_CODIGO DO
Write(lista^.codigo[i]);
Write(' -->  Bs = ', lista^.buenos, ',  Rs = ', lista^.regulares, ' (Turno: ', lista^.turno, ')');
WriteLn;
lista := lista^.siguiente
END;
ReadLn
END.

A mi lo que me llama la atención es esto:

https://www.kb.cert.org/vuls/id/228519

Parece que varios proveedores han sido notificados hace casi 2 meses y casi NINGUNO ha hecho nada por parchar, y solo MikroTik se ha manifestado sobre el asunto. Creo que está perfecto que se lo publique dado que se ha tratado el asunto con cautela, ya es hora de poner presión o nadie hará nada.

We sent out notifications to vendors whose products we tested ourselves around 14 July 2017.

Primero se creia que era un bug en la implementación, luego se dieron cuenta de que era una vulnerabilidad del protocolo. OpenBSD lanzo un parche en silencio en Agosto, es posible que alguien lo descubriese y haya explotado la vulnerabilidad.

[pow(a, 1/n)]

Resultado= pow(P,0.5);
    R= Z / B;

¿Qué es R?, ¿Qué es Z?, ¿Por qué usas 0.5?
Si quieres hallar la raiz n-esima de a es: pow(a, 1/n) Notese que si n es entero entonces 1/n devuelve la división entera. Si quieres hallar la raiz cuadrada es elevar a la 0.5
conio.h No es una libreria estandar y NO debes usarla.

Código (cpp) [Seleccionar] Expandir

#include <math.h>
#include <stdio.h>

int main() {
int a, b, op;
printf("\tOPERACIONES:\n");
printf(" 1) Suma (Sumandos)\n");
printf(" 2) Diferencia (Minuendo Sustraendo)\n");
printf(" 3) Producto (Multiplicando Multiplicador)\n");
printf(" 4) Divicion Real (Dividendo Divisor)\n");
printf(" 5) Potenciacion (Base Exponente)\n");
printf(" 6) Raiz n-esima (Radicando N)\n");
printf("\nIngrese el codigo de operacion: ");
scanf("%d", &op);
printf("\nIngrese los operandos: ");
scanf("%d %d", &a, &b);
printf("\nEl resultado es: ");
switch(op) {
case 1: printf("%d", a + b); break;
case 2: printf("%d", a - b); break;
case 3: printf("%d", a * b); break;
case 4: printf("%f", (float)a / b); break;
case 5: printf("%f", pow(a, b)); break;
case 6: printf("%f", pow(a, (float)1 / b)); break;
default: printf("\nERROR: opcion no valida.\n"); break;
}
return 0;
}

Una forma es almacenar los NxN elementos en un arreglo, el elemento de la posicion A(i,j) se almacena en A(i*N+j) y reciprocamente el elemento el la posicion i se encuentra en la fila i div N,
y en la columna j (mod N)

Código (cpp) [Seleccionar] Expandir

int* matriz = new int[N * N];
for (int i = 0; i < N * N; i++) {
int fila = i / N;
int columna = i % N;
matriz[fila * N + columna] = valor; // matriz[i] = valor
}

Y la forma tipica usando memoria dinámica:

Código (cpp) [Seleccionar] Expandir

int** matriz = new int*[N];
for (int i = 0; i < N; i++)
matriz[i] = new int[N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
matriz[i][j] = valor;