Problem:

Twoim celem jest dodanie dwóch liczb wejściowych bez korzystania z któregokolwiek z następujących operatorów matematycznych: +,-,*,/.

Ponadto nie można używać żadnych wbudowanych funkcji, które zostały zaprojektowane w celu zastąpienia tych operatorów matematycznych.

Punktacja:

Najmniejszy kod (w liczbie bajtów) wygrywa.

Aktualizacja

Większość programów, które widziałem, albo łączy dwie tablice zawierające ich liczby, albo markę first numberpostaci, dodaje second numberznaki, a następnie zlicza je wszystkie.

Najkrótszy licznik tablic: APL z 8 znakami, autor: Tobia

Najkrótsza konkatenacja macierzy: Golfscript z 4 znakami, autor: Doorknob

Najkrótsze rozwiązanie logarytmiczne: TI-89 Basic z 19 znakami, Quincunx

Rozwiązanie integracyjne: Mathematica z 45 znakami, autor: Michael Stern

Najfajniejsze, moim zdaniem: bitowe operatory w javascript, autor: dave

Smalltalk, 21 13

Wszystkie poniższe działania działają tylko na dodatnie liczby całkowite. Zobacz inną odpowiedź Smalltalk na poważną.

wersja 1

przejście do dużej liczby całkowitej i pytanie o jej wysoki indeks bitowy (źle, indeksowanie ST jest oparte na 1, więc potrzebuję dodatkowego przesunięcia w prawo):

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

wersja 2

podobne, a nawet nieco krótsze (ze względu na reguły pierwszeństwa Smalltalk i niepotrzebne przesunięcie w prawo):

1<<a<<b log:2 

wersja 3

kolejna odmiana motywu „rozmiar zestawiania-łączenia-pytania”, z
podaniem dwóch liczb a i b,

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

wykorzystując Interwały jako kolekcję, otrzymujemy wersję bardziej przyjazną dla pamięci ;-) w 21 znakach:

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

nie jest to jednak zalecane w przypadku dużej liczby awarii.

wersja 4

Dla rozrywki, jeśli chcesz wymienić czas na pamięć, spróbuj:

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

co zwykle jest wystarczająco dokładne (ale nie ma gwarancji ;-)))

wersja 5

napisz do pliku i zapytaj o jego rozmiar

(
    [
        '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

Dodaje to dwie zmienne x i y, używając tylko operacji bitowych, i zapisuje wynik w x.

Działa to również z liczbami ujemnymi.

C - 38 bajtów

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

Trochę tu oszukuję, OP powiedział, żeby nie używać żadnych operatorów matematycznych .

*W printf()użyciu wielkoformatowych że pole szerokość używane do drukowania znaku jest przenoszony z argumentem printf(), w tym przypadku, 3 i 4. Wartość zwracana printf()jest liczba znaków drukowanych. Więc drukuje jeden ' 'z polem o szerokości 3, a drugi z polem o szerokości 4, daje w sumie 3 + 4 znaki.

Wartość zwracana to dodane liczby w printf()połączeniu.

Python - 49 bajtów

Zakładając wkład przez umieszczenie w zmiennych xi y.

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

To 61 bajtowe rozwiązanie jest pełnym programem:

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

Biorąc pod uwagę, że nie zakazałeś potęgowania, musiałem to opublikować. Kiedy upraszczasz wyrażenie za pomocą właściwości logarytmów, po prostu dostajesz print input() + input().

Obsługuje zarówno liczby ujemne, jak i zmiennoprzecinkowe.

Uwaga: postępowałem zgodnie z radą gnibblera i podzieliłem tę odpowiedź na trzy. To jest rozwiązanie Mathematica , a to jest podstawowe rozwiązanie TI-89 .

JavaScript [25 bajtów]

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

Mathematica, 21 bajtów

Jest wiele sposobów na zrobienie tego w Mathematica. Po pierwsze, użyj funkcji Akumuluj i podrzuć wszystko oprócz ostatniej liczby na wyjściu. Podobnie jak w przypadku mojego innego rozwiązania poniżej, zakładam, że liczby wejściowe są w zmiennych ai b. 21 bajtów.

Last@Accumulate@{a, b}

Więcej zabawy, chociaż ma 45 znaków, użyj liczb, aby zdefiniować linię i zintegrować pod nią.

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

Jako bonus, oba rozwiązania działają dla wszystkich liczb zespolonych, a nie tylko dodatnich liczb całkowitych, jak się wydaje w przypadku niektórych innych rozwiązań tutaj.

GolfScript, 6 4 znaki / bajty

Dane wejściowe w postaci 10, 5(=> 15).

~,+,

Jest +to konkatenacja macierzy, a nie dodawanie.

Działa to tak, ,aby utworzyć tablicę o długości, która jest liczbą ( 0,1,...,n-2,n-1). Odbywa się to dla obu liczb, a następnie tablice są łączone. ,jest używany ponownie w innym celu, aby znaleźć długość wynikowej tablicy.

Teraz tutaj jest podstęp . Naprawdę podoba mi się ten, ponieważ nadużywa formatu wejściowego. To wygląda jak to tylko wprowadzanie tablicę, ale tak naprawdę, ponieważ wejście jest wykonany jako kod GolfScript, pierwszy ,jest już dla mnie zrobił! (Stara 6-znakowa wersja miała ~,\,+,format wejściowy 10 5, który ogoliłem 2 znaki, eliminując \,(swap-array)).

Stara wersja (12) :

Tworzy funkcję f.

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

*I +są powtórzeniem ciąg konkatenacji i odpowiednio, nie funkcje arytmetyczne.

Objaśnienie: ntworzy ciąg jednoznakowy (nowy wiersz). Jest to następnie powtarzane arazy, a następnie robi się to samo b. Ciągi są łączone, a następnie ,są używane do długości ciągu.

C, 29 27 bajtów

Używanie arytmetyki wskaźnika:

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

x jest zdefiniowany jako wskaźnik, ale osoba dzwoniąca powinna przekazać liczbę całkowitą.

Anonimowy użytkownik zasugerował następujące - również 27 bajtów, ale parametry są liczbami całkowitymi:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Działa to bez użycia prostego dodatku; przechodzi i kładzie ślad 1, a następnie je zlicza

Uwaga: +i -są tylko pojedynczymi przyrostami i bez nich nic nie można zrobić w mózgu *. Nie są to tak naprawdę dodawanie / odejmowanie, więc uważam, że to się nadal liczy.

J (6)

Nie powiedziałeś, że nie możemy użyć funkcji succ:

>:@[&0

Stosowanie:

   9>:@[&0(8)
17

Wykonuje tylko 9 powtórzeń z >:8.

Podejście lista konkatenacji działa zbyt: #@,&(#&0). I - Wiem, że jest to niezgodne z regułami - nie mogę pozwolić, by ta odpowiedź przebiegła bez najbardziej J-tego rozwiązania: *&.^(mnożenie pod potęgowaniem).

Postscriptum, 41

Definiujemy funkcję wyrażeniem o długości 41 bajtów, ponieważ:

/a{0 moveto 0 rmoveto currentpoint pop}def

Następnie nazywamy to np .:

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

Co daje

25.0

Z łatwością radzi sobie z negatywami i zmiennymi, w przeciwieństwie do większości konkurentów :-)

bash, 20 znaków

(seq 10;seq 4)|wc -l

Smalltalk (teraz poważnie), 123 118 105 (*)

Przepraszam, że odpowiedziałem dwa razy, ale uważaj to za poważną odpowiedź, podczas gdy druga była bardziej jak humor. W tym momencie na wszystkich naszych komputerach (choć sprzętowo) wykonywane jest poniższe polecenie. Dziwne, że nikomu to nie przyszło do głowy ...

Łącząc dwa pół-sumatory i wykonując wszystkie bity słów równolegle, otrzymujemy (dane wejściowe a, b; dane wyjściowe ws) wersji do odczytu:

  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           

Pętla służy do propagacji przenoszenia. Maski zapewniają obsługę podpisanych liczb całkowitych (bez nich możliwe są tylko niepodpisane liczby). Określają również długość słowa, powyższe dotyczy operacji 32-bitowej. Jeśli wolisz dodawanie 68-bitowe, zmień na 16rFFFFFFFFFFFFFFFFF.

wersja golfowa (123 znaki) (unikanie długiej maski poprzez ponowne użycie wm):

[: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]

(*) Używając -1 zamiast 16rFFFFFFFF, możemy lepiej grać w golfa, ale kod nie działa już dla liczb o dowolnej dokładności, tylko dla małych liczb całkowitych wielkości maszyny (reprezentacja dużych liczb całkowitych nie jest zdefiniowana w standardzie 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]

zmniejsza to rozmiar kodu do 105 znaków.

APL, 8 i 12

Nic nowego tutaj, wersja z liczeniem tablic:

{≢∊⍳¨⍺⍵}

oraz log version wersja dziennika:

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

Pomyślałem, że wyglądają świetnie w 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 bajtów (bez fantazyjnego formatowania)

Przepraszamy za późną odpowiedź i prawdopodobnie najdłuższą odpowiedź tutaj. Chciałem jednak sprawdzić, czy jest to możliwe dzięki 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/;
                       # # # # # # #  # # # # # # #

Jest to podobne do https://codegolf.stackexchange.com/a/38087/11259 , który po prostu zwiększa liczby w ciągu. Zamiast tego wykonuje operacje przyrostowe w pętli.

Dane wejściowe są pobierane ze STDIN w postaci „x y”. To jest najpierw przekształcane na „x: 0 :: y:”. Następnie zwiększamy wszystkie liczby występujące po znakach „:”, aż otrzymamy „x: x: :( x + y):”. Potem w końcu wracamy (x + y).

Wydajność

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

Zauważ, że działa to tylko dla liczb naturalnych. Jednak (przynajmniej teoretycznie) działa dla dowolnie dużych liczb całkowitych. Ponieważ wykonujemy operacje przyrostowe x na y, kolejność może mieć duży wpływ na szybkość: x <y będzie szybsze niż x> y.

Dash , 18 bajtów

time -f%e sleep $@

Wymaga czasu GNU 1.7 lub nowszego. Dane wyjściowe są do STDERR.

Wypróbuj online!

Zauważ, że to nie zadziała w B ash, ponieważ jego wbudowane polecenie czasu różni się od czasu GNU.

Kosztem jednego dodatkowego bajtu \timemożna użyć zamiast timezmusić Bash do użycia polecenia zewnętrznego.

JavaScript (67)

Prawdopodobnie jest znacznie lepiej

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

Ruby, 18 znaków

a.times{b=b.next}

I jeszcze dwa pełne warianty, 29 znaków

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

Kolejna wersja, 32 znaki

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

C # - przy generowaniu kodu w locie

Tak, w rzeczywistości jest tam dodatek, ale nie ma operatora +, a nawet funkcji ramowej, która dodaje, zamiast tego generujemy w locie metodę, która dodaje.

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

Rubin 39

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

R 36

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

gdzie repbuduje wektor xjedności, po których następują ydwójki.

TI Basic 89 - 19 bajtów

Uruchom to w TI-89 (ekranie głównym lub aplikacji do programowania):

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

Używa do tego reguł dziennika x+y, tak jak w tym rozwiązaniu . Jako bonus działa dla liczb dziesiętnych i liczb całkowitych. Działa dla wszystkich liczb rzeczywistych. Jeśli reguły logarytmu są nadal poprawne dla złożonych wykładników, to działa to również dla liczb zespolonych. Jednak mój kalkulator wyrzuca śmieci, gdy próbuję wstawić złożone wykładniki.

Podziękowania dla Michaela Sterna za nauczenie mnie notacji matematycznej .

Mathematica - 21 20 bajtów

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

Korzysta z tego samego podejścia co to rozwiązanie , ale w Mathematica jest krótsze. Działa to dla liczb ujemnych i zmiennoprzecinkowych, a także liczb całkowitych w xi y.

Uproszczenie wyrażenia przy użyciu reguł logów daje x+y, ale jest to poprawne, ponieważ używa potęgowania, a nie jednego z 4 podstawowych operatorów.

C # - arytmetyka ciągów

Konwertujemy obie liczby na ciągi znaków, robimy dodawanie odcinając ciągi znaków (z przeniesieniem i wszystkim, wiesz), a następnie analizujemy z powrotem na liczbę całkowitą. Testowane z i1, i2 w 0..200, działa jak urok. Znajdź dodatek w tym!

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

Python - 22 znaki

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

APL: 2

1⊥

Konwertuje to liczby z podstawy 1, więc (n * 1 ^ 1) + (m * 1 ^ 2), czyli dokładnie n + m.

Można wypróbować na TryApl.org

TI-BASIC, 10

Dodaje XiY

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

K, 2 bajty

#&

Przykład użycia:

  #&7 212
219

Zastosuj operator „where” (monadyczny &) do liczb na liście danych wejściowych (prawdopodobnie wykorzystując format wejściowy). Spowoduje to utworzenie listy zawierającej pierwszą liczbę zer, a następnie drugą liczbę zer:

  &3 2
0 0 0 1 1

Zwykle ten operator jest używany jako „gromadzenie” w celu wygenerowania listy wskaźników niezerowych elementów listy boolowskiej, ale uogólniona forma okazuje się przydatna.

Następnie po prostu policz tę listę (monadycznie #).

Jeśli moja interpretacja wymagań wejściowych jest nie do przyjęcia, poniższe nieco dłuższe rozwiązanie działa tak samo:

{#&x,y}

Pyth , 29 bajtów

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

Wypróbuj online!

Moje pierwsze zgłoszenie tutaj!

To kompiluje się do:

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