Problema:

Seu objetivo é somar dois números de entrada sem usar qualquer um dos seguintes operadores matemáticos: +,-,*,/.

Além disso, você não pode usar nenhuma função interna projetada para substituir esses operadores matemáticos.

Pontuação:

O menor código (em número de bytes) vence.

Atualizar

A maioria dos programas que eu vi concatenou duas matrizes contendo seus números ou a forma first numberde um caractere, anexou second numbercaracteres e contou todos.

Menor contador de matrizes: APL com 8 caracteres, de Tobia

Concatenação de matriz mais curta : Golfscript with 4 chars, by Doorknob

Solução logarítmica mais curta: TI-89 Basic com 19 caracteres, da Quincunx

Solução de integração: Mathematica com 45 caracteres, de Michael Stern

O mais legal, na minha opinião: operadores bit a bit em javascript, por dave

Smalltalk, 21 13

Todos os itens a seguir funcionam apenas em números inteiros positivos. Veja a outra resposta do Smalltalk para uma resposta séria.

versão 1

mudando para um número inteiro grande e solicitando seu alto índice de bits (ruim, a indexação ST é baseada em 1, então eu preciso de uma mudança à direita adicional):

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

versão 2

semelhante e até um pouco mais curto (devido às regras de precedência do Smalltalk, e nenhuma mudança à direita necessária):

1<<a<<b log:2 

version3

outra variação do tema "tamanho da solicitação de concatenação da coleção",
dados dois números a e b,

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

usando intervalos como coleção, obtemos uma versão mais amigável à memória ;-) em 21 caracteres:

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

não recomendado para trituração de números pesados, no entanto.

version4

Para sua diversão, se você quiser trocar tempo pela memória, tente:

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

que geralmente é preciso o suficiente (mas não garante ;-)))

version5

escreva em um arquivo e peça seu tamanho

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

Isso adiciona duas variáveis ​​x e y, usando apenas operações bit a bit e armazena o resultado em x.

Isso funciona com números negativos também.

C - 38 bytes

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

Eu trapaceio um pouco aqui, o OP disse para não usar nenhum operador matemático .

O *no printf()formato significa que a largura do campo usada para imprimir o caractere é obtida a partir de um argumento printf(), neste caso, 3 e 4. O valor de retorno printf()é o número de caracteres impressos. Portanto, imprimir um ' 'com largura de campo 3 e outro com largura de campo 4 gera um total de 3 + 4 caracteres.

O valor de retorno são os números adicionados na printf()chamada.

Python - 49 bytes

Assumindo entrada por posicionamento em variáveis xe y.

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

Esta solução de 61 bytes é um programa completo:

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

Considerando que você não proibiu a exponenciação, tive que postar isso. Quando você simplifica a expressão usando propriedades dos logaritmos, você simplesmente obtém print input() + input().

Isso suporta números de ponto negativo e de ponto flutuante.

Nota: Eu segui o conselho do mordedor e dividi esta resposta em três. Esta é a solução Mathematica , e esta é a solução básica TI-89 .

JavaScript [25 bytes]

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

Mathematica, 21 bytes

Existem várias maneiras de fazer isso no Mathematica. Primeiro, use a função Acumular e lance tudo, exceto o número final na saída. Como na minha outra solução abaixo, presumo que os números de entrada estejam nas variáveis ae b. 21 bytes.

Last@Accumulate@{a, b}

Mais divertido, embora tenha 45 caracteres, use os números para definir uma linha e integrar sob ela.

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

Como bônus, ambas as soluções funcionam para todos os números complexos, não apenas números inteiros positivos, como parece ser o caso de algumas outras soluções aqui.

GolfScript, 6 4 caracteres / bytes

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

~,+,

A +concatenação é de matriz, não adição.

Como funciona é que ,é usado para criar uma matriz do tamanho que o número é ( 0,1,...,n-2,n-1). Isso é feito para os dois números e as matrizes são concatenadas. ,é usado novamente para uma finalidade diferente, para encontrar o comprimento da matriz resultante.

Agora, aqui está o truque . Eu realmente gosto deste porque abusa do formato de entrada. Ele olha como ele está apenas introduzir um array, mas realmente, uma vez que a entrada está sendo executado como código GolfScript, o primeiro ,já está feito para mim! (A versão antiga de 6 caracteres estava ~,\,+,no formato de entrada 10 5, que eu retirei 2 caracteres eliminando o \,(swap-array)).

Versão antiga (12) :

Cria uma função f.

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

A repetição e a concatenação das cordas *e +são respectivamente funções não aritméticas.

Explicação: ncria uma cadeia de um caractere (uma nova linha). Isso é repetido várias avezes, e a mesma coisa é feita b. As cadeias são concatenadas e, em seguida, ,são usadas para o comprimento da cadeia.

C, 29 27 bytes

Usando a aritmética do ponteiro:

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

x é definido como um ponteiro, mas o chamador deve passar um número inteiro.

Um usuário anônimo sugeriu o seguinte - também 27 bytes, mas os parâmetros são inteiros:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Isso funciona sem o uso de adição simples; ele passa e estabelece uma trilha de 1 e depois os conta

Nota: Os +e -são apenas incrementos simples e nada pode ser feito no cérebro sem eles. Eles não são realmente adição / subtração, então acredito que isso ainda conta.

J (6)

Você não disse que não poderíamos usar a função succ:

>:@[&0

Uso:

   9>:@[&0(8)
17

Faz apenas 9 repetições de >:8.

A abordagem lista concatenação funciona, também: #@,&(#&0). E - eu sei que é contra as regras - não posso deixar essa resposta passar sem a solução mais j-ish: *&.^(multiplicação sob exponenciação).

Postscript, 41

Definimos função com expressão 41 bytes, desde que:

/a{0 moveto 0 rmoveto currentpoint pop}def

Então, nós o chamamos, por exemplo, como:

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

Que dá

25.0

Ele lida facilmente com negativos e carros alegóricos, ao contrário da maioria dos concorrentes :-)

festança, 20 caracteres

(seq 10;seq 4)|wc -l

Smalltalk (agora sério), 123 118 105 (*)

Desculpe por responder duas vezes, mas considere essa uma resposta séria, enquanto a outra era mais parecida com humor. O seguinte é realmente executado exatamente neste exato momento em todas as nossas máquinas (no hardware). Estranho que não viesse à mente de mais ninguém ...

Combinando dois semi-somadores e executando todos os bits das palavras em paralelo, obtemos a versão legível (entradas a, b; saída em 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           

O loop é para transportar propagação. As máscaras garantem que números inteiros assinados sejam manipulados (sem eles, apenas números não assinados são possíveis). Eles também definem o comprimento da palavra, sendo o anterior para operação de 32 bits. Se você preferir a adição de 68 bits, mude para 16rFFFFFFFFFFFFFFFFFFF.

versão golf (123 caracteres) (evita a máscara longa reutilizando em 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 em vez de 16rFFFFFFFF, podemos jogar melhor, mas o código não funciona mais para números de precisão arbitrários, apenas para smallIntegers do tamanho de palavras de máquinas (a representação para largeIntegers não está definida no padrão 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]

isso reduz o tamanho do código para 105 caracteres.

APL, 8 e 12

Nada de novo aqui, a versão que conta o array:

{≢∊⍳¨⍺⍵}

e o log ○ versão do log:

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

Eu apenas pensei que eles pareciam legais no 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 (sem a formatação sofisticada)

Desculpe pela resposta tardia e provavelmente a resposta mais longa aqui de longe. Mas eu queria ver se isso é possível com o 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/;
                       # # # # # # #  # # # # # # #

Isso é semelhante a https://codegolf.stackexchange.com/a/38087/11259 , que simplesmente incrementa números em uma sequência. Mas, em vez disso, realiza as operações de incremento em um loop.

A entrada é obtida de STDIN no formato "x y". Isso é transformado primeiro em "x: 0 :: y:". Em seguida, incrementamos todos os números que vêm depois dos caracteres ":", até obtermos "x: x: :( x + y):". Então finalmente retornamos (x + y).

Saída

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

Observe que isso funciona apenas para os números naturais. No entanto (pelo menos em teoria), ele funciona para números inteiros arbitrariamente grandes. Como estamos realizando operações de incremento de x em y, a ordem pode fazer uma grande diferença na velocidade: x <y será mais rápido que x> y.

Traço , 18 bytes

time -f%e sleep $@

Requer tempo GNU 1.7 ou superior. A saída é para STDERR.

Experimente online!

Observe que isso não funcionará no B ash, pois seu comando de tempo interno difere do tempo do GNU.

Ao custo de um byte adicional, \timepode ser usado em vez de timeforçar o Bash a usar o comando externo.

Javascript (67)

Provavelmente há muito melhor

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

Ruby, 18 caracteres

a.times{b=b.next}

E mais duas variantes detalhadas, 29 caracteres

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

Outra versão, 32 caracteres

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

Geração de código on-the-fly

Sim, há realmente uma adição lá, mas não o operador + e nem mesmo uma função de estrutura que adiciona, em vez disso, geramos um método instantâneo que faz a adição.

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

onde repconstrói um vetor de xuns seguidos por ydois.

TI Básico 89 - 19 bytes

Execute isso na sua TI-89 (tela inicial ou aplicativo de programação):

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

Isso usa regras de log para calcular x+y, assim como nesta solução . Como bônus, funciona para números decimais e números inteiros. Funciona para todos os números reais. Se as regras do logaritmo ainda são válidas com expoentes complexos, isso também funciona para números complexos. No entanto, minha calculadora cospe lixo quando tento inserir expoentes complexos.

Agradeço a Michael Stern por me ensinar a notação Mathematica .

Mathematica - 21 20 bytes

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

Isso usa a mesma abordagem que esta solução , mas está no Mathematica para torná-la mais curta. Isso funciona para números negativos e de ponto flutuante, além de números inteiros em xe y.

Simplificar a expressão usando regras de log gera x+y, mas isso é válido, pois usa exponenciação, não um dos quatro operadores básicos.

Aritmética de cordas

Convertemos os dois números em strings, fazemos a adição com o corte de strings (com carry e tudo, você sabe) e depois analisamos de volta para inteiro. Testado com i1, i2 em 0..200, funciona como um encanto. Encontre uma adição neste!

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⊥

Isso converte os números da base 1, então (n * 1 ^ 1) + (m * 1 ^ 2), que é exatamente n + m.

Pode ser experimentado em TryApl.org

TI-BASIC, 10

Adiciona XeY

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

K, 2 bytes

#&

Exemplo de uso:

  #&7 212
219

Aplique o operador "where" (monádico &) aos números em uma lista de entrada (possivelmente liberando o formato de entrada). Isso produzirá uma lista contendo o primeiro número de zeros, seguido pelo segundo número de zeros:

  &3 2
0 0 0 1 1

Normalmente, esse operador é usado como uma "coleta" para produzir uma lista dos índices dos elementos diferentes de zero de uma lista booleana, mas a forma generalizada é útil ocasionalmente.

Em seguida, basta fazer a contagem dessa lista (monádica #).

Se minha interpretação dos requisitos de entrada for inaceitável, a seguinte solução um pouco mais longa fará o mesmo truque:

{#&x,y}

Pitão , 29 bytes

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

Experimente online!

Minha primeira submissão aqui!

Isso compila para:

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