Entrada: dos enteros decimales. Estos pueden darse al código en la entrada estándar, como argumentos para el programa o función, o como una lista.

Salida: su producto, como un entero decimal. Por ejemplo, la entrada 5 16conduciría a la salida 80.

Restricciones: No hay lagunas estándar por favor. Este es el código de golf , la respuesta en la menor cantidad de bytes gana.

Notas: Diseño robado de mi desafío anterior, agregue dos números .

Casos de prueba:

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

O como 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

Tabla de clasificación

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 byte

*

Puede editar esta respuesta para agregar otros idiomas para los cuales *es una respuesta válida.

C (GCC), 13 bytes

No funciona en todas las implementaciones, pero está bien.

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

Pruébalo en 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

Pruébalo en línea!

Estoy usando el intérprete C porque el intérprete de Python en TIO ejecuta molestamente la dirección si no se cumple la condición para saltar hacia atrás. Una solución fácil para el intérprete de Python es rellenar algunos nops para que la dirección nop. Creo que ninguno es correcto:

                                   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

La entrada debe ser dos enteros separados por un espacio, sin líneas nuevas.

Esta respuesta funciona en teoría para todos los enteros, si cada celda puede almacenar un valor arbitrariamente grande, no limitado a 0 - 255. Pero se desborda si | A | + | B | > 22. Y funciona muy lentamente si | A | + | B | > 6. Por lo tanto, no hay muchos casos que pueda probar y una solución if-else para esos casos podría ser aún más corta.

La idea es calcular los números triangulares T (N) = N (N + 1) / 2 disminuyendo el valor a 0 y sumando todos los valores intermedios. Entonces podemos obtener la respuesta A * B = T (A + B) - T (A) - T (B).

Pero es complicado calcular los 3 valores. Lo hace calculando en primer lugar T (A + B) - A, dejando una copia de A en la pila para agregar más tarde y utilizando la entrada B. Luego, recursivamente, encuentra el mayor número triangular más pequeño que eso, que es T ( A + B-1) excepto para los casos especiales cero. Podemos recuperar B = T (A + B) - A - T (A + B-1) y calcular T (B) desde allí.

Un número N es un número triangular si es igual al mayor número triangular menor que N, más el número de números triangulares no negativos menores que N. Esto se ejecuta en O (2 ^ (T (A + B) -A)) y es la parte más lenta del programa.

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##&

Ejemplo de uso: 1##&[7,9]devoluciones 63. De hecho, esta misma función multiplica cualquier cantidad de argumentos de cualquier tipo juntos.

Como saben los codegolfers de Mathematica, esto funciona porque se ##refiere a la secuencia completa de argumentos a una función, y la concatenación en Mathematica (a menudo) representa la multiplicación; entonces se 1##refiere (1 veces) al producto de todos los argumentos de la función. El &es simplemente la abreviatura del Functioncomando que define una función pura (sin nombre).

Dentro de otro código, el símbolo común *actúa como multiplicación. También lo hace un espacio, por lo que 7 9se interpreta como 7*9(de hecho, la versión REPL actual de Mathematica en realidad muestra espacios como signos de multiplicación). Sin embargo, aún mejor, si Mathematica puede decir dónde comienza un token y termina otro, entonces no se necesitan bytes para un operador de multiplicación: 5yse interpreta automáticamente como 5*y, y 3.14Log[9]como 3.14*Log[9].

Retina , 38 37 31 bytes

Enfoque completamente nuevo, el anterior está debajo.

M!`-
*\)`-¶-

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

Pruébalo en línea!

Explicación

Primero, tratamos con el signo:

M!`-

coincide con todos -en la cadena y los devuelve separados por nuevas líneas

*\)`-¶-

(con una línea vacía siguiente)
*\)significa que el resultado de esto y las etapas anteriores deben imprimirse sin una nueva línea, y luego la cadena volverá a ser lo que era antes (la cadena de entrada). La parte restante elimina dos -separados por una nueva línea.

Luego convertimos el primer número a unario:

.* 
$*_

(hay un espacio al final de la primera línea). Usamos _como nuestro dígito unario en este caso, porque el dígito estándar 1puede estar presente en el segundo número, y esto entraría en conflicto más adelante.

Ahora llegamos a la multiplicación real:

_
$'$*_

Cada uno _se reemplaza por la representación unaria de todo lo que le sigue (todavía se usa _como dígito unario). Como la conversión a unario ignora los caracteres que no son dígitos, esto repetirá la representación unaria del segundo número por "primer número" veces. El segundo número permanecerá en representación decimal al final de la cadena.

Al final, con un solo _devolvemos el número de _en la cadena, que será el resultado de la multiplicación.

Respuesta anterior: (advertencia: genera una cadena vacía cuando debería producirse 0)

Retina ,  45  42 41 bytes

¡Vamos a jugar un juego! Multiplique números relativos con un lenguaje que no tenga operadores aritméticos y soporte limitado solo para números naturales ... Suena gracioso :)

O^`^|-
--

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

Explicación

Las primeras tres líneas tratan con el signo:

O^`^|-

Esto ordena Oy luego invierte ^todas las cadenas que coinciden con la expresión regular ^|-. En la práctica, esto coincide con la cadena vacía al comienzo y el signo menos eventual antes del segundo número, y los ordena colocando la cadena vacía en el lugar del signo menos. Después de esto, todos -están al comienzo de la cadena, y un par de ellos se pueden eliminar fácilmente con las siguientes dos líneas.

Después de eso, usamos una función integrada para convertir números a representación unaria, y luego viene la multiplicación real:

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

Hacemos coincidir cualquiera 1, y sustituimos cada uno de ellos con todos 1después del siguiente espacio. Cada dígito del primer número será reemplazado por el segundo número completo, mientras que cada dígito del segundo número será reemplazado por la cadena vacía.

La última parte es nuevamente una función incorporada para volver a convertir de unario a decimal.

Pruébalo en línea!

Rasguño , 1 byte

Uso: colocar números en ambos lados del *signo

Nota: Dado que Scratch es un lenguaje visual, no pude calcular cuántos bytes consume hasta que @ mbomb007 me notó acerca de un método para contar bytes de scratch

Brain-Flak , 56 bytes

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

Esto debe ejecutarse como un programa completo ya que no está limpio de pila y las entradas deben ser los únicos elementos en cualquiera de las pilas.

Pruébalo en línea!

Explicación: (llame a las entradas x e y)

Parte 1:

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

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

En este punto tenemos [x, y] en una pila y [-x, -y] en la otra.

Parte 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 bytes

ES6 tiene una función dedicada para enteros de 32 bits, más rápido que el *operador más genérico .

Math.imul

Por cierto, esto es tan largo como:

a=>b=>a*b

Brain-Flak , 56 54 52 bytes

2 bytes guardados gracias a un error detectado por Nitrodon

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

Pruébalo en línea!

Versión limpia de pila, 62 60 bytes

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

Pruébalo en línea!

Explicación

Esta explicación es más una explicación del algoritmo involucrado y omite cualquier código real. Se supone que sabes leer Brain-Flak de manera competente. Si necesita ayuda para comprender el código o el algoritmo, me complacería editar o responder si deja un comentario.

Esto es un poco extraño y utiliza algunas matemáticas raras que apenas funcionan. Lo primero que hice fue hacer un bucle que siempre terminaría en O (n) pasos. La forma normal de hacer esto es poner n y -n en pilas opuestas y agregar uno a cada uno hasta que uno llegue a cero, sin embargo lo hice de una manera un poco más extraña. En mi método pongo un contador debajo de la entrada y cada paso que incremente el contador lo agrego a n y volteo el signo de n .

Veamos un ejemplo. Di 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

No lo probaré aquí, pero esto siempre terminará para cualquier entrada y lo hará en aproximadamente 2n pasos. De hecho, terminará en 2n pasos si n es positivo y 2n-1 pasos si n es negativo. Puedes probar eso aquí .

Ahora tenemos alrededor de 2n pasos en nuestro ciclo, ¿cómo multiplicamos por n ? Bueno, aquí tienes un poco de magia matemática. Esto es lo que hacemos: hacemos un acumulador, en cada paso del proceso agregamos la segunda entrada ( m ) al acumulador y volteamos el signo de ambos, luego empujamos el total sobre todos los bucles que ocurren, este es el producto.

¿Por qué demonios es ese el caso?

Bueno, veamos un ejemplo y espero que quede claro. En este ejemplo estamos multiplicando 5 por 3 , mostraré solo los valores importantes

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

Esperemos que el mecanismo sea evidente aquí. Estamos recorriendo todos los múltiplos de m en orden de sus valores absolutos. A continuación, aviso de que el 2n ^º plazo es siempre m * n y el término antes siempre * -m n . Esto hace que nuestro bucle se alinee perfectamente con los resultados que queremos. Un poco de una feliz coincidencia;)

Dyalog APL , 1 byte

× toma un número a la izquierda y uno a la derecha

×... o incluso múltiples números a la izquierda o a la derecha o en ambos lados

×/ multiplica todos los números en una lista

×/¨ multiplica los pares en una lista dada

×/∊ mulitplies todos los números en una matriz

Esto se aplica a todas las funciones aritméticas, matrices de todos los tamaños y rangos, y números de todos los tipos de datos.

R, 3 bytes

'*'

Esta es una función que toma exactamente dos argumentos. Corre como '*'(a,b).

Vea también prodqué hace lo mismo pero puede tomar una cantidad arbitraria de argumentos.

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

Pruébalo en línea!

Hexagonía , 9 bytes.

?{?/*!@'/

Pruébalo en línea!

Esto es realmente bastante sencillo. Aquí está la versión desplegada:

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

El /solo redirige el flujo de control a la segunda línea para guardar bytes en la tercera. Eso reduce el código a este programa lineal:

?{?'*!@

Este código lineal por sí solo sería una solución válida si la entrada se limitara a números estrictamente positivos, pero debido a la posibilidad de resultados no positivos, no se garantiza que termine.

El programa hace uso de tres bordes de memoria en forma de Y:

A   B
 \ /
  |
  C

El puntero de memoria comienza en el borde Aapuntando hacia el centro.

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

Realicé una búsqueda de fuerza bruta para soluciones de 7 bytes (es decir, las que encajan en la longitud lateral 2), y si no cometí un error (o hay una solución de ocupado-castor que lleva mucho tiempo completar, que dudo) entonces no existe una solución de 7 bytes. Puede haber una solución de 8 bytes (por ejemplo, reutilizando ?o usando solo un comando de redirección en lugar de dos /), pero eso está más allá de lo que puede hacer mi búsqueda de fuerza bruta, y todavía no he encontrado una a mano.

Piet , 16 bytes

5bpiaibpikibptai

Intérprete en línea disponible aquí.

Explicación

Para ejecutar, pegue el código anterior en el cuadro de texto en el lado derecho de la página vinculada. A continuación se muestra una representación gráfica de este código con el tamaño de codel 31. La cuadrícula es para facilitar la lectura y puede interferir con los intérpretes tradicionales de Piet.
El código se ejecuta linealmente de izquierda a derecha, yendo a lo largo de la parte superior de la imagen hasta el primer bloque verde, donde el flujo del programa se mueve a la fila central de códeles. El códec blanco solitario blanco es necesario para el flujo del programa. Podría reemplazarse con un códec de cualquier color que no sea verde o azul oscuro, pero he elegido el blanco por legibilidad.

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]

Si cree que el texto no es la mejor manera de representar un programa de Piet o tiene un problema con el tamaño de bytes de los programas de Piet en general, deje que su opinión sea conocida en la discusión sobre meta .

BitCycle -U , 68 bytes

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

Pruébalo en línea!

Multiplicar dos números no es un problema trivial en BitCycle, ¡especialmente cuando los signos deben manejarse! Este es mi segundo intento; el primero (esencialmente el mismo algoritmo, diseño diferente) tenía 81 bytes, por lo que es muy posible que este también se acorte.

El programa toma los dos números como argumentos de línea de comandos y genera salidas en stdout. La -Ubandera es para convertir los números decimales a unario con signo , ya que BitCycle solo sabe de 0 y 1.

Explicación

Esta explicación asume que comprende los conceptos básicos de BitCycle (consulte Esolangs o el archivo Léame de GitHub). Basaré mi explicación en esta versión sin golf, que se ve aquí calculando los -2tiempos 3:

Visión general

Los números unarios con signo consisten en el signo ( 0para no positivo, vacío para positivo) seguido de la magnitud (un número de 1s igual al valor absoluto del número). Para multiplicar dos de ellos, necesitamos XOR los signos (salida a 0si exactamente uno de ellos es 0, o nada si ambos o ninguno lo son) y luego multiplicar las magnitudes (y generar esa cantidad1 s). Lograremos la multiplicación mediante la suma repetida.

Bits de signo

A partir de las dos fuentes ?, separamos los signos de las magnitudes usando +. 0s (bits de signo) giran a la izquierda y se dirigen a lo largo de la fila superior, mientras que 1s (magnitudes) giran a la derecha y terminan en los dos Bcolectores.

La sección que maneja los signos se ve así:

  v

  \  v
> \  /

! <

Si ambos números no son positivos, entran dos 0bits desde la parte superior v. El primero se refleja en la parte superior \, se envía hacia el sur y se refleja en el /. Mientras tanto, el segundo bit pasa a través de la parte superior desactivada \y se refleja en la parte inferior \. Los dos bits se cruzan, van directamente a través de los divisores ahora desactivados en la fila inferior y salen del campo de juego.

Si solo uno de los números no es positivo, uno 0viene desde arriba. Salta alrededor de los tres divisores y termina yendo hacia el norte nuevamente, hasta que golpea el vy es enviado nuevamente al sur. Esta vez, pasa a través de los divisores desactivados y llega al <, que lo envía al fregadero !.

Bucles para almacenar las magnitudes.

La magnitud del primer número va al Bcolector en esta sección:

B v
  \
  C v
^   <

0 A ^

Antes de que se Babra el recopilador, el Arecopilador libera el sencillo 0que se colocó en él, que luego pasa al final de la cola B. Lo usaremos como un valor de bandera para terminar el ciclo cuando todos los 1bits Bhayan desaparecido.

Cada vez que se Babren los colectores, el \divisor despega el primer bit de la cola y lo envía a la lógica de procesamiento en el medio. El resto de los bits entran C, y cuando los Ccolectores se abren, se envían nuevamente B.

La magnitud del segundo número va al Bcolector en esta sección:

v   ~
C B ~
    <

Cuando se Babren los colectores, las brocas van a la parte inferior del dupneg ~. Los 1bits originales giran a la derecha y se envían al oeste a la lógica de procesamiento en el medio. Las copias negadas 0giran a la izquierda e inmediatamente golpean otro dupneg. Aquí los 0s giran a la derecha y salen del campo de juego, mientras que los (ahora doblemente) negados 1giran a la izquierda y son enviados a C. Cuando se Cabre, vuelven aB .

Adición repetida

La lógica de procesamiento central es esta parte:

   v
   v


@  =  !

Los bits de ambos bucles (uno desde el lado occidental y todo desde el lado este) se envían al sur hacia el interruptor =. El tiempo tiene que establecerse para que el bit del bucle occidental llegue primero. Si es a 1, el conmutador cambia a }, enviando los siguientes bits hacia el este en el sumidero !para su salida. Una vez que todos los 1s se han ido, obtenemos el 0, que cambia el interruptor a {. Esto envía los siguientes bits al @, que termina el programa. En resumen, sacamos la magnitud (unaria) del segundo número tantas veces como haya 1s en la magnitud (unaria) del primer número.

Python 3 , 11 bytes

int.__mul__

Pruébalo en línea!

También funciona para enteros 2**32en Python 2.

Java 8, 10 9 bytes

a->b->a*b

Pruébalo aquí

Java 7, 31 bytes

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

Pruébalo aquí

Como programa completo ( 99 90 bytes) :

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

Pruébalo aquí

Pyth, 2 bytes

*E

Pruébalo aquí!

La evaluación automática de Pyth se interpone aquí. Para evitarlo, estoy usando una evaluación explícita para uno de los argumentos

TI-Basic, 2 bytes

Muy sencillo

prod(Ans

PHP, 21 bytes

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

toma datos de los argumentos de la línea de comandos. También funciona con carrozas.

Retina , 39 35 bytes

Gracias a Leo por dejarme usar una idea suya que terminó ahorrando 4 bytes.

[^-]

*\)`--

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

La entrada está separada por salto de línea.

Pruébalo en línea! (Conjunto de pruebas separadas por espacios para mayor comodidad).

Explicación

Las dos primeras etapas imprimen un signo menos si exactamente una de las dos entradas es negativa. Lo hacen sin cambiar realmente la entrada. Esto se hace agrupándolos en la segunda etapa con )y convirtiéndolos en una ejecución en seco con *. La \opción en la segunda etapa evita la impresión de un salto de línea final.

[^-]

Primero, eliminamos todo excepto los signos menos.

*\)`--

Luego cancelamos los signos menos si quedan dos de ellos.

.+
$*

Ahora convertimos cada línea a la representación unaria de su valor absoluto. Esto eliminará el signo menos porque $*solo busca el primer número no negativo en la coincidencia (es decir, no conoce los signos menos y los ignora).

\G1
_

La primera línea se convierte en _, haciendo coincidir los 1s individuales siempre que sean adyacentes a la coincidencia anterior (por lo tanto, no podemos hacer coincidir los 1s en la segunda línea, porque el salto de línea rompe esta cadena).

_|1+
$'

Esto realiza la multiplicación real. Reemplazamos cada uno _(en la primera línea), así como toda la segunda línea, todo después ese partido. Por _lo tanto, las coincidencias incluirán toda la segunda línea (multiplicándola por el número de 0s en la primera línea), y la segunda línea se eliminará porque no hay nada después de esa coincidencia. Por supuesto, el resultado también incluirá algo de basura en forma de _s y avances de línea, pero eso no importará.

1

Terminamos simplemente contando el número de 1s en el resultado.

MATLAB, 5 4 bytes

@dot

dottoma el producto escalar de dos vectores de igual longitud. Si lo alimentamos con dos escalares, simplemente multiplicará los dos números.

prodtoma el producto de los valores en todas las filas de cada columna de una matriz. Si la matriz es unidimensional (es decir, un vector), entonces actúa a lo largo de la dimensión no singleton, tomando el producto de todos los elementos en el vector.

dotes un byte más corto que el prodque es un byte más corto que el incorporado aún más obvio times.

Llámalo como tal:

@dot
ans(3,4)
ans = 
   12

PigeonScript , 1 byte

*

Explicación:
*mira a la pila para ver si hay algo allí. Si no, solicita entradas y multiplica las entradas juntas

Perl 6 , 4 bytes

&[*]

Este es solo el operador de multiplicación infijo ordinario *, expresado como una función ordinaria. Como beneficio adicional, si se le da un número, devuelve ese número, y si no se le da ningún número, devuelve 1la identidad multiplicativa.

> <>, 5 bytes

i|;n*

Toma la entrada como un carácter ascii, emite un número.

Explicación:

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

También podrías hacer

ii*n;

Pero siento que mi solución es muuuy más fresca.

Otra posibilidad es soltar el punto y coma, lo que daría como resultado que el puntero rebote en el espejo, presione el comando de impresión y arroje un error ya que la pila está vacía.

Código de máquina Intel 8080 , MITS Altair 8800 , 28 bytes

Esto implementa la multiplicación binaria en la CPU Intel 8080 (c. 1974) que no tenía instrucciones de multiplicación o división. Las entradas son valores de 8 bits y el producto es un valor de 16 bits devuelto enBC par de registros.

Aquí está el código de la máquina junto con las instrucciones paso a paso para cargar el programa en un Altair 8800 usando los interruptores del panel frontal.

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

Pruébalo en línea!

Si ha ingresado todo correctamente, en el cajón de estado de la máquina en el simulador, su contenido de RAM se verá así:

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

Entrada

Multiplicador en Cregistro y multiplicando en D. El stock de Altair no tiene STDINentrada, por lo que solo se realiza mediante interruptores del panel frontal.

Salida

El resultado se muestra en las luces D7- D0(fila superior derecha) en binario.

5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

Nota de compatibilidad: esto también debería ejecutarse en el IMSAI 8080 , aunque actualmente no se ha probado.

C #, 10 bytes

a=>b=>a*b;

Es solo una simple multiplicación.

Gelatina , 1 byte

×

Pruébalo en línea!

Presentación obligatoria de gelatina.

Clojure, 1 byte

*

: P Como beneficio adicional, esto funciona en cualquier número de argumentos:

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

Curiosamente, puede obtener fácilmente su código fuente:

(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

Esto se puede asignar a una función como esta:

multiply:λx.λy.x*y

y llamado así:

result<multiply(a,b)