Вы должны взять 2 строковых ввода и вывести сумму этих двух строк без преобразования их в int или использования любого числового типа данных.

ех.

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

Предположим, что строки не будут длиннее 10 цифр.

Это код гольф и самый короткий ответ в символах выигрывает. Редактирование ответа в C # заставит меня улыбнуться :).

Редактировать: преобразование в int может быть определено как что-либо подобное

Int.TryParse, (int), И Convert.ToIntт.д.

80836 в сборе ( 57 53 байта)

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

Это добавляет, цифра за цифрой, справа налево, без преобразования цифр ascii '0'-'9'в целые числа 0-9и переноса по мере необходимости. Байт-код является кодом для функции, которая может быть вызвана на C (см. Ниже).

Приведенный выше байт-код был написан вручную из следующей сборки (в стиле 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

Чтобы попробовать это в C (gcc, linux, процессор 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;
}

Рубин, 109 71

Сырный. Если вы не можете принести Мухаммеда на гору ...

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

Алгоритм:

1. Сравните строковое представление типа int с входом 1 и входом 2.
2. Добавьте это int к результату за матч.
3. Увеличивайте и повторяйте, пока не сделаете это дважды.
4. Рвота на себя

Изменения

71 короче как массив.

85 удалено объявление метода и объединены вызовы n.to_s

92 применил несколько советов

101 сохранить символ

102 использовать х для увеличения

109 начальный коммит

sed, 359 байт (без необычного форматирования)

Я все еще не уверен, является ли это дублированием Add без добавления (или любого из 4 основных арифметических операторов) . А пока позвольте мне опубликовать ответ на этот вопрос. Он не собирается выигрывать в гольф, но это начало, и я думаю, что легко соответствует спецификации:

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

Ввод берется из STDIN в виде "x y". Это сначала преобразуется в "x: 0 :: y:". Затем мы увеличиваем все числа после символов «:», пока не получим «x: x: :( x + y):». Тогда мы наконец вернемся (x + y).

Вывод

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

Обратите внимание, что это работает только для натуральных чисел. Однако (по крайней мере, в теории) это работает для сколь угодно больших целых чисел. Поскольку мы выполняем x операций инкремента для y, порядок может иметь большое значение для скорости: x <y будет быстрее, чем x> y.

Рубин - 485 432 265

Это кажется больше в духе того, что вы искали в вопросе.

Это в основном решает проблему, как это сделал бы человек - «запоминая» все результаты сложения, состоящие из одной цифры, добавляя каждый столбец и понимая, как «переносить один», когда это необходимо.

При этом также используется один «числовой тип данных» (переменная i), что запрещено вопросом, но только для индексации строк. Я постараюсь удалить это и отредактировать свой ответ.

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

Немного негольфя

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

РЕДАКТИРОВАТЬ: Использовал некоторые идеи из комментариев, чтобы сгенерировать «запомненную» таблицу сопоставления вместо простого ее кодирования.

CJam, 95 92 80 72 70 44 персонажа

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

что переводится как

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

Это определенно может быть много в гольфе. Я действительно не знаю, является ли мой подход оптимальным или нет.

ОБНОВЛЕНИЕ - встроенное создание матрицы суммы для сохранения байтов. Из-за этого программа теперь работает в 10 раз медленнее, но все еще остается постоянным временем для любого вида ввода.

Попробуйте онлайн здесь

Читает строку, содержащую два числа из STDIN как строку, и выводит как массив символов, который является самой строкой.

Например:

123 4567

Вывод содержит предшествующее 0. Дайте мне знать, если это проблема.

C # - 128 108 104

Спасибо Compass, BMac и Shawn за предложения по улучшению.

Сначала попробуйте Code Golf, и использование C # кажется здесь помехой ...

Используя .Compute()вы можете использовать строковые значения и суммировать их напрямую. В качестве бонуса это работает для других операторов, кроме "+".

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

Звонок t("123","456");дает вам 579.

GNU sed, 266 байт

Использует другой подход, чем решение DigitalTrauma. Как результат, этот работает еще хуже, используя O (m + n) . Конвертировать оба операнда в унарный, объединить, преобразовать обратно в десятичную (конечно, все используют регулярное выражение - sed не имеет понятия целого числа).

В качестве бонуса, эта программа суммирует все натуральные целые числа, заданные в stdin (в первой строке), что означает, что вы можете ничего не кормить, одно число или десять чисел, и это будет работать правильно независимо

Идея этого кода смутно вдохновлена ​​моим старым представлением PPCG, хотя я не помню, на какой вопрос это ответ.

Вот вам, «довольно», напечатанное для вашего «удобства», позаимствовать еще одну идею от 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#

(Чтобы получить 266-байтовую версию, удалите конечные точки с запятой, начальные пробелы и последний комментарий, предпочтительно используя sed.)

Заимствование некоторых тестов из 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

Я немного подправил действительно большие тесты из-за ужасной эффективности использования пространства. Из-за использования qобрабатывается только первая строка, отсюда и whileцикл в тесте.

Java 6 (181 символов)

Не быть превзойденным недостатком, известным как C # , Java во всей своей красе. Так много шаблонов! Использование предоставляет аргументы, разделенные пробелом, т.е.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]));
    }
}

Используя механизм JavaScript, доступный в javax, мы можем заставить другой язык делать свою работу за нас, и технически следовать правилам не использовать какие-либо числовые типы на родном языке или конвертировать.

Обоснование использования eval

Мы не преобразовали значения в int для JavaScript в eval. Мы создали строку, "123+456"которая не является числом. JS Engine обрабатывает формулу и оценивает строку как числовые литералы, которые не являются числовыми типами данных. Дурацкая логика Java! Кроме того, это также работает для doubleматематики.

APL (61)

Я думаю, что это подпадает под правила.

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

Это функция, которая принимает два строковых аргумента и возвращает строку:

      '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

Это также достаточно быстро, он добавляет число, образованное 999999 9с к себе в одно мгновение.

Он находит индекс каждого символа в ⎕D(который является строкой «0123456789»), затем выполняет добавление начальной школы к каждому индексу отдельно, перенося по мере необходимости, затем просматривает полученные цифры ⎕D. (Я думаю, что ⎕Dпоиск подпадает под правила, в основном это просто делает 'x'-48).

Объяснение:

• ⎕D∘⍳¨⍺⍵: поиск индексов ⎕Dдля каждого символа в обеих строках.
• ¯1+: вычитать 1из каждого, потому что массивы по умолчанию основаны на 1.
• ⌽↑⌽¨: перевернуть оба, превратить в матрицу (заполнение пустых квадратов нулями), затем перевернуть матрицу.
• +⌿: суммировать столбцы матрицы
• {... }перенести
  • ∨/T←9<Z←0,⍵: добавить дополнительный 0перед списком. Узнайте, какие цифры больше 9, и сохраните это в T. Если какие-либо цифры были выше 10:
    • Z-10×T: вычесть 10из каждой позиции больше 10,
    • T←(1⌽T)+: добавьте 1к каждой позиции рядом с каждой позицией, которая была выше 10, и сохраните в T.
    • T↓⍨~×⊃T: если Tначинается с нуля, удалите его,
    • ∇: применить функцию переноса к результату.
  • ⋄⍵: в противном случае вернуть значение без изменений
• 1+: добавить по одному на каждую позицию (потому что массив 1-индексирован)
• ⎕D[... ]: использовать результат как индексы в ⎕D.

Perl - 136 119 115 байт

Я изучаю Perl, это казалось хорошей практикой. Советы приветствуются!

Дрянной ответ, чтобы убрать это с дороги:

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

Актуальный ответ:

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

несжатый:

($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, оценка = 252

Для добавления не используются целые числа, длинные, байтовые, короткие, двойные, плавающие или любые встроенные библиотечные функции. Заверните в тело класса и позвоните с t(String1,String2). Пожалуйста, добавьте строки с 0, чтобы они имели одинаковую длину.

t("123","234")возвращается "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);}

Гольф Расширение с классом:

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

Частично гольф расширил:

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% расширен:

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 символов

как все знают Java, нет лучшего языка для игры в гольф, чем 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);}}

это нелегкое решение

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 байта

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

* Это делает несколько предположений:

• Мы находимся в среде ES6 REPL (например, консоль браузера FireFox 33.1)
• Производительность не имеет значения (серьезно, «9999999999», «9999999999» потребовалось около 20 минут, чтобы вернуться)
• Преобразование из целого числа в строку разрешено
• Ввод определен в переменных a и b, например:var a='123',b=321'; изменен на получение ввода из приглашения (+11).
• На входе нет ведущих нулей.

Python 2,7, 196 137 символов

версия 2 (короче, инициализируя словарь кодом):

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

Предыдущая версия 1 (196 символов):

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

например

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

Ключи словаря являются строками, значения словаря включают только числовые константы для сокращения кода, а вычисление выполняется путем объединения двух строк и получения результирующей длины, поэтому я надеюсь, что это считается «не преобразованием их в целые числа».

Python-версия с мелким шрифтом

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

Замечания:

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

Тип z - это пользовательский тип, который я определяю как: определенно не числовой тип по определению, которое использует спрашивающий, но он ведет себя достаточно близко к числовому типу, чтобы быть полезным в ограниченных обстоятельствах . Поведения типа z только частично реализованы в этом примере кода, и если интерпретатор CPython использует «int» для реализации z , это всего лишь деталь реализации, не связанная с рассматриваемой проблемой.