Codegolf — Сложение Без Сложения (Или Любой Из 4 Основных Арифметических Операторов)

Проблема:

Ваша цель — сложить два входных числа, не используя ни одного из следующих математических операторов: second number .

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

Оценка:

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

Обновлять

Большинство программ, которые я видел, либо объединяют два массива, содержащие их числа, либо создают first number of a character, append +,-,*,/ символов, затем посчитайте их все.

Кратчайший счетчик массива: APL с 8 символами, автор: Тобиа

Кратчайшая конкатенация массивов: Гольфскрипт из 4 символов, автор Doorknob

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

Интеграционное решение: Mathematica с 45 символами, Майкл Стерн

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

#код-гольф

Яваскрипт (25)

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

При этом добавляются две переменные x и y, используя только побитовые операции, и сохраняется результат в x.

Это работает и с отрицательными числами.

С – 38 байт

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

{#&x,y} in the # означает, что ширина поля, используемая для печати символа, берется из аргумента &3 2 0 0 0 1 1 , in this case, 3 and 4. The return value of & количество напечатанных символов. Итак, он печатает один #&7 212 219 with a field-width of 3, and one with a field-width of 4, makes 3 + 4 characters in total.

Возвращаемое значение — это добавленные числа в #& call.

Питон — 49 байт

Предполагая ввод путем размещения в переменных ln(ln(e^(e^(X))^e^(Y and Y .

Этот 61 байт решение представляет собой полную программу:

Учитывая, что возведение в степень вы не запретили, мне пришлось это выложить. Упрощая выражение, используя свойства логарифмов, вы просто получаете len(range(x)+range(y)) .

Это поддерживает как отрицательные числа, так и числа с плавающей запятой.

Примечание: я последовал совет грызуна и разделите этот ответ на три. Это решение Mathematica, и это Базовое решение ТИ-89.

JavaScript [25 байт]

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

Ввод в виде 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())); } (=> x+y ).

x is array concatenation, not addition.

Как это работает, так это Log@Log[(E^E^x)^E^y] is used to create an array of the length that the number is ( x+y ). Это делается для обоих чисел, затем массивы объединяются. ln(ln((e^e^x)^e^y)) is used again for a different purpose, to find the length of the resulting array.

Сейчас, вот в чем трюк. Мне очень нравится этот вариант, потому что он злоупотребляет форматом ввода. Это выглядит как будто это просто ввод массива, но на самом деле, поскольку ввод выполняется как код GolfScript, первый y is already done for me! (The old 6-character version was x с форматом ввода rep , which I shaved 2 chars off by eliminating the function(x,y)length(rep(1:2,c(x,y))) (массив подкачки)).

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

Создает функцию f=->a,b{[*1..a].concat([*1..b]).length} .

(''.rjust(a)<<''.rjust(b)).size and [*1..a].concat([*1..b]).size являются повторением и конкатенацией строк соответственно, а не арифметическими функциями.

Объяснение: a.times{b=b.next} creates a one-character string (a newline). This is then repeated a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length) раз, то то же самое делается с ( [ 't' asFilename writingFileDo:[:s | a timesRepeat:[ 'x' printOn:s ]. b timesRepeat:[ 'x' printOn:s ]]; fileSize ] ensure:[ 't' asFilename delete ] ) print . The strings are concatenated, and then Time secondsToRun:[ Delay waitForSeconds:a. Delay waitForSeconds:b. ] используется для длины строки.

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

В Mathematica есть несколько способов сделать это. Во-первых, используйте функцию Accumulate и выбросьте в выходные данные все, кроме окончательного числа. Как и в случае с другим моим решением ниже, я предполагаю, что входные числа находятся в переменных ((1to:a),(1to:b))size and ((Array new:a),(Array new:b)) size . 21 байт.

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

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

С, 29 27 байт

Использование арифметики указателей:

\time is defined as a pointer, but the caller should pass an integer.

Анонимный пользователь предложил следующее — тоже 27 байт, но параметры — целые числа:

Брейнф*к, 9 36

Это работает без использования простого сложения; он проходит и оставляет след из единиц, а затем подсчитывает их

Примечание: {⍟⍟ } the double logarithm of (**⍺) the double exponential of ⍺ * raised to *⍵ the exponential of ⍵ and {≢ } count ∊ all the elements in ⍳¨ the (two) sequences of naturals from 1 up to ⍺⍵ both arguments это всего лишь единичные приращения, и без них ничего сделать, черт возьми, невозможно. На самом деле это не сложение/вычитание, поэтому я считаю, что это все еще имеет значение.

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

Мы определяем функцию с выражением длиной 41 байт:

Тогда мы называем это, например. как:

Что дает

Он легко справляется с негативами и плавает, в отличие от большинства конкурентов:-)

Дж (6)

Вы не сказали, что мы не можем использовать функцию succ:

Использование:

Он просто делает 9 повторений (seq 10;seq 4)|wc -l on 8.

Подход конкатенации списков тоже работает: *&.^ . And - I know it's against the rules - I can't let this answer go without the most J-ish solution: #@,&(#&0) (умножение при возведении в степень).

Баш, 20 символов

Smalltalk (теперь серьезно), 123 118 105(*)

Извините, что отвечаю дважды, но считайте это серьезным ответом, а другой был больше похож на юмор. Следующее на самом деле выполняется прямо в этот самый момент на всех наших машинах (правда, аппаратно). Странно, что это никому не пришло в голову...

Объединив два полусумматора и выполняя все биты слов параллельно, мы получаем (входы a,b; вывод в s) читаемую версию:

Цикл предназначен для распространения переноса.

Маски обеспечивают обработку целых чисел со знаком (без них возможны только числа без знака).

Они также определяют длину слова, причем вышеприведенное относится к 32-битной операции. Если вы предпочитаете 68-битное сложение, измените его на 16rFFFFFFFFFFFFFFFFFF.

версия для гольфа (123 символа) (длинная маска позволяет избежать повторного использования в m):

это уменьшает размер кода до 105 символов.

АПЛ, 8 и 12

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

Я просто подумал, что они круто смотрятся в APL!

sed, 359 байт (без причудливого форматирования) https://codegolf.stackexchange.com/a/38087/11259Извините за поздний ответ, и, вероятно, это самый длинный ответ здесь. Но я хотел посмотреть, возможно ли это с помощью sed:

Это похоже на

, который просто увеличивает числа в строке. Но вместо этого он выполняет операции приращения в цикле.

Входные данные берутся из STDIN в форме «x y». Сначала это преобразуется в «x:0::y:». Затем мы увеличиваем все числа, которые идут после символов «:», пока не получим «x:x::(x+y):». Затем мы наконец возвращаем (x+y).

Обратите внимание, что это работает только для натуральных чисел. Однако (по крайней мере теоретически) это работает для сколь угодно больших целых чисел. Поскольку мы выполняем операции увеличения x над y, порядок может существенно повлиять на скорость: x < y будет быстрее, чем x > y.

Бросаться

, 18 байт

Обратите внимание, что это не будет работать в Бash, поскольку его встроенная команда времени отличается от времени GNU.

За счет одного дополнительного байта x can be used instead of f(x,y)char*x;{return&x[y];} чтобы заставить Bash использовать внешнюю команду.

Смоллток, 21 13

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

версия1

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

версия2

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

версия3

еще один вариант темы «объединение коллекций и запрос размера»,
даны два числа a и b,

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

Однако не рекомендуется для тяжелой обработки чисел.

версия4

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

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

версия5

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

Яваскрипт (67)

Наверное, есть намного лучше

Руби, 18 символов

И еще два многословных варианта, 29 символов.

Другая версия, 32 символа

C# — генерация кода на лету

Да, на самом деле там есть сложение, но не оператор + и даже не функция фреймворка, которая складывает, вместо этого мы на лету генерируем метод, который складывает.

Руби 39

36 рэндов

где 10 5 builds a vector of ~,\,+, те, за которыми следуют , twos.

TI Basic 89 – 19 байт

Запустите это на своем TI-89 (главный экран или приложение для программирования):

При этом используются правила журнала для вычисления 0,1,...,n-2,n-1 , just like in это решение. В качестве бонуса он работает для десятичных и целых чисел. Это работает для всех действительных чисел. Если правила логарифма по-прежнему действительны для комплексных показателей, то это работает и для комплексных чисел. Однако мой калькулятор выдает мусор, когда я пытаюсь вставить комплексные показатели.

Благодаря Майклу Штерну за то, что научил меня нотации Mathematica..

Математика - 21 20 байт

Здесь используется тот же подход, что и это решение, но в системе Mathematica оно сделано короче. Это работает для отрицательных чисел и чисел с плавающей запятой, а также для целых чисел в + and ~,+, .

Упрощение выражения с использованием правил журнала дает 15 , but this is valid since it uses exponentiation, not one of the 4 basic operators.

C# — строковая арифметика

Мы конвертируем оба числа в строки, выполняем сложение с обрезкой строк (с переносом и всем остальным, вы знаете), а затем возвращаем целое число. Протестировано с i1, i2 в диапазоне 0..200, работает как часы. Найдите дополнение в этом!

С (79)

Питон — 22 символа

АПЛ: 2

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

Можно попробовать на TryApl.org

ТИ-БЕЙСИК, 10

Добавляет from math import* print log(log((e**e**x)**e**y)) and y

К, 2 байта

Пример использования:

Примените оператор «где» (монадический printf() ) to the numbers in an input list (possibly taking liberty with the input format). This will produce a list containing the first number of zeroes followed by the second number of ones:

Обычно этот оператор используется как «сборщик» для создания списка индексов ненулевых элементов логического списка, но иногда бывает полезна обобщенная форма.

Затем просто посчитайте этот список (монадический printf() ).

Если моя интерпретация входных требований неприемлема, следующее немного более длинное решение делает тот же трюк:

Пиф, 29 байт

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

Моя первая подача здесь!

Это компилируется в: