Проблема:

Ваша цель состоит в том, чтобы добавить два входных чисел без использования какой - либо из следующих операторов математики: +,-,*,/.

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

Подсчет очков:

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

Обновить

Большинство программ, которые я видел, объединяют два массива, содержащие их номера, или делают first numberиз символов, добавляют second numberсимволы, а затем подсчитывают их все.

Самый короткий счетчик массива: APL с 8 символами, Tobia

Объединение кратчайшего массива: Golfscript с 4 символами, от Doorknob

Кратчайшее логарифмическое решение: TI-89 Basic с 19-ю символами, по Quincunx

Интеграционное решение: Mathematica с 45 символами, автор Michael Stern

Круто, на мой взгляд: побитовые операторы в JavaScript, Дэйв

Smalltalk, 21 13

Все перечисленные ниже работают только с натуральными числами. Смотрите другой ответ Smalltalk для серьезного.

version1

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

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

version2

аналогично и даже немного короче (из-за правил старшинства Smalltalk и не требуется смещение вправо):

1<<a<<b log:2 

Version3

другой вариант темы «размер коллекции-конкатенации»,
заданный двумя числами a и b,

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

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

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

хотя не рекомендуется для тяжелого хруста числа.

Version4

Для вашего удовольствия, если вы хотите обменять время на память, попробуйте:

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

что обычно достаточно точно (но не гарантирует ;-)))

version5

записать в файл и спросить его размер

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

Я тут немного обманываю, ОП сказал, что не использует никаких математических операторов.

Формат *in printf()означает, что ширина поля, используемого для печати символа, берется из аргумента printf(), в данном случае 3 и 4. Возвращаемым значением printf()является количество напечатанных символов. Таким образом, он печатает один ' 'с шириной поля 3, а другой с шириной поля 4, всего 3 + 4 символа.

Возвращаемое значение - добавленные номера в printf()вызове.

Python - 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 Basic .

JavaScript [25 байт]

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

Mathematica, 21 байт

Есть несколько способов сделать это в Mathematica. Во-первых, используйте функцию Accumulate и бросьте все, кроме последнего числа в выводе. Как и в моем другом решении ниже, я предполагаю, что входные числа находятся в переменных 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 символа, исключив \,(массив подкачки)).

Старая версия (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

Smalltalk (сейчас серьезно), 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-битное дополнение, измените на 16rFFFFFFFFFFFFFFFFF.

версия для гольфа (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, мы можем лучше играть в гольф, но код больше не работает для чисел с произвольной точностью, только для smallIntegers размером с машинное слово (представление для largeIntegers не определено в стандарте 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

Ничего нового здесь, версия для подсчета массивов:

{≢∊⍳¨⍺⍵}

и журнал ○ версия журнала:

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

Я просто думал, что они выглядят круто в 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, поскольку его встроенная команда time отличается от времени 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 .

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

С (79)

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

Python - 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