Вам потрібно взяти 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 procesor):

#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. Додайте цей результат до результату за матч.
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

EDIT: Використовували деякі ідеї з коментарів для створення «запам’ятованої» таблиці відображення, а не просто жорсткого кодування.

CJam, 95 92 80 72 70 44 символи

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

що перекладається на

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

Це, безумовно, можна багато в гольф. Я дійсно не знаю, чи є мій підхід оптимальним чи ні.

UPDATE - Вбудоване створення матриці суми для збереження байтів. Завдяки цьому програма зараз працює в 10 разів повільніше, але все ж є постійним часом для будь-якого введення.

Спробуйте його онлайн тут

Читає рядок, що містить два числа з STDIN, як рядок і виводить як масив символів, що є самим рядком.

Наприклад:

123 4567

Вихід містить попередні 0. Дайте мені знати, чи це проблема.

C # - 128 108 104

Завдяки Compass, BMac та Shawn за те, що вони запропонували покращення.

Спершу спробуйте Code Golf, і використання C #, здається, є гандикапом тут ...

За допомогою .Compute()ви можете використовувати рядкові значення та підсумовувати їх безпосередньо. Як бонус, це працює для інших операторів, крім просто «+».

Гольф:

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

Безголівки:

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

Безголівки:

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 перетравлює формулу і оцінює String як числові літерали, які не є числовими типами даних. 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 байт

Я вивчаю Перл, це здавалося гарною практикою. Поради цінуються!

Відповідь "сирний", щоб не вийти з цього шляху:

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

Гольф:

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

* Це робить кілька припущень:

• Ми перебуваємо в середовищі RE6 ES6 (наприклад, консоль браузера FireFox 33.1)
• Продуктивність не має значення (серйозно, "9999999999", "9999999999" потрібно було близько 20 хвилин, щоб повернутися)
• Дозволено перетворення з Integer в String
• Введення визначається змінними a і b, напр .:var a='123',b=321'; Змінено на отримання введення з підказки (+11).
• Введення не має провідних нулів.

Пітон 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

Клавіші словника - це рядки, значення словника включають лише числові константи для скорочення коду, і обчислення відбувається шляхом об'єднання двох рядків і отримання отриманої довжини, тому я сподіваюся, що він вважається "не перетворенням їх у ints".

Версія з дрібним шрифтом 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 , це лише детальна інформація про реалізацію і не пов'язана з проблемою.