quanto tempo leva um PC para contar até um trilhão

Esta é uma pergunta que veio após uma discussão com um colega sobre uma empresa que vale mais de 20 triliões de dólares – e nós simplesmente não podíamos imaginar como seria esse dinheiro em dinheiro. Só para ter uma idéia disso, calculamos quantas notas de cem dólares seriam necessárias para circundar a terra uma vez – a resposta foi que eu acredito que cerca de 240.000.000, ou seja, cerca de 24 bilhões de dólares americanos. É muito dinheiro. Quanto é preciso uma pessoa para contar tanto dinheiro? Ninguém pode ter a certeza.

mas podemos causar uma boa impressão de quanto seria preciso um computador para contar até um trilhão. Para simplesmente iterar, nenhuma outra acção no meio. Para que eu escrevi um simples pedaço de código que mede o quanto é preciso para contar até um milhão e, em seguida, faz uma matemática simples para calcular quanto seria necessário para a contagem até valores diferentes e, em seguida, exibe os resultados de uma forma amigável, usando um método de cortesia do StackOverflow.os resultados são interessantes. E a resposta é:: depende da tua máquina. Mesmo na mesma máquina você vai obter resultados diferentes, dependendo da carga. Mas vamos olhar o meu um pouco:

• um bilhão (9 zeros) está sendo alcançado rápido – 15 segundos
• mas, para chegar a um trilhão (12 zeros) – a diferença é incrível – 4 horas e 10 minutos. Basicamente 1000 vezes mais.
• as diferenças ficam ainda mais impressionante quando subimos para o quatrilhões (15 zeros) que poderiam levar 173 dias e, em seguida, quintillions (18 zeros) o que levaria a 475 anos
• o último para o qual eu fiz a matemática é uma sextillion (21 zeros) e prepare – levaria meu laptop exatamente 7708 anos, 292 dias, 6 horas, 43 minutos e 52 segundos para iterar até esse valor.

Como eu disse-Estes valores dependem muito da máquina. Então você pode tentar você mesmo e talvez compartilhar os resultados. Código abaixo:

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 tal iterar através de todos os guias?

então, no verdadeiro espírito de um engenheiro, eu mudei para outro assunto – totalmente relacionado (para mim) – a singularidade dos guias. Eu já me tinha perguntado o quão único um GUID realmente é. E, de certa forma, recebi a minha resposta na altura, mas agora acho que é ainda mais claro.

para iniciar – GUIDs são geralmente representados como 32 dígitos hexadecimais-o que significa 10 mais dígitos do que um sixtilião. Então novamente, cada um dos dígitos em um GUID pode ter valores de 0 A F (16 valores) em comparação com um inteiro normal que só permite 0 a 9 (ou seja, 10 valores). E onde no exemplo anterior é contabilizado até apenas um, aqui nós iremos até F.

Então, se minha matemática é correta, nós tomamos o tempo de sixtillion (7708 anos), multiplique-o por 10.000.000.000 (dez zeros), seguida por 1,6 – existem mais de 1,6 valores para cada dígito – e, em seguida, por 16 (F).isso é cerca de 1.973.248.000.000 anos-o que significa 1.973.248 milhões de milênios. É o quanto levaria o meu portátil para iterar todos os valores possíveis de um GUID. Quão único é isso?