Раніше було багато викликів "Зробити __ без _ _", але я сподіваюся, що це один з найбільш складних.

Змагання

Ви повинні написати програму, яка приймає два натуральних числа (цілі числа> 0) від STDIN і друкує суму двох чисел до STDOUT. Завдання полягає в тому, що ви повинні використовувати якомога менше знаків +та -знаків. Вам заборонено використовувати будь-які функції, подібні до сум або заперечень.

Приклади

вхід

123
468

вихід

591

вхід

702
720

вихід

1422

Tie Breaker: Якщо дві програми мають однакову кількість +та -символів, переможцем стає людина з меншою кількістю / * ( ) = . ,та 0-9символів.

Не дозволено: мови, у яких стандартні оператори додавання / віднімання та збільшення / зменшення є символами, іншими +або -не дозволяються. Це означає, що мова Whitespace не заборонена.

Perl (немає +/-, немає перерв для краватки, 29 символів)

s!!xx!;s!x!$"x<>!eg;say y!!!c

Як бонус, ви можете зробити суму коду більше двох чисел, додавши xдо s більше s s!!xx!.

Крім того, тут є два 21-знакових рішення з 1 і 3 краватками відповідно

say length$"x<>.$"x<>

say log exp(<>)*exp<>

Примітка. Ці рішення використовують sayфункцію, доступну з Perl 5.10.0 за -Eдопомогою перемикача командного рядка або з use 5.010. Перегляньте історію редагування цієї відповіді для версій, які працюють на старих колах.

Як працює рішення без вимикачів?

• s!!xx!є оператором заміни регулярного виразу , який за замовчуванням працює на $_змінній, яка замінює порожній рядок рядком xx. (Зазвичай /використовується в якості регулярного виразу роздільником в Perl, але на самому справі майже будь-який символ може бути використаний я вибрав. , !Так як це не тай-брейка.) Це просто химерний спосіб випереджаючи "xx"до $_- або, так як $_починається порожній (невизначений, насправді), це дійсно спосіб писати, $_ = "xx"не використовуючи знак рівності (і з одним символом менше).

• s!x!$"x<>!egще одна заміна регулярное_вираженіе, на цей раз замінюючи кожен xв $_зі значенням виразу $" x <>. ( gКомутатор визначає глобальну заміну, eвказує, що заміну слід оцінювати як код Perl, а не використовувати як буквальну рядок.) $"- це спеціальна змінна , значення за замовчуванням якої є єдиним пробілом; використання його замість того, щоб " "заощадити одну таблицю. (Будь-яка інша змінна, яка, як відомо, має значення одного символу, наприклад, $&або $/, буде однаково добре працювати тут, за винятком того, що використання $/коштувало б мені вимикача.)

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

• y!!!cце лише незрозумілий спосіб (ab) використовувати оператор транслітерації для підрахунку символів у рядку ( $_за замовчуванням, знову). Я міг би щойно писати say length, але затуманена версія на один символ коротша. :)

R (24 символи)

length(sequence(scan()))

Що це робить:

• scan читає вхід зі STDIN (або файлу)
• sequenceгенерує цілі послідовності, починаючи з 1, і з'єднує послідовності. Наприклад, sequence(c(2, 3))результати в векторі1 2 1 2 3
• length обчислює кількість елементів у з'єднаному векторі

Приклад 1:

> length(sequence(scan()))
1: 123
2: 468
3:
Read 2 items
[1] 591

Приклад 2:

> length(sequence(scan()))
1: 702
2: 720
3:
Read 2 items
[1] 1422

D

main(){
    int a,b;
    readf("%d %d",&a,&b);
    while(b){a^=b;b=((a^b)&b)<<1;}
    write(a);
}

біт подвійний за виграш

як бонус скомпільований код не містить операції додавання (не можу говорити для виклику readf)

Python 2, 43 байти

print len('%s%s'%(input()*'?',input()*'!'))

GolfScript

Немає +/- або краватки:

# Twiddle some bits to get a few small integers
[]!~abs:two~abs:three!:zero~:minusone;

~[two base minusone%\two base minusone%]zip
zero:c;
{
    # Stack holds [x y] or [x] with implicit y is zero
    # Half adder using x y c: want to end up with sum on stack and carry back in c
    [~c zero]three<zero$
    ~^^\
    $~;:c;;
}%
[~c]minusone%two base

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

~[\]{,~}%,

Я припускаю, що GolfScript не дискваліфікують за те ), що він є оператором приросту, оскільки я його фактично не використовую.

C (лише 32 біт)

int main(int ac, char *av) {
    scanf("%d\n%d", &ac, &av);
    return printf("%d\n", &av[ac]);
}

Арифметика вказівника так само хороша.
Як це відповідає вимогам?
* Ні +або -
* Ні /, =, ., 0- 9
* Тільки 3 пари дужок, які , на мою думку мінімальним (вам потрібно main, scanf, printf).
* Один *(підхід покажчика цього вимагає).
* Чотири ,(можна зберегти одну, визначивши звичайні змінні, ні ac,av)

C ++ 0 +/-, 3 вимикачі

#include <vector>
#include <iostream>

#define WAX (
#define WANE )
#define SPOT .

int main WAX WANE {
    unsigned x;
    unsigned y;
    std::cin >> x >> y;
    std::vector<int> v WAX x WANE;
    std::vector<int> u WAX y WANE;
    for WAX auto n : u WANE {
        v SPOT push_back WAX n WANE;
    }
    std::cout << v SPOT size WAX WANE;
}

Хаскелл, 0 + 2

import Monad
main = join $ fmap print $ fmap length $ fmap f $ fmap lines getContents
f x = join $ flip replicate [] `fmap` fmap read x

Для цього використовується жодне +або -символи, і лише два =з набору символів вимикача краватки, один з яких обов'язковий для прив’язки main. Сума проводиться шляхом об'єднання списків відповідної довжини.

EDIT Це було розміщено перед тим, як правила змінені на заборонуsum ...

Мова R: Ніяких дзвінків +або -... І 9 символів автоматичного вимикача!

sum(as.numeric(readLines(n=2)))

Приклад:

> sum(as.numeric(readLines(n=2)))
123
456
[1] 579

The [1] 579 відповідь 579 ( [1]полягає в тому, щоб відстежувати, де у векторі результату ви знаходитесь, оскільки в R всі значення є векторами - у цьому випадку довжиною 1)

Зауважте, що R має +операторів, як і більшість мов - це просто так трапляєтьсяsum занадто велику кількість векторів.

В цьому випадку, readLines повертає рядовий вектор довжиною 2. Потім я примушую його до числового (парного) і підсумовую ...

Просто, щоб показати деякі інші функції R:

> 11:20 # Generate a sequence
 [1] 11 12 13 14 15 16 17 18 19 20

> sum(1:10, 101:110, pi)
[1] 1113.142

Мова R

Нові правила, нова відповідь, та сама мова. Немає дзвінків до +або-

ОНОВЛЕННЯ Використовуючи scan, воно зменшується до 11 символів вимикача (і всього 27 символів).

as.numeric(scan())%*%c(1,1)

Оригінал: 13 символів-крамачів!

as.numeric(readLines(n=2)) %*% c(1,1)

Приклад:

> as.numeric(readLines(n=2)) %*% c(1,1)
123
456
     [,1]
[1,]  579

Цього разу результат досягається шляхом матричного множення. Відповідь відображається у вигляді матриці 1x1.

Haskell, 0 +/ -, 6 2 вимикачі ( =)

(не використовує трюк конкатенації рядка / списку)

main = interact f
f x = show $ log $ product $ map exp $ map read $ lines x

Javascript, 56

p=prompt;alert(Array(~~p()).concat(Array(~~p())).length)

Дякуємо @JiminP на ~~ підказці! Я збираюсь щонайменше байт, тому 1 байт збереження на p = підказку; все одно того варте. Я розумію ваш аргумент щодо символів вимикача, але якщо чесно, чи не найменше байтів :-p

Версія, 69

i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)

Завдяки деяким відгукам від @Ilmari та @JiminP, я поголив 13 байт від мого оригінального рішення.

Спочатку 82

i=parseInt;p=prompt;a=Array(i(p()));a.push.apply(a, Array(i(p())));alert(a.length)

С

b[500];i;j;main(){scanf("%d%d",&i,&j);printf("%d\n",sprintf(b,"%*s%*s",i,"",j,""));

APL (немає +/-, немає перерв для краватки, 8 або 10 символів)

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

Код:

⍴⊃⍪⌿⍳¨⎕⎕

Справа наліво:

• Кожна цитата-квадратик ( ⎕ ) ) запитує введення даних від користувача та оцінює його.
• Кожен оператор ( ¨ ) застосовує функцію генератора індексу () ⍳ ) до кожного з елементів масиву праворуч.
• Це згладжує отриманий масив масивів в один масив. Вхідний масив зменшується до плоского списку оператором скорочення ( /), який складає масив за допомогою функції конкатенації (, ). Для цього завдання використовується оператор одновимірного скорочення ( ⌿) разом з оператором конкатенації вздовж першої осі ( ⍪).
• В результаті використання оператора скорочення масив є укладається , що схоже на розміщення його в мішку; Все, що ми бачимо зовні, - це сумка, а не її вміст. Оператор розкриття (⊃ ) надає нам вміст вкладеного масиву (мішка).
• Нарешті, функція форми ( ⍴ ) дає нам довжини розмірів масиву. У цьому випадку у нас є одновимірний масив, тому ми отримуємо кількість елементів у масиві, що є нашим результатом.

Якщо нам потрібно чітко вивести результат, ми можемо зробити так:

⎕←⍴⊃⍪⌿⍳¨⎕⎕

Порівняний код Python з відповідними символами APL, наведеними вище:

import operator

⎕←     ⍴    ⌿        ⍪                 ¨              ⍳                ⎕        ⎕         ⊃
print (len (reduce (operator.__add__, [map (lambda n: range (1, n+1), [input(), input()])][0])))

Я хотів би знати , якщо є більш короткий варіант можна в APL - інший, більш простий варіант я придумав , що має більше краватки вимикачі (хоча до сих пір на 8 символів) є: ⍴(⍳⎕),⍳⎕.

Я не бачив, щоб хтось робив це з електротехніки, тож ось мій прийом (у рубіні):

def please_sum(a, b)
    return (a&b !=0)? please_sum( ((a&b)<<1) , a^b ):a^b
end

Це трохи некрасиво, але це робить роботу. Дві значення порівнюються порозрядно AND. Якщо у них немає спільних бітів, у наступний двійковий стовпчик немає "перенесення", тому додавання може бути завершено шляхом XORїх розрядного введення . Якщо є перенесення, вам доведеться додати перенесення по долотах XOR. Ось невеликий сценарій рубіну, який я використовував, щоб переконатися, що моя цифрова логіка не надто іржава:

100.times do
    a=rand 10
    b=rand 10
    c=please_sum(a,b)
    puts "#{a}+#{b}=#{c}"
    end

Ура!

Насіння , 3904 3846 11 байт, 0 +/-, 10 розривів краватки

4 141745954

Шелл, 52

read a
read b
(seq 1 $a;seq 1 $b)|wc|awk '{print$1}'

Це в основному та сама відповідь, яку я дав для іншої проблеми.

С

a,b;A(int a,int b){return a&b?A(a^b,(a&b)<<1):a^b;}
main(){scanf("%d%d",&a,&b);printf("%d\n",A(a,b));}

C #

Це не найкоротше з будь-якого розтягування:

private static int getIntFromBitArray(BitArray bitArray)
{
    int[] array = new int[1];
    bitArray.CopyTo(array, 0);
    return array[0];
}

private static BitArray getBitArrayFromInt32(Int32 a)
{
    byte[] bytes = BitConverter.GetBytes(a);
    return new BitArray(bytes);
}

static void Main(string[] args)
{
    BitArray first = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray second = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray result = new BitArray(32);

    bool carry = false;
    for (int i = 0; i < result.Length; i++)
    {
        if (first[i] && second[i] && carry)
        {
            result[i] = true;
        }
        else if (first[i] && second[i])
        {
            result[i] = false;
            carry = true;
        }
        else if (carry && (first[i] || second[i]))
        {
            result[i] = false;
            carry = true;
        }
        else
        {
            result[i] = carry || first[i] || second[i];
            carry = false;
        }
    }
    Console.WriteLine(getIntFromBitArray(result));
}

J, 15 7 символів, 1 краватка, неповна програма

Це моя спроба J. Це не повна програма, тому що я ще не зрозумів, як її написати. Просто введіть цей рядок у сценарій, щоб отримати функцію, pяку можна використовувати для додавання довільної кількості чисел. Це монада і приймає список номерів, які потрібно додати (наприклад, p 1 2 3 4):

p=:#@#~

Ідея дуже проста. Функція написана в негласному стилі ака. Ось чітке визначення:

p=:3 :'##~y'

Читайте справа наліво. У мовчазній версії @складено частини функції. (як ∘ з математики [(f∘g) (x) = f (g (x)])

• y є параметром p .
• ~робить дієслово рефлексивним. Для якогось дієсловаm , m~ aтак самоa m a .
• #(Копіювати, a#b): Кожен елемент в aреплицируется iраз, коли iце елемент , в той же індекс, що і поточний елемент aз b. Таким чином,#~ копіює предметn n раз.
• # (рахувати, #b ): кількість елементів у b.

Висновок: J чудовий і менш читабельний, ніж Perl (що робить його ще більш дивовижним)

Правки

• 15 -> 7, використовуючи #замістьi. . Ага! Менше символів, ніж гольфскрипт.

Більше програми

Цей запит на введення, але він все ще не є повноцінною програмою: (13 символів, 3 вимикачі)

##~".1!:1<#a:

Javascript (17 символів автоматичного вимикача)

eval('걢갽거걲걯걭거건갨걡갽거걲걯걭거건갨걹갽걦걵걮걣건걩걯걮갨걡갩걻걣갽걮걥걷갠걕걩걮건갸걁걲걲걡걹갨걡갩갻걦걯걲갨걩갠걩걮갠걣갩걩걦갨걩갽갽걾걾걩갩걸갮거걵걳걨갨갱갩걽갬걸갽걛걝갩갩갻걹갨걡갩갻걹갨걢갩갻걡걬걥걲건갨걸갮걬걥걮걧건걨갩갻'['split']('')['map'](function(_){return String['fromCharCode'](_['charCodeAt'](~~[])^0xac00)})['join'](''))

: P ("Замкнено", щоб зменшити кількість символів вимикача. Внутрішнє, це b=prompt(a=prompt(y=function(a){c=new Uint8Array(a);for(i in c)if(i==~~i)x.push(1)},x=[]));y(a);y(b);alert(x.length); .)

C #,

Програма працює на 1 рядку; розділені на кілька ліній, щоб уникнути горизонтальної прокрутки.

using C=System.Console;
class A{
static void Main(){
int a,b,x,y;
a=int.Parse(C.ReadLine());
b=int.Parse(C.ReadLine());
do{x=a&b;y=a^b;a=x<<1;b=y;}while(x>0);
C.WriteLine(y);
}}

Clojure (44 символи)

(pr(#(count(concat(%)(%)))#(repeat(read)0)))

Редагувати: виправлено для друку на STDOUT, а не просто повернення суми.

Скала

• оцінка:
  • + -: 0
  • (). : 5 + 5 + 3 = 13

Код:

(List.fill (readInt) (1) ::: List.fill (readInt) (2)).size

• List.fill (4) (7) створює Список (7, 7, 7, 7)
• a ::: b об'єднує 2 списки в один
• Решта має бути очевидним

К, 11

{#,[!x;!y]}

Той самий трюк конкатенації, як і рішення R. Читання справа наліво: Перелічіть дві вхідні змінні, об'єднайте і потім підрахуйте.

PowerShell , 27 42 байт, 0 +-, 4 1 середня

^{Завдяки маззі за збереження а +та 4 вторинників}

$args|%{[int[]]$_*$_}|measure|select count

Спробуйте в Інтернеті! або Гарненька таблиця на додаткові 3 байти

- Або - додавання чотирьох вторинних даних, щоб зберегти 19 байт:

32 23 байти, 1 0 +-, 12 5 вторинників

^{-9 байт завдяки мазі}

($args|%{,$_*$_}).count

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

Для кожного аргументу ми висуваємо nелементи масиву (що складається з, [n]але це не важливо) до конвеєра, які групуються по паренам і потім підраховуються.

Keg (SBCS на вікі Keg)

В основному порт відповіді R.

¿¿Ï_"Ï_!.

Пояснення

¿¿#        Take 2 integer inputs
  Ï_"Ï_#   Generate 2 arrays the length of the integer inputs
       !.# Output the length of the stack

05AB1E , 2 4 байти, 0 +/-

F>

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

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

Пояснення:

 F   #Loop A many times
  >  #Increment B
     #(Implicit output)

-2 байт завдяки Гримі.

Пітон 3

Не покладаючись на приховані підсумки в інших функціях.

h=input;x,y=int(h()),int(h())
while y:c=x&y;x^=y;y=c<<1
print(x)

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

D

main(){
    int a,b;
    readf("%d %d",&a,&b);
    write((new int[a]~new int[b]).length);
}

на цей раз з використанням довжини масиву