Recentemente, você fez uma conta em um site de apostas desonesto, onde por uma taxa de 25 dólares, eles pagarão uma quantia aleatória entre 0 e 50 dólares. Depois de receber cerca de 5 dólares duas vezes, você decide provar que o site é uma farsa. Depois de acessar o firewall externo com a senha padrão, você encontra o caminho para o servidor de banco de dados e descobre onde os valores dos valores mínimo e máximo são mantidos. Você decide conectar 25 '9's como o valor máximo, mas recebe uma mensagem de erro informando que o valor máximo deve ser do tipo' uint64 '. No entanto, agora você percebe que algumas teclas numéricas parecem não digitar corretamente no console remoto. O desafio aparece diante de você quase como se estivesse digitado em um site de perguntas e respostas.

usando apenas os programas convenientemente instalados para testar e executar seu idioma específico, gera o tamanho máximo de um valor inteiro não assinado de 64 bits; no entanto, quase tudo, exceto as ferramentas de programação, estão quebradas nesta máquina, deixando você sem o uso dos números 1, 2,4,6,8 - no código fonte ou nos literais, você também percebe que parece levar um tempo exponencialmente maior para executar o programa para cada pedaço adicional de código, portanto é melhor mantê-lo curto se quer ficar rico antes do desenho!

O desafio

• Escreva um programa que emita 18446744073709551615, o valor máximo de um número inteiro de 64 bits não assinado, como um número ou uma única sequência.

• Seu código-fonte não pode conter nenhum dos caracteres '1', '2', '4', '6' ou '8'

• se o seu idioma não tiver um número inteiro de 64 bits ou equivalente não assinado, a saída poderá estar no formato de sequência ou não, mas deve ser o número acima.

• esse é o código-golfe, então o código mais curto em cada idioma vence!

Cera de abelha , 3 bytes

_M{

Explicação:

_   # Create a bee going horizontally across the line, reading the code
 M  # Decrement the bee's counter, which starts at 0.
    # This will set the counter to 2^64-1, because as bees don't have a concept of
    # negative numbers, all values that are negative are translated to 2^64-n,
    # and in this case, n = -1, as we are calculating 0 - 1.
  { # Print the value

Experimente online!

Essa linguagem é perfeita para esse desafio.

Aqui está um extrato da página Esolang na cera de abelha :

Como todos sabem, as abelhas não têm um conceito de números negativos, mas descobriram que podem usar o endereço mais significativo para contornar isso. Assim, as coordenadas relativas à posição de uma abelha são realizadas pelos complementos das duas coordenadas. Dessa forma, metade do espaço de endereço de 64 bits está disponível para endereçamento local sem envolver em cada direção.

O endereço de complemento máximo positivo de dois bits de 64 bits é 9223372036854775807 ou 0x7fffffffffffffffff em hexadecimal de 64 bits. Todos os valores de 0 até esse valor são convertidos de maneira idêntica no mesmo valor de 64 bits. Todos os valores n na direção oposta (negativa) são convertidos em 2 ^ 64-n. Por exemplo: n = -1 é endereçado por 18446744073709551615. n = -9223372036854775808 é endereçado por 9223372036854775808.

Isso é basicamente longos não assinados.

EDIT: Eu ainda estou esperando Dennis me superar com uma solução de 2 bytes.

C, 26 bytes

main(){printf("%lu",~0l);}

Imprime um unsigned longvalor.

Requer o tamanho de long64 bits.

CJam (4 bytes)

GG#(

Demonstração online

Isso calcula 16 ¹⁶ - 1 usando builtin Gpara 16 e o ​​operador de decremento (.

Lisp comum SBCL de 64 bits, 18 bytes

most-positive-word

A palavra mais positiva no compilador de 64 bits é 64uint. É alguma coisa.

Python3 REPL, 12 bytes

No REPL: ~-(~-3<<9*7)

Fora do REPL: print~-(~-3<<9*7)<--> Python2!

Aqui está mais um aos 17 bytes: ~-(~-3<<ord("?")).

Explicação

Nada super chique. Aqui está dividido:

~-           | Subtract 1 from the next value.
  (          | 
   ~-3       | Subtract 1 from 3, resulting in 2
      <<     | Binary shift 2's digits to left,
        9*7  | by 9*7 (63).
           ) | The value inside the parentheses is now 2**64.

A expressão resultante é aproximadamente (mas não exatamente) ~-(2<<63)-> (2**64)-1. Eu uso o operador girino duas vezes aqui. Uma dica de golfe está aqui .

Também existe sys.maxintno Python2 que pode ser usado, mas não vou olhar para isso.

repl.it <- link de teste.

bc, 15 13 bytes

Economizou 2 bytes graças ao manatwork.

(a=9+7)^a-3/3

Nada extravagante, apenas (16 ^ 16) -1.

dc , 7 bytes

Acho que é permitido que os idiomas baseados em pilha deixem a resposta na célula superior da pilha, semelhante a um valor de retorno para funções. Se for necessária uma impressão explícita, adicione pno final do código.

AZ5E^z-

Experimente online!

Ele calcula (2 ⁶⁴ - 1) usando vários truques:

• 2é dado como o número de dígitos ( Z) encontrado no número inteiro 10 ( A)

• 64é dado como 5E. Por padrão, dc usa 10 como a raiz de entrada. Mesmo assim, ele pode aceitar números em notação hexadecimal, mas eles serão convertidos de maneira diferente do que você esperaria. Exemplo: (5E) _padrão = (5E) _{(raiz de entrada = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1é dado como a profundidade da pilha ( z), uma vez que apenas (2 ⁶⁴ ) estava presente

História alternativa:

No entanto, agora você percebe que algumas teclas numéricas parecem não digitar corretamente no console remoto. Você respira fundo e começa a testar cada tecla numérica. É pior do que você pensou! Nem um único funciona, e você terá a tarefa de produzir o número inteiro desejado usando apenas letras e símbolos.

Solução em dc: computing (16 ¹⁶ - 1), ainda 7 bytes!

Fz+d^z-          # push 15, push 1, add, duplicate, exponentiate, push 1, subtract

Experimente online!

Gelatina , 4 bytes

⁴*`’

Experimente online!

Explicação

⁴     # 16
 *    # exponentiate
  `   # last link as a monad, repeating the argument
   ’  # decrement

05AB1E , 4 bytes

žJn<

Explicação:

žJ   # Push 4294967296
  n  # Squared
   < # Decreased by one

Finalmente! Uma chance de usar 05AB1Eos componentes internos para poderes de dois!

Experimente online!

Outra resposta de 4 bytes:

žxo<

Explicação:

  o  # 2 to the power of
žx   # 64
   < # Decreased by one

Experimente online!

(se alguém estiver se perguntando, essa pergunta é anterior a todas as outras respostas de 4 bytes)

MATLAB / oitava, 5 bytes

A @Sanchises postou uma excelente resposta do MATLAB, no entanto, essa é uma abordagem consideravelmente diferente, então eu a postarei de qualquer maneira:

tic/0

No MATLAB, ticretorna o número de milissegundos passado desde que o programa foi aberto. Crucialmente, o valor que ele retorna é um uint64tipo. Isso uint64evita a necessidade de converter um número para o tipo padrão de MATLABs double.

Qualquer número dividido por 0 no MATLAB é considerado infinito, o que, para tipos de ponto não flutuante, MATLAB representa isso como o valor inteiro máximo para esse tipo.

Isso também funciona com o Octave, mas dependendo do intérprete usado, ele também pode emitir um aviso de "divisão por zero". Você pode tentar o código online aqui, porém, como eu digo, você recebe um aviso / 0 que não aparece no MATLAB.

bc ,18, 16 bytes

• 2 bytes salvos, thx @MrScapegrace

(9-7)^(55+9)-3/3

PHP, 16 bytes

Isso é muito parecido com a resposta do Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Para que isso funcione, você precisa estar em uma arquitetura de 64 bits. Isso ocorre porque ~ 0 é -1, que é 1111111111111111111111111111111111111111111111111111111111111111 em binário, em 64 bits, comparado com 11111111111111111111111111111111 em 32 bits, e os números dependem da plataforma - Ismael Miguel

MATLAB / oitava, 22 bytes

eye(['~rw}?='-9 ''])/0

Experimente online!

eyeé usado para criar uma matriz unitária (matriz 1na diagonal, zero caso contrário). Sem argumentos, isso cria uma 1x1matriz unitária ou, em outras palavras, apenas a 1. É necessário um argumento opcional, que é o tipo de dados ('classe' na terminologia MATLAB) da matriz criada. Assim, pedimos uma 1classe uint64e dividimos por zero, o que resulta Infem MATLAB, que é cortado em intmax('uint64').

O vetor é ['~rw}?='-9 '']avaliado como 'uint64'. Concatenar um caractere vazio para um vetor é 1 byte menor que o uso char('~rw}?='-9).

Raciocínio em relação a esta resposta: o built-in intmaxinfelizmente avalia até o máximo de um número inteiro assinado de 32 bits. A próxima opção óbvia é uint64(), que contém os caracteres proibidos. A alternativa é usar uma função que aceita uma string como um tipo de dados. Os candidatos óbvios são intmaxe cast, mas as alternativas incluem zeros, onese eye.

eye(['~rw}?='-9 ''])/0    % Winning version! 22 bytes.
intmax(['~rw}?='-9 ''])   % Obvious candidate. 23 bytes.
1/zeros(['~rw}?='-9 ''])  % 24 bytes
cast(Inf,['~rw}?='-9 '']) % 25 bytes. Also an obvious candidate, but actually very long.

^{Nota: O MATLAB é instalado por padrão em praticamente todos os sites de apostas desonestos.}

JavaScript, 39 38 33 32 bytes

alert(0xafebff0+'737095'+0xc99f)

Editar: salvou 5 bytes graças a @Arnauld.

Java 8, 30 bytes

()->Long.toUnsignedString(~0L)

Teste on-line

BF, 108 bytes

-[----->+<]>--.+++++++.----..++.+.---..----.+++++++.----.++++.-------.+++++++++.----..----.+++++.-----.++++.

Se cada comando for considerado como 3 bits, isso é potencialmente 41 bytes.

Retina , 28 27 bytes

Guardado 1 byte graças a Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Experimente online!

Explicação

bieegheeahdhajffbgbf

Substitui a entrada inexistente / vazia por esta sequência. Essa seqüência específica foi gerada pelo "inverso" deste programa. Ele codifica aatravés de jcomo 0através 9, respectivamente.

T`l`d

Este é um Testágio de ransliteração. Os conjuntos de caracteres le dsão usados ​​para transliteração. lrepresenta o alfabeto em minúsculas, dé todos os dígitos. Então, ele mapeia de abcdefghijvolta para 0123456789.

C ++, 46 bytes.

int m(){std::cout<<unsigned long long(5+3-9);}

É a primeira vez que faço golfe de código, mas estou bastante feliz comigo mesma. Terá todo o gosto em receber críticas / sugestões :)

Brain-Flak , 64, 62, 58 , 54 bytes

(((((()()()()){}){}){}){}){({}<(({}()){}[()])>[()])}{}

Experimente online!

[Experimente online!]

Quatro bytes salvos graças ao @Riley!

Explicação:

#Push a 64
(((((()()()()){}){}){}){})

#While true
{

  #Pop the top of the stack. We'll store this value for later, but first
  ({}

  #Before pushing the value
  <

    #Push (N + 1) * 2 - 1
    # (where N is the number underneath, originally 0)
    (({}()){}[()])

  >

  #And push the TOS minus one back on
  [()])

#endwhile
}

#Pop the zero left over
{}

#And decrement the number underneath
({}[()])

Para o registro, tentei empurrar 32 e quadruplicar, mas é a mesma contagem de bytes.

C # 6, 31 bytes

()=>System.Console.Write(~0UL);

Praticamente o mesmo que Java.

C # 5, 56 bytes

class P{static void Main(){System.Console.Write(~0UL);}}

Quarto (gforth), 11 9 7 bytes

true U.

Experimente online

trueé o mesmo que -1. U.imprime um número como um número inteiro não assinado.

Isso funciona no TIO, possivelmente por ter uma arquitetura de 64 bits? Não tenho certeza. Se eu executar -1 U.no repl.it, por exemplo, recebo 2 ** 32-1. Se repl.it suportasse números inteiros de comprimento duplo, seria necessário produzi-los UD..

Python3 REPL, 11 bytes

~0^~0>>~077

Como funciona

• ~ 0 é -1 (complemento de dois, uma sequência infinita de '1's)
• 077 é 63 em octal, então ~ 077 é -64
• Deslocar para a direita com parâmetro negativo é um deslocamento para a esquerda
• Juntando tudo, -1 xor (-1 << 64) é o número que estamos procurando

PowerShell , 29 14 bytes

0xC000PB/3-3/3

Experimente online!

Graças a @ n0rd por essencialmente jogar isso ao meio.

Isso aproveita o PBoperador unário embutido que basicamente funciona como "multiplique o número anterior por 1125899906842624" (ou seja, quantos bytes estão em um pebibyte). Isso é acoplado ao hexadecimal 0xC000, ou 49152mais 49152 pebibytes. Dividimos isso por 3, produzindo 18446744073709551616e subtraímos 3/3para obter o valor final.

JavaScript (ES6), 50 bytes

[...'䠎ᴐIF╏ɧ'].map(s=>s.charCodeAt()).join``

Montagem x64, 7 bytes

hex (montado): 4831C048FFC8C3

desmontado, comentou:
XOR RAX,RAX ;Zero the value of 64 bit register RAX DEC RAX ;Decrement the value of RAX RET ;Return this value

O RAX é um registro de 64 bits e é mais frequentemente usado para retornar argumentos inteiros (por exemplo, C). Ao decrementar 1, seu valor passa de 0 a ... 2 ^ 64-1, o que é exatamente necessário.
No entanto, o binário montado contém uns e quatro e oito, a montagem não, mas o arquivo montado é contado na montagem, então conta? Ai, minha cabeça.
Além disso, a saída é um valor de retorno neste caso.

Flak cerebral , 223 193 bytes

Inclui +1 por -A
-30 graças a DJMcMayhem

((((((((((((((((((((((((()()()){}){}()){}){}())[()()()()])[][]())[[]()()])[]))()()()())[[]()()])[][()])[()()()()])()()()())[(()()()){}()])()()()()))()()())[()])[()()]))()()()())[(()()()){}()])

Experimente online!

Isso apenas pressionou os valores ASCII e imprime como caracteres.

Para referência, são necessários 338 bytes para gerar o número real usando o meta-jogador inteiro .

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()){}()){}){}()){}()){({}[()])}{}()){}()){}())){}{})){}{})()){}{})){}{})){}{})()){}{})){}{})){}{}){}){}())){}{}){}())()){}{})){}{}){}){}){}())()){}{})()){}{})){}{}){}())){}{})()){}{})){}{})){}{})){}{})()){}{})()){}{})){}{}){}())){}{}){}){}())()){}{})()){}{})){}{})

Experimente Online!

MATL, 8 bytes

l_5Z%EZD

Provavelmente isso poderia ser melhorado, mas ainda não estou familiarizado com seqüências e tipos de MATL.

Experimente em matl.suever.net

Explicação:

l       % push 1
_       % unary minus
5       % push 5, corresponds to type 'uint64'
Z%      % convert 1 to this type
E       % double
ZD      % display as a string

Javascript 55 bytes

alert(""+(590300>>5)+(59530-3>>3)+7370955+(3*59*73>>3))

o código gera e alerta a sequência 18446744073709551615 usando operações bit a bit

590300 >> 5 18446
59530-3 >> 3 7440
7370955
3 * 59 * 73 >> 3 1615

Rápido, 8 bytes

UInt.max

playground externo / repl - 15 bytes

print(UInt.max)

TI-Basic, 10 bytes

9+7
Ans^Ans-0!