Додавання без додавання (або будь-якого з 4 основних арифметичних операторів)


40

Проблема:

Ваша мета полягає в тому, щоб додати два вхідних чисел без використання будь - якої з таких операторів математики: +,-,*,/.

Крім того, ви не можете використовувати будь-які вбудовані функції, призначені для заміни цих математичних операторів.

Оцінка:

Найменший код (у кількості байтів) виграє.

Оновлення

Більшість програм, які я бачив, або об'єднують два масиви, що містять їх номери, або складають first numberсимвол, додають second numberсимволи, а потім рахують їх усі.

Найкоротший лічильник масивів: APL з 8 знаками, Tobia

Найкоротший зв'язок масиву: Гольфскрипт з 4 символами, автор Doorknob

Найкоротший логарифмічний розчин: TI-89 Basic з 19 символами, Quincunx

Інтеграційне рішення: Математика на 45 знаків, Майкл Стерн

Найкрутіший, на мій погляд: бітові оператори в JavaScript, від Дейва


Чи будуть у нього поплавці?
Ісмаїл Мігель

7
Чи матиме це від’ємне число? (Наразі всі відповіді припускають, що цифри будуть позитивними, тому ви, ймовірно, не повинні цього змінювати)
Doorknob

4
Що з математичними рішеннями? Ви забули їх перерахувати! Це інтегрується, і це грає з логарифмами
Джастін

3
Чому ви прийняли одне з довших рішень? Це тому, що він приймає негативні числа, тоді як найкоротші рішення ( це та це ) не роблять? Якщо так, моя відповідь підтримує негативні числа (вона також підтримує плаваючу крапку) і коротша за цю. Ви позначили це питання як код-гольф , таким чином, ви зобов'язані прийняти найкоротше рішення.
Джастін

2
Визначте "число". Будь-яке ціле число? Невід’ємні цілі числа? Чи повинні вони бути базовими-10?
SuperJedi224

Відповіді:


2

Smalltalk, 21 13

Усі наступні роботи працюють лише на додатні цілі числа. Дивіться іншу відповідь Smalltalk на серйозну.

версія1

перехід на велике ціле число і запит на його високий бітовий індекс (погано, індексація ST заснована на 1, тому мені потрібен додатковий правильний зсув):

(((1<<a)<<b)>>1)highBit

версія2

подібний і навіть трохи коротший (із-за правил пріоритету Smalltalk, і немає потрібного зсуву вправо):

1<<a<<b log:2 

версія3

ще одна зміна теми "розмір-об'єднувально-запитуючий розмір" з
двома числами a і b,

((Array new:a),(Array new:b)) size

використовуючи Intervals як колекцію, ми отримуємо більш зручну для пам'яті версію ;-) у 21 символі:

((1to:a),(1to:b))size

не рекомендується при сильному хрускіті кількості.

версія4

Для розваги, якщо ви хочете торгувати часом на пам’ять, спробуйте:

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

що зазвичай досить точне (але гарантії немає ;-)))

версія5

написати в файл і задати його розмір

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

45

Javascript (25)

while(y)x^=y,y=(y&x^y)<<1

Це додає дві змінні x і y, використовуючи лише побітові операції, і зберігає результат у x.

Це працює і з від’ємними числами.


1
@dave, якщо ви переходите на деякий час, ви можете зберегти ще два символи while(y)x^=y,y=(y&x^y)<<1!
Дом Гастінгс


3
@ user3125280, Проблема полягає не в тому, щоб "робити додавання, не роблячи додавання" (що є трохи безглуздим), а скоріше "робити додавання без основних математичних операторів"
Brian S,

8
@ user3125280, вибачте, але будь-яка грубість, яку ви інтерпретували з мого коментаря, не передбачалася. Я думаю, що вам буде важко знайти дуже багато людей, які згодні з тим, що XOR слід згрупувати з PLUS в категорію "основна арифметика". Навіть поза тим, як знайти людей, які згодні, ОП чітко зазначає, які оператори заборонені, і XOR не є одним з них. Ерго, це правдива відповідь.
Брайан S

3
for(;y;y=(y&x^y)<<1)x^=yна 1 байт коротше :)
Вільям Барбоса

22

C - 38 байт

main(){return printf("%*c%*c",3,0,4);}

Я тут трохи обманюю, ОП сказав, що не використовувати жодних математичних операторів.

Формат *у printf()форматі означає, що ширина поля, використовувана для друку символу, береться з аргументу printf(), у цьому випадку 3 і 4. Повернене значення printf()- кількість друкованих символів. Таким чином, друкуючи один ' 'із шириною поля 3, а один із шириною поля 4, становить 3 + 4 символи.

Повернене значення - це додані номери у printf()виклику.


3
Ви повинні зробити 3 та 4 параметри, і функція не повинна бути main. Крім того , якщо ви не хвилює , що ви друкуєте, ви можете замінити один ' 'з 0і опустити друге.
угорен

17

Пітон - 49 байт

Припускаючи введення шляхом розміщення в змінних xта y.

from math import*
print log(log((e**e**x)**e**y))

Це 61-байтне рішення - це повна програма:

from math import*
print log(log((e**e**input())**e**input()))

Враховуючи те, що ви не забороняли експоненцію, мені довелося це опублікувати. Коли ви спростите вираз, використовуючи властивості логарифмів, ви просто отримаєте print input() + input().

Це підтримує як від’ємні, так і числа з плаваючою комою.

Примітка. Я дотримувався порад гніблера і розділив цю відповідь на три. Це рішення Mathematica , і це базове рішення TI-89 .


Я намагався зробити щось подібне до Javascript, але забув, що це за формула, оскільки це було кілька років з моменту, коли я бачив її та шукав Інтернет, щоб знайти його.
Віктор Стафуса

4
@Victor Я створив формулу самостійно. Я дуже чітко пам’ятаю математику.
Джастін

1
Ваша Mathematica дуже близька, вам просто потрібно використовувати великі символи вбудованих символів. Журнал [Журнал [(E ^ E ^ x) ^ (E ^ y)]] працює (23 символи або 22, якщо ви використовуєте нотацію @ для обгортання зовнішньої функції).
Майкл Стерн

"Якщо мені дозволено приймати введення, розміщуючи в змінних x і y .." Я думаю, що ви можете це зробити і інші.
blabla999

@MichaelStern: Ви можете зберегти ще два символи, пропустивши круглі дужки навколо E^y. Використання, Log[Log[(E^E^x)^E^y]]здається, працює добре.
alexwlchan

14

JavaScript [25 байт]

~eval([1,~x,~y].join(''))

1
Ваша відповідь виглядає погано (і привабливо приваблює), але насправді це приємна відповідь. Будь-ласка, видаліть цю, щоб позбутися поточних записів, і повторно додайте текст із поясненням цього тексту. Я підтримаю вашу нову відповідь.
Віктор Стафуса

1
Зараз це виглядає дійсно добре, мені це подобається. Звичайно, варто більше грошей.
VisioN

13

Математика, 21 байт

Існує ряд способів зробити це в Mathematica. По-перше, скористайтеся функцією накопичення і киньте все, крім кінцевого числа у виході. Як і в іншому моєму рішенні нижче, я припускаю, що вхідні цифри знаходяться у змінних aта b. 21 байт.

Last@Accumulate@{a, b}

Веселіше, хоча це 45 символів, використовуйте цифри, щоб визначити рядок та інтегруватися під ним.

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

Як бонус, обидва рішення працюють для всіх складних чисел, а не лише для натуральних чисел, як це здається в деяких інших рішеннях.


2
Я люблю інтеграцію! (хоча, строго кажучи, це щось додає). +1
blabla999

1-е рішення недійсне. Цитуючи автора завдання: "Крім того, ви не можете використовувати будь-які вбудовані функції, призначені для заміни цих математичних операторів." Я дав це рішення: function _(){return array_sum(func_get_args());}. Мені довелося її зняти, тому що я не зміг знайти короткий спосіб «виправити».
Ісмаїл Мігель

@Ismael Miguel Accumulate [] не призначений для заміни Plus. Трапляється дати суму списку чисел серед його результатів, і я цим скористаюся.
Майкл Стерн

Але це дійсно складає суму всіх елементів у цьому списку, правда? Якщо це робиться, на мою думку, це так само недійсно, як і використання array_sum()в php, що робить те саме саме.
Ісмаїл Мігель

3
@Ismael Miguel Існує функція Mathematica, яка підсумовує масив, який називається Total []. Я погоджуюся, що це було б проти правил, як зазначено, використовувати цю функцію, але я цього не робив. Вихід Accumulate [{a, b}] не є + b.
Майкл Стерн

12

GolfScript, 6 4 символів / байт

Введіть у вигляді 10, 5(=> 15).

~,+,

+Є масив конкатенація, а не доповнення.

Як це працює, це те, що ,використовується для створення масиву довжини, яка є числом ( 0,1,...,n-2,n-1). Це робиться для обох чисел, потім масиви об'єднуються. ,знову використовується з іншою метою, щоб знайти довжину отриманого масиву.

Тепер ось ось хитрість . Мені це дуже подобається, оскільки він зловживає форматом введення. Це виглядає , як це просто введення масиву, але на самому справі, так як вхід виконується в GolfScript коді, перший ,вже зробив для мене! (Стара версія 6 символів була ~,\,+,з форматом введення 10 5, який я поголив на 2 символи, усунувши \,(swap-масив)).

Стара версія (12) :

Створює функцію f.

{n*\n*+,}:f;

*І +є рядки повторення і конкатенації , відповідно, не арифметичні функції.

Пояснення: nстворює односимвольний рядок (новий рядок). Потім це повторюється aраз, потім робиться те саме b. Рядки об'єднуються, а потім ,використовуються для довжини струни.


Чи працює це і для від’ємних чисел?
Майкл Стерн

@MichaelStern Ні, але це ніколи не згадувалося в питанні. Хм, я додав коментар. Більшість (насправді, всі ) інших відповідей також вважають позитивними.
Дверна ручка

Дивіться моє рішення Mathematica. Правильною мовою можливі рішення негативних чисел.
Майкл Стерн

@MichaelStern LOL @ "потрібна мова" на цьому сайті з усіх місць…
Tobia

10

C, 29 27 байт

Використання арифметики вказівника:

f(x,y)char*x;{return&x[y];}

x визначається як вказівник, але абонент повинен передати ціле число.

Анонімний користувач запропонував таке - також 27 байт, але параметри - цілі числа:

f(x,y){return&x[(char*)y];}

Перша форма, ймовірно, погано руйнується, якщо проходження двох ints на теперішній загальній системі, де intмає 32 біти, а вказівники мають 64 біт. Друга уникає цієї проблеми.
hvd

@hvd, Обидва працюють, принаймні на Linux 64bit. Цілі параметри все одно розширюються до розміру регістра машини.
угорен

А, чесно кажучи, погодився, що це, мабуть, буде звичайним випадком. Прокоментую ще раз, якщо я можу знайти конкретний приклад, який не працює. :)
hvd

8

Brainf * ck, 9 36

,>,[-<+>]

++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

Це працює без використання простого додавання; він проходить і прокладає слід 1-х, а потім підраховує їх

Примітка: +і -є лише поодинокими приростами, і нічого не можна зробити в brainf * ck без них. Вони насправді не є додаванням / відніманням, тому я вважаю, що це все ще має значення.


-1. Це просте доповнення. Якщо ви зробили щось, що не є додаванням, множенням і т. Д., То воно рахується, але як є, це не враховується.
Джастін

@Quincunx я виправив це; Я зробив це, проїжджаючи через і залишаючи слід тих, а потім підмітаючи та «підбираючи» цей слід
ЗАПИТАТИ

3
Зворотний. Хороша робота.
Джастін

6

J (6)

Ви не сказали, що ми не можемо використовувати функцію succ:

>:@[&0

Використання:

   9>:@[&0(8)
17

Він просто робить 9 повторень >:на 8.

Список конкатенації підхід працює, теж: #@,&(#&0). І - я знаю, що це проти правил - я не можу відпустити цю відповідь без самого рішення J-ish: *&.^(множення під експоненцією).


5

Постскрипт, 41

Ми визначаємо функцію з виразом 41 байт, поки:

/a{0 moveto 0 rmoveto currentpoint pop}def

Тоді ми називаємо це, наприклад, як:

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

Що дає

25.0

Він легко обробляє негативи та плаває, на відміну від більшості конкурентів :-)



4

Малий розмову (зараз серйозно), 123 118 105 (*)

Вибачте, що відповіли двічі, але вважайте це серйозною відповіддю, тоді як інший був більше схожий на гумор. Наступне насправді виконується саме в цей момент на всіх наших машинах (хоча і в апаратному забезпеченні). Дивно, що це нікому не спадало на думку ...

Комбінуючи два напівсуміші та паралельно виконуючи всі біти слів, ми отримуємо (входи a, b; вихід у s) читабельну версію:

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

Петля призначена для поширення на носі. Маски забезпечують обробку підписаних цілих чисел (без них можливі лише неподписані числа). Вони також визначають довжину слова, зазначене вище для 32-бітної операції. Якщо ви віддаєте перевагу 68-бітовому додатку, перейдіть на 16rFFFFFFFFFFFFFFFFFFF.

версія для гольфу (123 знаків) (уникає тривалої маски шляхом повторного використання м):

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) Використовуючи -1 замість 16rFFFFFFFF, ми можемо грати в гольф краще, але код більше не працює для довільних точних чисел, лише для невеликих цілих розмірів у машинному слові (представлення для великихІнтересів не визначено в стандарті Ansi):

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

це зменшує розмір коду до 105 символів.


Це код-гольф, тому гольф - це ваша відповідь.
Віктор Стафуса

1
шансів на перемогу немає, але я зроблю це за вас ;-)
blabla999

Приємно бачити відповідь Smalltalk!
Зубна щітка

4

APL, 8 та 12

Нічого нового тут, версія підрахунку масиву:

{≢∊⍳¨⍺⍵}

і версія журналу the журналу:

{⍟⍟(**⍺)**⍵}

Я просто подумав, що вони виглядають круто в APL!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

 

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

2
Справедливо кажучи, в APL все виглядає круто.
Майкл Стерн

Ви можете зробити перший негласною функцією префікса для 5:≢∘∊⍳¨
Adám

@ Adám Так, але мені не подобаються мовчазні функції, і мені важко їх читати.
Тобія

@Tobia Можливо, вам вони не подобаються, тому що вам важко читати? Я веду семінар з цього питання ... Ви бачили мій урок на ньому ?
Адам

@ Adám класно, дякую! Перевіримо це.
Тобія

4

sed, 359 байт (без фантазійного форматування)

Вибачте за пізню відповідь і, мабуть, найдовшу відповідь тут на сьогоднішній день. Але я хотів подивитися, чи можливо це за допомогою sed:

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

Це схоже на https://codegolf.stackexchange.com/a/38087/11259 , який просто збільшує числа в рядку. Але натомість він робить операції приросту в циклі.

Вхід береться від STDIN у формі "x y". Це спочатку перетворюється на "x: 0 :: y:". Потім ми збільшуємо всі числа, що надходять після символів ":", поки не отримаємо "x: x: :( x + y):". Тоді ми нарешті повертаємося (x + y).

Вихідні дані

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

Зауважте, що це працює лише для натуральних чисел. Однак (принаймні теоретично) він працює для довільно великих цілих чисел. Оскільки ми робимо операції з збільшенням x на y, впорядкування може змінити велику швидкість: x <y буде швидше, ніж x> y.


4

Тире , 18 байт

time -f%e sleep $@

Потрібен час GNU 1,7 або вище. Вихід - STDERR.

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

Зауважте, що це не буде працювати в B ash, оскільки його вбудована команда часу відрізняється від часу GNU.

Ціною одного додаткового байта \timeможна використовувати замість того, timeщоб змусити Bash використовувати зовнішню команду.


що станеться, якщо один із входів негативний?
Майкл Стерн

4
Це виходить з ладу. Так само, як і всі інші відповіді.
Денніс

5
Плями! Я сподівався, що це дасть результат перед тим, як поставити питання.
Тобія

3
Так. Я також сподівався, що, вставивши випадкові випадки, sleep -3я зможу прискорити свої програми. Який пустир.
Альфе

1
@userunknown також \timeповинен працювати в Bash.
Денніс

3

Javascript (67)

Мабуть, набагато краще

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

Ви не повинні дати остаточну відповідь, не знаючи, чи потрібні йому поплавці чи ні. І це не буде справлятися з NaN. Але це досить приємний код!
Ісмаїл Мігель

Я думаю, що все joinsце непотрібне. ArrayКонструктор робить масив undefineds, який можна перерахувати:a=Array;p=parseInt;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)
Ben Reich

@BenReich, ти маєш рацію, дякую
Майкл М.

@Michael Також Numberконструктор економить 2 персонажіparseInt
Бен Рейх

@Michael Крім того, якщо ви вилучите alert, вихід буде все-таки переходити на консоль, але це робить відповідь трохи менш цікавою. Ви також можете використати promptзмінну замість попередження (конструктор попереджає аргумент із запитом). У будь-якому випадку, приємна відповідь!
Бен Рейх

3

Рубін, 18 ч

a.times{b=b.next}

І ще два багатослівні варіанти, 29 символів

[*1..a].concat([*1..b]).size

Інша версія, 32 символи

(''.rjust(a)<<''.rjust(b)).size

3

C # - покоління льоту коду

Так, насправді є додавання, але не оператор + і навіть не рамкова функція, яка робить додавання, натомість ми генеруємо метод на ходу, який робить додавання.

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}


2

R 36

function(x,y)length(rep(1:2,c(x,y)))

де repбудується вектор xодиниць з подальшим yподвійним.


2
Ви можете зробити програму, яка робить те ж саме трохи коротше:length(rep(1:2,scan()))
Masclins

2

TI Basic 89 - 19 байт

Запустіть це у своєму TI-89 (Домашній екран або програма програмування):

ln(ln((e^e^x)^e^y))

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


3
Чи не ln1 байт у TI Basic? Також ви можете скинути дужки, що закриваються, знизивши це до 15 байт.
ɐɔıʇǝɥʇuʎs

2

Дякую Майклу Стерну за те, що він навчав мене нотації з математики .

Mathematica - 21 20 байт

Log@Log[(E^E^x)^E^y]

Для цього використовується той же підхід, що і це рішення , але саме в Mathematica зробити його коротше. Це працює для від'ємних чисел із плаваючою комою, а також цілих чисел у xта y.

Спрощення виразу за допомогою правил журналу дає результат x+y, але це справедливо, оскільки він використовує експоненцію, а не один із 4 основних операторів.


Ви впевнені, що це працює для складних чисел?
Майкл Стерн

2

C # - арифметика рядків

Ми перетворюємо обидва числа в рядки, робимо додавання за допомогою нарізки рядків (з перенесенням і всім, знаєте), а потім розбираємо назад до цілого числа. Тестований на i1, i2 в 0..200, працює як шарм. Знайдіть доповнення в цьому!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}




2

TI-BASIC, 10

Додає XіY

ln(ln(e^(e^(X))^e^(Y

1
Ви точно знаєте, як скопіювати рішення: codegolf.stackexchange.com/a/21033/9498
Джастін

По-перше, це не працює, оскільки він використовує журнал (замість ln (. По-друге, це насправді десять байтів, якщо записано у формі ln (ln (e ^ (e ^ (X)) ^ e ^ (Y.
lirtosiast

2

К, 2 байти

#&

Приклад використання:

  #&7 212
219

Застосуйте оператор "де" (монадичний &) до чисел у списку вхідних даних (можливо, вільний від формату введення). Це створить список, що містить перше число нулів, а потім друге число одиниць:

  &3 2
0 0 0 1 1

Зазвичай цей оператор використовується як "збирати" для створення списку індексів ненульових елементів булевого списку, але узагальнена форма корисна іноді.

Потім просто візьміть підрахунок цього списку (монадійний #).

Якщо моє тлумачення вимог до введення неприйнятне, наступне трохи довше рішення робить ту саму хитрість:

{#&x,y}

2

Pyth , 29 байт

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

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

Моє перше подання тут!

Цей компілюється для:

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H

1
Ласкаво просимо на сайт!
Пшеничний майстер
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.