입력 : 두 개의 십진 정수. 이들은 표준 입력의 코드, 프로그램 또는 함수의 인수 또는 목록으로 제공 될 수 있습니다.

출력 : 10 진 정수로 표현 된 제품입니다. 예를 들어, 입력 5 16은 출력으로 이어 80집니다.

제한 사항 : 표준 허점은 없습니다. 이것은 code-golf 이며 가장 적은 양의 바이트로 응답합니다.

참고 사항 : 이전 도전에서 도난당한 레이아웃, 두 숫자 추가 .

테스트 사례 :

1 2   -> 2
4 5   -> 20
7 9   -> 63
-2 8  -> -16
8 -9  -> -72
-8 -9 -> 72
0 8   -> 0
0 -8  -> 0
8 0   -> 0
-8 0  -> 0
0 0   -> 0

또는 CSV로 :

a,b,c
1,2,2
4,5,20
7,9,63
-2,8,-16
8,-9,-72
-8,-9,72
0,8,0
0,-8,0
8,0,0
-8,0,0
0,0,0

리더 보드

var QUESTION_ID=106182,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc 1 바이트

*

이 답변을 편집 *하여 유효한 답변 인 다른 언어를 추가 할 수 있습니다 .

C (GCC), 13 바이트

모든 구현에서 작동 하지는 않지만 괜찮습니다.

f(a,b){a*=b;}

TIO에서 사용해보십시오!

Beatnik , 888 바이트

k I
j k ZZZZX z
xw k C vp yQ KD xw z j k ZZZZX z
j k ZZZD z xw bZ ZX
k XX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ XA xw xw xw xw z xw bZ K
xw xw k I
j k ZZZZX z
xw k C vp yQ XA hd k I z j k ZZZZX z
j xw k A vp bZ ZX
k ZZZZX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ F k ZZZZK xo
vp
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
qs z xw xw xw xw z qs
xw xw xw xw z qs k I qs k I z xw Xj ZC
qs bZ ZZZX qs xw yQ C hd xw
k I vp qs k I qs
xw Xj ZZC hd hd z Kz ZZD
k I z xw xw xw xw z qs k I qs k I Xj ZZZZF
z
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z qs xw
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z vp
xw xw z qs
xw xw z qs
k I qs
xw bZ ZZX k I z qs k I vp
xw k ZA z yQ ZA hd qs k I vp qs k I Xj ZZKD
qs xw Xj ZZK
hd qs xw Xj ZZZZ hd
k ZZZZKD vp xo xw Xj K

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

뒤로 점프하는 조건이 충족되지 않으면 TIO의 Python 인터프리터가 성가신 주소를 실행하기 때문에 C 인터프리터를 사용하고 있습니다. 파이썬 인터프리터의 쉬운 해결 방법은 주소 nop을 만들기 위해 nops를 채우는 것입니다. 나는 둘 다 옳지 않다고 믿는다.

                                   C       Python  My interpretation
IP after skiping N words           IP+N+1  IP+N+2  IP+N+2
IP after skiping back N words      IP-N    IP-N+1  IP-N+2
IP after not skiping N words       IP+2    IP+2    IP+2
IP after not skiping back N words  IP+2    IP+1    IP+2

입력은 줄 바꿈없이 공백으로 구분 된 두 정수 여야합니다.

이 답변은 각 셀이 0-255로 제한되지 않고 임의로 큰 값을 저장할 수있는 경우 모든 정수에 대해 이론적으로 작동합니다. 그러나 | A | + | B | > 22. 그리고 | A | + | B | > 6. 따라서 실제로 테스트 할 수있는 사례가 많지 않은 경우 if-else 솔루션이 더 짧을 수 있습니다.

아이디어는 값을 0으로 줄이고 모든 중간 값을 합산하여 삼각형 숫자 T (N) = N (N + 1) / 2를 계산하는 것입니다. 그러면 A * B = T (A + B)-T (A)-T (B)라는 답을 얻을 수 있습니다.

그러나 세 가지 값을 모두 계산하는 것은 까다 롭습니다. 먼저 T (A + B)-A를 계산하여 스택에 A의 사본을 남겨두고 나중에 다시 추가하고 입력 B를 사용하여이를 수행합니다. 그런 다음 그보다 작은 가장 큰 삼각형 수를 재귀 적으로 찾습니다. 특별한 경우를 제외하고 A + B-1). 우리는 B = T (A + B)-A-T (A + B-1)를 되찾고 거기서 T (B)를 계산할 수 있습니다.

숫자 N은 N보다 작은 가장 큰 삼각 수와 N보다 작은 음이 아닌 삼각 수의 수와 같은 경우 삼각 수입니다. 이것은 O (2 ^ (T (A + B) -A)에서 실행됩니다. 프로그램에서 가장 느린 부분입니다.

k I                                         Push 1
j k ZZZZKAAA z                              Input and decrement by 48.
xw k AAA vp yQ (input_a_loop)               If the character was '-':
xw z j k ZZZZKAAA z                           Replace with 0 and input another.
input_a_loop:
j k ZZZAA z xw bZ (input_a_end)             Input and break if it is a space.
k ZKA z qs xw vp xw xw vp xw vp vp vp       Otherwise multiply the previous
                                              value by 10 and add.
k I Xj (input_a_loop)                       Continue the loop.
input_a_end: hd                             Discard the space.
xw yQ (check_sign) k ZZZZKAAA xo exx        If A=0, print 0 and exit.
                                            Stack: ?, A_is_positive, A
check_sign:
qs yQ (check_sign_else)                     If A is positive... or not,
xw xw xw xw z xw bZ (check_sign_end)          in either cases, push 2 copies
check_sign_else: xw xw k I                    of A and the negated flag back
check_sign_end:                               as a constant.
                                            Stack: A, A, A, A_is_negative
j k ZZZZKAAA z                              Similar for B.
xw k AAA vp yQ (input_b_loop)               If the character was '-':
hd k I z j k ZZZZKAAA z                       Decrement the flag and input another.
input_b_loop:
j xw k A vp bZ (input_b_end)                EOF is checked instead of a space.
k ZZZZKAAA z qs xw vp xw xw vp xw vp vp vp
k I Xj (input_b_loop)
input_b_end: hd
xw yQ (output_sign) k ZZZZKAAA xo exx       If B=0, print 0 and exit.
                                            Stack: A, A, A, A*B_is_negative, B
output_sign:
qs yQ (output_sign_end) k ZZZZK xo          If negative, output '-'.
output_sign_end:

vp                                          Add.        Stack: A, A, A+B
xw xw z qs                                  Insert a 0. Stack: A, A, 0, A+B.
xw bZ { xw k I z xw Xj }                    Copy and decrement while nonzero.
                                            Stack: A, A, 0, A+B, A+B-1, ..., 0
qs xw bZ { vp qs xw Xj } hd                 Add while the second value in the
                                              stack is nonzero.
                                            Stack: A, A, T(A+B)
qs z xw xw xw xw z qs                       Stack: A, C0=T(A+B)-A, C0, F0=0, C0

expand_loop:
xw xw xw xw z qs k I qs                     Stack: A, C0, C0, F0=0,
                                              ..., [P=C, P, S=0, F=1], C
dec_expand: k I z xw Xj (expand_loop)       Decrement and continue if nonzero.
                                            Stack: [P=1, P, S, F], C=0
                                            The last number 0 is assumed to
                                              be a triangular number.
test: qs bZ (extract_end)                   If F=0, break.
qs xw yQ (test_not_first) hd xw             If S=0, it's the first triangular
                                              number below previous C. Set S=C.
test_not_first: k I vp qs k I qs            S+=1 and restore F=1.
xw Xj (dec_expand)                          If C!=0, recursively expand from C-1.
hd hd z Kz (test)                           If S=P, P is a triangular number,
                                              return to the previous level.
k I z xw xw xw xw z qs k I qs               Otherwise, decrement P and try again.
k I Xj (dec_expand)
extract_end:                                Stack: A, C0, C0, T(A+B-1)

z                                           Subtract and get B.
xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(B).
qs xw bZ { vp qs xw Xj } hd
                                            Stack: A, C0, T(B)
z qs xw                                     Stack: C0-T(B), A, A

xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(A).
qs xw bZ { vp qs xw Xj } hd
z vp                                        Get A*B=(C0-T(B))+(A-T(A))
xw xw z qs                                  Stack: 0, X=A*B

divide: xw xw z qs                          Stack: 0, ..., Y=0, X
subtract: k I qs                            Stack: 0, ..., Y, Z=1, X
xw bZ {                                     While X!=0:
k I z qs k I vp                               X-=1, Z+=1.
xw k ZA z yQ (not_ten)                        But if Z=11:
hd qs k I vp qs k I Xj (subtract)               Y+=1, reset Z and restart the loop.
not_ten: qs xw Xj }
hd qs xw Xj (divide)                        Put Z under Y and make Y the new X,
                                              continue the loop if X!=0.
hd                                          Discard X.

print_loop:
k ZZZZKAA vp xo xw Xj (print_loop)          Add each cell by 47 and print.

Mathematica, 4 바이트

1##&

사용법 예 : 1##&[7,9]returns 63. 실제로,이 동일한 함수는 모든 유형의 여러 인수를 함께 다중화합니다.

Mathematica codegolfers가 알고 있듯이 이것은 ##함수에 대한 전체 인수 시퀀스를 나타내며 Mathematica의 연결 (곱하기)은 곱셈을 나타냅니다. 그래서1## 함수의 모든 인수의 곱을 (1 회) 참조합니다. 는 &단지 짧은 Function순수한 (이름) 함수를 정의 명령.

다른 코드에서 공통 기호 *는 곱셈으로 작동합니다. 그이 때문에 그래서, 공간을 수행 7 9하는 것으로 해석된다 7*9(실제로, 매스 매 티카의 현재 REPL 버전이 실제로 곱셈 부호와 같은 공간을 표시합니다!). 그러나 Mathematica가 하나의 토큰이 시작하고 다른 토큰이 어디에서 끝나는 지 알 수 있다면 곱셈 연산자에 바이트가 전혀 필요하지 않습니다. 5y자동으로 5*y, 및 으로 해석 3.14Log[9]됩니다 3.14*Log[9].

망막 , 38 37 31 바이트

완전히 새로운 접근 방식, 이전 접근 방식은 다음과 같습니다.

M!`-
*\)`-¶-

.* 
$*_
_
$'$*_
_

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

설명

먼저, 우리는 부호를 다룹니다.

M!`-

-문자열에서 모두 일치 하고 개행으로 구분하여 반환합니다.

*\)`-¶-

(다음 빈 줄이 있음)
*\)은이 결과를 나타내며 이전 단계는 줄 바꿈없이 인쇄 된 다음 문자열이 이전 상태 (입력 문자열)로 되돌아갑니다. 나머지 부분은 2 개를 제거합니다- 줄 바꿈으로 구분 된 .

그런 다음 첫 번째 숫자를 단항으로 변환합니다.

.* 
$*_

(첫 줄 끝에 공백이 있습니다). _이 경우 표준 자릿수이므로 단항 자릿수로 사용합니다.1 가 두 번째 숫자로 표시 될 수 있고 나중에 충돌 할 수 .

이제 실제 곱셈에 도달합니다.

_
$'$*_

각각 _은 다음에 나오는 모든 것을 단항으로 대체합니다._ 단항 숫자로 사용). 단항으로의 변환은 숫자가 아닌 문자를 무시하므로 "첫 번째 숫자"시간 동안 두 번째 숫자의 단항 표현을 반복합니다. 두 번째 숫자는 문자열 끝에서 10 진수로 유지됩니다.

결국 단일로 문자열 _의 수를 반환합니다 _. 이는 곱셈의 결과입니다.

이전 답변 : (경고 : 출력해야 할 때 빈 문자열을 출력합니다 0)

망막 ,  45  42 41 바이트

게임하자! 산술 연산자가없고 자연수 만 지원하는 언어로 상대 숫자를 곱하십시오.

O^`^|-
--

\d+
$*
1(?=1* (1*))?
$1
1+
$.&

설명

처음 세 줄은 부호를 처리합니다.

O^`^|-

이것은 정규식과 일치하는 모든 문자열을 정렬 O한 후 되돌립니다 . 실제로 이것은 시작시 빈 문자열과 두 번째 숫자 앞의 마이너스 부호를 일치시키고 빼기 대신 빈 문자열을 배치합니다. 그 후에는 모두 문자열의 시작 부분에 있으며 다음 두 줄로 한 쌍을 쉽게 제거 할 수 있습니다.^^|--

그런 다음 내장 함수를 사용하여 숫자를 단항 표현으로 변환 한 다음 실제 곱셈을 수행합니다.

1(?=1* (1*))?
$1

우리는 any 1와 일치 1하고 다음 공간 뒤에서 각각을 대체 합니다. 첫 번째 숫자의 각 숫자는 전체 두 번째 숫자로 바뀌고 두 번째 숫자의 각 숫자는 빈 문자열로 바뀝니다.

마지막 부분은 다시 단항에서 십진수로 다시 변환하는 내장 기능입니다.

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

스크래치 , 1 바이트

사용법 : *부호의 양쪽에 숫자를 두십시오

참고 : 스크래치는 시각적 언어이므로 @ mbomb007에서 스크래치 바이트 수 를 계산 하는 방법에 대해 언급 할 때까지 얼마나 많은 바이트를 소비하는지 알 수 없었습니다.

Brain-Flak , 56 바이트

([({}<([({})<>])<>>)<>]){({}[()]<(({})<({}{})>)>)<>}{}{}

이것은 스택 클린이 아니기 때문에 전체 프로그램으로 실행되어야하며 입력은 스택의 유일한 요소 여야합니다.

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

설명 : (입력 x 및 y 호출)

1 부:

([({}<([({})<>])<>>)<>])

([                    ]) # Push negative x on top of:
      ([      ])         # negative y. After...
  ({}<            >)     # pushing x and...
        ({})             # y...
            <>  <>  <>   # on the other stack (and come back)

이 시점에서 한 스택에는 [x, y]가 있고 다른 스택에는 [-x, -y]가 있습니다.

2 부:

{({}[()]<(({})<({}{})>)>)<>}{}{}
{                          }     # Loop until x (or -x) is 0
 ({}[()]<              >)        # Decrement x
         (({})<      >)          # Hold onto y
               ({}{})            # Add y and the number under it (initially 0)
                         <>      # Switch stacks
                            {}{} # Pop x and y leaving the sum

자바 스크립트 (ES6), 9 바이트

ES6에는 32 비트 정수 전용 함수가 있으며보다 일반적인 *연산자 보다 빠릅니다 .

Math.imul

덧붙여 말하면, 이것은 다음과 같은 길이입니다.

a=>b=>a*b

Brain-Flak , 56 54 52 바이트

Nitrodon의 실수로 2 바이트가 절약되었습니다.

({}(<()>)<>)({<([{}({}())])><>([{}]([{}]))<>}<{}{}>)

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

스택 클린 버전, 62 60 바이트

({}(<()>)(<>))({<([{}({}())])><>([{}]([{}]))<>}<{}{}<>{}{}>)

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

설명

이 설명은 관련된 알고리즘에 대한 설명이며 실제 코드는 생략합니다. Brain-Flak을 능숙하게 읽는 방법을 알고 있다고 가정합니다. 코드 또는 알고리즘을 이해하는 데 도움이 필요하면 의견을 남기면 기꺼이 편집하거나 응답 할 것입니다.

이것은 약간 이상한 것으로 거의별로 효과가없는 이상한 수학을 사용합니다. 내가 한 첫 번째 일은 항상 O (n) 단계로 끝나는 루프를 만드는 것 입니다. 이 작업을 수행하는 일반적인 방법은 n 과 -n 을 반대 스택에 놓고 하나가 0이 될 때까지 하나씩 추가하는 것이지만 약간 낯선 방식으로 수행했습니다. 내 방법에서 나는 입력 아래에 카운터를 넣어 각 단계 나는 카운터에 추가 증가 N 과의 부호 플립 N을 .

예를 들어 봅시다. 가령 N = 7

7  -8   6  -9   5 -10   4 -11   3 -12   2 -13   1 -14   0
0   1   2   3   4   5   6   7   8   9  10  11  12  13  14

나는 그것을 증명하지는 않지만 이것은 항상 모든 입력에 대해 종료되며 약 2n 단계로 완료됩니다. 실제로 n 이 양수 이면 2n 단계로 종료되고 n 이 음수 이면 2n-1 단계로 종료됩니다 . 여기서 테스트 할 수 있습니다 .

이제 루프 에 약 2n 단계가 있습니다 .n을 어떻게 곱 합니까? 여기에 수학 마술이 있습니다. 여기에 우리가하는 일이 있습니다 : 우리는 누산기를 만들고, 프로세스의 각 단계에서 누산기에 두 번째 입력 ( m )을 추가하고 두 신호 의 부호를 뒤집은 다음 발생하는 모든 루프에 대해 총계를 푸시합니다. 생성물.

왜 그런가?

글쎄, 예를 들어 보면 좋을 것입니다. 이 예에서는 5 에 3을 곱 하면 중요한 값만 표시합니다.

total       -> 0  -5   5 -10  10 -15  15
accumulator -> 0  -5  10 -15  20 -25  30
m           -> 5  -5   5  -5   5  -5   5

바라건대 메커니즘이 여기에 분명합니다. 우리는 절대 값 순서로 m의 모든 배수를 단계별로 진행하고 있습니다. 당신은 통지 후 것 2N ^번째 용어는 항상 * N 해요 항상 전에 용어를 -m * N . 이를 통해 루핑이 원하는 결과와 완벽하게 일치합니다. 행복한 우연의 일치;)

Dyalog APL , 1 바이트

× 하나는 왼쪽에, 하나는 오른쪽에

×... 또는 여러 개의 번호를 왼쪽 이나 오른쪽 또는 양쪽에

×/ 리스트의 모든 숫자를 곱합니다

×/¨ 주어진 목록에서 쌍을 곱합니다.

×/∊ 배열의 모든 숫자를 다중화

이것은 모든 산술 함수, 모든 크기와 순위의 배열 및 모든 데이터 유형의 수에 적용됩니다.

R, 3 바이트

'*'

이것은 정확히 두 개의 인수를 취하는 함수입니다. 로 실행하십시오 '*'(a,b).

prod동일한 작업을 수행하지만 임의의 수의 인수를 사용할 수있는 항목도 참조하십시오 .

ArnoldC , 152 바이트

HEY CHRISTMAS TREE c
YOU SET US UP 0
GET TO THE CHOPPER c
HERE IS MY INVITATION a
YOU'RE FIRED b
ENOUGH TALK
TALK TO THE HAND c
YOU HAVE BEEN TERMINATED

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

헥사 고니 , 9 바이트

?{?/*!@'/

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

이것은 실제로 매우 간단합니다. 펼쳐진 버전은 다음과 같습니다.

  ? { ?
 / * ! @
' / . . .
 . . . .
  . . .

은 /단지 세 번째 바이트에 저장 번째 라인 제어 흐름을 재. 그러면이 선형 프로그램의 코드가 줄어 듭니다.

?{?'*!@

입력이 엄격하게 양수로 제한되면이 선형 코드 자체가 실제로 유효한 솔루션 일 수 있지만 양수가 아닌 결과로 인해 종료되지는 않습니다.

이 프로그램은 Y 자 형태로 3 개의 메모리 모서리를 사용합니다.

A   B
 \ /
  |
  C

메모리 포인터 A는 중앙을 가리키는 가장자리에서 시작합니다 .

?   Read first input into edge A.
{   Move forward to edge B.
?   Read second input into edge B.
'   Move backward to edge C.
*   Multiply edges A and B and store the result in C.
!   Print the result.
@   Terminate the program.

나는 7 바이트 솔루션 (즉, 측면 길이 2에 맞는 솔루션)에 대한 무차별 검색을 수행했으며 실수하지 않은 경우 (또는 완료하는 데 오랜 시간이 걸리는 바쁜 비버 솔루션이 있다면, 7 바이트 솔루션이 존재하지 않습니다. 8 바이트 솔루션이있을 수 있습니다 (예 :? 하거나 두 개 대신 하나의 리디렉션 명령 만 사용 /).하지만 그것은 무차별 대국 검색이 할 수있는 것 이상이며 아직 손으로 찾지 못했습니다.

Piet , 16 바이트

5bpiaibpikibptai

온라인 통역사가 제공됩니다.

설명

실행하려면 링크 된 페이지의 오른쪽에있는 텍스트 상자에 위의 코드를 붙여 넣으십시오. 아래는 코드 크기가 31 인이 코드의 그래픽 표현입니다.이 그리드는 가독성을위한 것이며 전통적인 Piet 인터프리터를 방해 할 수 있습니다.
코드는 왼쪽에서 오른쪽으로 선형으로 실행되어 첫 번째 녹색 블록까지 이미지의 상단을 따라 이동합니다. 여기서 프로그램 흐름은 코덱의 중간 행으로 이동합니다. 프로그램 흐름에는 흰색 고독한 흰색 코덱이 필요합니다. 녹색 또는 진한 파란색 이외의 다른 색상의 코렐로 대체 될 수 있지만 가독성을 위해 흰색을 선택했습니다.

Instruction    Δ Hue    Δ Lightness    Stack
-----------    -----    -----------    -----
In (Number)    4        2              m
In (Number)    4        2              n, m
Multiply       1        2              m*n
Out (Number)   5        1              [Empty]
[Exit]         [N/A]    [N/A]          [Empty]

텍스트가 Piet 프로그램을 나타내는 가장 좋은 방법이 아니라고 생각하거나 일반적으로 Piet 프로그램의 바이트 크기에 문제가 있다고 생각되면 meta에 관한 토론 에서 의견을 보내주십시오 .

BitCycle -U , 68 바이트

  >    > v
 ?+ >  +
Bv ?^ v ~
 \  v<CB~\v
 Cv  ^  <\/
^ <@=!   <
0A^

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

특히 부호를 처리해야 할 때 BitCycle에서 두 개의 숫자를 곱해도 문제가되지 않습니다! 이것은 나의 두 번째 시도입니다. 첫 번째 것 (본질적으로 동일한 알고리즘, 다른 레이아웃)은 81 바이트 이므로이 길이도 단축 될 수 있습니다.

프로그램은 두 개의 숫자를 명령 행 인수로 사용하여 stdout으로 출력합니다. -U플래그에 진수를 변환하는 것입니다 서명 단항 BitCycle는 0과 1 개의 알고 있기 때문에.

설명

이 설명에서는 BitCycle의 기본 사항을 이해한다고 가정합니다 ( Esolangs 또는 GitHub 추가 정보 참조). 이 계산되지 않은 버전에 대한 설명을 바탕으로 계산 -2시간을 보았습니다 3.

개요

부호있는 단항 숫자는 부호 ( 0양수가 아닌 경우 양수인 경우 비어 있음)와 크기 ( 1숫자의 절대 값과 같은 수)로 구성됩니다. 그중 두 개를 곱하려면 부호를 XOR ( 0정확히 하나만 있으면 출력 a 0또는 둘 다 아니면 아무것도 아닌 경우)을 출력 한 다음 크기를 곱하고 (그리고 그 수를 1s) 출력해야 합니다. 반복 가산을 통해 곱셈을 달성합니다.

부호 비트

두 가지 출처에서 시작하여 ?우리는를 사용하여 크기에서 부호를 분리합니다 +. 0s (부호 비트)는 왼쪽으로 돌리고 맨 윗줄을 향하고, 1s (크기)는 오른쪽으로 B돌아가 두 수집기 에서 끝납니다 .

표지판을 다루는 섹션은 다음과 같습니다.

  v

  \  v
> \  /

! <

두 숫자가 모두 양수가 아닌 0경우 맨 위에서 두 비트가 들어옵니다 v. 첫 번째는 상단 \에서 반사되어 남쪽으로 보내지고에서 반사됩니다 /. 한편, 두 번째 비트는 비활성화 된 상단을 통과 \하여 하단에서 반사됩니다 \. 두 비트는 서로를 통과하고 맨 아래 줄에있는 현재 비활성화 된 스플리터를 통해 직선으로 이동하여 경기장에서 나갑니다.

숫자 중 하나만 양수가 아닌 0경우 맨 위에서 시작합니다. 세 개의 스플리터를 모두 튕겨서 다시 북쪽으로 가면서 끝이 나고 다시 v남쪽으로 보내집니다. 이번에는 비활성화 된 스플리터를 통과하여에 도달 <하여 싱크로 보냅니다 !.

크기를 저장하는 루프

첫 번째 숫자의 크기는 B이 섹션 에서 수집기 로 들어갑니다 .

B v
  \
  C v
^   <

0 A ^

B콜렉터가 열리기 전에 콜렉터 는 배치 된 A싱글 0을 해제 한 다음의 큐 끝으로 이동합니다 B. 모든 1비트 B가 없어지면 루프를 종료하기 위해 플래그 값으로 사용합니다 .

B콜렉터가 열릴 때마다 \스플리터가 큐에서 첫 번째 비트를 벗기고 중간의 처리 로직으로 보냅니다. 비트의 나머지로 이동 C하고, 경우에 C수집 열고, 그들은 다시 전송됩니다B .

두 번째 숫자의 크기는 B이 섹션 에서 수집기 로 들어갑니다 .

v   ~
C B ~
    <

때 B수집 열고, 비트는 바닥 dupneg로 이동합니다 ~. 원래 1비트는 우회전하여 중간에 프로세싱 로직으로 보내집니다. 부정 된 사본 ( 0들)은 좌회전하여 즉시 다른 dupneg에 부딪쳤다. 여기서 0s는 우회전하고 경기장에서 나가고 (현재는 두 배로) 부정한 1s는 좌회전하여로 전송됩니다 C. 때 C열리고, 그들은 다시로 이동합니다 B.

반복 추가

중앙 처리 논리는이 부분입니다.

   v
   v


@  =  !

두 루프의 비트 (서쪽에서 하나, 동부 쪽에서 모두)는 스위치로 남쪽으로 전송됩니다 =. 웨스턴 루프의 비트가 먼저 도착하도록 타이밍을 설정해야합니다. 이 경우 1스위치는로 바뀌고 }다음 비트를 동쪽으로 싱크로 !보내 출력합니다. 모든 1s가 사라지면 0스위치가로 변경됩니다 {. 그러면 다음 비트가로 전송되어 @프로그램이 종료됩니다. 요컨대, 첫 번째 숫자의 단항 크기에있는 횟수만큼 두 번째 숫자의 단항 크기를 출력합니다 1.

파이썬 3 , 11 바이트

int.__mul__

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

2**32파이썬 2의 정수에서도 작동합니다 .

자바 8, 10 9 바이트

a->b->a*b

여기에서 시도하십시오.

자바 7, 31 바이트

int c(int a,int b){return a*b;}

여기에서 시도하십시오.

전체 프로그램으로 ( 99 90 바이트) :

interface M{static void main(String[]a){System.out.print(new Long(a[0])*new Long(a[1]));}}

여기에서 시도하십시오.

Pyth, 2 바이트

*E

여기 사용해보십시오!

Pyth의 자동 평가는 여기서 방해가됩니다. 그 문제를 해결하기 위해 인수 중 하나에 대한 명시 적 평가를 사용하고 있습니다.

TI 기본, 2 바이트

매우 간단합니다.

prod(Ans

PHP, 21 바이트

<?=$argv[1]*$argv[2];

명령 행 인수에서 입력을받습니다. 또한 수레와 함께 작동합니다.

망막 , 39 35 바이트

Leo에 감사하여 4 바이트를 절약 한 아이디어를 사용할 수있게되었습니다.

[^-]

*\)`--

.+
$*
\G1
_
_|1+
$'
1

입력이 줄 바꿈으로 구분됩니다.

온라인으로 사용해보십시오! 편의상 공백으로 구분 된 테스트 스위트

설명

처음 두 단계는 정확히 두 입력 중 하나가 음수이면 빼기 부호를 인쇄합니다. 실제로 입력을 변경하지 않고이 작업을 수행합니다. 이는 두 번째 단계에서로 그룹화하고와 함께 )드라 이런으로 전환하여 수행됩니다 *. \두 번째 단계 의 옵션은 후행 줄 바꿈을 인쇄하지 못하게합니다.

[^-]

먼저 빼기 부호를 제외한 모든 것을 제거합니다.

*\)`--

그런 다음 두 개가 남아 있으면 빼기 기호를 취소합니다.

.+
$*

이제 각 줄을 절대 값의 단항 표현으로 변환합니다. 마이너스 부호를 제거 $*합니다. 일치하는 음수가 아닌 첫 번째 숫자 만 찾습니다 (즉, 마이너스 부호를 모르고 무시합니다).

\G1
_

첫 번째 줄은 이전 일치와 인접한 한 _개별을 일치시켜 로 변환됩니다 1(따라서 1줄 바꿈이이 체인을 끊기 때문에 두 번째 줄 의 s를 일치시킬 수 없음 ).

_|1+
$'

이것은 실제 곱셈을 수행합니다. 우리는 서로 대체 _아니라 전체 두 번째 줄의 모든 등으로 (첫 번째 줄에) 후 일치하는. 따라서 _일치에는 전체 두 번째 행 ( 0첫 번째 행 의 s 수를 곱한 값)이 포함되며 두 번째 행은 해당 행 이후에 아무것도 없기 때문에 제거됩니다. 물론 결과에는 _s 및 줄 바꿈 형식의 일부 정크도 포함 되지만 중요하지는 않습니다.

1

우리는 단순히 1결과에서 s 의 수를 세어 마무리합니다 .

MATLAB, 5 4 바이트

@dot

dot길이가 같은 두 벡터의 내적을 취합니다 . 스칼라 두 개를 공급하면 두 숫자가 곱해집니다.

prod행렬의 각 열의 모든 행에있는 값의 곱을 가져옵니다. 행렬이 1 차원 (즉, 벡터)이면 벡터에있는 모든 요소의 곱을 취하여 비단 일 차원을 따라 작동합니다.

dot보다 한 바이트 짧은 prod짝수 더 분명 내장 이상의 바이트 짧은이다 times.

다음과 같이 호출하십시오.

@dot
ans(3,4)
ans = 
   12

PigeonScript , 1 바이트

*

설명 :
*스택이 있는지 확인합니다. 그렇지 않은 경우 입력을 요청하고 입력을 곱합니다.

펄 6 , 4 바이트

&[*]

이것은 *일반적인 함수로 표현 된 일반적인 접두사 곱셈 연산자 입니다. 보너스로 하나의 숫자가 주어지면 그 숫자를 반환하고, 숫자가 없으면 1곱셈 신분을 반환합니다 .

><>, 5 Bytes

i|;n*

입력을 ASCII 문자로 사용하고 숫자를 출력합니다.

설명:

i                        | Get input.
 |                       | Mirror: Change the pointer's direction.
i                        | Get input again.
    *                    | Loop around to the right side. Multiply
   n                     | Print the value on the stack, as a number
  ;                      | End the program

당신은 또한 할 수 있습니다

ii*n;

하지만 내 해결책은 waaay cooler.

또 다른 가능성은 세미콜론을 삭제하면 포인터가 미러에서 튀어 나와서 인쇄 명령에 도달하고 스택이 비었으므로 오류가 발생하는 것입니다.

인텔 8080 기계 코드 , MITS Altair 8800, 28 bytes

이것은 Intel 8080 CPU 에서 이진 곱셈 을 구현합니다. 곱셈 또는 나눗셈 명령이없는 (1974 년경) 합니다. 입력은 8 비트 값이고 곱은 16 비트 값입니다.BC register pair.

다음은 전면 패널 스위치를 사용하여 프로그램을 Altair 8800 에로드하기위한 단계별 지침과 함께 기계 코드 입니다.

Step    Switches 0-7    Control Switch  Instruction Comment
1                       RESET
2       00 001 110      DEPOSIT         MVI  C, 5   Load multiplier into C
3       00 000 101      DEPOSIT NEXT                value is 5
4       00 010 110      DEPOSIT NEXT    MVI  D, 16  Load multiplicand into D
5       00 010 000      DEPOSIT NEXT                value is 16
6       00 000 110      DEPOSIT NEXT    MVI  B, 0   clear B register (high byte of result)
7       00 000 000      DEPOSIT NEXT
8       00 011 110      DEPOSIT NEXT    MVI  E, 9   set loop counter E multiplier size
9       00 001 001      DEPOSIT NEXT                (8 bits + 1 since loop ends in middle)
10      01 111 001      DEPOSIT NEXT    MOV  A, C   move multiplier into A for shift
11      00 011 111      DEPOSIT NEXT    RAR         shift right-most bit to CF
12      01 001 111      DEPOSIT NEXT    MOV  C, A   move back into C
13      00 011 101      DEPOSIT NEXT    DCR  E      decrement loop counter
14      11 001 010      DEPOSIT NEXT    JZ   19 00  loop until E=0, then go to step 27
15      00 011 001      DEPOSIT NEXT
16      00 000 000      DEPOSIT NEXT
17      01 111 000      DEPOSIT NEXT    MOV  A, B   move sum high byte into A
18      11 010 010      DEPOSIT NEXT    JNC  14 00  add if right-most bit of 
19      00 010 100      DEPOSIT NEXT                multiplier is 1, else go to 22
20      00 000 000      DEPOSIT NEXT
21      10 000 010      DEPOSIT NEXT    ADD  D      add shifted sums
22      00 011 111      DEPOSIT NEXT    RAR         shift right new multiplier/sum
23      01 000 111      DEPOSIT NEXT    MOV  B, A   move back into B
24      11 000 011      DEPOSIT NEXT    JMP  08 00  go to step 10
25      00 001 000      DEPOSIT NEXT
26      00 000 000      DEPOSIT NEXT
27      11 010 011      DEPOSIT NEXT    OUT  255    display contents of A on data panel
28      11 111 111      DEPOSIT NEXT
30      01 110 110      DEPOSIT NEXT    HLT         Halt CPU
31                      RESET                       Reset program counter to beginning
32                      RUN
33                      STOP

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

모두 올바르게 입력하면 시뮬레이터의 머신 상태 서랍에서 RAM 내용이 다음과 같이 표시됩니다.

0000    0e 05 16 10 06 00 1e 09 79 1f 4f 1d ca 19 00 78 
0010    d2 14 00 82 1f 47 c3 08 00 d3 ff 76

입력

승수에 C등록하고, 피승수로 D. Altair의 재고는 없으므로 STDIN전면 패널 스위치만으로 입력됩니다.

산출

결과는에 표시됩니다 D7- D0이진 등 (오른쪽 상단 행).

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

호환성 참고 사항 : 현재 테스트되지 않았지만 IMSAI 8080 에서도 실행됩니다 .

C#, 10 bytes

a=>b=>a*b;

It's just a simply multiplication.

Jelly, 1 byte

×

Try it online!

Obligatory Jelly submission.

Clojure, 1 byte

*

:P As a bonus this works on any number of arguments:

[(*)
 (* 2)
 (* 2 3)
 (* 2 3 4)
 (* 2 3 4 5)] => [1 2 6 24 120]

Interestingly you can easily get its source code:

(source *)
(defn *
  "Returns the product of nums. (*) returns 1. Does not auto-promote
  longs, will throw on overflow. See also: *'"
  {:inline (nary-inline 'multiply 'unchecked_multiply)
   :inline-arities >1?
   :added "1.2"}
  ([] 1)
  ([x] (cast Number x))
  ([x y] (. clojure.lang.Numbers (multiply x y)))
  ([x y & more]
     (reduce1 * (* x y) more)))

Owk, 11 bytes

λx.λy.x*y

This can be assigned to a function like this:

multiply:λx.λy.x*y

and called like this:

result<multiply(a,b)