Vous avez récemment ouvert un compte sur un site de jeu risqué, où, moyennant 25 dollars, ils vous rembourseront un montant aléatoire compris entre 0 et 50 dollars. Après avoir obtenu 5 dollars environ deux fois, vous décidez de prouver que le site est une arnaque. Après avoir accédé à leur pare-feu externe avec le mot de passe par défaut, vous vous retrouvez sur leur serveur de base de données et vous déterminez où se trouvent les valeurs des montants minimum et maximum. Vous décidez de connecter 25 '9 en tant que valeur maximale, mais vous obtenez un message d'erreur indiquant que la valeur maximale doit être de type' uint64 '. Cependant, vous remarquerez que certaines touches numériques ne semblent pas taper correctement dans la console distante. Le défi se présente presque comme s'il était tapé sur un site de questions-réponses.

en n'utilisant que les programmes installés de manière pratique pour tester et exécuter votre langage particulier, indiquez la taille maximale d'un entier non signé de 64 bits. Toutefois, presque tout, à l'exception des outils de programmation, est cassé sur cette machine, ce qui vous évite d'utiliser les chiffres 1, 2,4,6,8 - en code source ou en littéraux, vous remarquerez également que l'exécution du programme semble prendre un temps exponentiellement plus long, pour chaque élément de code supplémentaire. Vous devriez donc le garder court. veux devenir riche avant le dessin!

Le défi

• Ecrivez un programme qui génère 18446744073709551615, la valeur maximale d'un entier non signé de 64 bits, sous forme de nombre ou de chaîne unique.

• Votre code source ne peut contenir aucun des caractères "1", "2", "4", "6" ou "8"

• si votre langue ne possède pas d'entier non signé de 64 bits ou son équivalent, la sortie peut être sous forme de chaîne ou autrement, mais doit correspondre au numéro ci-dessus.

• c'est du code-golf, donc le code le plus court dans chaque langue gagne!

Cire d'abeille , 3 octets

_M{

Explication:

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

Essayez-le en ligne!

Cette langue est parfaite pour ce défi.

Voici un extrait de la page Esolang sur la cire d'abeille :

Comme tout le monde le sait, les abeilles n'ont pas de concept de nombres négatifs, mais elles ont découvert qu'elles pouvaient utiliser l'adresse la plus significative pour contourner cela. Ainsi, les coordonnées relatives à la position d'une abeille sont réalisées par les deux compléments des coordonnées. De cette manière, la moitié de l'espace d'adressage 64 bits est disponible pour l'adressage local sans enveloppement dans chaque sens.

L'adresse complémentaire du complément double positif 64 bits maximum est 9223372036854775807 ou 0x7fffffffffffffffff en hex 64 bits. Toutes les valeurs comprises entre 0 et cette valeur se traduisent de manière identique par la même valeur 64 bits. Toutes les valeurs n dans la direction opposée (négative) se traduisent par 2 ^ 64-n. Par exemple: n = -1 est adressé par 18446744073709551615. n = -9223372036854775808 est adressé par 9223372036854775808.

Ceci est fondamentalement non signé longtemps.

EDIT: Je m'attends toujours à ce que Dennis me pardonne avec une solution à 2 octets.

C, 26 octets

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

Imprime une unsigned longvaleur.

Nécessite une taille de long64 bits.

CJam (4 octets)

GG#(

Démo en ligne

Ceci calcule 16 ¹⁶ - 1 en utilisant les fonctions intégrées Gpour 16 et l'opérateur de décrémentation (.

Common Lisp SBCL 64 bits, 18 octets

most-positive-word

Le mot le plus positif sur le compilateur 64 bits est 64uint. C'est quelque chose.

Python3 REPL, 12 octets

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

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

Voici un autre à 17 octets: ~-(~-3<<ord("?")).

Explication

Rien d'extraordinaire. Voici la ventilation:

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

L'expression résultante est à peu près (mais pas tout à fait) ~-(2<<63)-> (2**64)-1. J'utilise l' opérateur de têtard deux fois ici. Une astuce golfique à ce sujet est ici .

Il y a aussi sys.maxintdans Python2 qui peut être utilisé, mais je ne regarderai pas cela.

repl.it <- lien de test.

avant JC, 15 13 octets

Sauvegardé 2 octets grâce à manatwork.

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

Rien d'extraordinaire, juste (16 ^ 16) -1.

dc , 7 octets

Je pense qu'il est permis aux langues basées sur la pile de laisser la réponse sur la cellule supérieure de la pile, similaire à une valeur de retour pour les fonctions. Si une impression explicite est nécessaire, ajoutez pà la fin du code.

AZ5E^z-

Essayez-le en ligne!

Il calcule (2 ⁶⁴ - 1) en utilisant plusieurs astuces:

• 2est donné comme le nombre de digits ( Z) trouvé dans l'entier 10 ( A)

• 64est donné comme 5E. Par défaut, dc utilise 10 comme base d’entrée. Même dans ce cas, il peut accepter des nombres en notation hexadécimale, mais ils seront convertis différemment que prévu. Exemple: (5E) _{par défaut} = (5E) _{(base d'entrée = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1est donné comme la profondeur de la pile ( z), puisque seulement (2 ⁶⁴ ) était présent alors

Histoire alternative:

Cependant, vous remarquerez que certaines touches numériques ne semblent pas taper correctement dans la console distante. Vous prenez une profonde respiration et commencez à tester chaque touche numérique. C'est pire que tu ne le pensais! Pas un seul ne fonctionne, et il ne vous reste plus qu'à produire le nombre entier souhaité en n'utilisant que des lettres et des symboles.

Solution en courant continu: informatique (16 ¹⁶ - 1), encore 7 octets!

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

Essayez-le en ligne!

Gelée , 4 octets

⁴*`’

Essayez-le en ligne!

Explication

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

05AB1E , 4 octets

žJn<

Explication:

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

Finalement! Une chance d'utiliser 05AB1Eles fonctions intégrées pour des pouvoirs de deux!

Essayez-le en ligne!

Une autre réponse sur 4 octets:

žxo<

Explication:

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

Essayez-le en ligne!

(si quelqu'un se le demande, cette question est plus ancienne que toutes les autres réponses à 4 octets)

MATLAB / Octave, 5 octets

@Sanchises a posté une excellente réponse MATLAB, mais celle-ci est une approche considérablement différente, je vais donc la poster quand même:

tic/0

Dans MATLAB, ticrenvoie le nombre de millisecondes écoulées depuis l'ouverture du programme. De manière cruciale, la valeur renvoyée est un uint64type. Cela uint64évite de devoir attribuer un numéro au type par défaut de MATLAB double.

Tout nombre divisé par 0 dans MATLAB est considéré comme un infini qui, pour les types à virgule non flottante, MATLAB le représente comme la valeur entière maximale pour ce type.

Cela fonctionne également avec Octave, bien que, selon l’interprète que vous utilisez, il se peut qu’un avertissement «division par zéro» soit également émis. Vous pouvez essayer le code en ligne ici même si, comme je l'ai dit, vous obtenez un avertissement / 0 qui n'apparaît pas dans MATLAB.

bc ,18, 16 octets

• Enregistré 2 octets, merci @MrScapegrace

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

PHP, 16 octets

Cela ressemble beaucoup à la réponse de Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Pour que cela fonctionne, vous devez être dans une architecture 64 bits. C'est parce que ~ 0 est -1, ce qui correspond à 1111111111111111111111111111111111111111111111111111111111‌1111 en binaire, en 64 bits, par rapport à 11111111111111111111111111111111 en 32 bits, et les nombres sont dépendants du plataform - Ismael Miguel

MATLAB / Octave, 22 octets

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

Essayez-le en ligne!

eyeest utilisé pour créer une matrice unitaire (matrice avec 1sur la diagonale, zéro sinon). Sans arguments, cela crée une 1x1matrice d'unité, ou en d'autres termes, juste un 1. Il prend un argument optionnel, qui est le type de données ('class' dans la terminologie MATLAB) de la matrice créée. Nous demandons donc un 1de la classe uint64et le divisons par zéro, ce qui donne InfMATLAB, qui est écrêté intmax('uint64').

Le vecteur ['~rw}?='-9 '']évalue à 'uint64'. La concaténation d'un caractère vide sur un vecteur est inférieure d'un octet à celle d'utilisation char('~rw}?='-9).

Raisonnement vers cette réponse: le intmaxprédéfini évalue malheureusement au maximum d'un entier signé 32 bits. L'option suivante évidente est celle uint64()qui contient les caractères interdits. L'alternative consiste à utiliser une fonction qui prend une chaîne en tant que type de données. Les candidats évidents sont intmaxet cast, mais les alternatives incluent zeros, oneset 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.

^{Remarque: MATLAB est installé par défaut sur pratiquement tous les sites de jeux risqués.}

JavaScript, 39 38 33 32 octets

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

Edit: 5 octets enregistrés grâce à @Arnauld.

Java 8, 30 octets

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

Testez en ligne

BF, 108 octets

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

Si chaque commande est considérée comme 3 bits, il s'agit potentiellement de 41 octets.

Retina , 28 à 27 octets

Enregistré 1 octet grâce à Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Essayez-le en ligne!

Explication

bieegheeahdhajffbgbf

Remplace l'entrée non existante / vide par cette chaîne. Cette chaîne particulière a été générée par "l'inverse" de ce programme. Il code à atravers jcomme à 0travers 9, respectivement.

T`l`d

C'est une Tétape de ré - écriture. Les let dsont des jeux de caractères utilisés pour la translittération. lreprésente l'alphabet minuscule, dest tous les chiffres. Donc, il abcdefghijrevient à 0123456789.

C ++, 46 octets.

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

C'est la première fois que je pratique un code de golf, mais je suis assez content de moi-même. Acceptera volontiers toutes critiques / suggestions :)

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

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

Essayez-le en ligne!

[Essayez-le en ligne!]

Quatre octets sauvés grâce à @Riley!

Explication:

#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
({}[()])

Pour mémoire, j'ai essayé de pousser 32 et de quadrupler, mais c'est le même nombre d'octets.

C # 6, 31 octets

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

Quasiment la même chose que Java.

C # 5, 56 octets

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

Forth (gforth), 11 9 7 octets

true U.

Essayez-le en ligne

trueest le même que -1. U.affiche un nombre sous forme d'entier non signé.

Cela fonctionne sur TIO, probablement parce qu'il a une architecture 64 bits? Je ne suis pas sûr. Si je lance -1 U.sur repl.it, par exemple, je reçois 2 ** 32-1. Si repl.it prenait en charge les entiers double longueur, leur sortie les utiliserait à la UD.place.

Python3 REPL, 11 octets

~0^~0>>~077

Comment ça marche

• ~ 0 est -1 (complément à deux, une suite infinie de '1')
• 077 est 63 en octal, donc ~ 077 est -64
• Décalage à droite avec paramètre négatif est un décalage à gauche
• En somme, -1 xor (-1 << 64) est le nombre que nous recherchons

PowerShell , 29 à 14 octets

0xC000PB/3-3/3

Essayez-le en ligne!

Merci à @ n0rd d’avoir joué au golf en deux.

Ceci exploite l' PBopérateur unaire incorporé qui fonctionne essentiellement comme "multiplie le nombre précédent par 1125899906842624" (c'est-à-dire combien d'octets sont dans un pebibyte). C'est couplé avec l'hex 0xC000, ou 49152alors 49152 pebibytes. Nous divisons cela par 3, cédant 18446744073709551616et soustrayons 3/3pour obtenir la valeur finale.

JavaScript (ES6), 50 octets

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

Assemblage x64, 7 octets

hex (assemblé): 4831C048FFC8C3

démonté, a commenté:
XOR RAX,RAX ;Zero the value of 64 bit register RAX DEC RAX ;Decrement the value of RAX RET ;Return this value

RAX est un registre de 64 bits et est le plus souvent utilisé pour renvoyer des arguments entiers (par exemple, C). En décrémentant 1, sa valeur passe de 0 à ... 2 ^ 64-1, ce qui est exactement nécessaire.
Bien que le binaire assemblé contienne les uns, les quatre et les huit, l'assemblage n'en contient pas, mais le fichier assemblé est compté dans l'assemblage, est-ce que ça compte? Ow, ma tête.
De plus, la sortie est une valeur de retour dans ce cas.

Brain-Flak , 223 193 octets

Inclut +1 pour -A
-30 grâce à DJMcMayhem

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

Essayez-le en ligne!

Cela vient de pousser les valeurs ASCII de et imprime en tant que caractères.

Pour référence, il faut 338 octets pour générer le nombre réel à l’aide du méta-golfeur Integer .

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

Essayez-le en ligne!

MATL, 8 octets

l_5Z%EZD

Cela pourrait probablement être amélioré, mais je ne suis pas encore familiarisé avec les chaînes et les types dans MATL.

Essayez-le à matl.suever.net

Explication:

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 octets

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

le code génère puis alerte la chaîne 18446744073709551615 à l'aide d'opérations au niveau du bit

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

Rapide, 8 octets

UInt.max

aire de jeux extérieure / remplaçant - 15 octets

print(UInt.max)

TI-Basic, 10 octets

9+7
Ans^Ans-0!