Quanto tempo ci vuole un PC per contare fino a un trilione

Questa è una domanda che è arrivata dopo una discussione con un collega su una società del valore di oltre 20 trilioni di dollari – e non potevamo immaginare come sarebbero tanti soldi in contanti. Solo per avere un’idea di esso abbiamo calcolato quante centinaia di banconote da un dollaro ci vorrebbe per circondare la Terra una volta – la risposta è stata credo intorno 240.000.000 che significa circa 24 miliardi di dollari USA. Sono un sacco di soldi. Quanto ci vorrebbe una persona per contare così tanti soldi? Beh, nessuno può dirlo con certezza.

Ma possiamo fare una buona impressione di quanto ci vorrebbe un computer per contare fino a un trilione. Per semplicemente iterare, nessun’altra azione in mezzo. Per questo ho scritto un semplice pezzo di codice che misura quanto ci vuole per contare fino a un milione e poi fa un po ‘ di matematica semplice per stimare quanto ci vorrebbe per contare fino a valori diversi e quindi visualizza i risultati in modo amichevole usando un metodo per gentile concessione di StackOverflow.

I risultati sono interessanti. E la risposta è: dipende dalla vostra macchina. Anche sulla stessa macchina si ottengono risultati diversi a seconda del carico. Ma diamo un’occhiata al mio per un po’:

• un miliardo (9 zeri) viene raggiunto velocemente – 15 secondi
• ma per arrivare a un trilione (12 zeri) – la differenza è sorprendente – 4 ore e 10 minuti. Fondamentalmente 1000 volte di più.
• le differenze ancora più incredibile, come si va fino a biliardi (15 zeri) che sarebbe 173 giorni e poi quintillions (18 zeri) che sarebbe 475 anni
• l’ultimo per il quale ho fatto la matematica è uno sestilione (21 zeri) e di ottenere pronto, sarebbe il mio portatile esattamente 7708 anni, 292 giorni, 6 ore, 43 minuti e 52 secondi per scorrere fino a tale valore.

Come ho detto – questi valori dipendono molto dalla macchina. Così si può fare un tentativo da soli e magari condividere i risultati. Codice qui sotto:

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

Che ne dici di iterare tutti i GUID?

Poi, nel vero spirito di un ingegnere, sono passato a un altro argomento – totalmente correlato (per me) – l’unicità dei GUID. In precedenza mi ero chiesto quanto fosse unico un GUID. E in qualche modo ho avuto la mia risposta allora, ma ora penso che sia ancora più chiaro.

Per iniziare – i GUID sono solitamente rappresentati come 32 cifre esadecimali, ovvero 10 cifre in più rispetto a un sestiglione. Poi di nuovo, ciascuna delle cifre in un GUID può avere valori da 0 a F (16 valori) rispetto a un numero intero normale che consente solo da 0 a 9 (ovvero 10 valori). E dove nell’esempio precedente abbiamo contato fino a uno solo, qui andremo fino a F.

Quindi se la mia matematica è corretta, prendiamo il tempo dal sestiglione (7708 anni) – moltiplicalo per 10.000.000.000 (i dieci zeri), quindi per 1.6 – ci sono 1.6 più valori per ogni cifra – e poi per 16 (F).

Si tratta di 1.973.248.000.000.000 di anni – il che significa 1.973.248 milioni di millenni. Questo è quanto ci vorrebbe il mio portatile per iterare attraverso tutti i possibili valori di un GUID. Ora, come unico è che?