int로 변환하거나 숫자 데이터 유형을 사용 하지 않고 2 개의 문자열 입력을 가져 와서이 두 문자열의 합계를 출력해야 합니다.

전의.

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, 인텔 프로세서) :

#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 x를 사용하여 증분

109 초기 커밋

sed, 359 바이트 (멋진 포맷 제외)

이것이 추가없이 Add 의 dup인지 (또는 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
$

이것은 자연수에만 적용됩니다. 그러나 (이론적으로는) 임의로 큰 정수에 작동합니다. 우리는 y에 대해 x 증분 연산을 수행하기 때문에 순서에 따라 속도가 크게 달라질 수 있습니다. 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()문자열 값을 사용하여 직접 요약 할 수 있습니다합니다. 보너스로 이것은 "+"를 제외하고 다른 운영자에게 효과적입니다.

골프 :

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)을 사용하면 성능이 훨씬 저하 됩니다. 두 피연산자를 모두 단항으로 변환하고 연결하고 10 진수로 다시 변환합니다 (정규식을 사용하는 모든 것-sed에는 정수 개념 이 없음 ).

보너스로,이 프로그램 은 stdin (첫 번째 줄)에 주어진 모든 자연 정수를 합산합니다 . 즉, 아무 것도, 1 또는 10 개의 숫자를 공급할 수 없으며 관계없이 올바른 일을 할 수 있습니다.

이 코드의 아이디어는 오래된 PPCG sed 제출에 의해 모호하게 영감을 얻었지만 어떤 질문에 대한 답인지는 기억하지 못합니다.

DigitalTrauma에서 다른 아이디어를 빌리는 것은 "편의"를 위해 "꽤"인쇄 된 것입니다. :디

                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테스트 의 루프 가 처리됩니다 .

자바 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

JavaScript를 평가하기 위해 값을 int로 변환하지 않았습니다. "123+456"숫자가 아닌 문자열을 만들었습니다 . JS 엔진은 수식을 요약하고 문자열을 숫자 데이터 유형이 아닌 숫자 리터럴로 평가합니다. 자바 치즈 논리! 제쳐두고 이것은 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을 기반으로하기 때문에 각각에서 빼기 .
• ⌽↑⌽¨: 둘 다 뒤집고 행렬로 바꾸고 (빈 사각형을 0으로 채움) 행렬을 뒤집습니다.
• +⌿: 행렬의 열 합
• {... }: 이월 :
  • ∨/T←9<Z←0,⍵: 0목록 앞에 추가 항목을 추가 하십시오. 9보다 큰 '자리수'를 찾아서에 저장하십시오 T. 10보다 큰 숫자가있는 경우 :
    • Z-10×T: 1010보다 높은 각 위치에서 빼기
    • T←(1⌽T)+: 110보다 높은 각 위치 옆의 각 위치에 추가 하고에 저장 T합니다.
    • T↓⍨~×⊃T: T0으로 시작 하면 제거하십시오.
    • ∇: 캐리 기능을 결과에 적용합니다.
  • ⋄⍵: 그렇지 않으면 값을 변경하지 않고 반환
• 1+: 각 위치에 1 개 추가 (배열이 1- 인덱스되므로)
• ⎕D[... ]: 결과를에 인덱스로 사용합니다 ⎕D.

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

자바 7, 점수 = 252

정수, long, 바이트, short, double, float 또는 float에 내장 된 라이브러리 함수를 사용하지 않습니다. 수업 본문에 싸서로 전화하십시오 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);
    }
}

자바-257 자

모두가 자바를 알고 있기 때문에 자바보다 골프에 더 좋은 언어는 없습니다

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

하스켈 - 98 94 바이트

main=do
 a<-getLine
 b<-getLine
 let c d=last$takeWhile(\e->d/=(show$e-1))[0..]
 print$c a+c b

자바 스크립트 (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)에서 입력을받는 것으로 변경되었습니다.
• 입력에 선행 0이 없습니다.

Python 2.7, 196137 자

버전 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

사전 키는 문자열이며, 사전 값에는 코드를 단축하기위한 숫자 상수 만 포함되어 있으며 계산은 두 문자열을 연결하고 결과 길이를 가져 와서 "int로 변환하지 않음"으로 계산되기를 바랍니다.

파이썬 소형 프린트 규칙 치트 버전

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

노트 :

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

유형 z 는 내가 정의한 사용자 정의 유형입니다 . 질문자가 사용하는 정의에 따라 숫자 유형이 아니지만 제한된 상황에서 유용 할 수 있도록 숫자 유형에 가깝게 작동합니다 . 유형 z 동작은이 코드 샘플에서 부분적으로 만 구현되며 CPython 인터프리터가 'int'를 사용하여 z 를 구현 하는 경우 이는 구현 세부 사항 일 뿐이며 현재 문제와 관련이 없습니다.