Cuánto tiempo tarda una PC en contar hasta un billón

Esta es una pregunta que surgió después de una discusión con un colega sobre una empresa que vale más de 20 billones de dólares, y no podíamos imaginar cómo se vería esa cantidad de dinero en efectivo. Solo para tener una idea de ello calculamos cuántos billetes de cien dólares se necesitarían para rodear la Tierra una vez – la respuesta fue que creo que alrededor de 240.000.000, lo que significa alrededor de 24 mil millones de dólares estadounidenses. Eso es mucho dinero. ¿Cuánto le costaría a una persona contar tanto dinero? Bueno, nadie puede decirlo con seguridad.

Pero podemos dar una buena impresión de cuánto le tomaría a una computadora contar hasta un billón. Para simplemente iterar, no hay otra acción en el medio. Para eso he escrito un simple fragmento de código que mide cuánto se necesita para contar hasta un millón y luego hace algunas matemáticas simples para estimar cuánto se necesitaría para contar hasta diferentes valores y luego muestra los resultados de una manera amigable utilizando un método cortesía de StackOverflow.

Los resultados son interesantes. Y la respuesta es: depende de tu máquina. Incluso en la misma máquina obtendrá resultados diferentes dependiendo de la carga. Pero veamos el mío un poco:

• se está alcanzando rápidamente un billón (9 ceros), 15 segundos
• , pero para llegar a un billón (12 ceros), la diferencia es increíble: 4 horas y 10 minutos. Básicamente 1000 veces más.
• las diferencias se vuelven aún más impresionantes a medida que subimos a cuatrillones (15 ceros) que tomarían 173 días y luego quintillones (18 ceros) que tomarían 475 años
• el último para el que hice las matemáticas es un sextillón (21 ceros) y me prepararía: tomaría exactamente 7708 años, 292 días, 6 horas, 43 minutos y 52 segundos iterar hasta ese valor.

Como he dicho – estos valores dependen mucho de la máquina. Así que puedes probarlo tú mismo y tal vez compartir los resultados. Código a continuación:

static void Main(string args){ var startTimestamp = DateTime.Now; for (int i = 0; i <= 1000000; i++); var elapsedTime = DateTime.Now - startTimestamp; Console.WriteLine(string.Format("{0} for 1 billion (9 zeros),", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000)))); Console.WriteLine(string.Format("{0} for 1 trillion (12 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000)))); Console.WriteLine(string.Format("{0} for 1 quadrillion (15 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000)))); Console.WriteLine(string.Format("{0} for 1 quintillion (18 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000000)))); Console.WriteLine(string.Format("and {0} for it to count up to 1 sextillion (21 zeros).", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000000000)))); Console.ReadKey();} private static string GetReadableString(TimeSpan span){ string formatted = string.Format("{0}{1}{2}{3}{4}", span.Duration().Days > 364 ? string.Format("{0:0} year{1}, ", span.Days / 365, span.Days == 365 ? string.Empty : "s") : string.Empty, span.Duration().Days > 0 ? string.Format("{0:0} day{1}, ", span.Days % 365, span.Days % 365 == 1 ? String.Empty : "s") : string.Empty, span.Duration().Hours > 0 ? string.Format("{0:0} hour{1}, ", span.Hours, span.Hours == 1 ? String.Empty : "s") : string.Empty, span.Duration().Minutes > 0 ? string.Format("{0:0} minute{1}, ", span.Minutes, span.Minutes == 1 ? String.Empty : "s") : string.Empty, span.Duration().Seconds > 0 ? string.Format("{0:0} second{1}", span.Seconds, span.Seconds == 1 ? String.Empty : "s") : string.Empty); if (formatted.EndsWith(", ")) formatted = formatted.Substring(0, formatted.Length - 2); if (string.IsNullOrEmpty(formatted)) formatted = "0 seconds"; return formatted;}

¿Qué tal iterar a través de todos los GUID?

Entonces, en el verdadero espíritu de un ingeniero, cambié a otro tema-totalmente relacionado (para mí) – la singularidad de los GUID. Anteriormente me había preguntado cuán único es en realidad un GUID. Y de alguna manera obtuve mi respuesta en ese entonces, pero ahora creo que es aún más clara.

Para empezar, los GUID se representan generalmente como 32 dígitos hexadecimales, lo que significa 10 dígitos más que un seis millones. Por otra parte, cada uno de los dígitos en un GUID puede tener valores de 0 a F (16 valores) en comparación con un entero normal que solo permite de 0 a 9 (es decir, 10 valores). Y donde en el ejemplo anterior contamos hasta solo uno, aquí subiremos a F.

Así que si mi matemática es correcta, tomamos el tiempo de los seis billones (7708 años) – lo multiplicamos por 10.000.000.000 (los diez ceros), luego por 1.6 – hay 1.6 más valores para cada dígito – y luego por 16 (F).

Eso es aproximadamente 1.973.248.000.000.000 años, lo que significa 1.973.248 millones de milenios. Eso es lo mucho que me llevaría a mi portátil iterar a través de todos los valores posibles de un GUID. ¿Qué tan único es eso?