Hai recentemente creato un account su un sito di gioco d'azzardo ingannevole, dove per una commissione di 25 dollari, ti rimborseranno un importo casuale compreso tra 0 e 50 dollari. Dopo aver ottenuto circa 5 dollari due volte, decidi di provare che il sito è una truffa. Dopo aver effettuato l'accesso al firewall esterno con la password predefinita, ti trovi sul loro server di database e scopri dove sono conservati i valori per gli importi minimo e massimo. Decidi di inserire 25 '9 come valore massimo, ma ricevi un messaggio di errore che dice che il valore massimo deve essere di tipo' uint64 '. Tuttavia è ora che noti alcuni tasti numerici non sembrano digitare correttamente nella console remota. La sfida ti appare quasi come se fosse stata scritta su un sito di domande e risposte.

usando solo i programmi opportunamente installati per testare ed eseguire la tua lingua particolare, emetti la dimensione massima di un valore intero a 64 bit senza segno, tuttavia quasi tutto tranne gli strumenti di programmazione sono rotti su questa macchina, lasciandoti senza l'uso dei numeri 1, 2,4,6,8 - nel codice sorgente o letterale, noti anche che sembra richiedere un tempo esponenzialmente più lungo per eseguire il programma per ogni ulteriore porzione di codice, quindi è meglio tenerlo breve se vuoi diventare ricco prima del disegno!

La sfida

• Scrivere un programma che emetta 18446744073709551615, il valore massimo di un numero intero a 64 bit senza segno, come un numero o una singola stringa.

• Il codice sorgente non può contenere nessuno dei caratteri '1', '2', '4', '6' o '8'

• se la tua lingua non ha un numero intero a 64 bit senza segno o equivalente, l'output può essere in formato stringa o in altro modo, ma deve essere il numero sopra.

• questo è code-golf quindi vince il codice più corto in ogni lingua!

Cera d'api , 3 byte

_M{

Spiegazione:

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

Provalo online!

Questa lingua è perfetta per questa sfida.

Ecco un estratto dalla pagina di Esolang su cera d'api :

Come tutti sanno, le api non hanno un concetto di numeri negativi, ma hanno scoperto che possono usare la parte più significativa di un indirizzo per aggirare questo. Pertanto, le coordinate relative alla posizione di un'ape sono realizzate dai due complementi delle coordinate. In questo modo, metà dello spazio degli indirizzi a 64 bit è disponibile per l'indirizzamento locale senza avvolgimento in ciascuna direzione.

L'indirizzo di complemento massimo due a 64 bit positivo è 9223372036854775807 o 0x7fffffffffffffff in esadecimale a 64 bit. Tutti i valori compresi tra 0 e questo valore si traducono in modo identico nello stesso valore a 64 bit. Tutti i valori n nella direzione opposta (negativa) si traducono in 2 ^ 64-n. Ad esempio: n = -1 è indirizzato da 18446744073709551615. n = -9223372036854775808 è indirizzato da 9223372036854775808.

Si tratta sostanzialmente di desideri non firmati.

EDIT: Mi aspetto ancora che Dennis mi superi con una soluzione a 2 byte.

C, 26 byte

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

Stampa un unsigned longvalore.

Richiede una dimensione di long64 bit.

CJam (4 byte)

GG#(

Demo online

Questo calcola 16 ¹⁶ - 1 usando builtin Gper 16 e l'operatore di decremento (.

64 bit SBCL Common Lisp, 18 byte

most-positive-word

La parola più positiva sul compilatore a 64 bit è 64uint. È qualcosa.

Python3 REPL, 12 byte

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

Al di fuori di REPL: print~-(~-3<<9*7)<--> Python2!

Ecco un altro a 17 byte: ~-(~-3<<ord("?")).

Spiegazione

Niente di eccezionale. Ecco suddiviso:

~-           | 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'espressione risultante è approssimativamente (ma non del tutto) ~-(2<<63)-> (2**64)-1. Uso l' operatore girino due volte qui. Un consiglio da golf è qui .

C'è anche sys.maxintin Python2 che può essere usato, ma non lo guarderò.

repl.it <- link di test.

avanti Cristo, 15 13 byte

Risparmiato 2 byte grazie alla manatwork.

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

Niente di speciale, solo (16 ^ 16) -1.

dc , 7 byte

Penso che sia consentito alle lingue basate sullo stack di lasciare la risposta nella cella superiore dello stack, in modo simile a un valore restituito per le funzioni. Se è necessaria la stampa esplicita, aggiungere palla fine del codice.

AZ5E^z-

Provalo online!

Calcola (2 ⁶⁴ - 1) usando diversi trucchi:

• 2è dato come il numero di cifre ( Z) trovato nell'intero 10 ( A)

• 64è dato come 5E. Di default dc usa 10 come input radix. Anche così, può accettare numeri in notazione esadecimale, ma verranno convertiti in modo diverso da quello che ti aspetteresti. Esempio: (5E) _default = (5E) _{(input radix = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1viene dato come profondità dello stack ( z), poiché solo allora (2 ⁶⁴ ) era presente

Storia alternativa:

Tuttavia è ora che noti alcuni tasti numerici non sembrano digitare correttamente nella console remota. Fai un respiro profondo e inizi a testare ogni tasto numerico. È peggio di quanto pensassi! Non uno solo funziona e ti rimane il compito di produrre il numero intero desiderato utilizzando solo lettere e simboli.

Soluzione in cc: elaborazione (16 ¹⁶ - 1), ancora 7 byte!

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

Provalo online!

Gelatina , 4 byte

⁴*`’

Provalo online!

Spiegazione

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

05AB1E , 4 byte

žJn<

Spiegazione:

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

Finalmente! Una possibilità di usare 05AB1Ei builtin per potenze di due!

Provalo online!

Un'altra risposta a 4 byte:

žxo<

Spiegazione:

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

Provalo online!

(se qualcuno si sta chiedendo, questa domanda è più antica di tutte le altre risposte a 4 byte)

MATLAB / Octave, 5 byte

@Sanchises ha pubblicato un'ottima risposta MATLAB, tuttavia questo è un approccio notevolmente diverso, quindi lo posterò comunque:

tic/0

In MATLAB, ticrestituisce il numero di millisecondi trascorsi dall'apertura del programma. Fondamentalmente il valore che restituisce è un uint64tipo. Questo uint64evita di dover lanciare un numero dal tipo predefinito di MATLABs double.

Qualsiasi numero diviso per 0 in MATLAB è considerato come infinito che per i tipi a virgola mobile, MATLAB rappresenta questo come valore intero massimo per quel tipo.

Questo funziona anche con Octave anche se a seconda dell'interprete che usi può emettere anche un avviso di "divisione per zero". Puoi provare il codice online qui, però, mentre dico che ricevi un avviso / 0 che non appare in MATLAB.

bc ,18, 16 byte

• Salvato 2 byte, grazie a @Scapegrace

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

PHP, 16 byte

È molto simile alla risposta di Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Perché questo funzioni, è necessario trovarsi in un'architettura a 64 bit. Questo perché ~ 0 è -1, che è 11111111111111111111111111111111111111111111111111111111111111111111111111‌ 1111 in binario, in 64 bit, rispetto a 11111111111111111111111111111111 in 32 bit e i numeri sono dipendenti dalla plataform - Ismael Miguel

MATLAB / Ottava, 22 byte

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

Provalo online!

eyeè usato per creare una matrice unitaria (matrice con 1sulla diagonale, zero altrimenti). Senza argomenti, questo crea una 1x1matrice unitaria o, in altre parole, solo a 1. Prende un argomento facoltativo, che è il tipo di dati ('classe' nella terminologia MATLAB) della matrice creata. Chiediamo quindi una 1classe uint64e la dividiamo per zero, il che si traduce Infin MATLAB, che viene troncato intmax('uint64').

Il vettore ['~rw}?='-9 '']valuta 'uint64'. Concatenare un carattere vuoto a un vettore è più corto di 1 byte rispetto all'uso char('~rw}?='-9).

Ragionamento per questa risposta: il built-in intmaxpurtroppo valuta al massimo un numero intero con segno a 32 bit. L'ovvia opzione successiva è uint64(), che contiene i caratteri proibiti. L'alternativa è utilizzare una funzione che accetta una stringa come tipo di dati. I candidati ovvi sono intmaxe cast, ma le alternative includono 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: MATLAB è installato di default praticamente su tutti i siti di gioco d'azzardo ingannevoli.}

JavaScript, 39 38 33 32 byte

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

Modifica: salvato 5 byte grazie a @Arnauld.

Java 8, 30 byte

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

Test online

BF, 108 byte

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

Se ogni comando è considerato come 3 bit, questo è potenzialmente 41 byte.

Retina , 28 27 byte

Salvato 1 byte grazie a Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Provalo online!

Spiegazione

bieegheeahdhajffbgbf

Sostituisce l'input inesistente / vuoto con questa stringa. Questa particolare stringa è stata generata dall'inverso di questo programma. Codifica athrough jas 0through 9, rispettivamente.

T`l`d

Questa è una Tfase di riscrittura. I set di caratteri le dsono usati per la traslitterazione. lrappresenta l'alfabeto minuscolo, dè composto da tutte le cifre. Quindi, si abcdefghijricollega a 0123456789.

C ++, 46 byte.

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

La prima volta in assoluto a giocare a golf, ma sono abbastanza contento di me stesso. Sarà felice di prendere qualsiasi critica / suggerimento :)

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

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

Provalo online!

[Provalo online!]

Quattro byte salvati grazie a @Riley!

Spiegazione:

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

Per la cronaca, ho provato a spingere 32 e quadruplicare, ma è lo stesso conteggio dei byte.

C # 6, 31 byte

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

Praticamente uguale a Java.

C # 5, 56 byte

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

Forth (gforth), 11 9 7 byte

true U.

Provalo online

trueè lo stesso di -1. U.stampa un numero come numero intero senza segno.

Funziona su TIO, forse perché ha un'architettura a 64 bit? Non ne sono sicuro. Se corro -1 U.su repl.it, ad esempio, ottengo 2 ** 32-1. Se repl.it supportava numeri interi a doppia lunghezza, la loro emissione verrebbe UD.invece utilizzata .

Python3 REPL, 11 byte

~0^~0>>~077

Come funziona

• ~ 0 è -1 (complemento a due, una sequenza infinita di '1')
• 077 è 63 in ottale, quindi ~ 077 è -64
• Sposta a destra con parametro negativo è uno spostamento a sinistra
• Mettendo tutti insieme, -1 xor (-1 << 64) è il numero che stiamo cercando

PowerShell , 29 14 byte

0xC000PB/3-3/3

Provalo online!

Grazie a @ n0rd per aver praticamente giocato a golf a metà.

Ciò sfrutta l' PBoperatore unario integrato che sostanzialmente funziona come "moltiplica il numero precedente per 1125899906842624" (cioè, quanti byte sono in un pebibyte). Questo è accoppiato con l'esagono 0xC000, o 49152, quindi 49152 pebibytes. Dividiamo ciò per 3, cedendo 18446744073709551616e sottraendo 3/3per ottenere il valore finale.

JavaScript (ES6), 50 byte

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

x64 Assembly, 7 byte

esagonale (assemblato): 4831C048FFC8C3

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

RAX è un registro a 64 bit e viene spesso utilizzato per restituire argomenti interi (ad esempio, C). Decrementando 1, il suo valore passa da 0 a ... 2 ^ 64-1, che è esattamente necessario.
Tuttavia, il binario assemblato contiene uno, quattro e otto, l'assemblaggio no, ma il file assemblato viene conteggiato nell'assieme, quindi conta? Ow, la mia testa.
Inoltre, in questo caso l'output è un valore di ritorno.

Brain-Flak , 223 193 byte

Include +1 per -A
-30 grazie a DJMcMayhem

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

Provalo online!

Questo ha appena spinto i valori ASCII di e li stampa come caratteri.

Per riferimento, sono necessari 338 byte per generare il numero effettivo utilizzando il meta golfista Integer .

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

Provalo online!

MATL, 8 byte

l_5Z%EZD

Questo potrebbe probabilmente essere migliorato, ma non ho ancora familiarità con stringhe e tipi in MATL.

Provalo su matl.suever.net

Spiegazione:

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 byte

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

il codice genera e quindi avvisa la stringa 18446744073709551615 utilizzando operazioni bit a bit

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

Rapido, 8 byte

UInt.max

parco giochi esterno / sostituzione - 15 byte

print(UInt.max)

TI-Basic, 10 byte

9+7
Ans^Ans-0!