java - usar - multiplicar sumando

Multiplicando un número sin usar el operador*

Question

Estaba pasando por una clase de programación y se me hizo esta pregunta difícil que quedó sin respuesta hasta el final de la clase.

Pregunta :

¿Cómo puedo multiplicar cualquier entrada (Float, int, etc.) por 7, without using the operador * en TWO steps ?

Si alguien me puede dar la respuesta a esta pregunta con la explicación, sería muy útil.

Con DOS PASOS me refiero a suponer que está ejecutando un bucle (i = 0; i <7; i ++) en ese caso, el número de pasos será> 2, también TIPO DE CONVERSIÓN, DIVISIÓN, ADICIÓN, etc. (Cuenta para pasos).

Answer 1

Añadir 7 por x veces.

for(int i=0; i<10; i++)
    result = result+7;

Answer 2

Definir "dos pasos" ...

float result = 0.0f;
float input = 3.14f;
int times = 7;

// steps

while (times--)
    result += input;

Edición : dividir por (1/7) no funcionará con el tipo int . También en algunos idiomas para que funcione con el tipo flotante, deberías marcarlos como flotantes:

result = input / (1.0f / 7.0f);

Answer 3

En C, el siguiente truco debería funcionar para flotadores almacenados en formato de punto flotante de precisión simple IEEE :

#include <stdint.h>

float mul7 (float x) {
    union {
        float f;
        uint32_t i;
    } u;
    u.f = x;
    u.i += (3 << 23);  /* increment exponent by 3 <=> multiply by 8 */
    return u.f - x;    /* 8*x - x == 7*x */
}

Son dos pasos (una suma de enteros, una resta flotante), más o menos, dependiendo de lo que cuentes como un paso. Dado que C ++ es más o menos compatible con versiones anteriores de C, creo que un truco similar debería ser posible allí también.

Sin embargo, tenga en cuenta que este truco generalmente no dará resultados correctos para entradas subnormal , infinitas o NaN, ni para entradas tan grandes en magnitud que multiplicarlas por 8 se desbordaría.

Ajustar el código para usar dobles en lugar de flotar se deja como un ejercicio para el lector. (Pista: el número mágico es 52.)

Answer 4

Podrías simplemente usar la división por un séptimo:

x / (1.0 / 7)

Si esto cuenta como "dos pasos" depende completamente de su definición.

Answer 5

Suponiendo que float x o double x está definido en el alcance. Luego veo las siguientes posibilidades para multiplicarlo por 7 sin usar el operador * :

En C ++, puede usar los funtores estándar (primer paso: crear un funtor, segundo paso: llamar al funtor):

x = std::multiplies<float>()(x, 7.0f);  // if x is a float
x = std::multiplies<double>()(x, 7.0);  // if x is a double

O solo use división (ya que el compilador ya evalúa 1.0 / 7.0 , esto es solo un paso):

x = x / (1.0f / 7.0f);  // if x is a float
x = x / (1.0  / 7.0);   // if x is a double

O use el operador *= (técnicamente, no es el operador * , pero es solo un paso):

x *= 7.0f;  // if x is a float
x *= 7.0;   // if x is a double

O use la suma en la escala logarítmica (esto no debe tomarse muy en serio, ya que requiere más de dos "pasos"):

x = exp(log(x) + log(7.0));

Otra opción es usar una instrucción de ensamblaje, pero no quiero escribir eso ahora, ya que es demasiado complicado.

Si x es un entero, el desplazamiento de bits es otra opción, pero no se recomienda :

x = (x << 3) - x;   // (x * 8) - x

Answer 6

También puedes hacer lo siguiente para los enteros:

( x<< 3) - x

Answer 7

agregarlo

//initialise s as the number to be multiplied
 sum=0
for(i=0;i<7;i++)
    sum+=s

Answer 8

// String num = "10";
// int num = 10;
float num = 10;

BigDecimal bigD = new BigDecimal(num);
BigDecimal seven = new BigDecimal(7);
System.out.println(seven.multiply(bigD));

Podrías usar el BigDecimal y su método de multiply . Funciona para casi todo.