Recientemente ha creado una cuenta en un sitio de apuestas poco fiable, donde por una tarifa de 25 dólares, le reembolsarán una cantidad aleatoria entre 0 y 50 dólares. Después de obtener alrededor de 5 dólares dos veces, decide probar que el sitio es una estafa. Después de acceder a su cortafuegos externo con la contraseña predeterminada, puede acceder al servidor de su base de datos y encontrar dónde se encuentran los valores para las cantidades mínima y máxima. Decide conectar 25 '9 como valor máximo, pero recibe un mensaje de error que dice que el valor máximo debe ser del tipo' uint64 '. Sin embargo, es ahora cuando observa que algunas teclas numéricas no parecen escribirse correctamente en la consola remota. El desafío aparece ante usted casi como si estuviera escrito en un sitio de preguntas y respuestas.

usando solo los programas convenientemente instalados para probar y ejecutar su idioma en particular, genera el tamaño máximo de un valor entero de 64 bits sin signo, sin embargo, casi todo, excepto las herramientas de programación, se rompen en esta máquina, dejándolo sin el uso de los números 1, 2,4,6,8, ya sea en código fuente o en literales, también se da cuenta de que parece llevar una cantidad de tiempo exponencialmente más largo ejecutar el programa para cada pieza adicional de código, por lo que será mejor que se mantenga breve si quiero hacerse rico antes del sorteo!

El reto

• Escriba un programa que genere 18446744073709551615, el valor máximo de un entero de 64 bits sin signo, ya sea como un número o como una sola cadena.

• Su código fuente no puede contener ninguno de los caracteres '1', '2', '4', '6' u '8'

• Si su idioma no tiene un entero de 64 bits sin signo o equivalente, la salida puede estar en formato de cadena o de otro modo, pero debe ser el número anterior.

• Este es el código de golf, ¡el código más corto en cada idioma gana!

Cera de abejas , 3 bytes

_M{

Explicación:

_   # 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

Pruébalo en línea!

Este lenguaje es perfecto para este desafío.

Aquí hay un extracto de la página de Esolang en cera de abejas :

Como todos saben, las abejas no tienen un concepto de números negativos, pero descubrieron que pueden usar la parte más significativa de una dirección para evitar eso. Por lo tanto, las coordenadas relativas a la posición de una abeja se realizan por los dos complementos de las coordenadas. De esta forma, la mitad del espacio de direcciones de 64 bits está disponible para direccionamiento local sin envoltura en cada dirección.

La dirección máxima del complemento positivo de dos de 64 bits es 9223372036854775807 o 0x7fffffffffffffff en 64 bits hexadecimales. Todos los valores desde 0 hasta este valor se traducen idénticamente al mismo valor de 64 bits. Todos los valores n en la dirección opuesta (negativa) se traducen en 2 ^ 64-n. Por ejemplo: n = -1 se aborda en 18446744073709551615. n = -9223372036854775808 se aborda en 9223372036854775808.

Esto es básicamente largos sin firmar.

EDITAR: Todavía espero que Dennis me supere con una solución de 2 bytes.

C, 26 bytes

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

Imprime un unsigned longvalor.

Requiere que el tamaño longsea ​​de 64 bits.

CJam (4 bytes)

GG#(

Demostración en línea

Esto calcula 16 ¹⁶ - 1 usando builtin Gpara 16 y el operador de disminución (.

SBCL común de 64 bits, 18 bytes

most-positive-word

La palabra más positiva en el compilador de 64 bits es 64uint. Es algo.

Python3 REPL, 12 bytes

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

Fuera de REPL: print~-(~-3<<9*7)<--> Python2!

Aquí hay otro a los 17 bytes: ~-(~-3<<ord("?")).

Explicación

Nada súper lujoso. Aquí está desglosado:

~-           | 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.

La expresión resultante es aproximadamente (pero no del todo) ~-(2<<63)-> (2**64)-1. Yo uso el operador renacuajo dos veces aquí. Un consejo de golf al respecto está aquí .

También hay sys.maxinten Python2 que se puede usar, pero no lo miraré.

repl.it <- enlace de prueba.

antes de Cristo, 15 13 bytes

Guardado 2 bytes gracias a manatwork.

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

Nada lujoso, solo (16 ^ 16) -1.

dc , 7 bytes

Creo que está permitido que los idiomas basados ​​en la pila dejen la respuesta en la celda superior de la pila, similar a un valor de retorno para las funciones. Si se necesita una impresión explícita, agregue pal final del código.

AZ5E^z-

Pruébalo en línea!

Calcula (2 ⁶⁴ - 1) usando varios trucos:

• 2se da como el número de dígitos ( Z) encontrado en el entero 10 ( A)

• 64se da como 5E. Por defecto, dc usa 10 como la raíz de entrada. Aun así, puede aceptar números en notación hexadecimal, pero se convertirán de manera diferente de lo que cabría esperar. Ejemplo: (5E) _{predeterminado} = (5E) _{(entrada radix = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1se da como la profundidad de la pila ( z), ya que solo (2 ⁶⁴ ) estaba presente entonces

Historia alternativa:

Sin embargo, es ahora cuando observa que algunas teclas numéricas no parecen escribirse correctamente en la consola remota. Respira hondo y comienza a probar cada tecla numérica. ¡Es peor de lo que pensabas! No funciona ninguno, y le queda la tarea de producir su número entero deseado utilizando solo letras y símbolos.

Solución en dc: informática (16 ¹⁶ - 1), ¡todavía 7 bytes!

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

Pruébalo en línea!

Jalea , 4 bytes

⁴*`’

Pruébalo en línea!

Explicación

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

05AB1E , 4 bytes

žJn<

Explicación:

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

¡Finalmente! ¡Una oportunidad de usar 05AB1Elos builtins para poderes de dos!

Pruébalo en línea!

Otra respuesta de 4 bytes:

žxo<

Explicación:

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

Pruébalo en línea!

(si alguien se pregunta, esta pregunta es más antigua que todas las otras respuestas de 4 bytes)

MATLAB / Octave, 5 bytes

@Sanchises publicó una excelente respuesta de MATLAB, sin embargo, este es un enfoque considerablemente diferente, por lo que lo publicaré de todos modos:

tic/0

En MATLAB, ticdevuelve el número de milisegundos pasados ​​desde que se abrió el programa. Crucialmente el valor que devuelve es un uint64tipo. Esto uint64evita tener que emitir un número desde el tipo predeterminado de MATLAB double.

Cualquier número dividido por 0 en MATLAB se considera como infinito, lo que para los tipos de punto no flotante, MATLAB representa esto como el valor entero máximo para ese tipo.

Esto también funciona con Octave, aunque dependiendo del intérprete que use, también puede emitir una advertencia de "división por cero". Puede probar el código en línea aquí, ya que digo que recibe una advertencia de / 0 que no aparece en MATLAB.

a .18 años, 16 bytes

• Guardado 2 bytes, gracias @ MrScapegrace

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

PHP, 16 bytes

Esto es muy parecido a la respuesta de Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Para que esto funcione, debe estar en una arquitectura de 64 bits. Esto se debe a que ~ 0 es -1, que es 111111111111111111111111111111111111111111111111111111111111‌ 1111 en binario, en 64 bits, en comparación con 11111111111111111111111111111111 en 32 bits, y los números dependen de la plataforma - Ismael Miguel

MATLAB / Octave, 22 bytes

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

Pruébalo en línea!

eyese usa para crear una matriz unitaria (matriz con 1diagonal, cero en caso contrario). Sin argumentos, esto crea una 1x1matriz unitaria, o en otras palabras, solo a 1. Toma un argumento opcional, que es el tipo de datos ('clase' en la terminología de MATLAB) de la matriz creada. Por lo tanto, pedimos un 1de clase uint64, y lo dividimos por cero, lo que da como resultado InfMATLAB, que se recorta en intmax('uint64').

El vector ['~rw}?='-9 '']evalúa a 'uint64'. La concatenación de un carácter vacío a un vector es 1 byte más corto que el uso char('~rw}?='-9).

Razonando hacia esta respuesta: el incorporado intmaxevalúa tristemente al máximo de un entero con signo de 32 bits. La siguiente opción obvia es uint64(), que contiene los caracteres prohibidos. La alternativa es usar una función que tome una cadena como tipo de datos. Los candidatos obvios son intmaxy cast, pero las alternativas incluyen zeros, onesy 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: MATLAB se instala de manera predeterminada en prácticamente todos los sitios de juego poco fiables.}

JavaScript, 39 38 33 32 bytes

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

Editar: Guardado 5 bytes gracias a @Arnauld.

Java 8, 30 bytes

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

Prueba en línea

BF, 108 bytes

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

Si cada comando se considera como 3 bits, esto es potencialmente 41 bytes.

Retina , 28 27 bytes

Guardado 1 byte gracias a Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Pruébalo en línea!

Explicación

bieegheeahdhajffbgbf

Reemplaza la entrada inexistente / vacía con esta cadena. Esta cadena particular fue generada por el "inverso" de este programa. Codifica a através jcomo a 0través 9, respectivamente.

T`l`d

Esta es una Tetapa de ransliteración. El ly dson conjuntos de caracteres utilizados para la transliteración. lrepresenta el alfabeto en minúsculas, des todos los dígitos. Entonces, se asigna de abcdefghijnuevo a 0123456789.

C ++, 46 bytes.

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

Primera vez que hago un código de golf, pero estoy bastante feliz conmigo mismo. Estaremos encantados de recibir cualquier crítica / sugerencia :)

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

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

Pruébalo en línea!

[¡Pruébelo en línea!]

¡Cuatro bytes guardados gracias a @Riley!

Explicación:

#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 el registro, intenté presionar 32 y cuadruplicar, pero es el mismo conteo de bytes.

C # 6, 31 bytes

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

Más o menos lo mismo que Java.

C # 5, 56 bytes

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

Adelante (gforth), 11 9 7 bytes

true U.

Pruébalo en línea

truees el mismo que -1. U.imprime un número como un entero sin signo.

¿Esto funciona en TIO, posiblemente porque tiene una arquitectura de 64 bits? No estoy seguro. Si ejecuto -1 U.en repl.it, por ejemplo, obtengo 2 ** 32-1. Si repl.it admitiera enteros de doble longitud, en su UD.lugar se utilizarían los resultados .

Python3 REPL, 11 bytes

~0^~0>>~077

Cómo funciona

• ~ 0 es -1 (complemento de dos, una secuencia infinita de '1's)
• 077 es 63 en octal, entonces ~ 077 es -64
• Desplazar a la derecha con parámetro negativo es un desplazamiento a la izquierda
• Poniendo todo junto, -1 xor (-1 << 64) es el número que estamos buscando

PowerShell , 29 14 bytes

0xC000PB/3-3/3

Pruébalo en línea!

Gracias a @ n0rd por esencialmente jugar golf a la mitad.

Esto aprovecha el PBoperador unario incorporado que básicamente funciona como "multiplicar el número anterior por 1125899906842624" (es decir, cuántos bytes hay en un pebibyte). Eso está junto con el hex 0xC000, o 49152, entonces 49152 pebibytes. Dividimos eso entre 3rendimientos 18446744073709551616y restamos 3/3para obtener el valor final.

JavaScript (ES6), 50 bytes

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

Asamblea x64, 7 bytes

hexagonal (ensamblado): 4831C048FFC8C3

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

RAX es un registro de 64 bits, y se usa con mayor frecuencia para devolver argumentos enteros (por ejemplo, C). Al disminuir 1, su valor pasa de 0 a ... 2 ^ 64-1, que es exactamente lo que se necesita.
Sin embargo, el binario ensamblado contiene unos y cuatro y ocho, el ensamblado no, pero el archivo ensamblado se cuenta en ensamblaje, entonces ¿cuenta? Ay, mi cabeza.
Además, la salida es el valor de retorno en este caso.

Brain-Flak , 223193 bytes

Incluye +1 por -A
-30 gracias a DJMcMayhem

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

Pruébalo en línea!

Esto simplemente empujó los valores ASCII de e imprime como caracteres.

Como referencia, se necesitan 338 bytes para generar el número real utilizando el meta golfista Integer .

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

Pruébalo en línea!

MATL, 8 bytes

l_5Z%EZD

Esto probablemente podría mejorarse, pero todavía no estoy familiarizado con las cadenas y los tipos en MATL.

Pruébalo en matl.suever.net

Explicación:

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))

el código genera y luego alerta a la cadena 18446744073709551615 usando operaciones bit a bit

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

Rápido, 8 bytes

UInt.max

patio exterior / repl - 15 bytes

print(UInt.max)

TI-Basic, 10 bytes

9+7
Ans^Ans-0!