Dönüştürmeden dizelerin toplamı


9

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


2
Dizeleri sayılara dönüştürmediğimiz sürece kodumuzun başka yerlerindeki sayıları kullanabilir miyiz?
Doktor

5
Bunları int olarak yorumlamak yerine onları int'e dönüştürmek olarak tanımlanan nedir?
Pusula

4
Karakter kodlarıyla ne kadar yapabileceğimizi hala tam olarak bilmiyorum. Karakter kodlarını çıkarabilir miyiz? Bireysel rakamları karakter kodlarına dönüştürebilir miyiz?
Martin Ender

5
@ user15681218 Elbette olabilir. Ancak kurallarınızdan tam olarak ne yapabileceğimizi ve yapamayacağımızı tam olarak açık değil.
Martin Ender

2
Bu sorunun Add (veya 4 temel aritmetik işleçlerinden herhangi biri) olmadan bir eklenti olduğunu düşünmüyorum . Aslında, bu soru sayıları olmayan çarpma sorusuna eklemeden eklemeden daha benzerdir . Çarpma sorusu da başlangıçta ilave edilmeden bir ekleme kupası olarak kabul edildi.
Doktor

Yanıtlar:


16

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

14

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


2
@DigitalTrauma Oh, bence bu korkunç bir cevap, ama kesinlikle kriterleri karşılıyor.
Charles

1
@ DigitalTrauma benim bile cheesier cevap kullanır succveya prev.... ama bu golf bile eğlenceli değil.
Charles

1
"... onları int'e dönüştürmeden veya herhangi bir sayısal veri türü kullanmadan ." Cevabınızda, r, n, d ve x hepsi sayısal. Ayrıca, dize gösteriminin girilen dizeyle eşleşip eşleşmediğini görmek için her tamsayıyı kontrol etmek aslında int'e dönüştürmenin yavaş bir kaba-kuvvet yoludur.
Trey Thomas


1
@TreyThomas: Sanırım iki miktarı bir şekilde ölçmeden birleştirmek imkansız. Bu soruyu cevaplamak için herhangi bir kod i + j hesaplaması yapmak ve ne zaman durmak için doğru cevaba sahip olduğunu bilmek zorundadır, bu yüzden doğru cevap herhangi bir şekilde gizlenmiş int dönüştürmek için yavaş bir kaba-kuvvet yoludur.
TessellatingHeckler

10

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.


Emin değilim, ama artmayı ne zaman durduracağınızı nereden biliyorsunuz? X'i bir int olarak okuyamayacağınızdan ..
Optimizer

@Optimizer Artış algoritması şunlara dayanır: tamamen normal ikameler olan ve aritmetik olmayan codegolf.stackexchange.com/questions/38033/… . Üçlü {x, 0, y} ile başlıyoruz, sonra eleman 1 ve 2 eşit olana kadar elemanlar 2 ve 3'ü artırıyoruz (tekrar normal test). Bu noktada, 3. eleman gerekli toplam olacaktır.
Dijital Travma

2
Ah! Yani ydönüştürülür y+1sadece regex kullanarak? ve gerçek bir ekleme yok mu? Güzel!
Optimizer

9

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.


1
Muhtemelen "toplama haritanızı" bir şekilde hesaplayabilirsiniz ... belki[?1..?9].zip([?1..?9]).map{|x,y| Regex.new(x+y)}.map{/*something based on the order of results*/}
Charles

productdaha iyidirzip
Charles

1
/#{x+y}/daha kısadır Regexp.new(x+y). ;)
Ürdün

1
i=-1;(s=(?0..?9).to_a).product(s).map{|x,y|i+=1;/#{x+y}/=>(?0..'18').each_cons(10).to_a[i/10][i%10]}regex dizinizi verir.
Charles

ah ... ama bu bir sayısal ( i) kullanıyor ... bunun etrafında başka bir yol olmalı ... belki sadece each_cons(10)bir numaralandırıcı olarak ve nextküme aracılığıyla mı?
Charles

4

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.


4

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.


7
Güzel deneyin ve PPCG'ye hoş geldiniz. In kod golf , hepimiz gereksiz boşluğu silip kullandığımız kaç bayt söylüyorlar.

2
C # 'nın bir handikap olduğunu düşünüyorsanız, Java ile uğraşmaya başlayıncaya kadar bekleyin ...
Rodolfo Dias

1
Hesaplama çağrısına bir + "+" + b taşıyarak ve bildirimi yok sayarak satırları kaydedebilirsiniz.
Pusula

1
Bunun yerine ad alanlarını ve 'kullanarak' daha fazla değil kaydedebilirsinizSystem.Console.WriteLine(new System.Data.DataTable()...
bmac

1
Hiçbir şey, çıktının yeni bir Console.Write
satırla bitmesi

3

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 .


2

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 .


Sadece dc -e"$1 $2+p" teknik
TessellatingHeckler

2

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.

2

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;

2
Güzel. Sayılarınızı biraz azaltmak için bu ipuçlarını araştırabilirsiniz . Bir bakışta, ilk satırınızı değiştirmek ($x,$y)=@ARGVve sayyerine kullanmak printbirkaç karakterden kurtulacaktır.
Mark

Teşekkürler! Bunu yaptım ve bazı ebeveynleri çıkardım (Perl'in noktalama yaklaşımını seviyorum). Yine de çalışmak için söyleyemedim.
BMac

Ah. saybir Perl 6 şeydir (veya bu talimatlarla Perl 5'te kullanabilirsiniz , ancak bu çok uzun olurdu). Bunun yerine, bir karakteri tıraş etmek için saykullanın warn. Bu STDOUT yerine STDERR'a gönderilir, ancak bu kurallara aykırı değildir. :-)
Mark

0

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

1
Teknik olarak, java charsayısal veri türüdür ._.
Pusula

@Compass Dahili olarak öyle. Eğer karakter \u0030bir dizgeye dönüştürürsem, "0"anlamıyorum "48".
TheNumberOne

0

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

0

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

0

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.

@Optimizer Yeterince adil, istemden çekmek için güncellendi
SLuck49

Bu karakterleri çok fazla düşürmek için ES6'yı kullanabilirsiniz!
Optimize Edici

'Veya herhangi bir sayısal veri türünün kullanılması' döngüler için kullanmanıza bile izin verilmediği anlamına geliyor.
CSharpie

@CSharpie OP koddaki sayıların iyi olduğunu belirtti
SLuck49

0

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.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.