Problem:

Ihr Ziel ist es zwei Eingangsnummern hinzuzufügen , ohne eine der folgenden mathematischen Operatoren zu verwenden: +,-,*,/.

Darüber hinaus können Sie keine integrierten Funktionen verwenden, die diese mathematischen Operatoren ersetzen sollen.

Wertung:

Der kleinste Code (in Bytes) gewinnt.

Aktualisieren

Die meisten Programme, die ich gesehen habe, verknüpfen entweder zwei Arrays, die ihre Nummern enthalten, oder machen first numberaus einem Zeichen, fügen second numberZeichen hinzu und zählen sie dann alle.

Kürzester Array-Zähler: APL mit 8 Zeichen von Tobia

Kürzeste Array-Verkettung: Golfscript mit 4 Zeichen von Doorknob

Kürzeste logarithmische Lösung: TI-89 Basic mit 19 Zeichen von Quincunx

Integrationslösung: Mathematica mit 45 Zeichen, von Michael Stern

Am coolsten, meiner Meinung nach: bitweise Operatoren in Javascript, von Dave

Smalltalk, 21 13

Alle folgenden Befehle funktionieren nur mit positiven ganzen Zahlen. Siehe die andere Smalltalk- Antwort für eine ernsthafte.

Version 1

Verschieben zu einer großen Ganzzahl und Abfragen des hohen Bitindex (schlecht, die ST-Indizierung basiert auf 1, daher benötige ich eine zusätzliche Rechtsverschiebung):

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

Version 2

Ähnlich und sogar etwas kürzer (aufgrund der Smalltalk-Vorrangregeln und ohne Verschiebung nach rechts):

1<<a<<b log:2 

version3

eine weitere Variation des Themas "Sammlungsverkettung - Fragen nach Größe"
mit zwei Zahlen a und b,

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

Mit Intervals als Sammlung erhalten wir eine speicherfreundlichere Version ;-) in 21 Zeichen:

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

Nicht zu empfehlen für starkes Knirschen.

version4

Wenn Sie zu Ihrer Unterhaltung Zeit gegen Speicher eintauschen möchten, versuchen Sie Folgendes:

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

das ist normalerweise genau genug (aber keine garantie ;-)))

version5

Schreiben Sie in eine Datei und fragen Sie sie nach ihrer Größe

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

Dies fügt zwei Variablen x und y hinzu, wobei nur bitweise Operationen verwendet werden, und speichert das Ergebnis in x.

Dies funktioniert auch mit negativen Zahlen.

C - 38 Bytes

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

Ich schummle hier ein bisschen, sagte der OP, keine mathematischen Operatoren zu verwenden.

Das *im printf()Format bedeutet, dass die zum Drucken des Zeichens verwendete Feldbreite einem Argument von printf()in diesem Fall 3 und 4 entnommen wird. Der Rückgabewert von printf()ist die Anzahl der gedruckten Zeichen. Es werden also ' 'insgesamt 3 + 4 Zeichen gedruckt, wobei eines mit einer Feldbreite von 3 und eines mit einer Feldbreite von 4 gedruckt wird .

Der Rückgabewert sind die im printf()Anruf hinzugefügten Nummern .

Python - 49 Bytes

Annahme der Eingabe durch Platzierung in Variablen xund y.

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

Diese 61-Byte- Lösung ist ein vollständiges Programm:

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

Da Sie die Exponentiation nicht verboten haben, musste ich dies posten. Wenn Sie den Ausdruck mit den Eigenschaften von Logarithmen vereinfachen, erhalten Sie einfach print input() + input().

Dies unterstützt sowohl negative als auch Gleitkommazahlen.

Hinweis: Ich habe den Ratschlägen von Gnibbler gefolgt und diese Antwort in drei Teile geteilt. Dies ist die Mathematica-Lösung und dies ist die TI-89 Basic-Lösung .

JavaScript [25 Bytes]

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

Mathematica, 21 Bytes

In Mathematica gibt es eine Reihe von Möglichkeiten, dies zu tun. Erstens: Verwenden Sie die Funktion Akkumulieren und werfen Sie alles außer der endgültigen Zahl in die Ausgabe. Wie bei meiner anderen unten stehenden Lösung gehe ich davon aus, dass sich die eingegebenen Zahlen in den Variablen aund befinden b. 21 Bytes.

Last@Accumulate@{a, b}

Mehr Spaß, obwohl es 45 Zeichen sind, verwenden Sie die Zahlen, um eine Linie zu definieren und darunter zu integrieren.

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

Als Bonus funktionieren beide Lösungen für alle komplexen Zahlen, nicht nur für positive ganze Zahlen, wie dies bei einigen anderen Lösungen der Fall zu sein scheint.

GolfScript, 6 4 Zeichen / Byte

Eingabe in Form von 10, 5(=> 15).

~,+,

Das +ist Array Verkettung, nicht hinaus.

Wie es funktioniert, ,wird verwendet, um ein Array mit der Länge der Zahl ( 0,1,...,n-2,n-1) zu erstellen . Dies geschieht für beide Nummern, dann werden die Arrays verkettet. ,wird erneut für einen anderen Zweck verwendet, um die Länge des resultierenden Arrays zu ermitteln.

Nun, hier ist der Trick . Ich mag dieses wirklich, weil es das Eingabeformat missbraucht. Es sieht so aus, als würde nur ein Array eingegeben, aber da die Eingabe als GolfScript-Code ausgeführt wird, ist die erste ,für mich bereits erledigt! (Die alte 6-stellige Version hatte ein ~,\,+,Eingabeformat 10 5, bei dem ich 2 Zeichen weggelassen habe, indem ich das \,(Swap-Array) weggelassen habe).

Alte Version (12) :

Erzeugt eine Funktion f.

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

Die *und +sind String-Wiederholungen bzw. Verkettungen, keine arithmetischen Funktionen.

Erläuterung: nErstellt eine Zeichenfolge mit einem Zeichen (eine neue Zeile). Das wird dann amal wiederholt , dann wird das selbe mit gemacht b. Die Zeichenfolgen werden verkettet und dann ,für die Zeichenfolgenlänge verwendet.

C, 29 27 Bytes

Verwenden der Zeigerarithmetik:

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

x ist als Zeiger definiert, der Aufrufer sollte jedoch eine Ganzzahl übergeben.

Ein anonymer Benutzer schlug Folgendes vor - ebenfalls 27 Byte, aber die Parameter sind Ganzzahlen:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Dies funktioniert ohne einfache Addition. es geht durch und legt eine Spur von 1 und zählt sie dann auf

Hinweis: Die +und -sind nur einzelne Inkremente und ohne sie kann in brainf * ck nichts unternommen werden. Sie sind nicht wirklich Addition / Subtraktion, also glaube ich, dass dies immer noch zählt.

J (6)

Sie haben nicht gesagt, dass wir die succ-Funktion nicht verwenden könnten:

>:@[&0

Verwendungszweck:

   9>:@[&0(8)
17

Es werden nur 9 Wiederholungen von >:8 ausgeführt.

Die Liste Verkettung Ansatz funktioniert auch: #@,&(#&0). Und - ich weiß, es verstößt gegen die Regeln - ich kann diese Antwort nicht ohne die einfachste Lösung gehen lassen: *&.^(Multiplikation unter Potenzierung).

Nachschrift, 41

Wir definieren die Funktion mit dem Ausdruck 41 Bytes lang als:

/a{0 moveto 0 rmoveto currentpoint pop}def

Dann nennen wir es zB:

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

Welches gibt

25.0

Im Gegensatz zu den meisten Mitbewerbern kann es problemlos mit Negativen und Posen umgehen :-)

Bash, 20 Zeichen

(seq 10;seq 4)|wc -l

Smalltalk (jetzt ernst), 123 118 105 (*)

Tut mir leid, dass du zweimal geantwortet hast, aber halte dies für eine ernsthafte Antwort, während die andere eher humorvoll war. Das Folgende wird tatsächlich genau zu diesem Zeitpunkt in allen unseren Maschinen ausgeführt (allerdings in Hardware). Seltsam, dass es niemand anderem einfiel ...

Durch Kombinieren von zwei Halbaddierern und paralleles Ausführen aller Bits der Wörter erhalten wir eine lesbare Version (Eingaben a, b; Ausgabe in 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           

Die Schleife dient zur Übertragung von Überträgen. Die Masken stellen sicher, dass vorzeichenbehaftete Ganzzahlen behandelt werden (ohne sie sind nur vorzeichenlose Zahlen möglich). Sie definieren auch die Wortlänge, die oben für den 32-Bit-Betrieb angegeben ist. Wenn Sie eine 68-Bit-Addition bevorzugen, ändern Sie diese in 16rFFFFFFFFFFFFFFFF.

Golf-Version (123 Zeichen) (vermeidet die lange Maske durch Wiederverwendung in m):

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

(*) Durch die Verwendung von -1 anstelle von 16rFFFFFFFF können wir besser Golf spielen, aber der Code funktioniert nicht mehr für Zahlen mit willkürlicher Genauigkeit, sondern nur für smallIntegers mit Maschinenwortgröße (die Darstellung für largeIntegers ist im Ansi-Standard nicht definiert):

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

Dies reduziert die Codegröße auf 105 Zeichen.

APL, 8 und 12

Nichts neues hier, die Array-Zählversion:

{≢∊⍳¨⍺⍵}

und das Protokoll ○ Protokollversion:

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

Ich dachte nur, dass sie in APL cool aussehen!

{≢     }       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 bytes (ohne die ausgefallene formatierung)

Entschuldigen Sie die verspätete Antwort und wahrscheinlich die mit Abstand längste hier. Aber ich wollte sehen, ob das mit sed möglich ist:

                       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/;
                       # # # # # # #  # # # # # # #

Dies ist vergleichbar mit https://codegolf.stackexchange.com/a/38087/11259 , bei dem Zahlen einfach in einer Zeichenfolge inkrementiert werden. Stattdessen werden die Inkrementierungsoperationen in einer Schleife ausgeführt.

Die Eingabe erfolgt aus STDIN in der Form "x y". Das wird zuerst in "x: 0 :: y:" umgewandelt. Dann erhöhen wir alle Zahlen, die nach ":" stehen, bis wir "x: x: :( x + y):" erhalten. Dann kehren wir endlich zurück (x + y).

Ausgabe

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

Beachten Sie, dass dies nur für die natürlichen Zahlen funktioniert. Es funktioniert jedoch (zumindest theoretisch) für beliebig große ganze Zahlen. Da wir x-Inkrementierungsoperationen für y ausführen, kann die Reihenfolge einen großen Unterschied für die Geschwindigkeit bedeuten: x <y ist schneller als x> y.

Strich , 18 Bytes

time -f%e sleep $@

Benötigt GNU-Zeit 1.7 oder höher. Die Ausgabe erfolgt nach STDERR.

Probieren Sie es online!

Beachten Sie, dass dies in B ash nicht funktioniert , da der eingebaute Zeitbefehl von der GNU-Zeit abweicht.

\timeKann auf Kosten eines zusätzlichen Bytes verwendet werden time, um Bash zur Verwendung des externen Befehls zu zwingen.

Javascript (67)

Es ist wahrscheinlich viel besser

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

Rubin, 18 Zeichen

a.times{b=b.next}

Und zwei weitere ausführliche Varianten, 29 Zeichen

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

Eine andere Version, 32 Zeichen

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

On the fly Code-Generierung

Ja, es gibt tatsächlich eine Addition, aber nicht den Operator + und nicht einmal eine Framework-Funktion, die Addition ausführt. Stattdessen generieren wir eine Methode im laufenden Betrieb, die Addition ausführt.

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

Ruby 39

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

R 36

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

Dabei wird repein Vektor von xEinsen gefolgt von yZweien erstellt.

TI Basic 89 - 19 Bytes

Führen Sie dies in Ihrem TI-89 aus (Startbildschirm oder Programmier-App):

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

Hierbei werden x+ywie in dieser Lösung Protokollregeln zum Berechnen verwendet . Als Bonus funktioniert es für Dezimal- und Ganzzahlen. Es funktioniert für alle reellen Zahlen. Wenn die Logarithmusregeln für komplexe Exponenten noch gültig sind, funktioniert dies auch für komplexe Zahlen. Mein Rechner spuckt jedoch Müll aus, wenn ich versuche, komplexe Exponenten einzufügen.

Vielen Dank an Michael Stern, der mir Mathematica-Notation beigebracht hat .

Mathematica - 21 20 Bytes

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

Dies verwendet den gleichen Ansatz wie diese Lösung , wird jedoch in Mathematica verwendet, um sie zu verkürzen. Dies funktioniert für negative und Gleitkommazahlen sowie für ganze Zahlen in xund y.

Die Vereinfachung des Ausdrucks mithilfe von Protokollregeln ergibt zwar x+y, dies ist jedoch gültig, da die Potenzierung verwendet wird und nicht einer der vier Grundoperatoren.

C # - String-Arithmetik

Wir konvertieren beide Zahlen in Strings, addieren sie mit Hilfe von Strings (mit Carry und allem, was Sie wissen) und analysieren sie dann wieder in Integer. Getestet mit i1, i2 in 0..200, wirkt wie ein Zauber. Finden Sie einen Zusatz in diesem!

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 Zeichen

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

APL: 2

1⊥

Dies konvertiert die Zahlen von der Basis 1, also (n * 1 ^ 1) + (m * 1 ^ 2), was genau n + m ist.

Kann auf TryApl.org ausprobiert werden

TI-BASIC, 10

Fügt hinzu XundY

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

K, 2 Bytes

#&

Anwendungsbeispiel:

  #&7 212
219

Wenden Sie den "where" -Operator (monadisch &) auf die Zahlen in einer Eingabeliste an (möglicherweise mit dem Eingabeformat). Dies erzeugt eine Liste mit der ersten Anzahl von Nullen, gefolgt von der zweiten Anzahl von Einsen:

  &3 2
0 0 0 1 1

Normalerweise wird dieser Operator als "Zusammenstellung" verwendet, um eine Liste der Indizes der Nicht-Null-Elemente einer Booleschen Liste zu erstellen. Die verallgemeinerte Form ist jedoch gelegentlich nützlich.

Dann nehmen Sie einfach die Zählung dieser Liste (monadisch #).

Wenn meine Interpretation der Eingabeanforderungen nicht akzeptabel ist, führt die folgende etwas längere Lösung denselben Trick aus:

{#&x,y}

Pyth , 29 Bytes

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

Probieren Sie es online!

Meine erste Einreichung hier!

Dies kompiliert zu:

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