Musisz wziąć 2 ciągi wejściowe i wyprowadzić sumę tych dwóch ciągów bez konwertowania ich na int lub przy użyciu dowolnego typu danych liczbowych.

dawny.

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

Załóżmy, że łańcuchy nie będą dłuższe niż 10 cyfr.

To jest kod golfowy i wygrywa najkrótsza odpowiedź w postaci. Edycja odpowiedzi w C # rozśmieszy mnie :).

Edycja: Konwersja na int może być zdefiniowana jako cokolwiek tego rodzaju

Int.TryParse, (int), Convert.ToIntEtc

80836 Montaż ( 57 53 bajtów)

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

Dodaje to cyfra po cyfrze, od prawej do lewej, bez konwersji cyfr ascii '0'-'9'na liczby całkowite 0-9i przenoszenia w razie potrzeby. Kod bajtowy jest kodem funkcji, która może być wywołana w C (patrz poniżej).

Powyższy kod bajtowy został napisany ręcznie z następującego zestawu (skomentowano w stylu NASM):

; 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

Aby wypróbować to w C (gcc, Linux, procesor 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

Serowy. Jeśli nie możesz zabrać Mahometa w góry ...

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

Algorytm:

1. Porównaj reprezentację ciągu int z wejściem 1 i wejściem 2.
2. Dodaj tę liczbę całkowitą do wyniku według meczu.
3. Zwiększaj i powtarzaj, aż zrobisz to dwa razy.
4. Zwymiotuj na siebie

Dziennik zmian

71 krótszy jako tablica.

85 usunął deklarację metody i skonsolidował wywołania do n.to_s

92 zastosował kilka wskazówek

101 save char

102 użyj x do zwiększania

109 wstępne zatwierdzenie

sed, 359 bajtów (bez fantazyjnego formatowania)

Nadal nie jestem pewien, czy jest to duplikat Add bez dodawania (czy którykolwiek z 4 podstawowych operatorów arytmetycznych) . W międzyczasie pozwól mi przesłać moją odpowiedź na to pytanie. Nie wygra w golfa, ale jest to początek i myślę, że łatwo spełnia specyfikację:

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

Dane wejściowe są pobierane ze STDIN w postaci „x y”. To jest najpierw przekształcane na „x: 0 :: y:”. Następnie zwiększamy wszystkie liczby występujące po znakach „:”, aż otrzymamy „x: x: :( x + y):”. Potem w końcu wracamy (x + y).

Wynik

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

Zauważ, że działa to tylko dla liczb naturalnych. Jednak (przynajmniej teoretycznie) działa dla dowolnie dużych liczb całkowitych. Ponieważ wykonujemy operacje przyrostowe x na y, kolejność może mieć duży wpływ na szybkość: x <y będzie szybsze niż x> y.

Rubin - 485 432 265

Wydaje się to bardziej w duchu tego, czego szukałeś w pytaniu.

Zasadniczo rozwiązuje problem, w jaki sposób człowiek zapisałby się na papierze - „zapamiętując” wszystkie wyniki dodawania pojedynczych cyfr, dodając każdą kolumnę i rozumiejąc, jak „nieść jedną” w razie potrzeby.

Wykorzystuje to również jeden „numeryczny typ danych” (zmienna i), co jest zabronione przez pytanie, ale służy tylko do indeksowania ciągów. Spróbuję go usunąć i zmodyfikować swoją odpowiedź.

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

Nieco golfisty:

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

EDYCJA: Wykorzystałem kilka pomysłów z komentarzy, aby wygenerować „zapamiętaną” tabelę mapowania zamiast po prostu ją zakodować na stałe.

CJam, 95 92 80 72 70 44 znaków

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

co przekłada się na

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

To zdecydowanie można dużo zagrać w golfa. Naprawdę nie wiem, czy moje podejście jest optymalne, czy jeszcze nie.

AKTUALIZACJA - wstaw tworzenie macierzy sum, aby zapisać bajty. Z tego powodu program działa teraz 10 razy wolniej, ale wciąż jest to stały czas dla dowolnego rodzaju danych wejściowych.

Wypróbuj online tutaj

Czyta wiersz zawierający dwie liczby ze STDIN jako ciąg znaków i wyprowadza jako tablicę znaków, która sama jest ciągiem znaków.

Na przykład:

123 4567

Dane wyjściowe zawierają poprzedzające 0. Daj mi znać, jeśli to jest problem.

C # - 128 108 104

Dzięki Compass, BMac i Shawn za sugestie ulepszeń.

Najpierw spróbuj w Code Golf, a używanie C # wydaje się być utrudnieniem tutaj ...

Korzystając z tej opcji .Compute(), możesz użyć wartości ciągów i zsumować je bezpośrednio. Jako bonus działa to dla innych operatorów oprócz „+”.

Gra w golfa:

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

Nie golfowany:

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

Dzwonienie t("123","456");daje 579.

GNU sed, 266 bajtów

Stosuje inne podejście niż rozwiązanie DigitalTrauma. W rezultacie ten działa jeszcze gorzej, używając O (m + n) . Konwertuj oba operandy na jednoargumentowe, konkatenuj, konwertuj z powrotem na dziesiętne (wszystkie przy użyciu wyrażenia regularnego oczywiście - sed nie ma pojęcia liczby całkowitej).

Jako bonus, ten program sumuje wszystkie naturalne liczby całkowite podane na stdin (w pierwszym wierszu), co oznacza, że ​​nie możesz podać nic, jednej liczby lub dziesięciu liczb i zrobi to dobrze.

Idea tego kodu jest niejasno zainspirowana przez moje stare zgłoszenie PPCG, choć nie pamiętam, na jakie pytanie jest odpowiedź.

Oto „ładny” wydrukowany dla Twojej „wygody” pożyczenie innego pomysłu od 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#

(Aby uzyskać wersję 266 bajtów, usuń końcowe średniki, wiodące białe znaki i końcowy komentarz, najlepiej używając sed.)

Pożyczanie niektórych testów od 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

Poprawiłem trochę naprawdę duże testy ze względu na straszną (nie) efektywność przestrzeni. Ze względu na użycie qtylko pierwszej linii jest przetwarzana, stąd whilepętla w teście.

Java 6 (181 znaków)

Nie do pokonania przez upośledzenie znane jako C # , Java w całej okazałości. Tyle kotłów! Użycie polega na dostarczeniu argumentów oddzielonych spacją, tj123 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]));}}

Nie golfowany:

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

Korzystając z silnika JavaScript dostępnego w javax, możemy sprawić, że inny język wykona za nas pracę i technicznie postępuje zgodnie z zasadami nieużywania żadnych typów liczbowych w języku ojczystym lub konwersji.

Uzasadnienie użycia eval

Nie przekonwertowaliśmy wartości na int, aby JavaScript mógł zostać sprawdzony. Stworzyliśmy Łańcuch, "123+456"który nie jest liczbą. Silnik JS przetwarza formułę i ocenia Ciąg jako literały liczbowe, które nie są liczbowymi typami danych. Tandetna logika Java! Nawiasem mówiąc, działa to również dla doublematematyki.

APL (61)

Myślę, że jest to zgodne z zasadami.

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

Jest to funkcja, która pobiera dwa argumenty ciągu i zwraca ciąg:

      '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

Jest także dość szybki, dodaje do siebie liczbę utworzoną przez 999999 9s.

Znajduje indeks każdego znaku w ⎕D(który jest ciągiem „0123456789”), następnie dokonuje dodania do szkoły dla każdego indeksu osobno, przenosząc w razie potrzeby, a następnie wyszukuje wynikowe cyfry ⎕D. (Myślę, że ⎕Dwyszukiwanie jest zgodne z regułami, po prostu działa 'x'-48).

Wyjaśnienie:

• ⎕D∘⍳¨⍺⍵: wyszukaj indeksy ⎕Ddla każdego znaku w obu ciągach.
• ¯1+: odejmij 1od każdego, ponieważ tablice domyślnie są oparte na 1.
• ⌽↑⌽¨: odwróć oba, zamień w macierz (wypełniając puste kwadraty zerami), a następnie odwróć macierz.
• +⌿: zsumuj kolumny macierzy
• {... }: przenieść:
  • ∨/T←9<Z←0,⍵: dodaj dodatkowy 0przed listą. Dowiedz się, które „cyfry” są wyższe niż 9, i zapisz to T. Jeśli jakieś cyfry były większe niż 10:
    • Z-10×T: odejmij 10od każdej pozycji wyższej niż 10,
    • T←(1⌽T)+: dodaj 1do każdej pozycji obok każdej pozycji, która była wyższa niż 10, i zapisz T.
    • T↓⍨~×⊃T: jeśli Tzaczyna się od zera, usuń go,
    • ∇: zastosuj funkcję carry do wyniku.
  • ⋄⍵: w przeciwnym razie zwróć wartość bez zmian
• 1+: dodaj po jednym do każdej pozycji (ponieważ tablica jest indeksowana 1)
• ⎕D[... ]: użyj wyniku jako wskaźników do ⎕D.

Perl - 136 119 115 bajtów

Uczę się Perla, to wydawało się dobrą praktyką. Wskazówki są mile widziane!

Tandetna odpowiedź, aby to usunąć:

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

Rzeczywista odpowiedź:

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

Nieskompresowane:

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

Do dodawania nie używa liczb całkowitych, długich, bajtów, skrótów, podwójnych, pływaków ani żadnych wbudowanych funkcji bibliotecznych. Zawiń ciało klasy i zadzwoń t(String1,String2). Proszę wpisać ciągi zerowe, aby miały jednakową długość.

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

Gra w golfa:

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

Golfowy Rozszerzony z klasą:

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

Częściowo rozbudowany golf:

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

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 znaków

jak wszyscy wiedzą, java nie ma lepszego języka do gry w golfa niż 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);}}

to jest rozwiązanie nierozwiązane

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 bajtów

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

* To czyni kilka założeń:

• Jesteśmy w środowisku ESPL REPL (np. Konsola przeglądarki FireFox 33.1)
• Wydajność nie ma znaczenia (powrót „9999999999”, „9999999999” zajęło około 20 minut)
• Konwersja liczb całkowitych na ciąg jest dozwolona
• Dane wejściowe są zdefiniowane w zmiennych aib, np .:var a='123',b=321'; zmieniono na uzyskiwanie danych wejściowych z monitu (+11).
• Dane wejściowe nie mają zer wiodących.

Python 2.7, 196 137 znaków

wersja 2 (krótsza przez zainicjowanie słownika kodem):

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

Poprzednia wersja 1 (196 znaków):

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

na przykład

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

Klucze słownika to ciągi, wartości słownika zawierają tylko stałe liczbowe w celu skrócenia kodu, a obliczenia wykonuje się przez połączenie dwóch ciągów i uzyskanie wynikowej długości, więc mam nadzieję, że liczy się to jako „nie przekształcanie ich w wartości int”.

Wersja z kodem do drukarek w małych pytaniach

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

Uwaga:

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

Typ z jest niestandardowym typem, który definiuję jako: zdecydowanie nie jest typem liczbowym według jakiejkolwiek definicji używanej przez pytającego, ale zachowuje się wystarczająco blisko typu numerycznego, aby był użyteczny w ograniczonych okolicznościach . Zachowania typu z są tylko częściowo zaimplementowane w tym przykładzie kodu, a jeśli interpreter CPython używa „int” do implementacji z , jest to jedynie szczegół implementacji i nie jest związany z danym problemem.