Mensajes

[EaseUS Partition Master]

Pero disculpa Machacador, ¿EaseUS Partition Master las libera o las elimina (las particiones)? Es que me queda la duda, y más que nada porque ésa era la pregunta original de marax.

[simorg]

Disculpad simorg y Songoku, creo que NO habéis entendido lo que pregunta marax.

Yo creo que sí lo entendí. Pero como -algún modeador supongo- me borraron la respuesta conectada con otro hilo, pues os la pongo nuevamente.

marax os está examinando. No os está preguntandoos sobre cómo formatear, etc. Os está preguntando sobre la diferencia entre: "eliminar" - "liberar"... particiones lógicas...
signifique  ello lo que quiera que signifique... Y os lo está preguntando para examinaros.

Éso es lo que tenéis que contestar: ¿cuál puede ser la diferencia entre "eliminar" o "liberar" particiones... Es éso lo que tenéis que contestar...

¡No me echéis a mi la culpa!. No soy yo quién intenta examinaros... ¡es marax! Si no os gusta la respuesta/pregunta... echádle la culpa a él.... (y de paso al moderador que me borró mi respuesta cuando quise poner al descubierto la falacia de aquél... )

Solo para añadir algo a lo expuesto por Machacador, que está muy puesto en razón.

Y es que quizá el tener una máquina vieja (y que no sea fundamental para tu actividad normal, claro) puede venirte bien precisamente para experimentar con ella. Si te descargas "cositas" para experimentar con ellas y alguna de esas "cositas" trae "regalito"... pues formateas y a otra cosa. También puedes experimentar con distintos S.O., puedes experimentar con varios S.O en la misma máquina y arranques duales. Aunque como comenta Machacador puede ser lenta para experimentar con MVs, yo tengo un portátil con sólo 4GB de RAM (reales sólo 3 y pico) , 4 núcleos procesador AMD A4, y puedo trabajar (bueno trabajar no, hacer experimentos) hasta con 2 MVs; eso sí, sin dedicar el ordenador a ninguna otra cosa.

Si puedes tener otro ordenador (principal) para dedicar a las cuestiones "importantes", el portátil te puede venir muy bien para experimentar.

Incluso, desde otro punto de vista, usar el principal en tu red normal, y el portátil para entrar en "otras redes", ya sean redes públicas (bares, bibliotecas, aeropuertos, estaciones,...) o "entrar en redes ajenas",...  Ahí tienes un mundo; te puede venir muy bien esa latop ya viejita... 

[que ahora duplicas]

Sigo trasteando con Calc analizando datos.


CONTAR.SI.CONJUNTO(B2:U20;">=50")

Me cuenta las celdas que (en el intervalo dado)  son mayores o iguales que 50.
Funciona de cine.

He intentado varias veces el modificarlo par que me cuente pares o impares dentro de un intervalo y no logro dar en el clavo.
Utilizando la funcion RESIDUO(B2:U20;2=1 impares o RESIDUO(B2:U20;2=0 pares
Creo que voy bien encaminado, pero no lo consigo...

Creo  que ya te lo comenté en este hilo (que ahora duplicas):

https://foro.elhacker.net/dudas_generales/excel_funcion_si-t509250.0.html;msg2252336#msg2252336

La función RESIDUO no funciona sobre rangos. Funciona SOLO SOBRE DOS OPERANDOS. No puedes pretender aplicar "RESIDUO" a un rango. SOLO A DOS OPERADORES: dividendo y divisor. Punto. Dividendo y divisor pueden ser dos números, o dos celdas, o un número y una celda. Punto. Ni dividendo ni divisor pueden ser un rango.

Así de simple: que "RESIDUO" no opera sobre rangos.
__________________________________________________________
¿No te funcionó lo que te comentó el forero MCKSys Argentina ?
¿Probaste lo de duplicar el rango que te comenté yo?

[youtube=640,360]https://www.youtube.com/watch?v=3028oDEKZo4[/youtube]

O un asteroide, véte a saber.  O alguna civilización extraterrestre. O la Humanidad suicidándose en masa cuando vea que la existencia no tiene sentido y que es de idiotas traer y traer y seguir trayendo más seres al mundo para que sigan muriendo y sigan trayendo seres al mundo que sigan muriendo y... O el Sol cuando se convierta en gigante roja. Por probabilidades sobre lo que pase antes, el asteroide gana por goleada (bueno no, parece que ahora el volcán, para el caso es lo mismo); después la Humanidad autosuicidándose (la estupidez humana no tiene límites así que ésto parece que va para largo)... por último el Sol transformándose en gigante roja... éso tardara bastante... ahora  que..¡de éso si que no escapa ni Dios!

Esto es como lo de los Testigos de Jehová. Cuando vienen y me dicen: se va a acabar el mundo. Yo le contesto: pues sí; justo el día que yo me muera... ¡ése mismo día se va a acabar el mundo!... Y no va a tardar ni 30 años.

Y es que lo que pase después... no es asunto mío.

NSHT

[EDITO]

Creo que en LibreOffice Calc (y me parece que en OpenOffice Calc es lo mismo) la función "RESIDUO" opera sobre dos argumentos, que pueden ser dos números, dos celdas, o un número y una celda (o celda y número). No funciona sobre rangos.

EDITO:
Ten en cuenta que los restos de dividir las celdas de un rango por un número serán diferentes, en general, y sin embargo una función no puede devolver más que un valor.

Se me ocurren otras formas de conseguir lo que quieres. Una con macros. Escribes una rutina que lea una por una las celdas del rango C2:U20, aplique a cada una de ellas la doble condición y cuando la cumplan acumule sobre una variable; y al final pase el valor de la variable a otra celda de la hoja.

O bien, si solo quieres emplear recursos de la hoja, sin macros, que crees un rango homólogo al C2:U20 en otra parte de la hoja. Cada celda de este nuevo rango le pones una función "SI" con la doble de condición de que la celda homóloga (del rango C2:U2) sea >0 y RESIDUO de celda/2 = 0 (o directamente empleando la función ESPAR), y si se cumple pones la celda a 1 y si no a 0. De este modo tienes las celdas de este segundo rango homólogo al primero a 0 o 1, según cumplan la doble condición las celdas del primer rango. Ahora aplicas el CONTAR.SI.CONJUNTO a las celdas de este segundo rango homólogo con la condición =1, y te dará el conteo de las celdas del primer rango que cumplen la doble condición.

Siguiendo las indicaciones aportadas por Serapis en  este hilo sobre la similtud de las permutaciones de "n" objetos con los números -en base "n"- de "n" dígitos, he escrito un código que creo funciona.

Al menos para 3-4 parece que lo hace correctamente; para más me es difícil saberlo porque visualmente y de memoria empiezan ya a ser muchas permutaciones. Pero por el aspecto visual conforme va calculando y por inducción -si funciona para n, debería de funcionar para n+1- parece que sí. Además he añadido unas líneas (no necesarias) para comprobar el nº total de permutaciones (líneas 14, 35, 45) y contrastarlo con n! y también concuerda.

Cosa distinta será la eficacia y por éso quería tener opiniones. Sobre que secuencias de código  son poco eficaces y cómo se podrían mejorar. Solo ideas generales, ni siquiera pseudo-código, no estoy pensando en escribir una aplicación como tal sino tener una idea de conjunto de cosas que no se deban hacer en programación.

Yo, algunas me huelo. Por ejemplo yo determino la 1ª y 2ª permutaciones porque la 1ª es el nº menor y la siguiente la misma permutando los dos elementos de menor orden (los 2 de la derecha). Pero a partir de ahí ya voy a saco aumentando 1 el nº y comprobando si es permutación o no. Imagino que (matemáticamente) se podrían saltar varios elementos, dependiendo de la base "n"; pero lo sé.

Otra cosa que me huelo que es mejorable es que yo para determinar si es una permutación o no, yo lo hago a cascoporro, comparo a partir del 2º elemento por la izquierda (el [1]) y hasta el último (el [n-1]) con todos los anteriores, y quizá éso haya formas de mejorarlo comparando por parejas o algo así, no sé.

También tras cada nueva permutación encontrada comprueba si es la última, para no seguir el bucle indefinidamente, pero a lo mejor habría alguna forma de ahorrar comprobaciones. A mí no se me ocurre. Solamente comprobar si el total es = a n!; pero éso no loquiero hacer (el cálculo que he hecho del total es solamente a efectos de contrastar si el código coincide con el nº que debe de salir).

Yo lo he intentado hacer lo más simple y legible posible, pero saber si habría otras maneras de hacerlo más legible o más eficaz. Siempre referido a este tipo de algoritmo, no a los otros que se comentaron en el hilo señalado. (Si me animo igual lo intento con el algoritmo que construye una permut. siguiente a una dada).

Código (c) [Seleccionar] Expandir

// Escribe las permutaciones de "n" elementos
#include <stdio.h>
#include <stdlib.h>

void imprime (int n,  int [] );
void cuenta_uno (int n, int []); // Aumenta 1 unidad al nº en base "n"
int es_permutacion (int n, int []); // Devuelve 1 si es permutación y 0 si no lo es

int main ()
{
int n, i;
int *digitos; // de un nº de "n" dígitos en base "n"
int suma_comprob;
int total_permut = 2; // Solo para comprobar si coincide con n! BORRAR*********

printf ("Introducir nº de elementos a permutar: ");
scanf ("%d", &n);
digitos = (int *) malloc ( n*sizeof (int) );
for (i = 0; i < n; ++i) // primera permutación
digitos[i] = i;
imprime (n, digitos);

i = digitos[n-2]; // segunda permutación
digitos[n-2] = digitos[n-1];
digitos[n-1] = i;
imprime (n, digitos);

// permutaciones subsiguientes
for (;;)
{
cuenta_uno (n, digitos);
if ( es_permutacion(n, digitos) )
{
imprime (n, digitos);
total_permut += 1; // BORRAR*********

// Comprueba si es última permutación
suma_comprob = 0;
for (i= 0; i < n; ++i)
if (digitos[i] == n-1 - i)
++suma_comprob;
if (suma_comprob == n)
{
free (digitos);
printf ("\nTotal permutaciones = %d\n", total_permut); // BORRAR*******
return 0;
}
}
}
}

void imprime (int n, int digitos[])
{
int i;
printf ("%d-", digitos[0]);
for (i = 1; i < n-1; ++i)
printf ("%d-", digitos[i]);
printf ("%d\n", digitos[n-1]);
}

void cuenta_uno (int n, int digitos[])
{
int posicion; // digito que se trata en un momento dado: [0], [1],...,[n-1]

posicion = n-1;
if (digitos[posicion] + 1 == n)
do
{
digitos[posicion]= 0;
posicion -= 1;
}
while (digitos[posicion] == n-1);
digitos[posicion] += 1;
}

int es_permutacion (int n, int digitos[])
{
int i, j;

// Se comprueba que todos los digitos[] sean distintos entre sí
for (i = 1; i < n; ++i)
for (j = 0; j < i; ++j)
if (digitos[i] == digitos[j])
return 0;
return 1;
}


https://www.elperiodico.com/es/sucesos/20211103/chico-conoce-chico-facebook-acaba-12617137

También hay que ser ingenuo para tener una relación meramente electrónica y confiar lo suficiente como para invertir dinero. Hay personas que van pidiendo a gritos que las estafen.