Problema:

Il vostro obiettivo è quello di aggiungere due numeri di ingresso senza utilizzare uno dei seguenti operatori matematici: +,-,*,/.

Inoltre, non è possibile utilizzare alcuna funzione integrata progettata per sostituire quegli operatori matematici.

punteggio:

Vince il codice più piccolo (in numero di byte).

Aggiornare

La maggior parte dei programmi che ho visto concatena due matrici contenenti i loro numeri o crea first numberun personaggio, aggiunge second numbercaratteri e poi li conta tutti.

Contatore di array più corto: APL con 8 caratteri, di Tobia

Concatenazione di array più breve: Golfscript con 4 caratteri, di Doorknob

Soluzione logaritmica più breve: TI-89 Basic con 19 caratteri, di Quincunx

Soluzione di integrazione: Mathematica con 45 caratteri, di Michael Stern

Più bello, secondo me: operatori bit per bit in javascript, di dave

Smalltalk, 21 13

Tutti i seguenti funzionano solo su numeri interi positivi. Vedi l' altra risposta Smalltalk per una seria.

version1

passando a un intero di grandi dimensioni e chiedendogli il suo indice di bit elevato (cattivo, l'indicizzazione ST è basata su 1, quindi ho bisogno di un ulteriore spostamento a destra):

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

version2

simile e anche un po 'più breve (a causa delle regole di precedenza Smalltalk e non è necessario alcun spostamento a destra):

1<<a<<b log:2 

versione 3

un'altra variante del tema "raccolta-concatenare-chiedere dimensione",
dati due numeri aeb,

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

usando Intervals come collezione, otteniamo una versione più adatta alla memoria ;-) in 21 caratteri:

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

non raccomandato per lo scricchiolio di numeri pesanti, comunque.

version4

Per il tuo divertimento, se vuoi scambiare tempo con la memoria, prova:

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

che di solito è abbastanza preciso (ma nessuna garanzia ;-)))

version5

scrivere su un file e chiederne le dimensioni

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

Questo aggiunge due variabili xey, usando solo operazioni bit a bit, e memorizza il risultato in x.

Funziona anche con numeri negativi.

C - 38 byte

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

Faccio un po 'imbroglio qui, l'OP ha detto di non usare matematica operatore .

Il *nei printf()mezzi formato che il campo larghezza utilizzato per stampare il carattere viene prelevato da un argomento printf(), in questo caso, 3 e 4. Il valore di ritorno printf()è il numero di caratteri stampati. Quindi ne sta stampando uno' ' con una larghezza del campo di 3 e uno con una larghezza del campo di 4, per un totale di 3 + 4 caratteri.

Il valore restituito sono i numeri aggiunti nella printf()chiamata.

Python - 49 byte

Supponendo input per posizionamento in variabili xe y.

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

Questa soluzione a 61 byte è un programma completo:

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

Considerando che non hai vietato l'espiazione, ho dovuto pubblicare questo. Quando si semplifica l'espressione usando le proprietà dei logaritmi, si ottiene semplicementeprint input() + input() .

Questo supporta numeri sia in virgola mobile che negativi.

Nota: ho seguito il consiglio di gnibbler e ho diviso questa risposta in tre. Questa è la soluzione Mathematica e questa è la soluzione TI-89 Basic .

JavaScript [25 byte]

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

Mathematica, 21 byte

Esistono diversi modi per farlo in Mathematica. Uno, usa la funzione Accumula e lancia tutto tranne il numero finale nell'output. Come con la mia altra soluzione di seguito, presumo che i numeri di input siano nelle variabili ae b. 21 byte.

Last@Accumulate@{a, b}

Più divertente, sebbene abbia 45 caratteri, usa i numeri per definire una linea e integrarti sotto di essa.

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

Come bonus, entrambe le soluzioni funzionano per tutti i numeri complessi, non solo per i numeri interi positivi, come sembra essere il caso di alcune altre soluzioni qui.

GolfScript, 6 4 caratteri / byte

Immettere sotto forma di 10, 5(=> 15).

~,+,

Il + concatenazione di array, non l'aggiunta.

Come funziona è che ,viene utilizzato per creare un array della lunghezza che il numero è ( 0,1,...,n-2,n-1). Questo viene fatto per entrambi i numeri, quindi gli array vengono concatenati.,viene utilizzato nuovamente per uno scopo diverso, per trovare la lunghezza dell'array risultante.

Ora, ecco il trucco . Mi piace molto questo perché abusa del formato di input. E sembra come se fosse solo inserendo un array, ma in realtà, dal momento che l'ingresso è in esecuzione come codice GolfScript, il primo ,è già fatto per me! (La vecchia versione di 6 caratteri era ~,\,+,con il formato di input 10 5, che ho eliminato 2 caratteri eliminando il \,(swap-array)).

Vecchia versione (12) :

Crea una funzione f.

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

La *e +sono rispettivamente ripetizione e concatenazione di stringhe, non funzioni aritmetiche.

Spiegazione: ncrea una stringa di un carattere (una nuova riga). Questo è poi ripetuto avolte, poi si fa la stessa cosa b. Le stringhe vengono concatenate e quindi ,vengono utilizzate per la lunghezza della stringa.

C, 29 27 byte

Utilizzando l'aritmetica del puntatore:

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

x è definito come un puntatore, ma il chiamante deve passare un numero intero.

Un utente anonimo ha suggerito quanto segue - anche 27 byte, ma i parametri sono numeri interi:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Funziona senza usare la semplice aggiunta; passa attraverso e traccia una scia di 1 e poi li conta

Nota: +e -sono solo incrementi singoli e nulla può essere eseguito in brainf * ck senza di essi. Non sono davvero addizioni / sottrazioni, quindi credo che questo conti ancora.

J (6)

Non hai detto che non potevamo usare la funzione succ:

>:@[&0

Uso:

   9>:@[&0(8)
17

Fa solo 9 ripetizioni di >: su 8.

L'approccio lista di concatenazione lavora, anche: #@,&(#&0). E - so che è contro le regole - Non posso lasciar andare questa risposta senza la soluzione più j-ish:*&.^ (moltiplicazione sotto esponenziazione).

Postscript, 41

Definiamo funzione con espressione 41 byte purché:

/a{0 moveto 0 rmoveto currentpoint pop}def

Quindi lo chiamiamo ad esempio come:

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

Che dà

25.0

Gestisce facilmente negativi e galleggianti, a differenza della maggior parte dei concorrenti :-)

bash, 20 caratteri

(seq 10;seq 4)|wc -l

Smalltalk (ora seriamente), 123 118 105 (*)

Ci scusiamo per aver risposto due volte, ma considera questa una risposta seria, mentre l'altra era più simile all'umorismo. Quanto segue è effettivamente eseguito proprio in questo momento in tutte le nostre macchine (in hardware, però). Strano che non gli venisse in mente nessun altro ...

Combinando due semi-adduttori e facendo tutti i bit delle parole in parallelo, otteniamo (input a, b; output in s) versione leggibile:

  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           

Il loop è per la propagazione del carry. Le maschere assicurano che vengano gestiti numeri interi con segno (senza di essi sono possibili solo numeri senza segno). Definiscono anche la lunghezza della parola, quanto sopra per l'operazione a 32 bit. Se si preferisce l'aggiunta a 68 bit, passare a 16rFFFFFFFFFFFFFFFFF.

versione golf (123 caratteri) (evita la maschera lunga riutilizzando 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]

(*) Usando -1 anziché 16rFFFFFFFF, possiamo giocare a golf meglio, ma il codice non funziona più per numeri di precisione arbitrari, ma solo per numeri interi di dimensioni minime (la rappresentazione per numeri interi non è definita nello standard 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]

questo porta la dimensione del codice a 105 caratteri.

APL, 8 e 12

Niente di nuovo qui, la versione conteggio di array:

{≢∊⍳¨⍺⍵}

e il registro ○ versione registro:

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

Ho solo pensato che fossero belli in 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 byte (senza la formattazione elaborata)

Ci scusiamo per la risposta tardiva e probabilmente la risposta più lunga qui di gran lunga. Ma volevo vedere se questo è possibile con 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/;
                       # # # # # # #  # # # # # # #

Questo è simile a https://codegolf.stackexchange.com/a/38087/11259 , che aumenta semplicemente i numeri in una stringa. Ma invece esegue le operazioni di incremento in un ciclo.

L'immissione è presa da STDIN nella forma "x y". Quello viene prima trasformato in "x: 0 :: y:". Quindi incrementiamo tutti i numeri che seguono i caratteri ":", finché non otteniamo "x: x: :( x + y):". Quindi finalmente ritorniamo (x + y).

Produzione

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

Nota che questo funziona solo per i numeri naturali. Tuttavia (almeno in teoria) funziona per numeri interi arbitrariamente grandi. Poiché stiamo eseguendo operazioni di incremento x su y, l'ordinamento può fare una grande differenza per la velocità: x <y sarà più veloce di x> y.

Dash , 18 byte

time -f%e sleep $@

Richiede il tempo GNU 1.7 o successivo. L'output è su STDERR.

Provalo online!

Si noti che questo non funzionerà in B ash, poiché il suo comando di tempo incorporato differisce dal tempo GNU.

Al costo di un byte aggiuntivo, \timepuò essere utilizzato invece di timeforzare Bash a utilizzare il comando esterno.

Javascript (67)

Probabilmente c'è molto di meglio

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

Ruby, 18 chars

a.times{b=b.next}

And two more verbose variants, 29 chars

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

Another version, 32 chars

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

C# - on the fly code generation

Yeah, there is actually an addition in there, but not the + operator and not even a framework function which does adding, instead we generate a method on the fly that does the adding.

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

where rep builds a vector of x ones followed by y twos.

TI Basic 89 - 19 bytes

Run this in your TI-89 (Home screen or programming app):

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

This uses log rules to compute x+y, just like in this solution. As a bonus, it works for decimal and integer numbers. It works for all real numbers. If the logarithm rules are still valid with complex exponents, then this works for complex numbers too. However, my calculator spits out junk when I try to insert complex exponents.

Thanks to Michael Stern for teaching me Mathematica notation.

Mathematica - 21 20 bytes

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

This uses the same approach as this solution, but it is in Mathematica to make it shorter. This works for negative and floating point numbers as well as integers in x and y.

Simplifying the expression using log rules yields x+y, but this is valid since it uses exponentiation, not one of the 4 basic operators.

C# - string arithmetics

We convert both numbers to strings, do the addition with string cutting (with carry and everything, you know), then parse back to integer. Tested with i1, i2 in 0..200, works like a charm. Find an addition in this one!

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 characters

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

APL: 2

1⊥

This converts the numbers from base 1, so (n*1^1)+(m*1^2) which is exactly n+m.

Can be tried on TryApl.org

TI-BASIC, 10

Adds X and Y

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

K, 2 bytes

#&

Usage example:

  #&7 212
219

Apply the "where" operator (monadic &) 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:

  &3 2
0 0 0 1 1

Normally this operator is used as a "gather" to produce a list of the indices of the nonzero elements of a boolean list, but the generalized form comes in handy occasionally.

Then simply take the count of that list (monadic #).

If my interpretation of the input requirements is unacceptable, the following slightly longer solution does the same trick:

{#&x,y}

Pyth, 29 bytes

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

Try it online!

My first submission here!

This compiles to:

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