Combien de temps faut-il à un PC pour compter jusqu’à un billion

C’est une question qui est venue après une discussion avec un collègue sur une entreprise valant plus de 20 billions de dollars – et nous ne pouvions tout simplement pas imaginer à quoi ressemblerait autant d’argent en espèces. Juste pour nous en faire une idée, nous avons calculé combien de billets de cent dollars il faudrait pour faire le tour de la Terre une fois – la réponse était je crois autour de 240.000.000, ce qui signifie environ 24 milliards de dollars américains. C’est beaucoup d’argent. Combien faudrait-il à une personne pour compter autant d’argent? Personne ne peut le dire avec certitude.

Mais nous pouvons faire une assez bonne impression de combien il faudrait un ordinateur pour compter jusqu’à un billion. Pour simplement itérer, aucune autre action entre les deux. Pour cela, j’ai écrit un simple morceau de code qui mesure combien il faut pour compter jusqu’à un million, puis fait des calculs simples pour estimer combien il faudrait pour compter jusqu’à différentes valeurs, puis affiche les résultats de manière conviviale en utilisant une méthode gracieuseté de StackOverflow.

Les résultats sont intéressants. Et la réponse est: cela dépend de votre machine. Même sur la même machine, vous obtiendrez des résultats différents en fonction de la charge. Mais regardons le mien un peu:

• un milliard (9 zéros) est atteint rapidement – 15 secondes
• mais pour arriver à un billion (12 zéros) – la différence est incroyable – 4 heures et 10 minutes. Fondamentalement 1000 fois plus.
• les différences deviennent encore plus impressionnantes à mesure que nous passons aux quadrillions (15 zéros), ce qui prendrait 173 jours, puis aux quintillions (18 zéros), ce qui prendrait 475 ans
• le dernier pour lequel j’ai fait le calcul est un sextillion (21 zéros) et préparez–vous – il faudrait exactement 7708 ans, 292 jours, 6 heures, 43 minutes et 52 secondes à mon ordinateur portable pour itérer jusqu’à cette valeur.

Comme je l’ai dit – ces valeurs dépendent beaucoup de la machine. Vous pouvez donc essayer vous-même et peut-être partager les résultats. Code ci-dessous:

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

Que diriez-vous de parcourir tous les GUID?

Puis, dans le vrai esprit d’un ingénieur, je suis passé à un autre sujet – totalement lié (pour moi) – l’unicité des GUID. Je m’étais déjà demandé à quel point un GUID est unique. Et j’ai un peu eu ma réponse à l’époque, mais maintenant je pense que c’est encore plus clair.

Pour commencer, les GUID sont généralement représentés par 32 chiffres hexadécimaux– ce qui signifie 10 chiffres de plus qu’un sixtillion. Là encore, chacun des chiffres d’un GUID peut avoir des valeurs de 0 à F (16 valeurs) par rapport à un entier normal qui n’autorise que 0 à 9 (ce qui signifie 10 valeurs). Et là où dans l’exemple précédent nous avons compté jusqu’à un seul, ici nous irons jusqu’à F.

Donc si mes calculs sont corrects, nous prenons le temps à partir du sixtillion (7708 ans) – multipliez–le par 10.000.000.000 (les dix zéros), puis par 1,6 – il y a 1,6 plus de valeurs pour chaque chiffre – puis par 16 (F).

C’est environ 1.973.248.000.000.000 d’années – ce qui signifie 1.973.248 millions de millénaires. C’est combien il faudrait à mon ordinateur portable pour parcourir toutes les valeurs possibles d’un GUID. Maintenant, à quel point est-ce unique?