¿Por qué funciona Decimal.Divide (int, int), pero no (int / int)?

¿Por qué dividir dos números int de 32 bits como (int / int) me devuelve 0, pero si lo uso Decimal.Divide()obtengo la respuesta correcta? De ninguna manera soy un tío.

intes un tipo entero; dividir dos enteros realiza una división entera , es decir, la parte fraccionaria se trunca ya que no se puede almacenar en el tipo de resultado ( int¡ también !). Decimal, por el contrario, tiene una parte fraccionaria. Al invocar Decimal.Divide, sus intargumentos se convierten implícitamente en Decimals.

Puede imponer la división no entera en intargumentos al convertir explícitamente al menos uno de los argumentos a un tipo de punto flotante, por ejemplo:

int a = 42;
int b = 23;
double result = (double)a / b;

En el primer caso, está haciendo una división de enteros, por lo que el resultado se trunca (la parte decimal se corta) y se devuelve un entero.

En el segundo caso, los ints se convierten primero a decimales y el resultado es un decimal. Por lo tanto, no se truncan y obtiene el resultado correcto.

La siguiente línea:

int a = 1, b = 2;
object result = a / b;

... se realizará utilizando aritmética de enteros . Decimal.Dividepor otro lado, toma dos parámetros del tipo Decimal, por lo que la división se realizará en valores decimales en lugar de valores enteros. Eso es equivalente a esto:

int a = 1, b = 2;
object result = (Decimal)a / (Decimal)b;

Para examinar esto, puede agregar las siguientes líneas de código después de cada uno de los ejemplos anteriores:

Console.WriteLine(result.ToString());
Console.WriteLine(result.GetType().ToString());

La salida en el primer caso será

0
System.Int32

... y en el segundo caso:

0,5
System.Decimal

Creo que Decimal.Divide(decimal, decimal)implícitamente convierte sus 2 argumentos int a decimales antes de devolver un valor decimal (preciso) donde 4/5 se trata como una división de enteros y devuelve 0

Quieres lanzar los números:

doble c = (doble) a / (doble) b;

Nota: Si alguno de los argumentos en C # es un doble, se usa una división doble que da como resultado un doble. Entonces, lo siguiente también funcionaría:

doble c = (doble) a / b;

aquí hay un pequeño programa:

static void Main(string[] args)
        {
            int a=0, b = 0, c = 0;
            int n = Convert.ToInt16(Console.ReadLine());
            string[] arr_temp = Console.ReadLine().Split(' ');
            int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
            foreach (int i in arr)
            {
                if (i > 0) a++;
                else if (i < 0) b++;
                else c++;
            }
            Console.WriteLine("{0}", (double)a / n);
            Console.WriteLine("{0}", (double)b / n);
            Console.WriteLine("{0}", (double)c / n);
            Console.ReadKey();
        }

Si está buscando una respuesta 0 <a <1, int / int no será suficiente. int / int hace división de enteros. Intente convertir uno de los enteros en un doble dentro de la operación.

En mi caso, nada funcionó arriba.

lo que quiero hacer es dividir 278 entre 575 y multiplicar por 100 para encontrar el porcentaje.

double p = (double)((PeopleCount * 1.0 / AllPeopleCount * 1.0) * 100.0);

%: 48,3478260869565 -> 278/575 ---> 0%: 51,6521739130435 -> 297/575 ---> 0

si multiplico PeopleCount por 1.0 lo convierte en decimal y la división será 48.34 ... también multiplique por 100.0 no 100.

La respuesta marcada como tal está muy cerca, pero creo que vale la pena agregar que hay una diferencia entre usar doble y decimal.

No haría un mejor trabajo explicando los conceptos que Wikipedia, por lo que solo proporcionaré los consejos:

aritmética de coma flotante

tipo de datos decimal

En los sistemas financieros, a menudo es un requisito que podamos garantizar un cierto número de decimales (base 10) de precisión. Esto es generalmente imposible si los datos de entrada / fuente están en base-10 pero realizamos la aritmética en base-2 (porque el número de lugares decimales requeridos para la expansión decimal de un número depende de la base; un tercio toma infinitos decimales lugares para expresar en base-10 como 0.333333 ..., pero solo toma un decimal en base-3: 0.1).

Es más rápido trabajar con números de coma flotante (en términos de tiempo de CPU; en cuanto a programación, son igualmente simples) y se prefieren siempre que desee minimizar el error de redondeo (como en aplicaciones científicas).