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>
Réponses:
Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc 1 byte
Vous pouvez modifier cette réponse pour ajouter d'autres langues pour lesquelles la
*réponse est valide.la source
*(5,16)C (GCC), 13 octets
Ne fonctionne pas sur tous implémentations, mais c'est OK.
Essayez-le sur TIO!
la source
a? Je ne comprends pas ...aest une variable de pile locale pourf()- pourquoi sa valeur est-elle retournée?). +1, btw - abus très intelligent de l'ABI.returnmot-clé place simplement la redult de son argument dans le registre EAX. Dans ce cas, l'exécutable généré effectue le calcula*bdans ce registre, doncreturnne fait rien.f(a,b){a*=b;}pièce par1##&et en changeant simplement votre langue en Mathematica.Beatnik , 888 octets
Essayez-le en ligne!
J'utilise l'interpréteur C parce que l'interpréteur Python sur TIO exécute de manière ennuyeuse l'adresse si la condition pour sauter en arrière n'est pas remplie. Une solution de contournement facile pour l'interpréteur Python consiste à remplir certains nops pour rendre l'adresse nop. Je crois que ni l'un ni l'autre n'est correct:
L'entrée doit être deux entiers séparés par un espace, sans retour à la ligne.
Cette réponse fonctionne en théorie pour tous les entiers, si chaque cellule peut stocker une valeur arbitrairement grande, non limitée à 0 - 255. Mais elle déborde si | A | + | B | > 22. Et cela fonctionne très lentement si | A | + | B | > 6. Il n'y a donc pas beaucoup de cas que vous pouvez réellement tester et une solution if-else pour ces cas pourrait être encore plus courte.
L'idée est de calculer les nombres triangulaires T (N) = N (N + 1) / 2 en décrémentant la valeur à 0 et en additionnant toutes les valeurs intermédiaires. Ensuite, nous pouvons obtenir la réponse A * B = T (A + B) - T (A) - T (B).
Mais il est difficile de calculer les 3 valeurs. Pour ce faire, il calcule d'abord T (A + B) - A, en laissant une copie de A dans la pile pour l'ajouter plus tard, et en utilisant l'entrée B.Recursivement, trouvez le plus grand nombre triangulaire plus petit que celui, qui est T ( A + B-1) sauf pour les cas spéciaux zéro. Nous pouvons récupérer B = T (A + B) - A - T (A + B-1) et calculer T (B) à partir de là.
Un nombre N est un nombre triangulaire ssi il est égal au plus grand nombre triangulaire plus petit que N, plus le nombre de nombres triangulaires non négatifs plus petits que N. Cela s'exécute en O (2 ^ (T (A + B) -A)) et est la partie la plus lente du programme.
la source
Mathematica, 4 octets
Exemple d'utilisation:
1##&[7,9]retours63. En effet, cette même fonction multiplie un nombre illimité d'arguments de n'importe quel type.Comme les connaisseurs de code de Mathematica le savent, cela fonctionne car
##fait référence à la séquence entière d'arguments d'une fonction, et la concaténation dans Mathematica représente (souvent) la multiplication;1##fait donc référence (1 fois) au produit de tous les arguments de la fonction. Le&est juste court pour leFunctioncommande qui définit une fonction pure (sans nom).À l'intérieur d'un autre code, le symbole commun
*agit comme une multiplication. Il en va de même pour un espace, ce qui7 9est interprété comme7*9(en effet, la version REPL actuelle de Mathematica affiche en fait ces espaces comme des signes de multiplication!). Encore mieux, si Mathematica peut dire où un jeton commence et où un autre se termine, alors aucun octet n'est nécessaire pour un opérateur de multiplication:5yest automatiquement interprété comme5*y, et3.14Log[9]comme3.14*Log[9].la source
##&invalide?##&renvoie sa liste d'arguments en tant qu'objet 'Sequence' - adapté pour se connecter à d'autres fonctions qui acceptent plusieurs arguments. Dans ce contexte,##&ne fait rien à sa liste d'arguments; nous voulons que cette liste soit multipliée.Rétine ,
383731 octetsEntièrement nouvelle approche, l'ancienne est ci-dessous.
Essayez-le en ligne!
Explication
Tout d'abord, nous traitons du signe:
correspond à tous
-dans la chaîne et les renvoie séparés par des retours à la ligne(avec une ligne vide suivante)
*\)signifie que le résultat de cela et les étapes précédentes doivent être imprimés sans nouvelle ligne, puis la chaîne est revenue à ce qu'elle était avant (la chaîne d'entrée). La partie restante en supprime deux-séparés par une nouvelle ligne.Ensuite, nous convertissons le premier nombre en unaire:
(il y a un espace à la fin de la première ligne). Nous utilisons
_comme chiffre unaire dans ce cas, car le chiffre standard1peut être présent dans le deuxième nombre, et cela entrerait en conflit plus tard.Nous arrivons maintenant à la multiplication réelle:
Chacun
_est remplacé par la représentation unaire de tout ce qui le suit (toujours en utilisant_comme chiffre unaire). Étant donné que la conversion en unaire ignore les caractères non numériques, cela répétera la représentation unaire du deuxième nombre pour le "premier nombre" fois. Le deuxième nombre restera en représentation décimale à la fin de la chaîne.Au final, avec un seul
_on renvoie le nombre de_dans la chaîne, qui sera le résultat de la multiplication.Réponse précédente: (avertissement: sort une chaîne vide quand elle devrait sortir
0)Rétine ,
454241 octetsJouons à un jeu! Multipliez les nombres relatifs avec une langue qui n'a pas d'opérateurs arithmétiques et un support limité uniquement pour les nombres naturels ... Ça a l'air drôle :)
Explication
Les trois premières lignes concernent le signe:
Cela trie
Opuis inverse^toutes les chaînes correspondant à l'expression régulière^|-. En pratique, cela correspond à la chaîne vide au début et au signe moins éventuel avant le deuxième nombre, et les réordonne en plaçant la chaîne vide à la place du moins. Après cela, tous-sont au début de la chaîne, et une paire d'entre eux peut être supprimée facilement avec les deux lignes suivantes.Après cela, nous utilisons une fonction intégrée pour convertir les nombres en représentation unaire, puis vient la multiplication réelle:
Nous faisons correspondre
1chacun d'entre eux et les remplaçons par tous les1espaces suivants. Chaque chiffre du premier numéro sera remplacé par le deuxième numéro complet, tandis que chaque chiffre du deuxième numéro sera remplacé par la chaîne vide.La dernière partie est à nouveau une fonction intégrée pour reconvertir de unaire en décimal.
Essayez-le en ligne!
la source
$*devrait être_.).+,(.+)à$.($1**) mais c'est en fait plus d'octets ici.Scratch , 1 octet
Utilisation: placez des nombres des deux côtés du
*panneauRemarque: Étant donné que Scratch est un langage visuel, je n'ai pas pu comprendre combien d'octets il consomme jusqu'à ce que @ mbomb007 m'ait signalé une méthode pour compter les octets de travail
la source
Brain-Flak , 56 octets
Cela doit être exécuté comme un programme complet car il n'est pas propre à la pile et les entrées doivent être les seuls éléments de l'une ou l'autre pile.
Essayez-le en ligne!
Explication: (appelez les entrées x et y)
Partie 1:
À ce stade, nous avons [x, y] sur une pile et [-x, -y] sur l'autre.
Partie 2:
la source
JavaScript (ES6), 9 octets
ES6 a une fonction dédiée pour les entiers 32 bits, plus rapide que l'
*opérateur plus générique .Soit dit en passant, c'est aussi long que:
la source
Brain-Flak ,
565452 octets2 octets économisés grâce à une erreur rattrapée par Nitrodon
Essayez-le en ligne!
Stack clean version,
6260 octetsEssayez-le en ligne!
Explication
Cette explication est plus une explication de l'algorithme impliqué et laisse de côté tout code réel. Cela suppose que vous savez lire Brain-Flak avec compétence. Si vous avez besoin d'aide pour comprendre le code ou l'algorithme, je serais heureux de modifier ou de répondre si vous laissez un commentaire.
C'est un peu étrange et utilise des mathématiques étranges qui fonctionnent à peine. La première chose que j'ai faite a été de créer une boucle qui se terminerait toujours par étapes O (n) . La façon normale de le faire est de mettre n et -n sur des piles opposées et d'en ajouter un jusqu'à ce que l'un atteigne zéro, mais je l'ai fait d'une manière légèrement plus étrange. Dans ma méthode, je mets un compteur sous l'entrée et à chaque étape, j'incrémente le compteur, je l'ajoute à n et je retourne le signe de n .
Voyons un exemple. Dites n = 7
Je ne le prouverai pas ici, mais cela se terminera toujours pour toute entrée et le fera en environ 2n étapes. En fait, il se terminera en 2n étapes si n est positif et 2n-1 étapes si n est négatif. Vous pouvez tester cela ici .
Maintenant, nous avons environ 2n étapes dans notre boucle, comment multiplions-nous par n ? Eh bien, voici de la magie mathématique. Voici ce que nous faisons: nous créons un accumulateur, à chaque étape du processus, nous ajoutons la deuxième entrée ( m ) à l'accumulateur et retournons le signe des deux, nous poussons ensuite le total sur toutes les boucles qui se produisent, c'est la produit.
Pourquoi diable est-ce le cas?
Passons en revue un exemple et j'espère qu'il deviendra clair. Dans cet exemple, nous multiplions 5 par 3 , je ne montrerai que les valeurs importantes
Espérons que le mécanisme soit apparent ici. Nous parcourons tous les multiples de m par ordre de leurs valeurs absolues. Vous remarquerez alors que le 2n e terme est toujours m * n et le terme avant toujours -m * n . Cela fait en sorte que notre boucle s'aligne parfaitement avec les résultats que nous voulons. Une heureuse coïncidence;)
la source
Dyalog APL , 1 octet
×prend un chiffre à gauche et un à droite×... ou même plusieurs chiffres à gauche ou à droite ou des deux côtés×/multiplie tous les nombres dans une liste×/¨multiplie les paires dans une liste donnée×/∊multiplie tous les nombres dans un tableauCela s'applique à toutes les fonctions arithmétiques, aux tableaux de toutes tailles et rangs, et aux nombres de tous les types de données.
la source
R, 3 octets
Il s'agit d'une fonction qui prend exactement deux arguments. Exécuter en tant que
'*'(a,b).Voir aussi
prodqui fait la même chose mais peut prendre un nombre arbitraire d'arguments.la source
'*'.ArnoldC , 152 octets
Essayez-le en ligne!
la source
Hexagonie , 9 octets
Essayez-le en ligne!
C'est en fait assez simple. Voici la version dépliée:
Il
/suffit de rediriger le flux de contrôle vers la deuxième ligne pour économiser des octets sur la troisième. Cela réduit le code à ce programme linéaire:Ce code linéaire à lui seul serait en fait une solution valable si l'entrée était limitée à des nombres strictement positifs, mais en raison de la possibilité de résultats non positifs, il n'est pas garanti que cela se termine.
Le programme utilise trois bords de mémoire en forme de Y:
Le pointeur de mémoire commence sur le bord
Apointant vers le centre.J'ai exécuté une recherche par force brute pour des solutions de 7 octets (c'est-à-dire celles qui correspondent à la longueur de côté 2), et si je n'ai pas fait d'erreur (ou s'il y a une solution occupée-castor-y qui prend beaucoup de temps à compléter, dont je doute), il n’existe pas de solution sur 7 octets. Il pourrait y avoir une solution à 8 octets (par exemple en réutilisant
?ou en utilisant une seule commande de redirection au lieu de deux/), mais c'est au-delà de ce que ma recherche par force brute peut faire, et je n'en ai pas encore trouvé une à la main.la source
Piet , 16 octets
Interprète en ligne disponible ici.
Explication
Pour exécuter, collez le code ci-dessus dans la zone de texte sur le côté droit de la page liée. Ci-dessous est une représentation graphique de ce code avec la taille de codel 31. La grille est pour la lisibilité et peut interférer avec les interprètes Piet traditionnels.
Le code s'exécute linéairement de gauche à droite, en longeant le haut de l'image jusqu'au premier bloc vert, où le flux du programme se déplace vers la rangée centrale de codels. Le codel blanc seul blanc est nécessaire pour le déroulement du programme. Il pourrait être remplacé par un codel de toute couleur autre que le vert ou le bleu foncé, mais j'ai choisi le blanc pour la lisibilité.
Si vous pensez que le texte n'est pas la meilleure façon de représenter un programme Piet ou avez un problème avec la taille d'octet des programmes Piet en général, veuillez faire connaître votre opinion dans la discussion sur les méta .
la source
BitCycle
-U, 68 octetsEssayez-le en ligne!
La multiplication de deux nombres n'est pas un problème trivial dans BitCycle, surtout lorsque les signes doivent être manipulés! Ceci est ma deuxième tentative; le premier (essentiellement le même algorithme, une disposition différente) était de 81 octets, il est donc tout à fait possible que celui-ci puisse également être raccourci.
Le programme prend les deux nombres comme arguments de ligne de commande et les renvoie vers stdout. L'
-Uindicateur consiste à convertir les nombres décimaux en unaires signés , car BitCycle ne connaît que les 0 et les 1.Explication
Cette explication suppose que vous comprenez les bases de BitCycle (voir Esolangs ou le fichier Lisez - moi de GitHub). Je baserai mon explication sur cette version non golfée, vue ici les
-2temps de calcul3:Présentation
Les nombres unaires signés sont constitués du signe (
0pour non positif, vide pour positif) suivi de la magnitude (un nombre de1s égal à la valeur absolue du nombre). Pour multiplier deux d'entre eux, nous devons XOR les signes (produire un0si exactement l'un d'eux est0, ou rien si les deux ou aucun ne le sont), puis multiplier les grandeurs (et produire autant1s). Nous réaliserons la multiplication par addition répétée.Signer les bits
En partant des deux sources
?, nous séparons les signes des grandeurs utilisant+.0s (bits de signe) tournent à gauche et sont dirigés le long de la rangée supérieure, tandis que1s (magnitudes) tournent à droite et se retrouvent dans les deuxBcollecteurs.La section qui gère les signes ressemble à ceci:
Si les deux nombres ne sont pas positifs, deux
0bits viennent du hautv. Le premier est réfléchi par le haut\, est envoyé vers le sud et réfléchi par le/. Pendant ce temps, le deuxième bit passe par le haut désactivé\et se reflète sur le bas\. Les deux bits se croisent, traversent directement les séparateurs désormais désactivés de la rangée inférieure et quittent le terrain de jeu.Si un seul des nombres n'est pas positif, on
0arrive par le haut. Il rebondit autour des trois séparateurs et finit par repartir vers le nord, jusqu'à ce qu'il touche levet qu'il soit à nouveau envoyé vers le sud. Cette fois, il passe à travers les séparateurs désactivés et atteint le<, qui l'envoie dans l'évier!.Boucles pour stocker les grandeurs
La magnitude du premier nombre va dans le
Bcollecteur dans cette section:Avant l'ouverture du
Bcollecteur, leAcollecteur libère le single0qui y était placé, qui passe ensuite à la fin de la file d'attente dansB. Nous l'utilisons comme valeur de drapeau pour terminer la boucle lorsque tous les1bitsBsont partis.Chaque fois que les
Bcollecteurs s'ouvrent, le\séparateur décolle le premier bit de la file d'attente et l'envoie à la logique de traitement au milieu. Le reste des bits entreC, et lorsque lesCcollecteurs s'ouvrent, ils sont renvoyés dansB.L'amplitude du deuxième nombre va dans le
Bcollecteur dans cette section:Lorsque les
Bcollecteurs s'ouvrent, les bits entrent dans le dupneg inférieur~. Les1bits d' origine tournent à droite et sont envoyés vers l'ouest dans la logique de traitement au milieu. Les copies annulées0tournent à gauche et frappent immédiatement un autre dupneg. Ici, le0s tourne à droite et sort du terrain de jeu, tandis que le (maintenant doublement)1s tourne à gauche et est envoyé dansC. Lorsqu'ellesCs'ouvrent, elles y retournentB.Addition répétée
La logique de traitement centrale est cette partie:
Les bits des deux boucles (un du côté ouest et tout du côté est) sont envoyés au sud dans le commutateur
=. Le timing doit être réglé de sorte que le bit de la boucle ouest arrive en premier. Si c'est le cas1, le commutateur passe à}, envoyant les bits suivants vers l'est dans le récepteur!pour être émis. Une fois que tous les1s ont disparu, nous obtenons le0, qui change le commutateur en{. Cela envoie les bits suivants dans le@, qui termine le programme. En bref, nous émettons la grandeur (unaire) du deuxième nombre autant de fois qu'il y a de1s dans la grandeur (unaire) du premier nombre.la source
Python 3 , 11 octets
Essayez-le en ligne!
Fonctionne également pour les entiers sous
2**32dans Python 2.la source
Java 8,
109 octetsEssayez-le ici.
Java 7, 31 octets
Essayez-le ici.
En programme complet (
9990 octets) :Essayez-le ici.
la source
*installée+.a,bdans l'expression lambda.Pyth, 2 octets
Essayez-le ici!
L'évaluation automatique de Pyth fait obstacle ici. Pour contourner cela, j'utilise une évaluation explicite pour l'un des arguments
la source
TI-Basic, 2 octets
Très simple.
la source
Ansis not an allowed I/O method.PHP, 21 bytes
takes input from command line arguments. Also works with floats.
la source
Retina,
3935 bytesThanks to Leo for letting me use an idea of his that ended up saving 4 bytes.
Input is linefeed-separated.
Try it online! (Space-separated test suite for convenience.)
Explanation
Les deux premières étapes affichent un signe moins si exactement l'une des deux entrées est négative. Ils le font sans modifier réellement l'entrée. Cela se fait en les regroupant dans la deuxième étape avec
)et en les transformant en run-dry avec*. L'\option de la deuxième étape empêche l'impression d'un saut de ligne de fin.Tout d'abord, nous supprimons tout sauf les signes moins.
Ensuite, nous annulons les signes moins s'il en reste deux.
Maintenant, nous convertissons chaque ligne en la représentation unaire de sa valeur absolue. Cela supprimera le signe moins car il
$*ne recherche que le premier nombre non négatif de la correspondance (c'est-à-dire qu'il ne connaît pas les signes moins et les ignore).La première ligne est convertie en
_, en faisant correspondre les1s tant qu'ils sont adjacents à la correspondance précédente (par conséquent, nous ne pouvons pas faire correspondre les1s sur la deuxième ligne, car le saut de ligne rompt cette chaîne).This performs the actual multiplication. We replace each
_(on the first line) as well as the entire second line everything after that match. The_matches will therefore include the entire second line (multiplying it by the number of0s in the first line), and the second line will be removed because there is nothing after that match. Of course the result will also include some junk in the form of_s and linefeeds, but that won't matter.We finish by simply counting the number of
1s in the result.la source
MATLAB,
54 bytesdottakes the dot product of two vectors of equal length. If we feed it with two scalars, it will simply multiply the two numbers.prodtakes the product of the values in all rows of each column of a matrix. If the matrix is one-dimensional (i.e. a vector), then it acts along the non-singleton dimension, taking the product of all elements in the vector.dotis one byte shorter thanprodwhich is one byte shorter than the even more obvious builtintimes.Call it as such:
la source
PigeonScript, 1 byte
Explanation:
*looks to the stack to see if there is anything there. If not, it prompts for input and multiplies the inputs togetherla source
Perl 6, 4 bytes
This is just the ordinary infix multiplication operator
*, expressed as an ordinary function. As a bonus, if given one number it returns that number, and if given no numbers it returns1, the multiplicative identity.la source
*×*><>, 5 Bytes
Takes input as an ascii character, outputs a number.
Explanation:
You could also do
But I feel my solution is waaay cooler.
Another possibility is dropping the semicolon, which would result in the pointer bouncing off the mirror, hitting the print command, and throwing an error since the stack is empty.
la source
Intel 8080 machine code, MITS Altair 8800, 28 bytes
This implements binary multiplication on the Intel 8080 CPU (c. 1974) which did not have multiplication or division instructions. Inputs are 8-bit values and the product is a 16-bit value returned in the
BCregister pair.Here is the machine code along with step-by-step instructions to load the program into an Altair 8800 using the front panel switches.
Try it online!
If you've entered it all correctly, on the machine state drawer in the simulator your RAM contents will look like:
Input
Multiplier in
Cregister, and multiplicand intoD. The stock Altair has noSTDINso input is by front panel switches only.Output
The result is displayed on the
D7-D0lights (top right row) in binary.5 x 16 = 80 (0101 0000)4 x 5 = 20 (0001 0100)7 x 9 = 63 (0011 1111)8 x -9 = -72 (1011 1000)Compatibility note: this should also run on the IMSAI 8080, though currently untested.
la source
C#, 10 bytes
It's just a simply multiplication.
la source
Jelly, 1 byte
Try it online!
Obligatory Jelly submission.
la source
Clojure, 1 byte
:P As a bonus this works on any number of arguments:
Interestingly you can easily get its source code:
la source
Owk, 11 bytes
This can be assigned to a function like this:
and called like this:
la source