Debe tomar 2 entradas de cadena y generar la suma de estas dos cadenas sin convertirlas a int o usar ningún tipo de datos numéricos.

ex.

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

Suponga que las cadenas no tendrán más de 10 dígitos.

Este es el código de golf y la respuesta más corta en caracteres gana. Una edición de la respuesta en C # me hará sonreír :).

Editar: la conversión a int se puede definir como cualquier cosa de esta naturaleza

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

80836 Asamblea ( 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

Esto agrega, dígito a dígito, de derecha a izquierda, sin convertir dígitos ascii '0'-'9'a los enteros 0-9, y transferirlos según sea necesario. El bytecode es el código para una función, que se puede llamar en C (ver más abajo).

El bytecode anterior se escribió a mano, a partir del siguiente ensamblado (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 probar esto en C (gcc, linux, procesador 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;
}

Rubí, 109 71

Caseoso. Si no puedes traer a Mohammad a la montaña ...

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 la representación de cadena de un int con la entrada 1 y la entrada 2.
2. Agregue ese int al resultado por partido.
3. Incremente y repita hasta que lo haya hecho dos veces.
4. Vomita contigo mismo

Registro de cambios

71 más corto como una matriz.

85 declaración de método eliminado y consolidar llamadas a n.to_s

92 aplicaron algunos consejos

101 guardar un char

102 usa x para incrementar

109 confirmación inicial

sed, 359 bytes (sin el formato elegante)

Todavía no estoy seguro de si este es un duplicado de Agregar sin adición (o cualquiera de los 4 operadores aritméticos básicos) . Mientras tanto, permítanme publicar mi respuesta cruzada para esa pregunta. No va a ganar golf, pero es un comienzo, y creo que cumple fácilmente con las especificaciones:

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

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):". Entonces 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.

Rubí - 485 432 265

Esto parece más en el espíritu de lo que estaba buscando en la pregunta.

Básicamente resuelve el problema como lo haría un humano en el papel: "memorizando" todos los resultados de suma de un solo dígito, agregando cada columna y entendiendo cómo "cargar el uno" cuando sea necesario.

Esto también está utilizando un "tipo de datos numéricos" (variable i), que está prohibido por la pregunta, pero es solo para la indexación de cadenas. Intentaré eliminar esto y editaré mi respuesta.

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

Algo descabellado:

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

EDITAR: Usó algunas ideas de los comentarios para generar la tabla de mapeo "memorizada" en lugar de simplemente codificarla.

CJam, 95 92 80 72 70 44 caracteres

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

lo que se traduce en

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

Esto definitivamente se puede jugar mucho al golf. Realmente no sé si mi enfoque es óptimo o no todavía.

ACTUALIZACIÓN : en línea la creación de la matriz de suma para guardar bytes. Debido a esto, el programa ahora se ejecuta 10 veces más lento, pero sigue siendo un tiempo constante para cualquier tipo de entrada.

Pruébalo en línea aquí

Lee la línea que contiene dos números de STDIN como una cadena y genera una matriz de caracteres que es una cadena en sí misma.

Por ejemplo:

123 4567

La salida contiene precedente 0. Avíseme si eso es un problema.

C # - 128 108 104

Gracias a Compass, BMac y Shawn por sugerir mejoras.

Primero intente en Code Golf, y usar C # parece ser una desventaja aquí ...

Al usar .Compute()puede usar los valores de cadena y sumarlos directamente. Como beneficio adicional, esto funciona para otros operadores además de "+".

Golfizado:

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

Sin golf:

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

Llamar t("123","456");te da 579.

GNU sed, 266 bytes

Utiliza un enfoque diferente que la solución de DigitalTrauma. Como efecto, este funciona aún peor, usando O (m + n) . Convierta ambos operandos a unario, concatene, vuelva a convertir a decimal (todo utilizando expresiones regulares, por supuesto, sed no tiene el concepto de un entero).

Como beneficio adicional, este programa resume todos los enteros naturales dados en stdin (en la primera línea), lo que significa que no puede alimentarlo con nada, un número o diez números y hará lo correcto independientemente.

La idea detrás de este código está vagamente inspirada en una antigua presentación de PPCG, aunque no recuerdo para qué pregunta es una respuesta.

Aquí está, "bonito", impreso para su "conveniencia", para tomar prestada otra idea de DigitalTrauma. :RE

                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 obtener la versión de 266 bytes, elimine los puntos y comas finales, los espacios en blanco iniciales y el comentario final, preferiblemente usando sed).

Préstamo de algunas pruebas de 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

Ajusté un poco las pruebas realmente grandes debido a la terrible eficiencia de espacio (in). Debido al uso de qsolo se procesa la primera línea, de ahí el whilebucle en la prueba.

Java 6 (181 caracteres)

Para no ser superado por la discapacidad conocida como C # , Java en todo su esplendor. ¡Tanto repetitivo! El uso es proporcionar los argumentos separados por un espacio, es decir123 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]));}}

Sin golf:

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

Al usar el motor de JavaScript disponible en javax, podemos hacer que otro idioma haga el trabajo por nosotros, y técnicamente seguir las reglas de no usar ningún tipo numérico en el idioma nativo, o convertir.

Justificación para usar eval

No hemos convertido los valores a int para que JavaScript evalúe. Hemos creado una cadena que "123+456"no es un número. JS Engine digiere la fórmula y evalúa la cadena como literales numéricos, que no son tipos de datos numéricos. Java lógica cursi! Por otro lado, esto también funciona para las doublematemáticas.

APL (61)

Creo que esto cae dentro de las reglas.

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

Esta es una función que toma dos argumentos de cadena y devuelve una cadena:

      '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

También es razonablemente rápido, agrega el número formado por 999999 9s en un instante.

Encuentra el índice de cada carácter en ⎕D(que es la cadena '0123456789'), luego suma la escuela primaria en cada índice por separado, transporta según sea necesario, luego busca los dígitos resultantes ⎕D. (Creo que la ⎕Dbúsqueda se encuentra dentro de las reglas, básicamente solo lo está haciendo 'x'-48).

Explicación:

• ⎕D∘⍳¨⍺⍵: busca los índices ⎕Dpara cada personaje en ambas cadenas.
• ¯1+: resta 1de cada uno, porque las matrices están basadas en 1 por defecto.
• ⌽↑⌽¨: invierta ambos, conviértalos en una matriz (llenando cuadrados vacíos con ceros), luego invierta la matriz.
• +⌿: suma las columnas de la matriz
• {... }: transferir:
  • ∨/T←9<Z←0,⍵: agregue un extra 0al frente de la lista. Averigüe qué 'dígitos' son mayores que 9 y guárdelos T. Si alguno de los dígitos fuera superior a 10:
    • Z-10×T: resta 10de cada posición que sea superior a 10,
    • T←(1⌽T)+: agregue 1a cada posición al lado de cada posición que era superior a 10 y almacene en T.
    • T↓⍨~×⊃T: si Tcomienza con un cero, elimínelo,
    • ∇: aplica la función carry al resultado.
  • ⋄⍵: de lo contrario, devuelve el valor sin cambios
• 1+: agregue uno a cada posición (porque la matriz está indexada en 1)
• ⎕D[... ]: usa el resultado como índices en ⎕D.

Perl - 136 119 115 bytes

Estoy aprendiendo Perl, esto parecía una buena práctica. Los consejos son apreciados!

Respuesta cursi, para sacar eso del camino:

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

Respuesta 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;

Sin comprimir:

($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, Puntuación = 252

No utiliza números enteros, largos, bytes, cortos, dobles, flotantes ni ninguna función de biblioteca integrada para agregar. Envuelva en un cuerpo de clase y llame con t(String1,String2). Rellene las cadenas con 0 para que tengan la misma longitud.

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

Golfizado:

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

Golf ampliado con clase:

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 golfizado 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 el mundo sabe Java, no hay mejor lenguaje para el golf 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 es una solución sin golf

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

* Esto hace algunas suposiciones:

• Estamos en un entorno REPL ES6 (por ejemplo, consola de navegador FireFox 33.1)
• El rendimiento no importa (en serio, '9999999999', '9999999999' tardó unos 20 minutos en regresar)
• La conversión de entero a cadena está permitida
• La entrada se define en las variables ayb, por ejemplo: sevar a='123',b=321'; cambió para obtener la entrada desde el indicador (+11).
• La entrada no tiene ceros a la izquierda.

Python 2.7, 196137 caracteres

versión 2 (más corta inicializando el diccionario con 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))

Versión 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))

p.ej

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

Las teclas del diccionario son cadenas, los valores del diccionario solo incluyen constantes numéricas para acortar el código, y el cálculo se realiza concatenando dos cadenas y obteniendo la longitud resultante, por lo que espero que cuente como "no convertirlas en ints".

Versión de trampa de reglas de letra pequeña de Python

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

Nota:

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

El tipo z es un tipo personalizado que defino como: definitivamente no es un tipo numérico por cualquier definición que utilice el interrogador, pero se comporta lo suficientemente cerca de un tipo numérico como para ser útil en circunstancias limitadas . Los comportamientos de tipo z solo se implementan parcialmente en este ejemplo de código, y si el intérprete de CPython usa 'int' para implementar z , eso es simplemente un detalle de implementación y no está relacionado con el problema en cuestión.