Проблема:

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

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

Оцінка:

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

Оновлення

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

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

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

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

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

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

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

Javascript (25)

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

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

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

C - 38 байт

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

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

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

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

Пітон - 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 [25 байт]

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

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

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

Last@Accumulate@{a, b}

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

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

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

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. Рядки об'єднуються, а потім ,використовуються для довжини струни.

C, 29 27 байт

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

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

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

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

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

Brainf * ck, 9 36

,>,[-<+>]

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

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

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

J (6)

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

>:@[&0

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

   9>:@[&0(8)
17

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

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

Постскрипт, 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

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

баш, 20 символів

(seq 10;seq 4)|wc -l

Малий розмову (зараз серйозно), 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 символів.

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 ⍵

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.

Тире , 18 байт

time -f%e sleep $@

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

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

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

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

Javascript (67)

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

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

Рубін, 18 ч

a.times{b=b.next}

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

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

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

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

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

Рубін 39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

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

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

TI Basic 89 - 19 байт

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

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

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

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

Mathematica - 21 20 байт

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

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

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

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()));
}

C (79)

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

Пітон - 22 символи

len(range(x)+range(y))

APL: 2

1⊥

Це перетворює числа з бази 1, тому (n * 1 ^ 1) + (m * 1 ^ 2), що рівно n + m.

Можна спробувати на TryApl.org

TI-BASIC, 10

Додає XіY

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

К, 2 байти

#&

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

  #&7 212
219

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

  &3 2
0 0 0 1 1

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

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

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

{#&x,y}

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