Bu iki dizeleri toplamını 2 girdileri dize almak ve çıkış zorunda kalmadan int dönüştürerek veya herhangi bir sayısal veri türünü kullanarak.

ex.

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

Dizelerin 10 basamaktan büyük olmayacağını varsayalım.

Bu kod golf ve karakterler kısa cevap kazanır. C # 'daki cevaba yapılan bir düzenleme beni gülümsetecek :).

Edit: int dönüştürmek bu doğanın herhangi bir şey olarak tanımlanabilir

Int.TryParse, (int), Convert.ToIntVb

80836 Montaj ( 57 53 bayt)

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

Bu, ascii basamaklarını '0'-'9'tamsayılara dönüştürmeden 0-9ve gerektiğinde devam ettirmeden, rakamdan, sağdan sola ekler . Bayt kodu C'de çağrılabilen bir fonksiyonun kodudur (aşağıya bakınız).

Yukarıdaki bayt kodu aşağıdaki derlemeden elle yazılmıştır (NASM stili, yorumlanmıştır):

; 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

Bunu C'de denemek için (gcc, linux, intel işlemci):

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

Yakut, 109 71

Sevimsiz. Eğer Muhammed'i dağa getiremezsen ....

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

Algoritma:

1. Bir int'in dize temsilini giriş 1 ve giriş 2 ile karşılaştırın.
2. Bu int değerini maç başına sonuca ekleyin.
3. İki kez yapana kadar artırın ve tekrarlayın.
4. Kendinize kusun

Değişiklikler

71 bir dizi olarak daha kısa.

85 kaldırılan yöntem bildirimi ve çağrıları birleştirmek n.to_s

92 bazı ipuçları uyguladı

101 karakter kaydet

102 artış için x kullan

109 ilk taahhüt

sed, 359 bayt (süslü biçimlendirme olmadan)

Hala bu ek olmadan Ekle (veya 4 temel aritmetik işleçlerinden herhangi biri) olup olmadığını emin değilim . Bu arada, bu soruya verdiğim yanıtı çapraz olarak göndereyim. Herhangi bir golf kazanmak için gitmeyecek, ama onun bir başlangıç ​​ve kolayca spec karşılar düşünüyorum:

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

Giriş STDIN'den "x y" biçiminde alınır. Bu önce "x: 0 :: y:" biçimine dönüştürülür. Sonra ":" karakterlerinden sonra gelen tüm sayıları "x: x: :( x + y):" elde edene kadar arttırırız. Sonra nihayet (x + y) dönüyoruz.

Çıktı

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

Bunun yalnızca doğal sayılar için işe yaradığını unutmayın. Ancak (en azından teoride) keyfi olarak büyük tamsayılar için çalışır. Y üzerinde x artış işlemleri yaptığımızdan, sipariş verme hızı büyük bir fark yaratabilir: x <y, x> y'den daha hızlı olacaktır.

Yakut - 485 432 265

Bu daha çok soruda aradığınız şeyin ruhunda görünüyor.

Temel olarak, bir insanın kağıt üzerinde nasıl olacağı sorununu çözer - tüm tek haneli toplama sonuçlarını "ezberleyerek", her sütunu ekleyerek ve gerektiğinde "birini nasıl taşıyacağınızı" anlayarak.

Bu aynı zamanda soru tarafından yasaklanan bir "sayısal veri türü" (değişken i) kullanır, ancak yalnızca dize dizine ekleme için kullanılır. Bunu kaldırmayı ve cevabımı düzenlemeyi deneyeceğim.

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

Biraz soluksuz:

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: yorumlardan bazı fikirler sadece kodlama yerine "ezberlenmiş" eşleme tablosu oluşturmak için kullanılır.

CJam, 95 92 80 72 70 44 karakter

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

bunun anlamı

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

Bu kesinlikle çok golf olabilir. Yaklaşımımın optimal olup olmadığını gerçekten bilmiyorum.

GÜNCELLEME - Bayt kaydetmek için toplam matris oluşturma satır içi. Bu nedenle, program şimdi 10 kat daha yavaş çalışıyor, ancak yine de her türlü giriş için sabit bir süre.

Buradan çevrimiçi deneyin

STDIN'den iki sayı içeren satırı dize olarak okur ve dizenin kendisi olan bir karakter dizisi olarak çıkar.

Örneğin:

123 4567

Çıktı öncekiler içerir 0. Bunun bir sorun olup olmadığını bana bildirin.

C # - 128 108 104

Geliştirmeleri önerdikleri için Compass, BMac ve Shawn'a teşekkürler.

Önce Code Golf deneyin ve C # kullanmak burada bir handikap gibi görünüyor ...

Kullanarak .Compute() dize değerlerini kullanabilir ve doğrudan toplayabilirsiniz. Bonus olarak bu sadece "+" dışında diğer operatörler için de geçerlidir.

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

Aramak t("123","456");seni 579 alır.

GNU sed, 266 bayt

DigitalTrauma'nın çözümünden farklı bir yaklaşım kullanır. Bir etki olarak, bu, O (m + n) kullanarak daha da kötü performans gösterir . Her iki işleneni de tekli, bitiştir, ondalık biçime dönüştür (hepsi elbette normal ifadeyi kullanarak — sed kavramına sahip değil bir tamsayı ).

Bonus olarak, bu program stdin'de (ilk satırda) verilen tüm doğal tamsayıları toplar, yani hiçbir şey, bir sayı veya on sayı besleyemezsiniz ve ne olursa olsun doğru olanı yapar.

Bu kodun arkasındaki fikir belirsiz bir şekilde eski bir PPCG sed benim teslim esinlenerek ilham verdi, ancak hangi soru için bir cevap olduğunu hatırlamıyorum.

İşte size, "rahatlığınız" için basılan "oldukça", DigitalTrauma'dan başka bir fikir ödünç almak. : 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 baytlık sürümü elde etmek için, tercihen noktalı virgül, baş boşluk ve son yorumu tercihen sed kullanarak kaldırın.)

DigitalTrauma'dan bazı testler ödünç almak:

% 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

Korkunç alan (in) verimliliği nedeniyle gerçekten büyük testleri biraz değiştirdim. qSadece ilk satırın kullanılması nedeniyle while, testteki döngü işlenir .

Java 6 (181 karakter)

Tüm ihtişamıyla C # , Java olarak bilinen handikap tarafından aşılmamalıdır . Çok fazla kazan plakası! Kullanım, boşlukla ayrılmış argümanları sağlamaktır, yani123 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]));
    }
}

Kullanılabilir JavaScript motorunu kullanarak, javaxbaşka bir dilin bizim için işi yapmasını sağlayabiliriz ve teknik olarak yerel dilde herhangi bir sayısal tür kullanmamak veya dönüştürmek kurallarını izleyebiliriz.

Kullanmanın gerekçesi eval

JavaScript'in değerlendirilmesi için değerleri int değerine dönüştürmedik. "123+456"Sayı olmayan bir Dize oluşturduk . JS Engine, formülü sindirir ve Dizeyi sayısal veri türleri olmayan sayı değişmezleri olarak değerlendirir. Java sevimsiz mantık! Bir yana, bu doublematematik için de işe yarıyor .

APL (61)

Ben düşünüyorum bu kuralları içinde düşer.

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

Bu, iki dize argümanı alan ve bir dize döndüren bir işlevdir:

      '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

Oldukça hızlıdır, 999999 9s'nin oluşturduğu sayıyı anında ekler .

Her karakterin indeksini bulur ⎕D('0123456789' dizesidir), daha sonra gerektiğinde taşıyan her bir indekste ayrı ayrı sınıf eklenmesi yapar, ardından ortaya çıkan rakamları arar ⎕D. (Bence ⎕Darama kuralların içine giriyor, temelde sadece yapıyor 'x'-48).

Açıklama:

• ⎕D∘⍳¨⍺⍵: ⎕Dher iki dizgideki her karakter için indekslere bakın .
• ¯1+: 1diziler varsayılan olarak 1 tabanlı olduğu için her birinden çıkartın.
• ⌽↑⌽¨: her ikisini de ters çevirin, bir matrise dönüştürün (boş kareleri sıfırlarla doldurun), ardından matrisi ters çevirin.
• +⌿: matrisin sütunlarını topla
• {... }: devam ettirmek:
  • ∨/T←9<Z←0,⍵: 0listenin önüne bir satır daha eklemenizi sağlar . Hangi 'rakamların' 9'dan yüksek olduğunu bulun ve bunu saklayın T. Herhangi bir basamak 10'dan büyükse:
    • Z-10×T: 1010'dan daha yüksek olan her konumdan çıkar,
    • T←(1⌽T)+: 110'dan daha yüksek olan her bir konumun yanındaki her bir konuma ekleyin ve depolayın T.
    • T↓⍨~×⊃T: Tsıfır ile başlıyorsa, kaldırın,
    • ∇: sonuca taşıma işlevini uygular.
  • ⋄⍵: aksi takdirde, değeri değiştirmeden döndür
• 1+: her konuma bir tane ekleyin (dizi 1 dizinli olduğu için)
• ⎕D[... ]: sonucu indeks olarak kullan ⎕D.

Perl - 136 119 115 bayt

Perl öğreniyorum, bu iyi bir uygulama gibi görünüyordu. İpuçları takdir!

Sevimsiz cevap, bunu yoldan çıkarmak için:

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

Gerçek cevap:

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

sıkıştırılmamış:

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

Eklemek için tamsayı, uzun, bayt, kısa, çift, kayan veya yerleşik kitaplık işlevlerini kullanmaz. Bir sınıf gövdesine sarın ve arayın t(String1,String2). Eşit uzunlukta olmaları için lütfen dizeleri 0'larla doldurun.

t("123","234")döner "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);}

Golf Sınıfla genişletildi:

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

Kısmen golf sahası genişletildi:

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 Genişletilmiş:

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 Karakter

herkes java'yı bildiği için golf için java'dan daha iyi bir dil yoktur

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

bu çözümsüz çözüm

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 bayt

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

* Bu birkaç varsayım yapar:

• ES6 REPL ortamındayız (ör. FireFox 33.1 tarayıcı konsolu)
• Performansın önemi yok (ciddi bir şekilde, '9999999999', '9999999999' geri dönmek yaklaşık 20 dakika sürdü)
• Tamsayıdan Dizgeye dönüştürmeye izin verilir
• Girdi a ve b değişkenlerinde tanımlanır, örn .: Bilgivar a='123',b=321'; isteminden (+11) girdi almaya değiştirildi.
• Girişin önünde sıfır yok.

Python 2.7, 196137 karakter

sürüm 2 (sözlüğü kodla başlatarak daha kısa):

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

Önceki sürüm 1 (196 karakter):

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

Örneğin

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

Sözlük anahtarları dizelerdir, sözlük değerleri sadece kodu kısaltmak için sayı sabitlerini içerir ve hesaplama iki dizeyi birleştirip elde edilen uzunluğu alarak yapılır, bu yüzden umarım "onları ints'e dönüştürmüyor" olarak sayılır.

Python küçük baskı kural hile sürümü

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

Not:

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

Tip z I olarak tanımlamak özel bir türüdür: kesinlikle ne tanımlama sorgulayıcı kullanımları ile sayısal bir tip ama bir sayısal tür davranır yeterince yakın sınırlı durumlarda yararlı olması için . Tür z davranışları bu kod örneğinde yalnızca kısmen uygulanır ve CPython yorumlayıcısı z uygulamak için 'int' kullanırsa , bu yalnızca bir uygulama ayrıntısıdır ve eldeki sorunla ilgili değildir.