hvor lang tid tager det en PC at tælle til en billion

dette er et spørgsmål, der kom efter en diskussion med en kollega om et firma til en værdi af over 20 billioner dollars – og vi kunne bare ikke forestille os, hvordan så mange penge ville se ud i kontanter. Bare for at få en ide om det beregnede vi, hvor mange hundrede dollarsedler det ville tage at cirkulere jorden en gang – svaret var, at jeg tror omkring 240.000.000, hvilket betyder omkring 24 milliarder amerikanske dollars. Det er mange penge. Hvor meget ville det tage en person at tælle så mange penge? Nå, ingen kan sige med sikkerhed.

men vi kan gøre et ret godt indtryk af, hvor meget det ville tage en computer at tælle op til en billion. For blot at gentage, ingen anden handling imellem. Til det har jeg skrevet et simpelt stykke kode, der måler, hvor meget det tager at tælle op til en million, og derefter gør nogle enkle matematik for at estimere, hvor meget det ville tage at tælle op til forskellige værdier og derefter viser resultaterne på en venlig måde ved hjælp af en metode med tilladelse til Stackoverløb.

resultaterne er interessante. Og svaret er: det afhænger af din maskine. Selv på samme maskine får du forskellige resultater afhængigt af belastningen. Men lad os se lidt på min:

• en milliard (9 nuller) nås hurtigt – 15 sekunder
• men for at komme til en billioner (12 nuller) – forskellen er fantastisk – 4 timer og 10 minutter. Dybest set 1000 gange mere.
• forskellene bliver endnu mere imponerende, da vi går op til kvadrillioner (15 nuller), hvilket ville tage 173 dage og derefter kvintillioner (18 nuller), hvilket ville tage 475 år
• den sidste, som jeg gjorde matematikken til, er en sekstillion (21 nuller) og gør dig klar – det ville tage min bærbare computer nøjagtigt 7708 år, 292 dage, 6 timer, 43 minutter og 52 sekunder at gentage op til den værdi.

som jeg har sagt – disse værdier afhænger meget af maskinen. Så du kan prøve det selv og måske dele resultaterne. Kode nedenfor:

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

hvad med at gentage gennem alle GUID ‘ erne?

derefter skiftede jeg i en ingeniørs sande ånd til et andet emne – helt relateret (for mig) – det unikke ved GUIDs. Jeg havde tidligere spurgt mig selv, hvor unik en GUID faktisk er. Og jeg fik noget mit svar dengang, men nu synes jeg det er endnu mere klart.

for at starte – GUID ‘ er er normalt repræsenteret som 32 seksadecimale cifre – hvilket betyder 10 flere cifre end en sekstillion. Så igen kan hvert af cifrene i en GUID have værdier fra 0 til F (16 værdier) sammenlignet med et normalt heltal, som kun tillader 0 til 9 (hvilket betyder 10 værdier). Og hvor vi i det foregående eksempel tællede op til kun en, her går vi op til F.

så hvis min matematik er korrekt, tager vi tiden fra sekstillionen (7708 år) – multiplicer den med 10.000.000.000 (de ti nuller), derefter med 1,6 – der er 1,6 flere værdier for hvert ciffer – og derefter med 16 (f).

det er omkring 1.973.248.000.000.000 år – hvilket betyder 1.973.248 millioner årtusinder. Det er, hvor meget det ville tage min bærbare computer at gentage gennem alle mulige værdier af en GUID. Hvor unikt er det nu?