Sie haben kürzlich ein Konto auf einer zwielichtigen Glücksspiel-Website eingerichtet, auf der Sie gegen eine Gebühr von 25 US-Dollar einen zufälligen Betrag zwischen 0 und 50 US-Dollar zurückerhalten. Nachdem Sie zweimal ungefähr 5 Dollar erhalten haben, entscheiden Sie sich, zu beweisen, dass die Website ein Betrug ist. Nachdem Sie auf die externe Firewall mit dem Standardkennwort zugegriffen haben, finden Sie den Weg auf den Datenbankserver und den Speicherort für die Werte für die minimalen und maximalen Beträge. Sie beschließen, 25 '9's als Maximalwert einzustecken, erhalten jedoch eine Fehlermeldung, dass der Maximalwert vom Typ' uint64 'sein muss. Inzwischen stellen Sie jedoch fest, dass einige Zifferntasten nicht richtig in die Remote-Konsole eingegeben wurden. Die Herausforderung erscheint vor Ihnen, als ob Sie auf einer Q + A-Site getippt wären.

Verwenden Sie nur die komfortabel installierten Programme zum Testen und Ausführen Ihrer Sprache, und geben Sie die maximale Größe eines 64-Bit-Ganzzahlwerts ohne Vorzeichen aus. Auf diesem Computer ist jedoch fast alles außer den Programmiertools fehlerhaft, sodass Sie auf die Verwendung der Zahlen 1 verzichten müssen. 2,4,6,8 - Sowohl im Quellcode als auch in den Literalen stellen Sie außerdem fest, dass die Ausführung des Programms für jedes weitere Codestück exponentiell länger zu dauern scheint. Sie sollten es daher kurz halten, wenn Sie dies möchten will vor der Ziehung reich werden!

Die Herausforderung

• Schreiben Sie ein Programm, das 18446744073709551615 ausgibt, den Maximalwert einer 64-Bit-Ganzzahl ohne Vorzeichen, entweder als Zahl oder als einzelne Zeichenfolge.

• Ihr Quellcode darf keine der Zeichen "1", "2", "4", "6" oder "8" enthalten.

• Wenn Ihre Sprache keine 64-Bit-Ganzzahl ohne Vorzeichen oder eine gleichwertige hat, kann die Ausgabe im Zeichenfolgenformat oder auf andere Weise erfolgen, muss jedoch die obige Zahl sein.

• Das ist Code-Golf, also gewinnt der kürzeste Code in jeder Sprache!

Bienenwachs , 3 Bytes

_M{

Erläuterung:

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

Probieren Sie es online!

Diese Sprache ist perfekt für diese Herausforderung.

Hier ist ein Auszug aus der Esolang-Seite über Bienenwachs :

Wie jeder weiß, haben Bienen kein Konzept negativer Zahlen, aber sie haben herausgefunden, dass sie das höchstwertige Bit einer Adresse verwenden können, um das zu umgehen. Somit werden Koordinaten in Bezug auf die Position einer Biene durch die Zweierkomplemente der Koordinaten realisiert. Auf diese Weise steht die Hälfte des 64-Bit-Adressraums für die lokale Adressierung zur Verfügung, ohne dass ein Umlauf in jede Richtung erforderlich ist.

Die maximale positive 64-Bit-Zweierkomplementadresse ist 9223372036854775807 oder 0x7fffffffffffffff in 64-Bit-Hexadezimalzahl. Alle Werte von 0 bis zu diesem Wert werden identisch zu demselben 64-Bit-Wert übersetzt. Alle Werte n in der entgegengesetzten (negativen) Richtung ergeben 2 ^ 64-n. Beispiel: n = -1 wird von 18446744073709551615 adressiert. N = -9223372036854775808 wird von 9223372036854775808 adressiert.

Dies ist im Grunde Longs ohne Vorzeichen.

EDIT: Ich erwarte immer noch, dass Dennis mich mit einer 2-Byte-Lösung übertrifft.

C 26 Bytes

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

Gibt einen unsigned longWert aus.

Erfordert eine Größe von long64 Bit.

CJam (4 Bytes)

GG#(

Online-Demo

Dies berechnet 16 ¹⁶ - 1 unter Verwendung von builtin Gfor 16 und des Dekrementierungsoperators (.

64-Bit-SBCL Common Lisp, 18 Byte

most-positive-word

Das positivste Wort im 64-Bit-Compiler ist 64uint. Es ist etwas.

Python3 REPL, 12 Bytes

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

Außerhalb von REPL: print~-(~-3<<9*7)<-> Python2!

Hier ist ein weiteres mit 17 Bytes: ~-(~-3<<ord("?")).

Erläuterung

Nichts super schickes. Hier ist es aufgeschlüsselt:

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

Der resultierende Ausdruck ist ungefähr (aber nicht ganz) ~-(2<<63)-> (2**64)-1. Ich benutze den Kaulquappenoperator hier zweimal. Ein Golftipp dazu ist hier .

Es gibt auch sys.maxintPython2, das verwendet werden kann, aber das werde ich nicht betrachten.

repl.it <- Testlink .

bc, fünfzehn 13 Bytes

2 Bytes dank Handarbeit gespart.

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

Nichts Besonderes, nur (16 ^ 16) -1.

Gleichstrom , 7 Bytes

Ich denke, es ist für stapelbasierte Sprachen erlaubt, die Antwort in der obersten Zelle des Stapels zu belassen, ähnlich einem Rückgabewert für Funktionen. Wenn explizites Drucken erforderlich ist, fügen Sie pam Ende des Codes hinzu.

AZ5E^z-

Probieren Sie es online!

Es berechnet (2 ⁶⁴ - 1) mit mehreren Tricks:

• 2wird als die Anzahl der Ziffern ( Z) angegeben, die in Ganzzahl 10 ( A) gefunden wurden

• 64ist gegeben als 5E. Standardmäßig verwendet DC 10 als Eingabe-Radix. Trotzdem kann es Zahlen in hexadezimaler Schreibweise akzeptieren, aber sie werden anders konvertiert als erwartet. Beispiel: (5E) _Standard = (5E) _{(Eingaberadix = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1wird als Tiefe des Stapels angegeben ( z), da damals nur (2 ⁶⁴ ) vorhanden war

Alternative Geschichte:

Inzwischen stellen Sie jedoch fest, dass einige Zifferntasten nicht korrekt in die Remote-Konsole eingegeben wurden. Sie atmen tief ein und testen die einzelnen Zifferntasten. Es ist schlimmer als du gedacht hast! Es funktioniert kein einziger, und Sie müssen die gewünschte Ganzzahl nur aus Buchstaben und Symbolen erstellen.

Lösung in dc: computing (16 ¹⁶ - 1), noch 7 Bytes!

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

Probieren Sie es online!

Gelee , 4 Bytes

⁴*`’

Probieren Sie es online!

Erläuterung

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

05AB1E , 4 Bytes

žJn<

Erläuterung:

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

Endlich! Eine Chance, die 05AB1Eeingebauten Funktionen für Zweierpotenzen zu nutzen !

Probieren Sie es online!

Eine weitere 4-Byte-Antwort:

žxo<

Erläuterung:

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

Probieren Sie es online!

(Wenn sich jemand wundert, ist diese Frage älter als alle anderen 4-Byte-Antworten.)

MATLAB / Octave, 5 Bytes

@Sanchises hat eine exzellente MATLAB-Antwort gepostet, dies ist jedoch ein ganz anderer Ansatz, daher werde ich es trotzdem posten:

tic/0

Gibt in MATLAB ticdie Anzahl der Millisekunden seit dem Öffnen des Programms zurück. Entscheidend ist, dass der zurückgegebene Wert ein uint64Typ ist. Dadurch müssen Sie keine Zahl in uint64den Standardtyp von MATLAB übertragen double.

Jede Zahl, die in MATLAB durch 0 geteilt wird, wird als unendlich betrachtet. Bei Nicht-Gleitkommatypen repräsentiert MATLAB dies als den maximalen ganzzahligen Wert für diesen Typ.

Dies funktioniert auch mit Octave. Je nachdem, welchen Interpreter Sie verwenden, wird möglicherweise auch eine Warnung "Division durch Null" ausgegeben. Sie können den Code hier online ausprobieren, da ich sage, dass Sie eine / 0-Warnung erhalten, die in MATLAB nicht angezeigt wird.

bc ,1816 Bytes

• 2 Bytes gespeichert, danke @MrScapegrace

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

PHP, 16 Bytes

Dies ähnelt der Antwort von Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Damit dies funktioniert, müssen Sie sich in einer 64-Bit-Architektur befinden. Dies liegt daran, dass ~ 0 -1 ist, was 11111111111111111111111111111111111111111111111111111111‌ 1111 in binärer Form in 64 Bit im Vergleich zu 111111111111111111111111 in 32 Bit ist und die Zahlen plattformabhängig sind - Ismael Miguel

MATLAB / Octave, 22 Bytes

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

Probieren Sie es online!

eyewird verwendet, um eine Einheitsmatrix zu erstellen (Matrix mit 1auf der Diagonale, sonst Null). Ohne Argumente wird eine 1x1Einheitsmatrix erstellt, oder mit anderen Worten, nur eine 1. Ein optionales Argument ist der Datentyp ('class' in der MATLAB-Terminologie) der erstellten Matrix. Wir fragen also nach a 1von class uint64und dividieren es durch Null, was zu InfMATLAB führt, das abgeschnitten wird intmax('uint64').

Der Vektor wird zu ['~rw}?='-9 '']ausgewertet 'uint64'. Die Verkettung eines leeren Zeichens mit einem Vektor ist 1 Byte kürzer als die Verwendung char('~rw}?='-9).

Argumentation für diese Antwort: Die integrierte Funktion intmaxwertet leider maximal eine 32-Bit-Ganzzahl mit Vorzeichen aus. Die naheliegende nächste Option ist uint64(), die die verbotenen Zeichen enthält. Die Alternative besteht darin, eine Funktion zu verwenden, die eine Zeichenfolge als Datentyp verwendet. Offensichtliche Kandidaten sind intmaxund cast, aber Alternativen sind zeros, onesund 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.

^{Hinweis: MATLAB wird standardmäßig auf praktisch allen zwielichtigen Glücksspielseiten installiert.}

JavaScript, 39 38 33 32 Bytes

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

Bearbeiten: 5 Bytes dank @Arnauld gespeichert.

Java 8, 30 Bytes

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

Online testen

BF, 108 Bytes

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

Wenn jeder Befehl als 3 Bits betrachtet wird, sind dies möglicherweise 41 Bytes.

Retina , 28 27 Bytes

Dank Kritixi Lithos 1 Byte gespart

bieegheeahdhajffbgbf
T`l`d

Probieren Sie es online!

Erläuterung

bieegheeahdhajffbgbf

Ersetzt die nicht vorhandene / leere Eingabe durch diese Zeichenfolge. Diese bestimmte Zeichenfolge wurde durch die "Inverse" dieses Programms generiert. Es kodiert jeweils adurch jals 0durch 9.

T`l`d

Dies ist eine TRansliterationsphase. Die lund dsind Zeichensätze, die für die Transliteration verwendet werden. lStellt das Kleinbuchstaben dar, dbesteht aus allen Ziffern. Also, es kartiert abcdefghijzurück zu 0123456789.

C ++, 46 Bytes.

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

Ich mache zum ersten Mal Codegolf, bin aber ziemlich zufrieden mit mir. Nehmen gerne kritik / vorschläge entgegen :)

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

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

Probieren Sie es online!

[Online ausprobieren!]

Vier Bytes gespart dank @Riley!

Erläuterung:

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

Für den Datensatz habe ich versucht, 32 zu pushen und zu vervierfachen, aber es ist die gleiche Byteanzahl.

C # 6, 31 Bytes

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

So ziemlich das gleiche wie Java.

C # 5, 56 Bytes

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

Viertens (gviertens), 11 9 7 Bytes

true U.

Probieren Sie es online aus

trueist das gleiche wie -1. U.Gibt eine Zahl als vorzeichenlose Ganzzahl aus.

Dies funktioniert auf TIO, möglicherweise, weil es eine 64-Bit-Architektur hat? Ich bin mir nicht sicher. Wenn ich -1 U.zum Beispiel auf repl.it laufe, erhalte ich 2 ** 32-1. Wenn repl.it Ganzzahlen mit doppelter Länge unterstützt, würde die Ausgabe UD.stattdessen verwendet.

Python3 REPL, 11 Bytes

~0^~0>>~077

Wie es funktioniert

• ~ 0 ist -1 (Zweierkomplement, eine unendliche Folge von Einsen)
• 077 ist 63 im Oktal, also ist ~ 077 -64
• Verschiebung nach rechts mit negativem Parameter ist eine Verschiebung nach links
• Alles in allem ist -1 xor (-1 << 64) die gesuchte Zahl

PowerShell , 29 14 Bytes

0xC000PB/3-3/3

Probieren Sie es online!

Vielen Dank an @ n0rd, dass Sie im Wesentlichen die Hälfte davon gespielt haben.

Dies nutzt den eingebauten unären PBOperator, der im Grunde genommen als "Multiplikation der vorhergehenden Zahl mit 1125899906842624" fungiert (dh wie viele Bytes in einem Pebibyte sind). Das ist , mit der Hex - gekoppelt 0xC000, oder 49152, so 49152 pebibytes. Wir dividieren das durch 3, geben nach 18446744073709551616und subtrahieren 3/3, um den endgültigen Wert zu erhalten.

JavaScript (ES6), 50 Byte

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

x64-Assembly, 7 Byte

Sechskant (zusammengebaut): 4831C048FFC8C3

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

RAX ist ein 64-Bit-Register und wird am häufigsten verwendet, um Ganzzahlargumente (z. B. C) zurückzugeben. Durch Verringern von 1 wird der Wert von 0 auf ... 2 ^ 64-1 verschoben, was genau erforderlich ist.
Die assemblierte Binärdatei enthält zwar Einsen, Vierern und Achtern, die Assembly jedoch nicht, aber die assemblierte Datei wird in der Assembly gezählt. Zählt sie also? Au, mein Kopf.
Die Ausgabe ist in diesem Fall auch der Rückgabewert.

Brain-Flak , 223 193 Bytes

Enthält +1 für -A
-30 dank DJMcMayhem

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

Probieren Sie es online!

Dies hat nur die ASCII-Werte von gepusht und wird als Zeichen gedruckt.

Als Referenz werden 338 Bytes benötigt, um die tatsächliche Zahl mit dem Integer- Metagolfspieler zu generieren .

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

Probieren Sie es online!

MATL, 8 Bytes

l_5Z%EZD

Dies könnte wahrscheinlich verbessert werden, aber ich bin noch nicht mit Zeichenfolgen und Typen in MATL vertraut.

Probieren Sie es bei matl.suever.net

Erläuterung:

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

Der Code generiert und alarmiert dann die Zeichenfolge 18446744073709551615 mit bitweisen Operationen

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

Schnell, 8 Bytes

UInt.max

Außenspielplatz / Repl - 15 Bytes

print(UInt.max)

TI-Basic, 10 Bytes

9+7
Ans^Ans-0!