Devi prendere 2 input di stringa e generare la somma di queste due stringhe senza convertirle in int o utilizzare qualsiasi tipo di dato numerico.

ex.

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

Supponiamo che le stringhe non siano più grandi di 10 cifre.

Questo è il golf del codice e vince la risposta più breve nei personaggi. Una modifica alla risposta in C # mi farà sorridere :).

Modifica: la conversione in int può essere definita come qualsiasi cosa di questa natura

Int.TryParse, (int), Convert.ToIntEcc

80836 Assembly ( 57 53 byte)

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

Ciò aggiunge, cifra per cifra, da destra a sinistra, senza convertire le cifre ASCII in numeri '0'-'9'interi 0-9e trasferendole secondo necessità. Il bytecode è il codice per una funzione, che può essere chiamato in C (vedi sotto).

Il bytecode sopra è stato scritto a mano, dal seguente assembly (stile NASM, commentato):

; 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

Per provare questo in C (gcc, linux, processore 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

Cheesy. Se non riesci a portare Mohammad sulla montagna ...

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. Confronta la rappresentazione di stringa di un int con input 1 e input 2.
2. Aggiungi quell'int al risultato per corrispondenza.
3. Incrementa e ripeti finché non lo hai fatto due volte.
4. Vomita su te stesso

changelog

71 più corto come un array.

85 ha rimosso la dichiarazione del metodo e ha consolidato le chiamate a n.to_s

92 ha applicato alcuni suggerimenti

101 salva un carattere

102 usa x per incrementare

109 commit iniziale

sed, 359 byte (senza la formattazione elaborata)

Non sono ancora sicuro che si tratti di un dup di Aggiungi senza aggiunta (o di uno dei 4 operatori aritmetici di base) . Nel frattempo, lasciami inviare la mia risposta per quella domanda. Non vincerà alcun golf, ma è un inizio e penso che soddisfi facilmente le specifiche:

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

L'input è preso 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
$

Si noti 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.

Rubino - 485 432 265

Questo sembra più nello spirito di ciò che stavi cercando nella domanda.

Risolve fondamentalmente il problema di come un umano farebbe sulla carta - "memorizzando" tutti i risultati di addizione a singola cifra, aggiungendo ogni colonna e comprendendo come "trasportare quello" quando necessario.

Questo utilizza anche un "tipo di dati numerico" (variabile i), che è proibito dalla domanda, ma è solo per l'indicizzazione delle stringhe. Proverò a rimuoverlo e a modificare la mia risposta.

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

Abbastanza ungolfed:

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: usato alcune idee dai commenti per generare la tabella di mapping "memorizzata" invece di codificarla semplicemente.

CJam, 95 92 80 72 70 44 caratteri

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

che si traduce in

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

Questo può sicuramente essere giocato a golf molto. Non so davvero se il mio approccio sia ottimale o meno.

AGGIORNAMENTO : incorpora la creazione della matrice di somma per salvare i byte. A causa di ciò, il programma ora funziona 10 volte più lentamente, ma rimane sempre un tempo costante per qualsiasi tipo di input.

Provalo online qui

Legge la riga contenente due numeri da STDIN come stringa e genera un array di caratteri che è una stringa stessa.

Per esempio:

123 4567

L'output contiene precedenti 0. Fammi sapere se questo è un problema.

C # - 128 108 104

Grazie a Compass, BMac e Shawn per aver suggerito miglioramenti.

Prima prova a Code Golf, e l'uso di C # sembra essere un handicap qui ...

Usando .Compute()puoi usare i valori di stringa e sommarli direttamente. Come bonus, questo funziona per altri operatori a parte solo "+".

golfed:

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

La chiamata t("123","456");ti fa 579.

GNU sed, 266 byte

Utilizza un approccio diverso rispetto alla soluzione di DigitalTrauma. Di conseguenza, questo funziona ancora più male, usando O (m + n) . Converti entrambi gli operandi in unari, concatenati, riconvertiti in decimali (ovviamente tutti usano regex: sed non ha il concetto di un numero intero).

Come bonus, questo programma riassume tutti gli interi naturali dati su stdin (nella prima riga), il che significa che non puoi fornirgli nulla, un numero o dieci numeri e farà la cosa giusta indipendentemente.

L'idea alla base di questo codice è vagamente ispirata da una mia vecchia presentazione PPCG sed, anche se non ricordo per quale domanda sia una risposta.

Ecco, "grazioso" stampato per la tua "convenienza", prendere in prestito un'altra idea 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#

(Per ottenere la versione a 266 byte, rimuovere i punti e virgola finali, lo spazio bianco iniziale e il commento finale, preferibilmente usando sed.)

Prendendo in prestito alcuni test da 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

Ho modificato un po 'i test davvero grandi a causa della terribile efficienza dello spazio (in). A causa dell'utilizzo della qsola prima riga viene elaborata, quindi il whileloop nel test.

Java 6 (181 caratteri)

Non essere superato dall'handicap noto come C # , Java in tutto il suo splendore. Tanta piastra di cottura! L'uso sta fornendo gli argomenti separati da uno spazio, ad es123 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]));
    }
}

Utilizzando il motore JavaScript disponibile in javax, possiamo fare in modo che un'altra lingua faccia il lavoro per noi e tecnicamente seguire le regole di non utilizzare alcun tipo numerico nella lingua nativa o di conversione.

Giustificazione per l'utilizzo eval

Non abbiamo convertito i valori in int per JavaScript in eval. Abbiamo creato una stringa che "123+456"non è un numero. JS Engine digerisce la formula e valuta la stringa come valori letterali numerici, che non sono tipi di dati numerici. Logica di formaggio Java! A parte questo, questo funziona anche per la doublematematica.

APL (61)

Penso che questo rientri nelle regole.

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

Questa è una funzione che accetta due argomenti stringa e restituisce una stringa:

      '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

È anche abbastanza veloce, aggiunge il numero formato da 999999 9s a se stesso in un istante.

Trova l'indice di ciascun personaggio in ⎕D(che è la stringa "0123456789"), quindi aggiunge l'istruzione elementare su ciascun indice separatamente, portando secondo necessità, quindi cerca le cifre risultanti ⎕D. (Penso che la ⎕Dricerca rientri nelle regole, in pratica sta solo facendo 'x'-48).

Spiegazione:

• ⎕D∘⍳¨⍺⍵: cerca gli indici ⎕Dper ciascun carattere in entrambe le stringhe.
• ¯1+: sottrai 1da ciascuno, poiché le matrici sono 1 in base di default.
• ⌽↑⌽¨: inverti entrambi, trasforma in una matrice (riempiendo i quadrati vuoti di zero), quindi inverti la matrice.
• +⌿: somma le colonne della matrice
• {... }: riporto:
  • ∨/T←9<Z←0,⍵: aggiungi un extra 0davanti all'elenco. Scopri quali "cifre" sono superiori a 9 e memorizzale in T. Se qualche cifra era superiore a 10:
    • Z-10×T: sottrarre 10da ogni posizione superiore a 10,
    • T←(1⌽T)+: aggiungi 1a ciascuna posizione accanto a ciascuna posizione superiore a 10 e memorizza in T.
    • T↓⍨~×⊃T: Se T inizia con uno zero, rimuovilo,
    • ∇: applica la funzione carry al risultato.
  • ⋄⍵: altrimenti, restituisce il valore invariato
• 1+: aggiungine uno a ciascuna posizione (poiché l'array è 1 indicizzato)
• ⎕D[... ]: usa il risultato come indice in ⎕D.

Perl - 136 119 115 byte

Sto imparando il Perl, mi è sembrata una buona pratica. I consigli sono apprezzati!

Risposta di formaggio, per toglierlo di mezzo:

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

Risposta effettiva:

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

Non compresso:

($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, Punteggio = 252

Non utilizza numeri interi, long, byte, short, doppi, float o qualsiasi funzione di libreria integrata per l'aggiunta. Avvolgi un corpo di classe e chiama cont(String1,String2) . Riempi le stringhe con 0 in modo che abbiano la stessa lunghezza.

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

golfed:

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

Golfed Ampliato con 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);
    }
}

Parzialmente golf espanso:

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% espanso:

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 personaggi

come tutti sanno java non esiste un linguaggio migliore per giocare a golf di 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);}}

questa è una soluzione non golfata

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 byte

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

* Questo fa alcune ipotesi:

• Siamo in un ambiente REPL ES6 (es. Console browser FireFox 33.1)
• Le prestazioni non contano (sul serio, "9999999999", "9999999999" hanno impiegato circa 20 minuti per tornare)
• È consentita la conversione da Integer a String
• L'input è definito nelle variabili aeb, es:var a='123',b=321'; modificato per ottenere l'input dal prompt (+11).
• L'input non ha zeri iniziali.

Python 2.7, 196 137 caratteri

versione 2 (più breve inizializzando il dizionario con codice):

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

Versione precedente 1 (196 caratteri):

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

per esempio

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

Le chiavi del dizionario sono stringhe, i valori del dizionario includono solo costanti numeriche per accorciare il codice e il calcolo viene eseguito concatenando due stringhe e ottenendo la lunghezza risultante, quindi spero che conti come "non convertirle in ints".

Versione Python per trucchi con caratteri piccoli

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

Nota:

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

Il tipo z è un tipo personalizzato che definisco come: sicuramente non un tipo numerico in base alla definizione utilizzata dall'interrogante, ma si comporta abbastanza vicino a un tipo numerico da essere utile in circostanze limitate . I comportamenti di tipo z sono implementati solo parzialmente in questo esempio di codice e se l'interprete CPython usa 'int' per implementare z , questo è solo un dettaglio di implementazione e non è correlato al problema attuale.