Cómo escribir un programa para encontrar el mayor número entre cuatro números, sin usar sentencias if y variables de tipo de matriz

No hay matrices, por lo que solo usaremos 4 variables separadas para mantener nuestros 4 números.

No se pueden usar declaraciones if, por lo que usaremos declaraciones ternarias. (Esencialmente, declaraciones if-else, pero no uso de la palabra clave ‘if’, por lo que asumiré que es válida y seguiré adelante)

Para simplificar, usaremos 2 declaraciones ternarias para encontrar el máximo, pero todo podría ser una gran declaración ternaria anidada.

Código:

#include
int main ()
{
int a = 1, b = 6, c = 3, d = 4;
int max;
// Encuentra el mayor número en a o b.
max = (a> b? a: b);
/ * Encuentra el mayor número en cyd, y compáralo con el anterior
encontrado máximo en ay b. * /
max = (c> d? (c> max? c: max): (d> max? d: max));
printf (“Máx .:% d \ n”, máx.);
devuelve 0;
}

Así es como funciona una declaración ternaria, en caso de que el lector no se dé cuenta:

condición? si la condición es verdadera: si la condición es falsa;

Por eso cuando escribo,

max = a> b? a: b;

es equivalente a:

si (a> b)
{
max = a;
}
más
{
max = b;
}

Entonces nuestras dos declaraciones ternarias son equivalentes a esto:

si (a> b)
{
max = a;
}
más
{
max = b;
}
si (c> d)
{
si (c> max)
{
max = c;
}
}
más
{
si (d> max)
{
max = d;
}
}

Aquí hay una implementación en C:

// … Códigos
int max4 (int a, int b, int c, int d) {
int e = a> b? a: b;
int f = c> d? discos compactos;
volver e> f? e: f;
}
// … Códigos

Creo que podemos inspirarnos en los diseños digitales y evitar el uso de cualquiera de las construcciones condicionales como operador ternario o declaración de cambio.

  • Solo una de las siguientes expresiones puede devolver True o 1. Rest devolverá False o 0.
  • (a> = b) (a> = c) (a> = d), cuando el valor de a es el más alto de todos.
  • (b> a) (b> = c) (b> = d), cuando el valor de b es el más alto de todos, con la condición de que sea estrictamente mayor que a .
  • (c> a) (c> b) (c> = d), cuando el valor de c es el más alto de todos, con la condición de que sea estrictamente mayor que a y b.
  • (d> a) (d> b) (d> c), cuando el valor de d es estrictamente mayor que el resto.
  • Por lo tanto, la siguiente función de c ++ dará el valor del número máximo entre los cuatro enteros:
  • int get_max (int a, int b, int c, int d) {
    devuelve a * (a> = b) * (a> = c) * (a> = d) +
    b * (b> a) * (b> = c) * (b> = d) +
    c * (c> a) * (c> b) * (c> = d) +
    d * (d> a) * (d> b) * (d> c);
    }

    Hay una manera señalada por Mukesh Kumar

    #include
    #include
    int main ()
    {
    int a, b, c, d, mayor;

    // Obteniendo los números
    printf (“Ingrese los números de los cuales tiene que encontrar el mayor \ n”);
    scanf (“% d% d% d% d”, & a, & b, & c, & d);

    // Cálculo real
    mayor = (a> b)? (a> c)? (a> d)? a: d: (c> d)? c: d: (b> c)? (b> d)? b: d: (c> d)? c: d;
    printf (“El número más grande es% d”, el más grande);
    devuelve 0;
    }

    Otra forma es con la ayuda de la instrucción switch, pero tiene un inconveniente: que necesita especificar el límite superior de los números que va a ingresar. Aquí hay un código C

    #include
    #include
    #define MAX_LIMIT 10000
    int main ()
    {
    int a, b, c, d, mayor;

    // Obteniendo los números
    printf (“Ingrese los números de los cuales tiene que encontrar el mayor \ n”);
    scanf (“% d% d% d% d”, & a, & b, & c, & d);

    // Cálculo real
    para (int i = MAX_LIMIT; i> = – (MAX_LIMIT); i–)
    {
    interruptor (ai)
    {
    caso 0: printf (“% d es el número más grande \ n”, a);
    salida (-1);
    }
    interruptor (bi)
    {
    caso 0: printf (“% d es el número más grande \ n”, b);
    salida (-1);
    }
    interruptor (ci)
    {
    caso 0: printf (“% d es el número más grande \ n”, c);
    salida (-1);
    }
    interruptor (di)
    {
    caso 0: printf (“% d es el número más grande \ n”, d);
    salida (-1);
    }
    }
    devuelve 0;
    }

    Si encuentra un error en esto u obtiene una mejor manera, escríbalo en los comentarios.

    Al usar el operador ternario podemos implementarlo …

    incluir
    vacío principal()
    {
    int n1 = 8, n2 = 7, n3 = 9, n4 = 6;
    int t1, t2, mayor;

    t1 = (n1> n2? n1: n2);
    t2 = (n3> n4 \ theta n3: n4);
    mayor = (t1> t2? t1: t2);
    printf (“mayor =% d”, mayor);
    }

    Espero que funcione …

    La mejor manera (la más corta) de resolver esto es el uso del operador ternario.

    x = (a> b? a: b);

    y = (c> d? c: d);

    mayor = (x> y? x: y);

    Sin embargo, también puedes probar lo siguiente:

    int i = 0;

    mientras (i

    i ++;

    mientras que (i

    i ++;

    mientras (i

    i ++;

    mientras que (i

    i ++;

    volver i;

    Utilice el operador ternario, como se menciona a continuación:

    t1 = (n1> n2? n1: n2);

    t2 = (n3> n4 \ theta n3: n4);

    mayor = (t1> t2? t1: t2);

    volver más grande;

    La comparación realizada en los tres pasos anteriores se puede hacer en una sola declaración, pero eso depende de usted para probar \ U0001f600

    Espero que esto ayude ☺️