Problema:

Su objetivo es añadir dos números de entrada sin necesidad de utilizar cualquiera de los siguientes operadores matemáticos: +,-,*,/.

Además, no puede usar ninguna función incorporada que esté diseñada para reemplazar esos operadores matemáticos.

Tanteo:

El código más pequeño (en número de bytes) gana.

Actualizar

La mayoría de los programas que he visto concatenan dos matrices que contienen sus números, o hacen first numberun personaje, agregan second numbercaracteres y luego los cuentan.

Contador de matriz más corto: APL con 8 caracteres, por Tobia

Concatenación de matriz más corta: Golfscript con 4 caracteres, por Doorknob

La solución logarítmica más corta: TI-89 Basic con 19 caracteres, por Quincunx

Solución de integración: Mathematica con 45 caracteres, por Michael Stern

Mejor, en mi opinión: operadores bit a bit en JavaScript, por Dave

Smalltalk, 21 13

Todo lo siguiente solo funciona en enteros positivos. Vea la otra respuesta Smalltalk para una respuesta seria.

versión 1

cambiando a un número entero grande y pidiéndole su alto índice de bits (incorrecto, la indexación ST está basada en 1, por lo que necesito un desplazamiento a la derecha adicional):

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

versión 2

similar, e incluso un poco más corto (debido a las reglas de precedencia Smalltalk, y no se necesita un desplazamiento a la derecha):

1<<a<<b log:2 

version3

Otra variación del tema "tamaño de solicitud de concatenación de colección",
dados dos números ayb,

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

Usando Intervalos como colección, obtenemos una versión más amigable con la memoria ;-) en 21 caracteres:

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

Sin embargo, no se recomienda para el procesamiento de números pesados.

version4

Para su diversión, si desea cambiar el tiempo por la memoria, intente:

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

que suele ser lo suficientemente precisa (pero no hay garantía ;-)))

version5

escribir en un archivo y pedirle su tamaño

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

Esto agrega dos variables x e y, usando solo operaciones bit a bit, y almacena el resultado en x.

Esto también funciona con números negativos.

C - 38 bytes

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

Aquí hago trampa un poco, dijo el OP para no usar ningún operador matemático .

El *en el printf()formato significa que el ancho del campo utilizado para imprimir el carácter se toma de un argumento de printf(), en este caso, 3 y 4. El valor de retorno de printf()es el número de caracteres impresos. Por lo tanto, está imprimiendo uno ' 'con un ancho de campo de 3 y uno con un ancho de campo de 4, hace 3 + 4 caracteres en total.

El valor de retorno son los números agregados en la printf()llamada.

Python - 49 bytes

Asumiendo entrada por colocación en variables xy y.

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

Esta solución de 61 bytes es un programa completo:

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

Teniendo en cuenta que no prohibiste la exponenciación, tuve que publicar esto. Cuando simplifica la expresión usando propiedades de logaritmos, simplemente obtiene print input() + input().

Esto admite números negativos y de coma flotante.

Nota: Seguí el consejo de gnibbler y dividí esta respuesta en tres. Esta es la solución de Mathematica , y esta es la solución básica de TI-89 .

JavaScript [25 bytes]

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

Mathematica, 21 bytes

Hay varias maneras de hacer esto en Mathematica. Uno, use la función Acumular y arroje todo menos el número final en la salida. Al igual que con mi otra solución a continuación, supongo que los números de entrada están en las variables ayb . 21 bytes.

Last@Accumulate@{a, b}

Más divertido, aunque tiene 45 caracteres, use los números para definir una línea e integrar debajo de ella.

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

Como beneficio adicional, ambas soluciones funcionan para todos los números complejos, no solo para enteros positivos, como parece ser el caso para algunas otras soluciones aquí.

GolfScript, 6 4 caracteres / bytes

Entrada en forma de 10, 5(=> 15).

~,+,

El +es concatenación de matriz, no suma.

Cómo funciona es que ,se usa para crear una matriz de la longitud que tiene el número ( 0,1,...,n-2,n-1). Esto se hace para ambos números, luego las matrices se concatenan. ,se usa nuevamente para un propósito diferente, para encontrar la longitud de la matriz resultante.

Ahora, aquí está el truco . Realmente me gusta este porque abusa del formato de entrada. Se ve como si estuviera simplemente insertando una matriz, pero en realidad, ya que la entrada está siendo ejecutado como código GolfScript, el primero ,ya está hecho por mí! (La versión anterior de 6 caracteres tenía ~,\,+,formato de entrada 10 5, que eliminé 2 caracteres al eliminar el\, (matriz de intercambio)).

Versión anterior (12) :

Crea una función f.

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

El *y+ son cadenas de repetición y concatenación respectivamente, no funciones aritméticas.

Explicación: ncrea una cadena de un carácter (una nueva línea). Esto se repite varias aveces y luego se hace lo mismo b. Las cadenas se concatenan y luego ,se utilizan para la longitud de la cadena.

C, 29 27 bytes

Usando aritmética de puntero:

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

x se define como un puntero, pero la persona que llama debe pasar un número entero.

Un usuario anónimo sugirió lo siguiente: también 27 bytes, pero los parámetros son enteros:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Esto funciona sin usar la suma simple; pasa y deja un rastro de 1 y luego los cuenta

Nota: Los +y -son simplemente incrementos individuales y no se puede hacer nada en brainf * ck sin ellos. No son realmente sumas / restas, así que creo que esto todavía cuenta.

J (6)

No dijiste que no podíamos usar la función succ:

>:@[&0

Uso:

   9>:@[&0(8)
17

Solo hace 9 repeticiones de >: 8.

El enfoque de la lista de concatenación funciona, también: #@,&(#&0). Y, sé que va en contra de las reglas, no puedo dejar pasar esta respuesta sin la solución más J-ish: *&.^(multiplicación bajo exponenciación).

Postdata, 41

Definimos función con expresión de 41 bytes de longitud como:

/a{0 moveto 0 rmoveto currentpoint pop}def

Entonces lo llamamos, por ejemplo, como:

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

Lo que da

25.0

Maneja fácilmente negativos y flotadores, a diferencia de la mayoría de los competidores :-)

bash, 20 caracteres

(seq 10;seq 4)|wc -l

Smalltalk (ahora en serio), 123 118 105 (*)

Perdón por responder dos veces, pero considera esta una respuesta seria, mientras que la otra era más como humor. Lo siguiente se ejecuta en este momento en todas nuestras máquinas (en hardware, sin embargo). Es extraño que no le viniera a la mente a nadie más ...

Al combinar dos medios sumadores y hacer todos los bits de las palabras en paralelo, obtenemos (entradas a, b; salida en s) versión legible:

  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           

El bucle es para llevar propagación. Las máscaras aseguran que se manejen los enteros con signo (sin ellos, solo son posibles los números sin signo). También definen la longitud de la palabra, lo anterior es para operación de 32 bits. Si prefiere la adición de 68 bits, cambie a 16rFFFFFFFFFFFFFFFFF.

versión de golf (123 caracteres) (evita la máscara larga reutilizándola en 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]

(*) Al usar -1 en lugar de 16rFFFFFFFF, podemos jugar mejor al golf, pero el código ya no funciona para números de precisión arbitrarios, solo para smallIntegers del tamaño de palabras de máquina (la representación para largeIntegers no está definida en el estándar 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]

Esto reduce el tamaño del código a 105 caracteres.

APL, 8 y 12

Nada nuevo aquí, la versión de conteo de matrices:

{≢∊⍳¨⍺⍵}

y el registro ○ versión de registro:

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

¡Solo pensé que se veían geniales en 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 bytes (sin el formato elegante)

Perdón por la respuesta tardía, y probablemente la respuesta más larga aquí con diferencia. Pero quería ver si esto es posible 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/;
                       # # # # # # #  # # # # # # #

Esto es similar a https://codegolf.stackexchange.com/a/38087/11259 , que simplemente incrementa los números en una cadena. Pero en cambio, realiza las operaciones de incremento en un bucle.

La entrada se toma de STDIN en la forma "x y". Eso se transforma primero en "x: 0 :: y:". Luego incrementamos todos los números que vienen después de los caracteres ":", hasta obtener "x: x: :( x + y):". Luego finalmente regresamos (x + y).

Salida

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

Tenga en cuenta que esto solo funciona para los números naturales. Sin embargo (al menos en teoría) funciona para enteros arbitrariamente grandes. Debido a que estamos haciendo operaciones de incremento de x en y, ordenar puede hacer una gran diferencia en la velocidad: x <y será más rápido que x> y.

Guión , 18 bytes

time -f%e sleep $@

Requiere tiempo GNU 1.7 o superior. La salida es a STDERR.

Pruébalo en línea!

Tenga en cuenta que esto no funcionará en B ash, ya que su comando de tiempo incorporado difiere del tiempo de GNU.

A costa de un byte adicional, \timese puede usar en lugar de timeforzar a Bash a usar el comando externo.

Javascript (67)

Probablemente hay mucho mejor

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

Ruby, 18 caracteres

a.times{b=b.next}

Y dos variantes más detalladas, 29 caracteres.

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

Otra versión, 32 caracteres

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

C # - en la generación de código de vuelo

Sí, en realidad hay una adición allí, pero no el operador + y ni siquiera una función de marco que agrega, sino que generamos un método sobre la marcha que agrega.

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

Rubí 39

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

R 36

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

donde repconstruye un vector de xunos seguido de ydos.

TI Basic 89 - 19 bytes

Ejecute esto en su TI-89 (pantalla de inicio o aplicación de programación):

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

Esto utiliza reglas de registro para calcular x+y, al igual que en esta solución . Como beneficio adicional, funciona para números decimales y enteros. Funciona para todos los números reales. Si las reglas de logaritmo siguen siendo válidas con exponentes complejos, entonces esto también funciona para números complejos. Sin embargo, mi calculadora escupe basura cuando intento insertar exponentes complejos.

Gracias a Michael Stern por enseñarme la notación de Mathematica. .

Mathematica - 21 20 bytes

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

Utiliza el mismo enfoque que esta solución , pero está en Mathematica para acortarlo. Esto funciona para números negativos y de coma flotante, así como para enteros xyy .

Simplificar la expresión usando reglas de registro produce x+y, pero esto es válido ya que usa exponenciación, no uno de los 4 operadores básicos.

C # - aritmética de cuerdas

Convertimos ambos números en cadenas, hacemos la suma con corte de cadena (con acarreo y todo, ya sabes), luego volvemos al entero. Probado con i1, i2 en 0..200, funciona de maravilla. ¡Encuentra una adición en este!

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 caracteres

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

APL: 2

1⊥

Esto convierte los números de la base 1, entonces (n * 1 ^ 1) + (m * 1 ^ 2) que es exactamente n + m.

Se puede probar en TryApl.org

TI-BASIC, 10

Agrega XyY

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

K, 2 bytes

#&

Ejemplo de uso:

  #&7 212
219

Aplique el operador "donde" (monádico &) a los números en una lista de entrada (posiblemente tomando la libertad con el formato de entrada). Esto producirá una lista que contiene el primer número de ceros seguido del segundo número de unos:

  &3 2
0 0 0 1 1

Normalmente, este operador se utiliza como "reunión" para producir una lista de los índices de los elementos distintos de cero de una lista booleana, pero la forma generalizada resulta útil ocasionalmente.

Luego simplemente tome el recuento de esa lista (monádico # ).

Si mi interpretación de los requisitos de entrada es inaceptable, la siguiente solución un poco más larga hace el mismo truco:

{#&x,y}

Pyth , 29 bytes

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

Pruébalo en línea!

Mi primera presentación aquí!

Esto compila a:

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