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>
Respostas:
Brachylog V1, 05AB1E, J, K, Underload, MATL, Adiante, PigeonScript, Empilhado, implícito, Jolf, Clojure, Braingolf, 8o, Lisp comum, Julia, Pyt, Appleseed, Stax, Realidade, dc 1 byte
Você pode editar esta resposta para adicionar outros idiomas para os quais
*é uma resposta válida.fonte
*(5,16)C (GCC), 13 bytes
Não funciona em todas as implementações, mas tudo bem.
Experimente no TIO!
fonte
a? Eu não entendi ...aé uma variável de pilha local paraf()- por que seu valor é retornado?). +1, btw - abuso muito inteligente da ABI.returnpalavra-chave simplesmente coloca o resultado do seu argumento no registro EAX. Nesse caso, o executável gerado faz o cálculoa*bnesse registrador, portantoreturnnão faz nada.f(a,b){a*=b;}peça1##&e mudando seu idioma para Mathematica.Beatnik , 888 bytes
Experimente online!
Estou usando o intérprete C, porque o intérprete Python no TIO executa o endereço irritantemente se a condição para retroceder não for atendida. Uma solução fácil para o interpretador Python é preencher alguns nops para tornar o endereço nop. Eu acredito que nenhum dos dois está correto:
A entrada deve ser dois números inteiros separados por um espaço, sem novas linhas à direita.
Esta resposta funciona em teoria para todos os números inteiros, se cada célula puder armazenar um valor arbitrariamente grande, não limitado a 0 - 255. Mas ela excederá se | A | + | B | > 22. E corre muito lentamente se | A | + | B | > 6. Portanto, não há muitos casos que você pode testar e uma solução if-else para esses casos pode ser ainda mais curta.
A idéia é calcular os números triangulares T (N) = N (N + 1) / 2, diminuindo o valor para 0 e somando todos os valores intermediários. Então podemos obter a resposta A * B = T (A + B) - T (A) - T (B).
Mas é complicado calcular todos os 3 valores. Ele faz isso computando primeiro T (A + B) - A, deixando uma cópia de A na pilha para adicionar novamente mais tarde e usando a entrada B. Em seguida, encontre recursivamente o maior número triangular menor que aquele, que é T ( A + B-1), exceto nos casos especiais nulos. Podemos recuperar B = T (A + B) - A - T (A + B-1) e calcular T (B) a partir daí.
Um número N é um número triangular se for igual ao maior número triangular menor que N, mais o número de números triangulares não negativos menores que N. Isso ocorre em O (2 ^ (T (A + B) -A)) e é a parte mais lenta do programa.
fonte
Mathematica, 4 bytes
Exemplo de uso:
1##&[7,9]retorna63. De fato, essa mesma função multiplica qualquer número de argumentos de qualquer tipo juntos.Como os codegolfistas do Mathematica sabem, isso funciona porque
##se refere a toda a sequência de argumentos de uma função, e a concatenação no Mathematica (geralmente) representa multiplicação; portanto1##refere-se a (1 vezes) do produto de todos os argumentos da função. o&é apenas uma abreviação doFunctioncomando que define uma função pura (sem nome).Dentro de outro código, o símbolo comum
*atua como multiplicação. O mesmo acontece com um espaço, de modo que7 9é interpretado como7*9(de fato, a versão atual do Mathematica do REPL realmente exibe esses espaços como sinais de multiplicação!). Melhor ainda, se o Mathematica pode dizer onde um token inicia e outro termina, então nenhum bytes é necessário para um operador de multiplicação:5yé automaticamente interpretado como5*ye3.14Log[9]como3.14*Log[9].fonte
##&inválido?##&retorna sua lista de argumentos como um objeto 'Sequência' - adequado para conectar-se a outras funções que recebem vários argumentos. Nesse contexto,##&não faz nada com sua lista de argumentos; queremos que essa lista seja multiplicada.Retina ,
383731 bytesAbordagem completamente nova, a antiga está abaixo.
Experimente online!
Explicação
Primeiro, lidamos com o sinal:
corresponde a tudo
-na string e os retorna separados por novas linhas(com uma linha vazia a seguir)
*\)significa que o resultado deste e dos estágios anteriores deve ser impresso sem uma nova linha e, em seguida, a sequência reverte para a que era antes (a sequência de entrada). A parte restante remove dois-separados por uma nova linha.Em seguida, convertemos o primeiro número em unário:
(há um espaço no final da primeira linha). Usamos
_como nosso dígito unário nesse caso, porque o dígito padrão1pode estar presente no segundo número e isso entraria em conflito mais tarde.Agora chegamos à multiplicação real:
Cada um
_é substituído pela representação unária de tudo o que segue (ainda usando_como dígito unário). Como a conversão para unário ignora caracteres que não são dígitos, isso repetirá a representação unária do segundo número por vezes do "primeiro número". O segundo número permanecerá na representação decimal no final da string.No final, com um único
_, retornamos o número de_na string, que será o resultado da multiplicação.Resposta anterior: (aviso: gera uma string vazia quando deve ser exibida
0)Retina ,
454241 bytesVamos jogar um jogo! Multiplique números relativos por um idioma que não possui operadores aritméticos e suporte limitado apenas a números naturais ... Parece engraçado :)
Explicação
As três primeiras linhas tratam do sinal:
Isso classifica
Oe, em seguida, reverte^todas as seqüências correspondentes ao regex^|-. Na prática, isso corresponde à sequência vazia no início e ao eventual sinal de menos antes do segundo número, e reordena-os colocando a sequência vazia no lugar do menos. Depois disso, todos-estão no início da sequência e um par deles pode ser removido facilmente com as próximas duas linhas.Depois disso, usamos um builtin para converter números em representação unária e, em seguida, vem a multiplicação real:
Combinamos qualquer um
1e substituímos cada um deles por todo o1espaço a seguir. Cada dígito do primeiro número será substituído pelo segundo número inteiro, enquanto que cada dígito do segundo número será substituído pela sequência vazia.A última parte é novamente incorporada para converter novamente de unário para decimal.
Experimente online!
fonte
$*deve ser_)..+,(.+)para$.($1**), mas na verdade são mais bytes aqui.Zero , 1 byte
Uso: Coloque números nos dois lados do
*sinalNota: Como o Scratch é uma linguagem visual, não consegui descobrir quantos bytes ele consome até @ mbomb007 me mencionar sobre um método para contar bytes de scratch
fonte
Brain-Flak , 56 bytes
Isso deve ser executado como um programa completo, pois não é uma pilha limpa e as entradas devem ser os únicos elementos em qualquer pilha.
Experimente online!
Explicação: (chame as entradas x e y)
Parte 1:
Neste ponto, temos [x, y] em uma pilha e [-x, -y] na outra.
Parte 2:
fonte
JavaScript (ES6), 9 bytes
O ES6 possui uma função dedicada para números inteiros de 32 bits, mais rápido que o
*operador mais genérico .Aliás, isso é apenas enquanto:
fonte
Explosão Cerebral ,
565452 bytes2 bytes salvos graças a um erro detectado pelo Nitrodon
Experimente online!
Versão limpa da pilha,
6260 bytesExperimente online!
Explicação
Esta explicação é mais uma explicação do algoritmo envolvido e deixa de fora qualquer código real. Supõe-se que você saiba ler o Brain-Flak proficientemente. Se você precisar de ajuda para entender o código ou o algoritmo, ficarei feliz em editar ou responder se você deixar um comentário.
Isso é um pouco estranho e usa uma matemática estranha que mal funciona. A primeira coisa que fiz foi fazer um loop que sempre terminava em O (n) etapas. A maneira normal de fazer isso é colocar n e -n em pilhas opostas e adicionar uma a cada uma até chegar a zero, no entanto, eu fiz isso de uma maneira um pouco mais estranha. No meu método, coloquei um contador embaixo da entrada e a cada passo que incremento o contador, adicione-o a ne aponte o sinal de n .
Vamos dar um exemplo. Diga n = 7
Não vou provar aqui, mas isso sempre terminará para qualquer entrada e o fará em cerca de 2n etapas. De fato, terminará em 2n etapas se n for positivo e 2n-1 etapas se n for negativa. Você pode testar isso aqui .
Agora, temos cerca de 2n etapas em nosso loop, como multiplicamos por n ? Bem, aqui tem um pouco de magia matemática. Aqui está o que fazemos: Criamos um acumulador; em cada etapa do processo, adicionamos a segunda entrada ( m ) ao acumulador e mostramos o sinal de ambos; depois, empurramos o total sobre todos os loops que ocorrem, esse é o produtos.
Por que diabos é esse o caso?
Bem, vamos percorrer um exemplo e espero que fique claro. Neste exemplo, estamos multiplicando 5 por 3 , mostrarei apenas os valores importantes
Espero que o mecanismo seja aparente aqui. Estamos percorrendo todos os múltiplos de m na ordem de seus valores absolutos. Você notará que o 2º th é sempre m * n e o termo antes de sempre -m * n . Isso faz com que nosso loop se alinhe perfeitamente com os resultados que queremos. Um pouco de feliz coincidência;)
fonte
Dyalog APL, 1 byte
×takes one number on the left, and one on the right×... or even multiple numbers on the left or on the right or on both sides×/multiplies all numbers in a list×/¨multiplies the pairs in a given list×/∊mulitplies all numbers in an arrayThis applies to all arithmetic functions, arrays of all sizes and ranks, and numbers of all datatypes.
fonte
R, 3 bytes
This is a function which takes exactly two arguments. Run as
'*'(a,b).See also
prodwhich does the same thing but can take an arbitrary number of arguments.fonte
'*'.ArnoldC, 152 bytes
Try it online!
fonte
Hexagony, 9 bytes
Try it online!
This is actually fairly straightforward. Here is the unfolded version:
The
/just redirect the control flow to the second line to save bytes on the third. That reduces the code to this linear program:This linear code on its own would actually be a valid solution if the input was limited to strictly positive numbers, but due to the possibility of non-positive results, this isn't guaranteed to terminate.
The program makes use of three memory edges in a Y-shape:
The memory pointer starts on edge
Apointing towards the centre.I ran a brute force search for 7-byte solutions (i.e. those that fit into side-length 2), and if I didn't make a mistake (or there's a busy-beaver-y solution that takes a long time to complete, which I doubt) then a 7-byte solution doesn't exist. There might be an 8-byte solution (e.g. by reusing the
?or using only one redirection command instead of two/), but that's beyond what my brute force search can do, and I haven't found one by hand yet.fonte
Piet, 16 bytes
Online interpreter available here.
Explanation
To run, paste the code above in the text box on the right side of the linked page. Below is a graphical representation of this code with codel size 31. The grid is for readability and may interfere with traditional Piet interpreters.
The code runs linearly from left to right, going along the top of the image until the first green block, where program flow moves to the middle row of codels. The white lone white codel is necessary for program flow. It could be replaced with a codel of any color other than green or dark blue, but I have chosen white for readability.
If you think that text is not the best way to represent a Piet program or have an issue with the byte size of Piet programs in general, please let your opinion be known in the discussion on meta.
fonte
BitCycle
-U, 68 bytesTry it online!
Multiplying two numbers is not a trivial problem in BitCycle, especially when signs need to be handled! This is my second attempt; the first one (essentially same algorithm, different layout) was 81 bytes, so it's quite possible this one could be shortened too.
The program takes the two numbers as command-line arguments and outputs to stdout. The
-Uflag is to convert the decimal numbers to signed unary, since BitCycle knows only of 0's and 1's.Explanation
This explanation assumes you understand the basics of BitCycle (see Esolangs or the GitHub readme). I'll base my explanation on this ungolfed version, seen here computing
-2times3:Overview
Signed unary numbers consist of the sign (
0for nonpositive, empty for positive) followed by the magnitude (a number of1s equal to the number's absolute value). To multiply two of them, we need to XOR the signs (output a0if exactly one of them is0, or nothing if both or neither are) and then multiply the magnitudes (and output that many1s). We'll achieve the multiplication by repeated addition.Sign bits
Starting from the two sources
?, we split off the signs from the magnitudes using+.0s (sign bits) turn left and are directed along the top row, while1s (magnitudes) turn right and end up in the twoBcollectors.The section that handles the signs looks like this:
If both numbers are nonpositive, two
0bits come in from the topv. The first one reflects off the top\, is sent southward, and reflects off the/. Meanwhile, the second bit passes through the deactivated top\and reflects off the bottom\. The two bits pass each other, go straight through the now-deactivated splitters on the bottom row, and go off the playfield.If only one of the numbers is nonpositive, one
0comes in from the top. It bounces around all three splitters and ends up going northward again, until it hits thevand is once more sent south. This time, it passes through the deactivated splitters and reaches the<, which sends it into the sink!.Loops to store the magnitudes
The magnitude of the first number goes into the
Bcollector in this section:Before the
Bcollector opens, theAcollector releases the single0that was placed in it, which then goes onto the end of the queue inB. We'll use it as a flag value to terminate the loop when all the1bits inBare gone.Each time the
Bcollectors open, the\splitter peels off the first bit from the queue and sends it to the processing logic in the middle. The rest of the bits go intoC, and when theCcollectors open, they are sent back intoB.The magnitude of the second number goes into the
Bcollector in this section:When the
Bcollectors open, the bits go into the bottom dupneg~. The original1bits turn right and are sent west into the processing logic in the middle. The negated copies (0s) turn left and immediately hit another dupneg. Here the0s turn right and go off the playfield, while the (now doubly) negated1s turn left and are sent intoC. WhenCopens, they go back intoB.Repeated addition
The central processing logic is this part:
Bits from both loops (one from the western side, and everything from the eastern side) are sent south into the switch
=. The timing has to be set up so that the bit from the western loop gets there first. If it is a1, the switch changes to}, sending the following bits eastward into the sink!to be output. Once all the1s are gone, we get the0, which changes the switch to{. This sends the following bits into the@, which terminates the program. In short, we output the (unary) magnitude of the second number as many times as there are1s in the (unary) magnitude of the first number.fonte
Python 3, 11 bytes
Try it online!
Also works for integers under
2**32in Python 2.fonte
Java 8,
109 bytesTry it here.
Java 7, 31 bytes
Try it here.
As full program (
9990 bytes):Try it here.
fonte
*instaed of+.a,bin the lambda expression.Pyth, 2 bytes
Try it here!
Pyth's automatic evaluation gets in the way here. To get around it, I'm using explicit evaluation for one of the arguments
fonte
TI-Basic, 2 bytes
Very straightforward.
fonte
Ansis not an allowed I/O method.PHP, 21 bytes
takes input from command line arguments. Also works with floats.
fonte
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
The first two stages print a minus sign if exactly one of the two inputs is negative. They do this without actually changing the input. This is done by grouping them in the second stage with
)and turning them into a dry-run with*. The\option on the second stage prevents printing a trailing linefeed.First, we remove everything except the minus signs.
Then we cancel the minus signs if there are two of them left.
Now we convert each line to the unary representation of its absolute value. This will get rid of the minus sign because
$*only looks for the first non-negative number in the match (i.e. it doesn't know about minus signs and ignores them).The first line is converted to
_, by matching individual1s as long as their adjacent to the previous match (hence, we can't match the1s on the second line, because the linefeed breaks this chain).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.fonte
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:
fonte
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 togetherfonte
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.fonte
*×*><>, 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.
fonte
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.
fonte
C#, 10 bytes
It's just a simply multiplication.
fonte
Jelly, 1 byte
Try it online!
Obligatory Jelly submission.
fonte
Clojure, 1 byte
:P As a bonus this works on any number of arguments:
Interestingly you can easily get its source code:
fonte
Owk, 11 bytes
This can be assigned to a function like this:
and called like this:
fonte