Вы недавно создали учетную запись на хитром сайте азартных игр, где за плату в 25 долларов они вернут вам случайную сумму от 0 до 50 долларов. Получив около 5 долларов дважды, вы решаете доказать, что сайт является мошенничеством. Получив доступ к их внешнему брандмауэру с паролем по умолчанию, вы попадаете на их сервер базы данных и узнаете, где хранятся значения для минимальных и максимальных сумм. Вы решаете включить 25 '9 в качестве максимального значения, но получаете сообщение об ошибке, в котором говорится, что максимальное значение должно быть типа' uint64 '. Однако теперь вы заметили, что некоторые цифровые клавиши неправильно вводятся в удаленную консоль. Задача предстает перед вами почти так же, как если бы вы набрали ее на сайте Q + A.

используя только удобно установленные программы для тестирования и выполнения вашего конкретного языка, выведите максимальный размер 64-разрядного целого числа без знака, однако почти все, кроме инструментов программирования, не работает на этом компьютере, оставляя вас без использования цифр 1, 2,4,6,8 - как в исходном коде, так и в литералах вы также заметили, что выполнение программы для каждого дополнительного фрагмента кода занимает значительно более длительное время, поэтому лучше, если вы будете коротким хочу разбогатеть перед розыгрышем!

Соревнование

• Напишите программу, которая выводит 18446744073709551615, максимальное значение беззнакового 64-разрядного целого числа, в виде числа или отдельной строки.

• Ваш исходный код не может содержать символы «1», «2», «4», «6» или «8»

• если ваш язык не имеет 64-разрядного целого числа без знака или его эквивалента, выходные данные могут быть в строковом формате или иным образом, но должны иметь вышеуказанное число.

• это код-гольф, поэтому выигрывает самый короткий код на каждом языке!

Пчелиный воск , 3 байта

_M{

Объяснение:

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

Попробуйте онлайн!

Этот язык идеально подходит для этой задачи.

Вот выдержка из страницы Esolang о пчелином воске :

Как все знают, у пчел нет понятия отрицательных чисел, но они обнаружили, что могут использовать самый значимый бит адреса, чтобы обойти это. Таким образом, координаты относительно положения пчелы реализуются двумя дополнениями координат. Таким образом, половина 64-битного адресного пространства доступна для локальной адресации без обхода в каждом направлении.

Максимальный положительный 64-битный адрес дополнения до двух равен 9223372036854775807 или 0x7fffffffffffffff в 64-битном шестнадцатеричном формате. Все значения от 0 до этого значения одинаково преобразуются в одно и то же 64-битное значение. Все значения n в противоположном (отрицательном) направлении переводятся в 2 ^ 64-n. Например: n = -1 адресуется 18446744073709551615. n = -9223372036854775808 адресуется 9223372036854775808.

Это в основном неподписанные лонги.

РЕДАКТИРОВАТЬ: Я все еще ожидаю, что Деннис превзойдет меня с 2-байтовым решением.

C, 26 байтов

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

Печатает unsigned longзначение.

Требуется размер long64 бит.

CJam (4 байта)

GG#(

Онлайн демо

Это вычисляет 16 ¹⁶ - 1, используя встроенную Gдля 16 и оператор декремента (.

64-битный SBCL Common Lisp, 18 байт

most-positive-word

Самое положительное слово на 64-битном компиляторе - 64uint. Это что-то.

Python3 REPL, 12 байт

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

За пределами REPL: print~-(~-3<<9*7)<-> Python2!

Вот еще один в 17 байт: ~-(~-3<<ord("?")).

объяснение

Ничего особенного. Вот это сломано:

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

Полученное выражение примерно (но не совсем) ~-(2<<63)-> (2**64)-1. Я использую оператор головастика дважды здесь. Советы по поводу игры в гольф здесь .

Есть также sys.maxintв Python2, который можно использовать, но я не буду смотреть на это.

repl.it <- ссылка для тестирования.

До нашей эры, 15 13 байт

Сохранено 2 байта благодаря manatwork.

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

Ничего особенного, просто (16 ^ 16) -1.

постоянный ток , 7 байтов

Я думаю, что для языков на основе стека разрешено оставлять ответ в верхней ячейке стека, аналогично возвращаемому значению для функций. Если требуется явная печать, добавьте pв конце кода.

AZ5E^z-

Попробуйте онлайн!

Он вычисляет (2 ⁶⁴ - 1), используя несколько приемов:

• 2задается как число цифр ( Z), найденное в целом числе 10 ( A)

• 64дается как 5E. По умолчанию dc использует 10 в качестве входного радиуса. Несмотря на это, он может принимать числа в шестнадцатеричном формате, но они будут преобразованы не так, как вы ожидаете. Пример: (5E) по _{умолчанию} = (5E) _{(основание входа = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 + 14 = 64

• 1задается как глубина стека ( z), так как только (2 ⁶⁴ ) присутствовал тогда

Альтернативная история:

Однако теперь вы заметили, что некоторые цифровые клавиши неправильно вводятся в удаленную консоль. Вы делаете глубокий вдох и начинаете тестировать каждую цифровую клавишу. Это хуже, чем вы думали! Ни один из них не работает, и вам остается задача создать желаемое целое число, используя только буквы и символы.

Решение в DC: вычисления (16 ¹⁶ - 1), все еще 7 байтов!

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

Попробуйте онлайн!

Желе , 4 байта

⁴*`’

Попробуйте онлайн!

объяснение

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

05AB1E , 4 байта

žJn<

Объяснение:

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

В заключение! Шанс использовать 05AB1Eвстроенные функции для двух сил!

Попробуйте онлайн!

Еще один 4-байтовый ответ:

žxo<

Объяснение:

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

Попробуйте онлайн!

(если кому-то интересно, этот вопрос старше всех остальных 4-байтовых ответов)

MATLAB / Octave, 5 байтов

@Sanchises опубликовал отличный ответ на MATLAB, однако этот подход - совершенно другой, поэтому я все равно опубликую его:

tic/0

В MATLAB ticвозвращает количество миллисекунд, прошедших с момента открытия программы. Важно, что возвращаемое значение является uint64типом. Это uint64избавляет от необходимости приводить число к типу по умолчанию MATLABs double.

Любое число, деленное на 0 в MATLAB, рассматривается как бесконечность, которая для типов без плавающей запятой MATLAB представляет это как максимальное целочисленное значение для этого типа.

Это также работает с Octave, хотя в зависимости от того, какой интерпретатор вы используете, он может также выдавать предупреждение «деление на ноль». Вы можете попробовать код онлайн здесь, хотя, как я уже сказал, вы получаете предупреждение / 0, которое не появляется в MATLAB.

до н.э. ,1816 байт

• Сохранено 2 байта, спасибо @MrScapegrace

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

PHP, 16 байт

Это очень похоже на ответ от Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

Чтобы это работало, вам нужно использовать 64-битную архитектуру. Это связано с тем, что ~ 0 равно -1, что равно 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111‌ 1111 в двоичном формате, по сравнению с 11111111111111111111111111111111 в 32-разрядном формате, а числа зависят от платформ - Исмаэль Мигель

MATLAB / Octave, 22 байта

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

Попробуйте онлайн!

eyeиспользуется для создания единичной матрицы (матрица с 1диагональю, в противном случае ноль). Без аргументов это создает 1x1единичную матрицу, или, другими словами, просто a 1. Он принимает необязательный аргумент, который является типом данных («класс» в терминологии MATLAB) созданной матрицы. Таким образом, мы запрашиваем a 1класса uint64и делим его на ноль, что приводит Infк MATLAB, который обрезается intmax('uint64').

Вектор ['~rw}?='-9 '']оценивается как 'uint64'. Конкатенация пустого символа с вектором на 1 байт короче, чем при использовании char('~rw}?='-9).

Причины этого ответа: встроенная intmaxфункция, к сожалению, оценивает максимум 32-разрядного целого числа со знаком. Очевидная следующая опция uint64(), которая содержит запрещенные символы. Альтернативой является использование функции, которая принимает строку в качестве типа данных. Очевидными кандидатами являются intmaxи cast, но альтернативы включают zeros, onesи 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.

^{Примечание: MATLAB по умолчанию устанавливается практически на всех хитрых игровых площадках.}

JavaScript, 39 38 33 32 байта

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

Редактировать: 5 байтов сохранено благодаря @Arnauld.

Java 8, 30 байт

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

Тест онлайн

BF, 108 байт

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

Если каждая команда рассматривается как 3 бита, это потенциально составляет 41 байт.

Retina , 28 27 байт

Сохранено 1 байт благодаря Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Попробуйте онлайн!

объяснение

bieegheeahdhajffbgbf

Заменяет несуществующий / пустой ввод этой строкой. Эта конкретная строка была сгенерирована "инверсией" этой программы. Кодирует aсквозной jкак 0сквозной 9, соответственно.

T`l`d

Это Tэтап транслитерации. lИ dнаборы символов , используемые для транслитерации. lпредставляет строчный алфавит, dэто все цифры. Итак, он отображается abcdefghijобратно 0123456789.

C ++, 46 байт.

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

Впервые играю в гольф, но я вполне доволен собой. С радостью приму любую критику / предложения :)

Brain-Flak , 64, 62, 58 , 54 байта

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

Попробуйте онлайн!

[Попробуйте онлайн!]

Четыре байта сохранены благодаря @Riley!

Объяснение:

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

Для записи я попытался нажать 32 и увеличить в четыре раза, но это тот же счетчик байтов.

C # 6, 31 байт

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

Почти так же, как Java.

C # 5, 56 байт

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

Forth (gforth), 11 9 7 байтов

true U.

Попробуйте онлайн

trueтак же, как -1. U.печатает число в виде целого числа без знака.

Это работает на TIO, возможно, потому что он имеет 64-битную архитектуру? Я не уверен. -1 U.Например, если я запускаю repl.it, я получаю 2 ** 32-1. Если repl.it поддерживает целые числа двойной длины, UD.вместо них будет использоваться их вывод .

Python3 REPL, 11 байт

~0^~0>>~077

Как это работает

• ~ 0 - это -1 (дополнение к двум, бесконечная последовательность из 1)
• 077 это 63 в восьмеричном, поэтому ~ 077 это -64
• Сдвиг вправо с отрицательным параметром - это сдвиг влево
• Собирая все вместе, -1 xor (-1 << 64) это число, которое мы ищем

PowerShell , 29 14 байт

0xC000PB/3-3/3

Попробуйте онлайн!

Спасибо @ n0rd за то, что играли в гольф пополам.

Это использует встроенный унарный PBоператор, который в основном функционирует как «умножить предыдущее число на 1125899906842624» (т. Е. Сколько байтов в пебибайте). Это в сочетании с гексом 0xC000, или 49152, так 49152 pebibytes. Мы делим это на 3, уступая 18446744073709551616, и вычитаем, 3/3чтобы получить окончательное значение.

JavaScript (ES6), 50 байт

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

сборка x64, 7 байт

шестнадцатеричный (в сборе): 4831C048FFC8C3

разобрал, прокомментировал:
XOR RAX,RAX ;Zero the value of 64 bit register RAX DEC RAX ;Decrement the value of RAX RET ;Return this value

RAX является 64-битным регистром и чаще всего используется для возврата целочисленных аргументов (например, C). При уменьшении 1 его значение изменяется от 0 до ... 2 ^ 64-1, что точно необходимо.
Хотя собранный двоичный файл содержит единицы, четверки и восьмерки, сборка - нет, но собранный файл считается в сборке, так что же он считается? Ой, моя голова.
Кроме того, выход является возвращаемым значением в этом случае.

Brain-Flak , 223 193 байта

Включает +1 для -A
-30 благодаря DJMcMayhem

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

Попробуйте онлайн!

Это только выдвинуло значения ASCII и напечатало как символы.

Для справки, требуется 338 байтов, чтобы сгенерировать фактическое число, используя метагольфер Integer .

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

Попробуйте онлайн!

MATL, 8 байт

l_5Z%EZD

Возможно, это можно улучшить, но я пока не знаком со строками и типами в MATL.

Попробуйте это на matl.suever.net

Объяснение:

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 байт

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

код генерирует и затем предупреждает строку 18446744073709551615, используя побитовые операции

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

Swift, 8 байт

UInt.max

внешняя игровая площадка / repl - 15 байт

print(UInt.max)

TI-Basic, 10 байтов

9+7
Ans^Ans-0!