Нещодавно ви зареєстрували обліковий запис на химерному азартному сайті, де за плату в 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 або 0x7fffffffffffffffffff в 64-бітній шістнадцятковій версії. Усі значення від 0 до цього значення ідентично переводяться на те саме 64-бітове значення. Усі значення n у зворотному (негативному) напрямку переводяться на 2 ^ 64-n. Наприклад: n = -1 адресовано 18446744073709551615. n = -9223372036854775808 адресовано 9223372036854775808.

Це в основному неподписані довги.

EDIT: Я все ще очікую, що Денніс перевершить мене за допомогою 2-байтного рішення.

C, 26 байт

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

Друкує unsigned longзначення.

Потрібен розмір longдо 64 біт.

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.maxintPython2 є також який можна використовувати, але я не буду на це дивитись.

repl.it <- посилання для тестування.

до н.е., 15 13 байт

Збережено 2 байти завдяки маневреній роботі.

(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 _(Е) * 10 ⁰ ) = 50 + 14 = 64

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

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

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

Рішення в постійному струмі: обчислення (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 / Октава, 5 байт

@Sanchises опублікував чудову відповідь MATLAB, однак цей підхід є значно іншим, тому я все-таки опублікую його:

tic/0

У MATLAB ticповертає кількість минулих мілісекунд з моменту відкриття програми. Найважливіше значення, яке воно повертає, - це uint64тип. Це відходить від необхідності uint64додавати номер до типу MATLAB за замовчуванням double.

Будь-яке число, поділене на 0 в MATLAB, розглядається як нескінченність, яке для типів без плаваючої точки MATLAB представляє це як максимальне ціле значення для цього типу.

Це також працює з Octave, хоча залежно від того, який інтерпретатор ви використовуєте, він також може виплюнути попередження "поділ на нуль". Ви можете спробувати код в Інтернеті тут, хоча, як я кажу, ви отримуєте попередження / 0, яке не відображається в MATLAB.

до н.е. ,18, 16 байт

• Збережено 2 байти, thx @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, що є 1111111111111111111111111111111111111111111111111111111111‌ 1111 у двійковій формі, у 64 біти, порівняно з 1111111111111111111111111111111111 в 32 бітах, а цифри залежать від платаформи - Ісмаел Мігель

MATLAB / Октава, 22 байти

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

Спробуйте в Інтернеті!

eyeвикористовується для створення одиничної матриці (матриця з 1по діагоналі, нуль інакше). Без аргументів це створює 1x1одиничну матрицю, або іншими словами, просто a 1. Він займає необов'язковий аргумент, який є типом даних ('class' у термінології MATLAB) створеної матриці. Таким чином, ми запитуємо 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 байт.

Сітківка , 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);}

Вперше коли-небудь робив кодовий гольф, але я досить задоволений собою. З радістю прийму будь-яку критику / пропозиції :)

Мозг-Флак , 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);}}

Четвертий (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, що саме потрібно.
Хоча зібраний двійковий файл містить одиниці і четвірки, і вісімки, збірка не робить, але зібраний файл зараховується у збірку, так чи вважається він? Ой, моя голова.
Також вихідний показник - це повернене значення в цьому випадку.

Мозг-Флак , 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

Швидкий, 8 байт

UInt.max

зовнішній майданчик / відбиток - 15 байт

print(UInt.max)

TI-Basic, 10 байт

9+7
Ans^Ans-0!