문제:

목표는 다음 수학 연산자를 사용하지 않고 두 개의 입력 숫자를 추가하는 것입니다 +,-,*,/.

또한 해당 수학 연산자를 대체하도록 설계된 내장 함수를 사용할 수 없습니다.

채점 :

가장 작은 코드 (바이트 수)가 이깁니다.

최신 정보

내가 본 대부분의 프로그램은 숫자를 포함하는 두 개의 배열을 연결하거나 first number문자를 만들고 문자를 추가 second number한 다음 모두 계산합니다.

가장 짧은 배열 카운터 : 8 자 APL, Tobia

최단 배열 연결 : Doorknob에 의해 4 개의 문자가 포함 된 골프 스크립트

가장 짧은 로그 솔루션 : Quincunx의 TI-89 Basic (19 자)

통합 솔루션 : 45 개의 문자가있는 Mathematica, Michael Stern

내 의견으로는 가장 멋지다 : dave의 자바 스크립트 비트 연산자

스몰 토크, 21 13

다음은 모두 양의 정수에서만 작동합니다. 심각한 답변 은 다른 스몰 토크 답변을 참조하십시오 .

version1

큰 정수로 이동하여 높은 비트 인덱스를 요구합니다 (나쁜 ST 인덱스는 1 기반이므로 추가 오른쪽 시프트가 필요합니다).

(((1<<a)<<b)>>1)highBit

version2

비슷하고 조금 더 짧습니다 (Smalltalk 우선 규칙으로 인해 올바른 이동이 필요하지 않음).

1<<a<<b log:2 

version3

두 개의 숫자 a와 b가 주어 졌을 때 "컬렉션 연결 요청 크기"테마의 또 다른 변형

((Array new:a),(Array new:b)) size

Intervals를 컬렉션으로 사용하면 21 문자로 메모리 친화적 인 버전 ;-)을 얻습니다.

((1to:a),(1to:b))size

그러나 많은 수의 크 런칭에는 권장되지 않습니다.

version4

오락을 위해 시간을 기억과 교환하고 싶다면 다음을 시도하십시오.

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

일반적으로 충분히 정확합니다 (그러나 보증은 없습니다 ;-))

version5

파일에 쓰고 크기를 물어보십시오

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

자바 스크립트 (25)

while(y)x^=y,y=(y&x^y)<<1

비트 연산 만 사용하여 두 개의 변수 x와 y를 추가하고 결과를 x에 저장합니다.

이것은 음수에서도 작동합니다.

C-38 바이트

main(){return printf("%*c%*c",3,0,4);}

나는 여기서 약간 속임수를 쓰고 OP는 수학 연산자를 사용하지 않는다고 말했다 .

*에 printf()문자를 인쇄하는 데 사용 폭 필드의 인수에서 촬영되는 형식 수단 printf()이 경우는, 제 3 및 반환 값은 printf()인쇄 된 문자의 수이다. 따라서 ' '필드 너비가 3 인 필드 너비가 4 인 필드를 인쇄 하면 총 3 + 4자가됩니다.

반환 값은 printf()통화에 추가 된 숫자입니다 .

파이썬-49 바이트

변수 x및 로 배치하여 입력을 가정합니다 y.

from math import*
print log(log((e**e**x)**e**y))

이 61 바이트 솔루션은 전체 프로그램입니다.

from math import*
print log(log((e**e**input())**e**input()))

지수화를 금지하지 않았다는 것을 고려하여 이것을 게시해야했습니다. 대수의 속성을 사용하여 식을 단순화하면 간단히 얻을 수 print input() + input()있습니다.

음수 및 부동 소수점 숫자를 모두 지원합니다.

참고 : 나는 gnibbler의 조언을 따르고이 답변을 세 가지로 나누었습니다. 이것이 Mathematica 솔루션 이며 TI-89 기본 솔루션 입니다.

자바 스크립트 [25 바이트]

~eval([1,~x,~y].join(''))

수학, 21 바이트

Mathematica에는 여러 가지 방법이 있습니다. 하나는 Accumulate 기능을 사용하고 출력에서 ​​최종 숫자를 제외한 모든 것을 던집니다. 아래에있는 내 다른 솔루션과 마찬가지로, I는 입력 숫자 변수에 있다고 가정 a하고 b. 21 바이트

Last@Accumulate@{a, b}

더 재미있는 것은 45 자이지만 숫자를 사용하여 줄을 정의하고 그 아래에 통합하십시오.

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

보너스로, 두 솔루션 모두 여기에 다른 솔루션의 경우처럼 양의 정수뿐만 아니라 모든 복잡한 숫자에 대해 작동합니다.

GolfScript, 6 4 자 / 바이트

10, 5(=> 15) 형식으로 입력하십시오 .

~,+,

가 +어레이 연결하지 추가이다.

작동 방식은 ,숫자 길이 ( 0,1,...,n-2,n-1) 의 배열을 만드는 데 사용됩니다 . 이것은 두 숫자에 대해 수행 된 다음 배열이 연결됩니다. ,결과 배열의 길이를 찾기 위해 다른 목적으로 다시 사용됩니다.

자, 여기 속임수가 있습니다. 입력 형식을 남용하기 때문에 이것을 정말로 좋아합니다. 그것은 외모 가 입력이 GolfScript 코드로 실행되고 있기 때문에 그냥, 정말하지만, 배열을 입력있어 처음처럼 ,이미 나를 위해 이루어집니다! (이전의 6 문자 버전은 ~,\,+,input format으로 10 5, \,(스왑 배열) 을 제거하여 2 개의 문자를 제거했습니다 ).

구 버전 (12) :

함수를 만듭니다 f.

{n*\n*+,}:f;

*와는 +각각 문자열의 반복과 연결하지 연산 함수입니다.

설명 : n한 문자 문자열 (줄 바꾸기)을 작성합니다. 그런 다음이 a시간 을 반복 한 다음 동일한 작업을 수행합니다 b. 문자열이 연결되고 ,문자열 길이에 사용됩니다.

C, 29 27 바이트

포인터 산술 사용하기 :

f(x,y)char*x;{return&x[y];}

x 는 포인터로 정의되지만 호출자는 정수를 전달해야합니다.

익명 사용자가 27 바이트를 제안했지만 매개 변수는 정수입니다.

f(x,y){return&x[(char*)y];}

브레인 프 * ck, 9 36

,>,[-<+>]

++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

이것은 간단한 추가를 사용하지 않고 작동합니다. 그것은 통과하고 1의 흔적을 낳은 다음 계산합니다.

참고 : +및 -단지 하나의 단위로하고 아무것도 brainf에서 수행 할 수 있습니다 * 그들없이 CK. 그들은 실제로 더하기 / 빼기가 아니므로 이것이 여전히 중요하다고 생각합니다.

J (6)

succ 함수를 사용할 수 없다고 말하지 않았습니다.

>:@[&0

용법:

   9>:@[&0(8)
17

>:8에서 9 번 반복 합니다.

목록 연결 접근 방식도 작동합니다 #@,&(#&0). 그리고-나는 그것이 규칙에 위배된다는 것을 알고 있습니다-나는 가장 J-ish 솔루션 없이는이 답변을 놓을 수 없습니다 : *&.^(지수의 곱셈).

포스트 스크립트, 41

다음과 같이 길이가 41 바이트 인 함수를 정의합니다.

/a{0 moveto 0 rmoveto currentpoint pop}def

그런 다음 예를 들면 다음과 같습니다.

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

어느 것이

25.0

대부분의 경쟁 업체와 달리 음수와 부동을 쉽게 처리합니다.

배쉬, 20 자

(seq 10;seq 4)|wc -l

스몰 토크 (현재 심각), 123118105 (*)

두 번 답변 해 주셔서 죄송하지만이 답변을 진지한 답변으로 여기고 다른 답변은 유머와 비슷했습니다. 다음은 실제로 모든 기계 (하드웨어)에서 바로 지금 실행됩니다. 다른 사람의 마음에 들지 않는 것이 이상합니다 ...

두 개의 반가산기를 결합하고 단어의 모든 비트를 병렬로 수행하면 읽을 수있는 버전 (입력 a, b; s로 출력)을 얻습니다.

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

루프는 캐리 전파를위한 것입니다. 마스크는 부호있는 정수가 처리되도록합니다 (그것이 없으면 부호없는 숫자 만 가능합니다). 또한 워드 길이를 정의하며, 위의 32 비트 작동을위한 것입니다. 68 비트 추가를 선호하는 경우 16rFFFFFFFFFFFFFFFFFFF로 변경하십시오.

골프 버전 (123 자) (m에서 재사용하여 긴 마스크를 피함) :

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) 16rFFFFFFFF 대신 -1을 사용하면 더 나은 골프를 즐길 수 있지만 코드는 더 이상 임의의 정밀 숫자에 대해서는 작동하지 않으며 기계 단어 크기의 smallInteger에 대해서만 작동합니다 (largeInteger에 대한 표현은 Ansi 표준에 정의되어 있지 않음).

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

이것은 코드 크기를 105 문자로 줄입니다.

APL, 8 및 12

여기에 새로운 것은 없습니다, 배열 카운팅 버전 :

{≢∊⍳¨⍺⍵}

및 로그 ○ 로그 버전 :

{⍟⍟(**⍺)**⍵}

나는 그들이 APL에서 멋지게 보였다고 생각했습니다!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

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

답이 늦어서 미안하지만 아마도 가장 긴 대답입니다. 그러나 sed로 이것이 가능한지 알고 싶었습니다.

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

이것은 단순히 문자열의 숫자를 증가시키는 https://codegolf.stackexchange.com/a/38087/11259 와 유사 합니다. 그러나 대신 루프에서 증가 작업을 수행합니다.

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보다 빠릅니다.

대시 , 18 바이트

time -f%e sleep $@

GNU 시간 1.7 이상이 필요합니다. 출력은 STDERR입니다.

온라인으로 사용해보십시오!

이 작동하지 않습니다 B의 GNU 시간에서의 내장 시간 명령 다르므로, 애쉬입니다.

Bash가 외부 명령을 사용하도록 \time하는 대신 1 바이트를 추가 로 사용할 수 있습니다 time.

자바 스크립트 (67)

아마도 훨씬 나아질 것입니다

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

루비, 18 자

a.times{b=b.next}

그리고 두 가지 더 자세한 변형, 29 자

[*1..a].concat([*1..b]).size

다른 버전, 32 자

(''.rjust(a)<<''.rjust(b)).size

C #-즉석 코드 생성

예, 실제로 거기에 추가가 있지만 + 연산자는 없으며 추가하는 프레임 워크 함수조차 없습니다. 대신 추가를 수행하는 메소드를 즉시 생성합니다.

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}

루비 39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

function(x,y)length(rep(1:2,c(x,y)))

여기서 1과 2로 rep구성된 벡터를 만듭니다 .xy

TI 기본 89-19 바이트

TI-89 (홈 화면 또는 프로그래밍 앱)에서이를 실행하십시오.

ln(ln((e^e^x)^e^y))

이것은 이 솔루션x+y 에서처럼 로그 규칙을 사용하여 계산 합니다 . 보너스로 십진수 및 정수에 사용할 수 있습니다. 모든 실수에 적용됩니다. 대수 지수에 대해 로그 규칙이 여전히 유효한 경우 복소수에도 적용됩니다. 그러나 복잡한 지수를 삽입하려고하면 계산기가 정크를 뱉어냅니다.

Mathematica 표기법을 가르쳐 준 Michael Stern에게 감사합니다 .

Mathematica- 21 20 바이트

Log@Log[(E^E^x)^E^y]

이것은 이 솔루션 과 동일한 접근 방식을 사용 하지만 Mathematica에서는 더 짧게 만듭니다. 이는 음수 및 부동 소수점 숫자와 in x및 정수에 적용 y됩니다.

로그 규칙을 사용하여 식을 단순화하면을 산출 x+y하지만 4 개의 기본 연산자 중 하나가 아닌 지수를 사용하므로 유효합니다.

C #-문자열 산술

우리는 두 숫자를 모두 문자열로 변환하고 문자열 절단 (carry와 모든 것을 사용하여)을 추가 한 다음 다시 정수로 구문 분석합니다. 0..200의 i1, i2로 테스트하여 매력처럼 작동합니다. 이것에서 추가를 찾으십시오!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}

C (79)

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

파이썬-22 자

len(range(x)+range(y))

APL : 2

1⊥

이것은 밑수 1의 숫자를 변환하므로 정확히 n + m 인 (n * 1 ^ 1) + (m * 1 ^ 2)입니다.

TryApl.org에서 시도 가능

TI-BASIC, 10

추가 X하고Y

ln(ln(e^(e^(X))^e^(Y

K, 2 바이트

#&

사용 예 :

  #&7 212
219

"where"연산자 (monadic &)를 입력 목록의 숫자에 적용하십시오 (입력 형식을 자유롭게 사용할 수 있음). 첫 번째 0과 두 번째 0이 포함 된 목록이 생성됩니다.

  &3 2
0 0 0 1 1

일반적으로이 연산자는 부울리스트의 0이 아닌 요소의 인덱스리스트를 생성하기 위해 "수집"으로 사용되지만 일반화 된 형식은 때때로 편리합니다.

그런 다음 간단히 해당 목록의 수를 계산하십시오 (monadic #).

입력 요구 사항에 대한 나의 해석이 용납 될 수 없다면 다음과 같은 약간 더 긴 솔루션은 동일한 트릭을 수행합니다.

{#&x,y}

Pyth , 29 바이트

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

온라인으로 사용해보십시오!

내 첫 번째 제출!

이것은 다음과 같이 컴파일됩니다.

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H