Você precisa pegar 2 entradas de string e gerar a soma dessas duas strings sem convertê-las em int ou usar qualquer tipo de dado numérico.

ex.

string one = "123";
string two = "456";    
string sum = "579";

Suponha que as strings não tenham mais que 10 dígitos.

Este é o código de golfe e a resposta mais curta em caracteres ganha. Uma edição da resposta em C # me fará sorrir :).

Editar: a conversão para int pode ser definida como algo dessa natureza

Int.TryParse, (int), Convert.ToIntEtc.

80836 Montagem ( 57 53 bytes)

53 55 89 E5 8B 4D 0C 8B 55 10 B0 0A 30 DB 88 CF 00 C1 00 C2 49 4A 8A 01 8A 22 00 E0 00 D8 2C 30 30 DB 3C 39 7E 04 B3 01 2C 0A 88 01 88 22 38 CF 75 E2 5D 5B C3

Isso adiciona, dígito por dígito, da direita para a esquerda, sem converter dígitos ASCII em números '0'-'9'inteiros 0-9e continuar conforme necessário. O bytecode é o código para uma função, que pode ser chamada em C (veja abaixo).

O bytecode acima foi escrito à mão, a partir da seguinte montagem (estilo NASM, comentado):

; save ebx, ebp
push ebx        ; 53
push ebp        ; 55
; copy esp
mov ebp, esp    ; 8B EC
; load arguments
mov ecx, [ebp+0x0C] ; 8B 4D 0C
mov edx, [ebp+0x10] ; 8B 55 10
; initialize stuff
mov al, 10      ; B0 0A
xor bl, bl      ; 30 DB
mov bh, cl      ; 88 CF
; send edx, ecx to end of string
add cl, al     ; 00 C1
add dl, al     ; 00 C2

; decrement everything
dec ecx         ; 49
dec edx         ; 4A

; get rightmost unprocessed digit of each number
mov al, [ecx]   ; 8A 01
mov ah, [edx]   ; 8A 22

; add two ascii digits
add al, ah      ; 00 E0
; add carry if needed
add al, bl      ; 00 D8
; subtract 0x30 ('0') to get the resulting ascii digit
sub al, 0x30    ; 2C 30

; set bl to 0
xor bl, bl      ; 30 DB

; if greater than '9': must carry over to next place
cmp al, 0x39    ; 3C 39
jle $+6         ; 7E 04
; set bl to 1 if carrying over
mov bl, 1       ; B3 01
; subtract 10 from ascii digit if carrying over
sub al, 0x0A    ; 2C 0A

mov [ecx], al   ; 88 01
mov [edx], ah   ; 88 22


; check if loop has ended
cmp bh, cl      ; 38 CF
jne $-28        ; 75 E2

; restore ebx, ebp
pop ebp         ; 5D
pop ebx         ; 5B
; return
ret             ; C3

Para tentar isso em C (gcc, linux, processador intel):

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

int main(){
    // bytecode from earlier
    char code[] = {
        0x53, 0x55, 0x8B, 0xEC, 0x8B, 0x4D, 0x0C, 0x8B, 
        0x55, 0x10, 0x31, 0xC0, 0xB0, 0x09, 0x30, 0xDB, 
        0x01, 0xC1, 0x01, 0xC2, 0x40, 0x50, 0x8A, 0x01,
        0x8A, 0x22, 0x00, 0xE0, 0x00, 0xD8, 0x2C, 0x30,
        0x30, 0xDB, 0x3C, 0x39, 0x7E, 0x04, 0xB3, 0x01,
        0x2C, 0x0A, 0x88, 0x01, 0x88, 0x22, 0x58, 0x48,
        0x49, 0x4A, 0x85, 0xC0, 0x75, 0xDF, 0x5D, 0x5B,
        0xC3,
    };
    // allocate executable memory to a function pointer called 'add'
    void __attribute__( (__cdecl__) ) (*add)(char*,char*) = mmap(0,sizeof code,PROT_WRITE|PROT_EXEC,MAP_ANON|MAP_PRIVATE,-1,0);
    memcpy(add, code, sizeof code);

    // test inputs
    char number1[] = "0878295272", number2[] = "8184206821";

    puts(number1);
    puts(number2);

    // call the bytecode as a c function
    add(number1, number2);

    // output is in the first argument
    puts(number1);

    // release allocated memory
    munmap(add, sizeof code);

    return 0;
}

Ruby, 109 71

Brega. Se você não pode trazer Mohammad para a montanha ...

j=$*
r=n=d=0
(d+=x=j.count{|v|n.to_s==v}
r+=x*n
n+=1)until d>1
p r.to_s

Algoritmo:

1. Compare a representação da string de um int com a entrada 1 e a entrada 2.
2. Adicione esse int ao resultado por correspondência.
3. Incremente e repita até que você tenha feito isso duas vezes.
4. Vomitar em si mesmo

Changelog

71 mais curto como uma matriz.

Declaração de método removida e consolidar chamadas para n.to_s

92 aplicou algumas dicas

101 salvar um char

102 use x para incrementar

109 confirmação inicial

sed, 359 bytes (sem a formatação sofisticada)

Ainda não tenho certeza se este é um dup de Add sem adição (ou qualquer um dos 4 operadores aritméticos básicos) . Enquanto isso, deixe-me postar minha resposta para essa pergunta. Não vai ganhar golfe, mas é um começo, e acho que atende facilmente às especificações:

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

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

Resultado

$ 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 ordenação pode fazer uma grande diferença na velocidade: x <y será mais rápido que x> y.

Rubi - 485 432 265

Isso parece mais com o espírito do que você estava procurando na pergunta.

Basicamente, resolve o problema que um ser humano faria no papel - "memorizando" todos os resultados de adição de um dígito, adicionando cada coluna e entendendo como "transportar o um" quando necessário.

Isso também está usando um "tipo de dados numérico" (variável i), que é proibido pela pergunta, mas é apenas para indexação de string. Vou tentar remover isso e editar minha resposta.

def s p
(y=(?0..?9).to_a).product(y).map{|x|/#{x.join}/}.zip((?0..'18').to_a.each_cons(10).to_a.flatten).each{|k,v|return v if k=~p.sort.join}
end
a,b=$*.map{|n|n.rjust(10,?0).reverse}
r=?0
c=''
(0..9).each{|i|d=s [a[i],b[i]]
c=s([d[-1],r])+c
r=d[-2]||?0}
puts r+c

Um pouco não-destruído:

def s p
  y = (?0..?9).to_a
  y.product(y).map{ |x|
    /#{x.join}/
  }.zip(
    (?0..'18').to_a.each_cons(10).to_a.flatten
  ).each{ |k,v|
    return v if k =~ p.sort.join
  }
end

a,b=$*.map{ |n| n.rjust(10,?0).reverse }

r = ?0
c = ''

(0..9).each { |i|
  d = s [ a[i], b[i] ]
  c = s([ d[-1], r ]) + c
  r = d[-2] || '0'
}

puts r+c

EDIT: Utilizou algumas idéias dos comentários para gerar a tabela de mapeamento "memorizada" em vez de apenas codificá-la.

CJam, 95 92 80 72 70 44 caracteres

"Ǻᨌ⹝瀶噄頼୅籌◳ॶ騥箄덮庸匕帯標ឭ⹞➻䗧㩱砡࣍㤬醻孹꽬"2G#b127b:c~

que se traduz em

lW%'0A*+S/zW%{{A,__m*{_1b\saa*~}%\{_saa*~}%+\aa/,(s_,({(@+\}*}%_Wf<s}g

Definitivamente, isso pode ser muito praticado. Realmente não sei se minha abordagem é ótima ou ainda não.

UPDATE - Inline a criação da matriz de soma para salvar bytes. Devido a isso, o programa agora roda 10 vezes mais devagar, mas ainda é um tempo constante para qualquer tipo de entrada.

Experimente online aqui

Lê a linha que contém dois números de STDIN como string e gera como uma matriz de caracteres que é uma string em si.

Por exemplo:

123 4567

A saída contém precedentes 0. Deixe-me saber se isso é um problema.

C # - 128 108 104

Agradecemos a Compass, BMac e Shawn por sugerirem melhorias.

Primeira tentativa no Code Golf, e usar C # parece ser uma desvantagem aqui ...

Ao usar, .Compute()você pode usar os valores da sequência e soma-los diretamente. Como bônus, isso funciona para outros operadores além de apenas "+".

Golfe:

static void t(string a,string b){System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));}

Ungolfed:

static void t(string a, string b)
{
    System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));
}

Ligar para t("123","456");você 579.

GNU sed, 266 bytes

Usa uma abordagem diferente da solução da DigitalTrauma. Como efeito, este apresenta desempenho ainda pior, usando O (m + n) . Converta os dois operandos em unário, concatenado e convertido em decimal (todos usando regex, é claro - sed não tem o conceito de um número inteiro).

Como um bônus, este programa resume todos os números naturais fornecidos no stdin (na primeira linha), o que significa que você não pode alimentar nada, um número ou dez números e fará a coisa certa independentemente.

A idéia por trás desse código é vagamente inspirada em uma antiga submissão minha do PPCG sed, embora eu não me lembre para que pergunta seja uma resposta.

Aqui está, "bonito", impresso para sua "conveniência", emprestando outra idéia da DigitalTrauma. : D

                s/9/x8/g;
                s/8/x7/g;
                s/7/x6/g;
                s/6/x5/g;
                s/5/x4/g;
                s/4/x3/g;
  s/3/x2/g;s/2/x1/g;s/1/x0/g;s/0\b//g;;
  :l;s/x0/0xxxxxxxxxx/;/x0/bl;s/[^x]//g
  s/^$/0/;:m;s/x{10}/!/g;s/!\b/&0/;;;;;
  s/0x/1/;s/1x/2/;s/2x/3/;s/3x/4/;;;;;;
  s/4x/5/;s/5x/6/;s/6x/7/;s/7x/8/;;;;;;
                s/8x/9/;;
                s/!/x/g;;
                /x{10}/bm
                /x/!q;;;;
                s/^/0/;bm
                #sum.sed#

(Para obter a versão de 266 bytes, remova o ponto e vírgula à direita, o espaço em branco à esquerda e o comentário final, de preferência usando o sed.)

Emprestando alguns testes do DigitalTrauma:

% printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 6789" "123 100" | while read l; do sed -rf /tmp/sum.sed <<<"$l"; done 
0
1
1
1008
1008
19134
223

Apertei um pouco os testes realmente grandes por causa da terrível (in) eficiência do espaço. Devido ao uso de qapenas a primeira linha é processada, daí o whileloop no teste.

Java 6 (181 caracteres)

Não deve ser superado pelo handicap conhecido como C # , Java em toda a sua glória. Muito clichê! O uso é fornecer os argumentos separados por um espaço, ou seja,123 456

import javax.script.*;class T {public static void main(String[] a) throws Exception {System.out.print(new ScriptEngineManager().getEngineByName("JavaScript").eval(a[0]+"+"+a[1]));}}

Ungolfed:

import javax.script.*;

class T {
    public static void main(String[] a) throws Exception {
        System.out.print(new ScriptEngineManager()
                .getEngineByName("JavaScript").eval(a[0] + "+" + a[1]));
    }
}

Ao usar o mecanismo JavaScript disponível no javax, podemos fazer com que outro idioma faça o trabalho por nós e tecnicamente siga as regras de não usar nenhum tipo numérico no idioma nativo ou converter.

Justificação para usar eval

Não convertemos os valores em int para que o JavaScript avalie. Criamos uma String que "123+456"não é um número. O JS Engine digere a fórmula e avalia a String como literais numéricos, que não são tipos de dados numéricos. Java brega lógica! Como um aparte, isso também funciona para doublematemática.

APL (61)

Eu acho que isso se enquadra nas regras.

{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}

Esta é uma função que recebe dois argumentos de sequência e retorna uma sequência:

      '123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
579
      ⍝ show dimensions (if it was a number, this would give the empty list)
      ⍴'123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
3

Também é razoavelmente rápido, adiciona o número formado por 999999 9s a si mesmo em um instante.

Ele encontra o índice de cada caractere em ⎕D(que é a string '0123456789'), depois adiciona a escola primária em cada índice separadamente, carregando conforme necessário, depois pesquisa os dígitos resultantes ⎕D. (Acho que a ⎕Dpesquisa se enquadra nas regras, é basicamente fazer'x'-48 ).

Explicação:

• ⎕D∘⍳¨⍺⍵: procure os índices ⎕Dpara cada caractere nas duas strings.
• ¯1+: subtraia 1de cada um, porque as matrizes são baseadas em 1 por padrão.
• ⌽↑⌽¨: inverta ambos, vire uma matriz (preenchendo quadrados vazios com zeros) e depois inverta a matriz.
• +⌿: soma as colunas da matriz
• {... }: transitar:
  • ∨/T←9<Z←0,⍵: adicione um extra 0na frente da lista. Descubra quais 'dígitos' são maiores que 9 e armazene-os em T. Se algum dígito for maior que 10:
    • Z-10×T: subtraia 10de cada posição superior a 10,
    • T←(1⌽T)+: adicione 1a cada posição ao lado de cada posição superior a 10 e armazene-a T.
    • T↓⍨~×⊃T: se Tcomeçar com zero, remova-o,
    • ∇: aplique a função carry ao resultado.
  • ⋄⍵: caso contrário, retorne o valor inalterado
• 1+: adicione um a cada posição (porque a matriz é indexada 1)
• ⎕D[... ]: use o resultado como índices em ⎕D.

Perl - 136 119 115 bytes

Estou aprendendo Perl, isso parecia uma boa prática. Dicas são apreciadas!

Resposta brega, para tirar isso do caminho:

print$ARGV[0]+$ARGV[1]; #Adding strings

Resposta real:

($x,$y)=@ARGV;while($x.$y.$s){$s-=48-ord$&if$x=~s/.$//;$s-=48-ord$&if$y=~s/.$//;$r=chr($s%10+48).$r;$s=$s>9;}print$r;

Descomprimido:

($x,$y)=@ARGV;
while($x.$y.$s){
$s-=48-ord$&if$x=~s/.$//;
$s-=48-ord$&if$y=~s/.$//;
$r=chr($s%10+48).$r;
$s=$s>9;
}
print$r;

Java 7, Pontuação = 252

Não usa números inteiros, compridos, bytes, curtos, duplos, flutuadores ou quaisquer funções internas da biblioteca para adicionar. Envolva um corpo de classe e ligue para t(String1,String2). Coloque as cordas com zeros para que elas tenham o mesmo comprimento.

t("123","234")retorna "0357".

Golfe:

char c,d,e,f,g,k;String t(String a,String b){g++;char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];for(d=(char)h.length;d>f;)j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;j[0]=(char)('0'+c);return new String(j);}

Golfe Expandido com classe:

public class T{

    public static void main(String[] args){
        System.out.println(new T().t(args[0],args[1]));
    }

    char c,d,e,f,g,k;
    String t(String a,String b){
        g++;
        char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];
        for(d=(char)h.length;d>f;)
            j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;
        j[0]=(char)('0'+c);
        return new String(j);
    }
}

Parcialmente golfe expandido:

public class TrickSum{

    public static void main(String[] args){
        System.out.println(new TrickSum().trickSum(args[0], args[1]));
    }

    char carry, i, aSum,nullChar,oneChar;
    public String trickSum(String a, String b){
        oneChar++;
        char[] number1 = toCharArray(a), number2 = toCharArray(b), sum = new char[number1.length + 1];
        for (i = (char) number1.length; i > nullChar;)
            sum[--i + 1] = (carry = (aSum = (char) (number1[i] + number2[i] - '0' + carry)) > '9' ? oneChar : nullChar) == oneChar ? (char) (aSum - '\n') : aSum;
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }

    char[] toCharArray(String string){
        return string.toCharArray();
    }
}

100% expandido:

public class TrickSum{

    public static void main(String[] args){
        System.out.println(trickSum(args[0], args[1]));
    }

    public static String trickSum(String a, String b){
        char[] number1 = a.toCharArray();
        char[] number2 = b.toCharArray();
        char[] sum = new char[number1.length + 1];
        char carry = '\u0000';
        for (char i = (char)(number1.length - 1); i != '\uFFFF'; i--){
            char aSum = (char) (number1[i] + number2[i] - '0' + carry);
            carry = aSum > '9' ? '\u0001' : '\u0000';
            aSum = (carry == '\u0001') ? (char) (aSum - '\n') : aSum;
            sum[i + 1] = aSum;
        }
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }
}

Java - 257 caracteres

como todo mundo sabe java, não há linguagem melhor para jogar golfe do que java

    class A{public static void main(String[]s){char[]a=s[0].toCharArray();char[]b=s[1].toCharArray();int c=a.length;int d=b.length;int e=0;String f="";for(int i=0;i<Math.max(c,d);i++){f=f+(((i<c?a[i]-48:0)+(i<d?b[i]-48:0)+e)%10);e/=10;}System.out.println(f);}}

esta é uma solução não destruída

public static void main(String[] args) {
        char[] aa = args[0].toCharArray();
        char[] bb = args[1].toCharArray();
        int aal = aa.length;
        int bbl = bb.length;

        int reminder = 0;
        String result ="";
        for(int i=0;i<Math.max(aal,bbl);i++){
            result=result+(((i<aal?aa[i]-48:0)+(i<bbl?bb[i]-48:0)+reminder)%10);
            reminder/=10;
        }
        System.out.println(result);
    }

Haskell - 98 94 bytes

main=do
 a<-getLine
 b<-getLine
 let c d=last$takeWhile(\e->d/=(show$e-1))[0..]
 print$c a+c b

JavaScript (ES6), 55 66 59 *

 f=x=>{for(i=0;i+[]!=x;i++);return i};f((p=prompt)())+f(p())

* Isso faz algumas suposições:

• Estamos em um ambiente ES6 REPL (por exemplo, console do navegador FireFox 33.1)
• O desempenho não importa (sério, '9999999999', '9999999999' levaram cerca de 20 minutos para retornar)
• A conversão de Inteiro para String é permitida
• A entrada é definida nas variáveis ​​aeb, ex:var a='123',b=321'; Alterada para obter entrada do prompt (+11).
• A entrada não possui zeros à esquerda.

Python 2.7, 196 137 caracteres

versão 2 (mais curta inicializando o dicionário com código):

n={}
for i in range(10):n[`i`]=i*' '
def q(a,b):f=lambda x:''.join([10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

Versão anterior 1 (196 caracteres):

def q(a,b):n,f={0:'','1':' ','2':'  ','3':'   ','4':4*' ','5':5*' ','6':6*' ','7':7*' ','8':8*' ','9':9*' '}, lambda x:''.join(
    [10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

por exemplo

>>> print q('123','111')
234

As chaves do dicionário são strings, os valores do dicionário incluem apenas constantes numéricas para encurtar o código, e o cálculo é feito concatenando duas strings e obtendo o comprimento resultante, então espero que isso conte como "não as converta em ints".

Versão de regra de fraude de letras pequenas do Python

class z(int):0
def s(a,b): return z(a)+z(b)

Nota:

>>> type(z('4'))
<class '__main__.z'>

O tipo z é um tipo personalizado que eu defino como: definitivamente não é um tipo numérico, seja qual for a definição que o questionador use, mas se comporte perto o suficiente de um tipo numérico para ser útil em circunstâncias limitadas . Os comportamentos do tipo z são implementados apenas parcialmente neste exemplo de código e se o interpretador CPython usar 'int' para implementar z , isso é apenas um detalhe da implementação e não está relacionado ao problema em questão.