Eingabe: Zwei Dezimalzahlen. Diese können dem Code in der Standardeingabe, als Argumente für das Programm oder die Funktion oder als Liste übergeben werden.

Ausgabe: Ihr Produkt als Dezimalzahl. Zum Beispiel 5 16würde die Eingabe zur Ausgabe führen 80.

Einschränkungen: Keine Standardlücken bitte. Dies ist Code-Golf , Antwort in der niedrigsten Anzahl von Bytes gewinnt.

Notizen: Layout von meiner früheren Herausforderung gestohlen, zwei Zahlen hinzufügen .

Testfälle:

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

Oder als 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

Bestenliste

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, Unterlast, MATL, Forth, PigeonScript, Gestapelt, Implizit, Jolf, Clojure, Braingolf, 8., Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc 1 Byte

*

Sie können diese Antwort bearbeiten, um weitere Sprachen hinzuzufügen, für die *eine gültige Antwort vorliegt.

C (GCC), 13 Bytes

Funktioniert nicht bei allen Implementierungen, aber das ist in Ordnung.

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

Probieren Sie es auf TIO!

Beatnik , 888 Bytes

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

Probieren Sie es online!

Ich verwende den C-Interpreter, weil der Python-Interpreter auf TIO die Adresse ärgerlicherweise ausführt, wenn die Bedingung für das Zurückspringen nicht erfüllt ist. Ein einfacher Workaround für den Python-Interpreter besteht darin, einige Nops aufzufüllen, um die Adresse als Nop zu definieren. Ich glaube keiner ist richtig:

                                   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

Die Eingabe sollte aus zwei durch ein Leerzeichen getrennten Ganzzahlen bestehen, ohne dass Zeilenumbrüche folgen.

Diese Antwort funktioniert theoretisch für alle ganzen Zahlen, wenn jede Zelle einen willkürlich großen Wert speichern kann, der nicht auf 0 - 255 beschränkt ist. Sie läuft jedoch über, wenn | A | + | B | > 22. Und es läuft sehr langsam, wenn | A | + | B | > 6. Es gibt also nicht viele Fälle, die Sie tatsächlich testen können, und eine If-else-Lösung für diese Fälle könnte sogar noch kürzer sein.

Die Idee ist, die Dreieckszahlen T (N) = N (N + 1) / 2 durch Dekrementieren des Wertes auf 0 und Summieren aller Zwischenwerte zu berechnen. Dann können wir die Antwort A * B = T (A + B) - T (A) - T (B) erhalten.

Es ist jedoch schwierig, alle drei Werte zu berechnen. Dies geschieht, indem zuerst T (A + B) - A berechnet wird, eine Kopie von A im Stapel verbleibt, die später addiert wird, und die Eingabe B verwendet wird. Dann wird rekursiv die größte dreieckige Zahl ermittelt, die kleiner als diejenige ist, die T (ist. A + B-1) mit Ausnahme der Sonderfälle Null. Wir können B = T (A + B) - A - T (A + B-1) zurückholen und von dort T (B) berechnen.

Eine Zahl N ist eine Dreieckszahl, wenn sie der größten Dreieckszahl kleiner als N plus der Anzahl der nicht negativen Dreieckszahlen kleiner als N entspricht. Dies läuft in O (2 ^ (T (A + B) -A)) und ist der langsamste Teil im Programm.

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 Bytes

1##&

Anwendungsbeispiel: 1##&[7,9]Rückgabe 63. In der Tat multipliziert dieselbe Funktion eine beliebige Anzahl von Argumenten eines beliebigen Typs.

Wie Mathematica-Codegolfer wissen, funktioniert dies, weil es ##sich auf die gesamte Folge von Argumenten für eine Funktion bezieht und die Verkettung in Mathematica (oft) die Multiplikation darstellt. so 1##bezieht sich auf (1 - mal) , um das Produkt aller Argumente der Funktion. Das &ist nur kurz für dieFunction Befehl, der eine reine (unbenannte) Funktion definiert.

In anderen Codes fungiert das gemeinsame Symbol *als Multiplikation. Ebenso ein Leerzeichen, das 7 9interpretiert wird als 7*9(tatsächlich zeigt die aktuelle REPL-Version von Mathematica solche Leerzeichen als Multiplikationszeichen an!). Noch besser ist, wenn Mathematica erkennen kann, wo ein Token beginnt und ein anderes endet, dann werden für einen Multiplikationsoperator überhaupt keine Bytes benötigt: Wird 5yautomatisch als 5*yund 3.14Log[9]als interpretiert 3.14*Log[9].

Retina , 38 37 31 Bytes

Völlig neuer Ansatz, der alte ist unten.

M!`-
*\)`-¶-

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

Probieren Sie es online!

Erläuterung

Zunächst beschäftigen wir uns mit dem Zeichen:

M!`-

-Stimmt mit allen in der Zeichenfolge überein und gibt sie durch Zeilenumbrüche getrennt zurück

*\)`-¶-

(mit einer folgenden leeren Zeile)
*\)bedeutet, dass das Ergebnis dieses und der vorherigen Schritte ohne eine neue Zeile gedruckt werden sollte und die Zeichenfolge dann auf die vorherige zurückgesetzt wird (die Eingabezeichenfolge). Der verbleibende Teil entfernt zwei -durch einen Zeilenumbruch getrennte.

Dann konvertieren wir die erste Zahl in unary:

.* 
$*_

(Es gibt ein Leerzeichen am Ende der ersten Zeile). Wir verwenden _in diesem Fall als unäre Ziffer, da die Standardziffer 1in der zweiten Ziffer vorhanden sein kann und dies später zu Konflikten führen würde.

Nun kommen wir zur eigentlichen Multiplikation:

_
$'$*_

Jedes _wird durch die unäre Darstellung von allem ersetzt, was darauf folgt (immer noch _als unäre Ziffer verwendend). Da bei der Konvertierung nach Unary nicht-stellige Zeichen ignoriert werden, wird die unäre Darstellung der zweiten Zahl "für die erste Zahl" wiederholt. Die zweite Zahl bleibt am Ende der Zeichenfolge in dezimaler Darstellung.

Am Ende geben _wir mit single die Anzahl von zurück_ in der Zeichenkette zurück, die das Ergebnis der Multiplikation ist.

Vorherige Antwort: (Warnung: Gibt eine leere Zeichenfolge aus, wenn sie ausgegeben werden soll 0 )

Netzhaut ,  45  42 41 Bytes

Lassen Sie uns ein Spiel spielen! Multiplizieren Sie relative Zahlen mit einer Sprache, die keine arithmetischen Operatoren und nur eingeschränkte Unterstützung für natürliche Zahlen hat ... Klingt lustig :)

O^`^|-
--

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

Erläuterung

Die ersten drei Zeilen befassen sich mit dem Vorzeichen:

O^`^|-

Dadurch werden alle Zeichenfolgen sortiert Ound umgekehrt ^, die dem regulären Ausdruck entsprechen ^|-. In der Praxis stimmt dies mit der leeren Zeichenfolge am Anfang und dem eventuellen Minuszeichen vor der zweiten Zahl überein und ordnet sie neu an, indem sie die leere Zeichenfolge an die Stelle des Minus setzen. Danach -befinden sich alle am Anfang der Zeichenfolge, und ein Paar von ihnen kann mit den nächsten beiden Zeilen problemlos entfernt werden.

Danach verwenden wir ein Builtin, um Zahlen in eine unäre Darstellung umzuwandeln, und dann kommt die tatsächliche Multiplikation:

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

Wir passen jeden 1an und ersetzen jeden durch alle1 folgenden Leerzeichen. Jede Ziffer der ersten Ziffer wird durch die vollständige zweite Ziffer ersetzt, während jede Ziffer der zweiten Ziffer durch die leere Zeichenfolge ersetzt wird.

Der letzte Teil ist wieder ein eingebautes Element, das von unär nach dezimal konvertiert werden kann.

Probieren Sie es online!

Scratch , 1 Byte

Verwendung: Platzieren Sie die Zahlen auf beiden Seiten des *Zeichens

Hinweis: Da Scratch eine visuelle Sprache ist, konnte ich nicht herausfinden, wie viele Bytes es verbraucht, bis @ mbomb007 mich über eine Methode zum Zählen von Scratch-Bytes informierte

Brain-Flak , 56 Bytes

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

Dies muss als vollständiges Programm ausgeführt werden, da es nicht stapelbereinigt ist und die Eingaben die einzigen Elemente in jedem Stapel sein müssen.

Probieren Sie es online!

Erklärung: (benenne die Eingänge x und y)

Teil 1:

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

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

Zu diesem Zeitpunkt haben wir [x, y] auf einem Stapel und [-x, -y] auf dem anderen.

Teil 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

JavaScript (ES6), 9 Byte

ES6 verfügt über eine dedizierte Funktion für 32-Bit-Ganzzahlen, die schneller ist als der allgemeinere *Operator.

Math.imul

Das ist übrigens nur so lange wie:

a=>b=>a*b

Brain-Flak , 56 54 52 Bytes

2 Bytes gespart durch einen Fehler von Nitrodon

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

Probieren Sie es online!

Stack saubere Version, 62 60 Bytes

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

Probieren Sie es online!

Erläuterung

Diese Erklärung ist eher eine Erklärung des beteiligten Algorithmus und lässt den tatsächlichen Code weg. Es wird vorausgesetzt, dass Sie wissen, wie man Brain-Flak richtig liest. Wenn Sie Hilfe benötigen, um den Code oder den Algorithmus zu verstehen, bearbeite oder antworte ich gerne, wenn Sie einen Kommentar hinterlassen.

Dies ist ein bisschen seltsam und verwendet etwas seltsame Mathematik, die gerade noch klappt. Als erstes habe ich eine Schleife erstellt, die immer in O (n) Schritten endet . Der normale Weg, dies zu tun, ist, n und -n auf entgegengesetzte Stapel zu setzen und eins zu jedem zu addieren, bis man Null erreicht, aber ich habe es auf eine etwas seltsamere Weise getan. Bei meiner Methode setze ich einen Zähler unter die Eingabe und inkrementiere den Zähler bei jedem Schritt zu n und kehre das Vorzeichen von n um .

Lassen Sie uns ein Beispiel durchgehen. Sagen Sie 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

Ich werde es hier nicht beweisen, aber dies wird immer für jede Eingabe beendet und dies in ungefähr 2n Schritten tun . Tatsächlich endet es in 2n Schritten, wenn n positiv ist, und in 2n-1 Schritten, wenn n negativ ist. Sie können das testen hier .

Jetzt haben wir ungefähr 2n Schritte in unserer Schleife. Wie multiplizieren wir mit n ? Nun, hier haben Sie etwas Mathe-Magie. Folgendes tun wir: Wir erstellen einen Akkumulator. In jedem Schritt des Prozesses fügen wir den zweiten Eingang ( m ) zum Akkumulator hinzu und kippen das Vorzeichen von beiden. Dann schieben wir die Summe über alle auftretenden Schleifen Produkt.

Warum um alles in der Welt ist das so?

Lassen Sie uns ein Beispiel durchgehen und es wird hoffentlich klar. In diesem Beispiel multiplizieren wir 5 mit 3 , ich zeige nur die wichtigen Werte

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

Hoffentlich ist der Mechanismus hier offensichtlich. Wir gehen alle Vielfachen von m in der Reihenfolge ihrer absoluten Werte durch. Sie werden dann feststellen , dass das 2n - ^te Term ist immer m * n und der Begriff vor immer -m * n . Dies macht es so, dass unser Looping perfekt mit den gewünschten Ergebnissen übereinstimmt. Ein bisschen ein glücklicher Zufall;)

Dyalog APL , 1 Byte

× Nimmt eine Nummer links und eine rechts

×... oder auch mehrere Zahlen links oder rechts oder beidseitig

×/ multipliziert alle Zahlen in einer Liste

×/¨ multipliziert die Paare in einer gegebenen Liste

×/∊ multipliziert alle Zahlen in einem Array

Dies gilt für alle arithmetischen Funktionen, Arrays aller Größen und Ränge sowie Zahlen aller Datentypen.

R, 3 Bytes

'*'

Dies ist eine Funktion, die genau zwei Argumente akzeptiert. Führen Sie so '*'(a,b).

Sehen Sie auch, prodwas dasselbe tut, aber eine beliebige Anzahl von Argumenten annehmen kann.

ArnoldC , 152 Bytes

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

Probieren Sie es online!

Hexagony , 9 Bytes

?{?/*!@'/

Probieren Sie es online!

Das ist eigentlich ziemlich einfach. Hier ist die entfaltete Version:

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

Das /Umleiten nur den Steuerablauf zu der zweiten Zeile Bytes auf dem dritten zu speichern. Das reduziert den Code auf dieses lineare Programm:

?{?'*!@

Dieser lineare Code alleine wäre eine gültige Lösung, wenn die Eingabe auf streng positive Zahlen beschränkt wäre. Aufgrund der Möglichkeit nicht positiver Ergebnisse kann jedoch nicht garantiert werden, dass die Eingabe beendet wird.

Das Programm verwendet drei Speicherflanken in Y-Form:

A   B
 \ /
  |
  C

Der Speicherzeiger beginnt an der Kante und Azeigt zur Mitte.

?   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.

Ich habe eine Brute-Force-Suche nach 7-Byte-Lösungen durchgeführt (dh nach Lösungen, die in die Seitenlänge 2 passen), und wenn ich keinen Fehler gemacht habe (oder es gibt eine Lösung für vielbeschäftigte Biber, deren Fertigstellung viel Zeit in Anspruch nimmt). was ich bezweifle) dann gibt es keine 7-byte-lösung. Möglicherweise gibt es eine 8-Byte-Lösung (z. B. durch Wiederverwenden des ?Befehls oder durch Verwenden nur eines Umleitungsbefehls anstelle von zwei /), aber meine Brute-Force-Suche kann dies nicht. Ich habe noch keinen von Hand gefunden.

Piet , 16 Bytes

5bpiaibpikibptai

Online-Dolmetscher hier verfügbar.

Erläuterung

Fügen Sie zum Ausführen den obigen Code in das Textfeld auf der rechten Seite der verknüpften Seite ein. Unten finden Sie eine grafische Darstellung dieses Codes mit der Codelgröße 31. Das Raster dient der Lesbarkeit und kann traditionelle Piet-Interpreter stören.
Der Code verläuft linear von links nach rechts und verläuft am oberen Bildrand bis zum ersten grünen Block, in dem der Programmfluss zur mittleren Codereihe wechselt. Der White-Lone-White-Codel ist für den Programmablauf erforderlich. Es könnte durch ein Codel einer anderen Farbe als Grün oder Dunkelblau ersetzt werden, aber ich habe mich aus Gründen der Lesbarkeit für Weiß entschieden.

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]

Wenn Sie der Meinung sind, dass Text nicht die beste Art ist, ein Piet-Programm darzustellen, oder wenn Sie ein Problem mit der Bytegröße von Piet-Programmen im Allgemeinen haben, teilen Sie uns Ihre Meinung in der Diskussion über Meta mit .

BitCycle -U , 68 Bytes

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

Probieren Sie es online!

Das Multiplizieren von zwei Zahlen ist in BitCycle kein triviales Problem, insbesondere wenn Zeichen verarbeitet werden müssen! Dies ist mein zweiter Versuch; Der erste (im Wesentlichen derselbe Algorithmus, anderes Layout) war 81 Byte, so dass es durchaus möglich ist, dass dieser auch gekürzt werden könnte.

Das Programm nimmt die beiden Zahlen als Befehlszeilenargumente und gibt sie an stdout aus. Das -UFlag dient dazu, die Dezimalzahlen in vorzeichenlose Zahlen umzuwandeln , da BitCycle nur Nullen und Einsen kennt.

Erläuterung

Diese Erklärung setzt voraus, dass Sie die Grundlagen von BitCycle verstehen (siehe Esolangs oder die GitHub-Readme). Ich werde meine Erklärung auf dieser ungolfed Version, gesehen hier Computing Base -2Zeiten 3:

Überblick

Vorzeichenlose Zahlen bestehen aus dem Vorzeichen ( 0für nicht positiv, leer für positiv), gefolgt von der Größe (eine Zahl von 1s, die dem absoluten Wert der Zahl entspricht). Um zwei von ihnen zu multiplizieren, müssen wir die Vorzeichen XOR-verknüpfen (a ausgeben, 0wenn genau eines von ihnen ist 0, oder nichts, wenn beide oder keine vorhanden sind) und dann die Größen multiplizieren (und so viele 1s ausgeben ). Wir werden die Multiplikation durch wiederholte Addition erreichen.

Zeichen Bits

Ausgehend von den beiden Quellen ?trennen wir die Vorzeichen von den verwendeten Größen ab +. 0s (Vorzeichenbits) biegen nach links ab und sind entlang der oberen Reihe ausgerichtet, während 1s (Größen) nach rechts abbiegen und in den beiden BKollektoren landen .

Der Abschnitt, der die Zeichen behandelt, sieht folgendermaßen aus:

  v

  \  v
> \  /

! <

Wenn beide Zahlen nicht positiv sind, kommen zwei 0Bits von oben herein v. Der erste reflektiert von der Spitze \, wird nach Süden geschickt und reflektiert von der Spitze /. In der Zwischenzeit passiert das zweite Bit die deaktivierte Oberseite \und wird von der Unterseite reflektiert \. Die beiden Bits passieren sich gegenseitig, durchlaufen die jetzt deaktivierten Splitter in der unteren Reihe und verlassen das Spielfeld.

Wenn nur eine der Zahlen nicht positiv ist, 0kommt eine von oben. Es springt um alle drei Splitter herum und landet wieder in nördlicher Richtung, bis es auf den trifft vund erneut nach Süden geschickt wird. Dieses Mal passiert es die deaktivierten Splitter und erreicht die <, die es in die Spüle schickt !.

Loops zum Speichern der Größen

Die Größe der ersten Zahl wird Bin diesem Abschnitt in den Sammler eingegeben:

B v
  \
  C v
^   <

0 A ^

Bevor der BCollector geöffnet wird, gibt der ACollector die 0darin platzierte Single frei , die dann am Ende der Warteschlange eingeht B. Wir werden es als Flag-Wert verwenden, um die Schleife zu beenden, wenn alle 1Bits Bweg sind.

Bei jedem BÖffnen der Kollektoren entfernt der \Splitter das erste Bit aus der Warteschlange und sendet es an die Verarbeitungslogik in der Mitte. Der Rest der Bits geht in Cund wenn die CKollektoren geöffnet werden, werden sie zurück in gesendet B.

Die Größe der zweiten Zahl wird Bin diesem Abschnitt in den Kollektor eingegeben:

v   ~
C B ~
    <

Wenn sich die BKollektoren öffnen, gehen die Bits in den unteren Dupneg ~. Die ursprünglichen 1Bits biegen nach rechts ab und werden in der Mitte nach Westen in die Verarbeitungslogik gesendet. Die negierten Kopien 0drehen sich nach links und treffen sofort einen anderen Dupneg. Hier 0biegen Sie rechts ab und verlassen das Spielfeld, während die (jetzt doppelt) negierten 1s links abbiegen und in gesendet werden C. Wenn Cgeöffnet, gehen sie zurück in B.

Wiederholte Zugabe

Die zentrale Verarbeitungslogik ist dieser Teil:

   v
   v


@  =  !

Bits von beiden Schleifen (eine von der Westseite und alles von der Ostseite) werden nach Süden in den Switch gesendet =. Das Timing muss so eingestellt werden, dass das Bit aus der westlichen Schleife zuerst dort ankommt. Wenn dies der Fall ist 1, wechselt der Schalter zu }und sendet die folgenden Bits nach Osten in die Senke !, um ausgegeben zu werden. Sobald alle 1s weg sind, bekommen wir die0 , die den Schalter auf ändert {. Dies sendet die folgenden Bits in das @, was das Programm beendet. Kurz gesagt, wir geben die (unäre) Größe der zweiten Zahl so oft aus, wie es 1s in der (unären) Größe der ersten Zahl gibt.

Python 3 , 11 Bytes

int.__mul__

Probieren Sie es online!

Funktioniert auch für Ganzzahlen unter 2**32in Python 2.

Java 8, 10 9 Bytes

a->b->a*b

Probieren Sie es hier aus.

Java 7, 31 Bytes

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

Probieren Sie es hier aus.

Als volles Programm ( 99 bis 90 Bytes) :

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

Probieren Sie es hier aus.

Pyth, 2 Bytes

*E

Probieren Sie es hier aus!

Pyths automatische Auswertung steht hier im Weg. Um das zu umgehen, verwende ich eine explizite Auswertung für eines der Argumente

TI-Basic, 2 Bytes

Sehr einfach.

prod(Ans

PHP, 21 Bytes

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Funktioniert auch mit Schwimmern.

Retina , 39-35 Bytes

Vielen Dank an Leo, der mir erlaubt hat, eine Idee von ihm zu verwenden, die letztendlich 4 Bytes einspart.

[^-]

*\)`--

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

Der Eingang ist zeilenweise getrennt.

Probieren Sie es online! (Durch Leerzeichen getrennte Testsuite zur Vereinfachung.)

Erläuterung

Die ersten beiden Stufen geben ein Minuszeichen aus, wenn genau einer der beiden Eingänge negativ ist. Sie tun dies, ohne die Eingabe tatsächlich zu ändern. Dies geschieht, indem man sie in der zweiten Stufe mit gruppiert )und in einen Trockenlauf mit umwandelt *. Die \Option in der zweiten Stufe verhindert das Drucken eines nachfolgenden Zeilenvorschubs.

[^-]

Zuerst entfernen wir alles außer den Minuszeichen.

*\)`--

Dann löschen wir die Minuszeichen, wenn noch zwei übrig sind.

.+
$*

Nun konvertieren wir jede Zeile in die unäre Darstellung ihres absoluten Wertes. Das Minuszeichen wird dadurch entfernt$* nur nach der ersten nicht-negativen Zahl im Match gesucht wird (dh Minuszeichen werden nicht erkannt und ignoriert).

\G1
_

Die erste Zeile wird konvertiert in _, indem einzelne 1s abgeglichen werden, solange sie neben der vorherigen Übereinstimmung liegen (daher können wir die nicht abgleichen1 s in der zweiten Zeile nicht zuordnen, da der Zeilenvorschub diese Kette unterbricht).

_|1+
$'

Dies führt die tatsächliche Multiplikation durch. Wir ersetzen jede _(in der ersten Zeile) sowie die gesamte zweite Zeile alles nach diesem Spiel. Die _Übereinstimmungen umfassen daher die gesamte zweite Zeile (multipliziert mit der Anzahl von 0s in der ersten Zeile), und die zweite Zeile wird entfernt, da nach dieser Übereinstimmung nichts mehr vorhanden ist. Natürlich wird das Ergebnis auch etwas Müll in Form von enthalten_ S und Linefeeds enthalten, aber das spielt keine Rolle.

1

Zum Schluss zählen wir einfach die Anzahl der 1s im Ergebnis.

MATLAB, 5 4 Bytes

@dot

dotNimmt das Skalarprodukt zweier Vektoren gleicher Länge. Wenn wir es mit zwei Skalaren füttern, multipliziert es einfach die beiden Zahlen.

prodNimmt das Produkt der Werte in allen Zeilen jeder Spalte einer Matrix. Wenn die Matrix eindimensional ist (dh ein Vektor), wirkt sie entlang der Nicht-Singleton-Dimension und nimmt das Produkt aller Elemente im Vektor.

dotist ein Byte kürzer als proddas noch offensichtlicher eingebaute times.

Nennen Sie es als solches:

@dot
ans(3,4)
ans = 
   12

PigeonScript , 1 Byte

*

Erläuterung:
*Überprüft den Stapel, um festzustellen, ob dort etwas vorhanden ist. Andernfalls werden Sie zur Eingabe aufgefordert und die Eingaben werden miteinander multipliziert

Perl 6 , 4 Bytes

&[*]

Dies ist nur der gewöhnliche Infix-Multiplikationsoperator *, ausgedrückt als gewöhnliche Funktion. Als Bonus gibt es, wenn es eine Zahl gibt, diese Zahl zurück, und wenn es keine Zahlen gibt 1, die multiplikative Identität.

> <>, 5 Bytes

i|;n*

Nimmt die Eingabe als ASCII-Zeichen und gibt eine Zahl aus.

Erläuterung:

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

Das könntest du auch tun

ii*n;

Aber ich denke, meine Lösung ist noch cooler.

Eine andere Möglichkeit besteht darin, das Semikolon zu löschen, was dazu führen würde, dass der Zeiger vom Spiegel abprallt, den Druckbefehl ausführt und einen Fehler ausgibt, da der Stapel leer ist.

Intel 8080 Maschinencode , MITS Altair 8800 , 28 Bytes

Dies implementiert eine binäre Multiplikation auf der Intel 8080-CPU (ca. 1974), die keine Multiplikations- oder Divisionsanweisungen hatte. Eingaben sind 8-Bit-Werte und das Produkt ist ein 16-Bit-Wert, der in der zurückgegeben wirdBC Registerpaar zurückgegeben wird.

Hier finden Sie den Maschinencode sowie schrittweise Anleitungen zum Laden des Programms in einen Altair 8800 mithilfe der Schalter an der Vorderseite.

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

Probieren Sie es online!

Wenn Sie alles richtig eingegeben haben, sieht Ihr RAM-Inhalt in der Maschinenstatus-Schublade im Simulator folgendermaßen aus:

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

Eingang

Multiplikator im CRegister und Multiplikand in D. Die Aktie Altair hat keineSTDIN Eingabe, daher erfolgt die Eingabe nur über Schalter an der Vorderseite.

Ausgabe

Das Ergebnis wird binär auf den D7- D0Leuchten (obere rechte Reihe) angezeigt .

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

Hinweis zur Kompatibilität: Dies sollte auch auf dem IMSAI 8080 ausgeführt werden , obwohl es derzeit nicht getestet wird.

C #, 10 Bytes

a=>b=>a*b;

Es ist nur eine einfache Multiplikation.

Gelee , 1 Byte

×

Probieren Sie es online!

Obligatorische Jelly Vorlage.

Clojure, 1 Byte

*

: P Als Bonus funktioniert dies mit einer beliebigen Anzahl von Argumenten:

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

Interessanterweise können Sie den Quellcode leicht erhalten:

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

Eule , 11 Bytes

λx.λy.x*y

Dies kann einer Funktion wie dieser zugewiesen werden:

multiply:λx.λy.x*y

und so genannt:

result<multiply(a,b)