Hoe lang duurt het voor een PC telt tot een biljoen

Dit is een vraag die kwam na een discussie met een collega over een bedrijf ter waarde van meer dan 20 biljoen dollar – en we konden ons gewoon niet voorstellen hoe veel geld er in contanten uit zou zien. Om er een idee van te krijgen hebben we berekend hoeveel honderd dollarbiljetten er nodig zouden zijn om eenmaal om de aarde te cirkelen – het antwoord was volgens mij rond 240.000.000 wat ongeveer 24 miljard dollar betekent. Dat is veel geld. Hoeveel kost iemand om zoveel geld te tellen? Niemand kan het met zekerheid zeggen.

maar we kunnen een vrij goede indruk maken van hoeveel een computer nodig heeft om tot een biljoen te tellen. Gewoon herhalen, geen andere actie ertussen. Daarvoor heb ik een eenvoudig stukje code geschreven die meet hoeveel het kost om te tellen tot een miljoen en dan doet wat eenvoudige wiskunde om te schatten hoeveel het zou duren om te tellen tot verschillende waarden en geeft vervolgens de resultaten op een vriendelijke manier met behulp van een methode hoffelijkheid van StackOverflow.

de resultaten zijn interessant. En het antwoord is: dat hangt van je machine af. Zelfs op dezelfde machine krijgt u verschillende resultaten, afhankelijk van de belasting. Maar laten we eens kijken naar de mijne voor een beetje:

• een miljard (9 nullen) wordt snel bereikt – 15 seconden
• maar om een biljoen (12 nullen) – het verschil is verbazingwekkend – 4 uur en 10 minuten. In principe 1000 keer meer.
• de verschillen worden nog indrukwekkender als we omhoog gaan naar quadrillions (15 nullen) wat 173 dagen zou duren en dan quintillions (18 nullen) wat 475 jaar zou duren
• de laatste waarvoor ik de berekening deed is één sextillion (21 nullen) en maak je klaar – het zou mijn laptop precies 7708 jaar, 292 dagen, 6 uur, 43 minuten en 52 seconden kosten om tot die waarde te herhalen.

zoals ik al zei-deze waarden hangen sterk af van de machine. Dus je kunt het zelf proberen en misschien de resultaten delen. Code hieronder:

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;}

wat dacht je van itereren door alle GUIDs?

toen, in de ware geest van een ingenieur, schakelde ik over op een ander onderwerp – totaal gerelateerd (voor mij) – de uniciteit van GUIDs. Ik had me eerder afgevraagd hoe uniek een GUID eigenlijk is. En ik kreeg toen een beetje mijn antwoord, maar nu denk ik dat het nog duidelijker is.

naar start-GUIDs worden meestal weergegeven als 32 hexadecimale cijfers – dat wil zeggen 10 meer cijfers dan een zestiljoen. Aan de andere kant kan elk van de cijfers in een GUID waarden hebben van 0 tot F (16 waarden) in vergelijking met een normaal geheel getal dat alleen 0 tot 9 toestaat (wat 10 waarden betekent). En waar we in het vorige voorbeeld tot slechts één geteld hebben, gaan we hier tot F.

dus als mijn wiskunde correct is, nemen we de tijd van het zestiljoen (7708 jaar) – vermenigvuldig het met 10.000.000.000 (de tien nullen), dan met 1,6 – er zijn 1,6 meer waarden voor elk cijfer – en dan met 16 (F).

dat is ongeveer 1.973.248.000.000.000 jaar-wat betekent 1.973.248 miljoen millennia. Dat is hoeveel het nodig zou zijn om mijn laptop te herhalen door alle mogelijke waarden van een GUID. Hoe uniek is dat?