四个整数中的最大值和最小值（无数组、无函数、最少的'；if'；语句） 你看，我已经自学了C++（不完全是，我还在拖延——-）。所以，现在我开始上大学，他们教C，他们让我们做一个输入四个整数的程序，我们必须从中分辨出最大和最小的整数。简单，不是吗

问题是，我已经对函数和数组有了很好的理解。是的，我可以在数组中编程，没问题。但由于这是第一个实验室，我们还没有“了解”到这一点，所以我不能使用任何一个，这将非常简单

这就是我在那里写的（不知怎么的，感觉是错的）

#包括
内部主（空）
{
第一，第二，第三，第四；
printf（“输入四个整数（用空格分隔）：”；
scanf（“%d%d%d%d”&第一、第二、第三和第四）；
如果（（第一个>第二个）&&（第一个>第三个）&&（第一个>第四个））
printf（“\n第一个数字最大”）；
否则，如果（（第二次>第一次）&&（第二次>第三次）&&（第二次>第四次））
printf（“\n第二个数字最大”）；
否则如果（（第三次>第二次）&&（第三次>第一次）&&（第三次>第四次））
printf（“\n第三个数字最大”）；
否则如果（（第四次>第二次）&&（第四次>第三次）&&（第四次>第一次））
printf（“\n第四个数字最大”）；
如果（（首先这太容易了，因为数字是a、b、c、d:

#define min(a,b)  ((a) < (b) ? (a) : (b))
#define max(a,b)  ((a) > (b) ? (a) : (b))
biggest  = max (max(a,b), max(c,d))
smallest = min (min(a,b), min(c,d))

定义最小值（a，b）（（a）<（b）？（a）：（b））
#定义最大值（a，b）（（a）>（b）？（a）：（b））
最大值=最大值（最大值（a，b），最大值（c，d））
最小值=最小值（最小值（a，b），最小值（c，d））

---

这里，没有if语句，没有函数（尽管后者是我所听过的最愚蠢和最有害于熟练者的要求）。

试试这样的方法

int main(void) {
    int a=-2,b=-3,c=-4,d=-5;
    int max=a,min=a;

    if(b>max){
        max=b;
    }else if(b<min){
        min=b;
    }
    if(c>max){
        max=c;
    }else if(c<min){
        min=c;
    }
    if(d>max){
        max=d;
    }else if(d<min){
        min=d;
    }
    printf("max: %d min : %d",max,min);
    return 0;
}

int main（无效）{
INTA=-2，b=-3，c=-4，d=-5；
int max=a，min=a；
如果（b>最大值）{
max=b；
}else if（bmax）{
max=c；
}否则如果（cmax）{
max=d；
}否则，如果（d做一个“手册”，或者仅仅是第二部分：

从概念上讲，合并排序的工作方式如下

将未排序的列表划分为n个子列表，每个子列表包含1个元素（1个元素的列表视为已排序）
重复合并子列表以生成新的子列表，直到只剩下1个子列表。这将是排序列表

代码：

inta=5，b=4，c=7，d=9；
int min_ab，min_cd，min；
min_ab=a

..对于max也是如此

如果愿意，您可以将三元运算符扩展为
If（a
（为了可读性，扩展到多行）

合并排序的复杂性为
O（n*log（n））
，因此如果
s（请参阅），您最多需要
O（n*log（n））
。根据维基百科，“……这些都是比较排序，因此在平均或最坏的情况下不能比O（n logn）更好”（），因此，我认为这在
if
s的最小数量方面应该不会太远。尽管您可以尝试查看手动执行其他算法之一是否会减少
if
s；-）.
课堂问题要求同时找出最大值和最小值，其关键在于教你从每次比较中提取最大有价值的信息

例如，如果您知道
a>b
是真的，那么通过单个比较，您应该意识到
a
不再是最小值的候选项，并且不应该再参与任何专门用于查找最小值的比较。同时，您应该意识到
b
不再是最小值的候选项最大。对于4个数字，两个测试
a>b
和
c>d
已经清楚地将数字分为两个独立的类：两个最大的候选者和两个最小的候选者。其余的很简单

换言之，整个想法是并行地找到极值，利用每次比较所提供的信息进一步完成找到最小值和最大值的任务

if (first > second) { 
  int t = first; first = second; second = t; 
}

if (third > fourth) { 
  int t = third; third = fourth; fourth = t; 
}

/* Now 'first' and 'third' are candidates for the smallest,
   while 'second' and 'fourth' are candidates for the largest */

int min = first < third ? first : third;
int max = second > fourth ? second : fourth;

如果（第一次>第二次）{
int t=第一；第一=第二；第二=t；
}
如果（第三个>第四个）{
int t=第三；第三=第四；第四=t；
}
/*现在“第一”和“第三”是最小的，
而"第二"和"第四"是最大的竞争对手*/
int min=第一个<第三个？第一个：第三个；
int max=秒>第四？秒：第四；

如您所见，这只需要四次比较就可以找到这两个数字

请注意，上面的代码给出了最小值和最大值，但它没有告诉您原始的“索引”提供每个值的数字。目前还不清楚它是否真的有必要。问题的文本没有说明这一点，而您提供的代码示例实现了它。在任何情况下，更新上述代码以使其“跟踪”并不困难这些数字的来源。
一个想法可能是计算前两个数字的最大值和最小值。然后，将其余数字成对比较。每对数字中较大的一个与当前最大值进行比较，每对数字中较小的一个与当前最小值进行比较。这样，每2个数字进行3次比较元素，这比Arpit的答案稍微有效（每个元素有2个比较）

代码：

#include <stdio.h>

int main(int argc, char **argv) {
    int a, b, c, d;
    printf("Enter four integers (separated by space): ");
    scanf("%d %d %d %d", &a, &b, &c, &d);

    int max, min;
    if (a > b) {
       max = a;
       min = b;
    }
    else {
       max = b;
       min = a;
    }

    if (c > d) {
       if (c > max) {
          max = c;
       }
       if (d < min) {
          min = d;
       }
    }
    else {
       if (d > max) {
          max = d;
       }
       if (c < min) {
          min = c;
       }
    }
    printf("max = %d, min = %d\n", max, min);
    return 0;
}

#包括
int main（int argc，字符**argv）{
INTA、b、c、d；
printf（“输入四个整数（用空格分隔）：”；
scanf（“%d%d%d%d”、&a、&b、&c、&d）；
int max，min；
如果（a>b）{
max=a；
min=b；
}
否则{
max=b；
min=a；
}
如果（c>d）{
如果（c>最大值）{
max=c；
}
如果（d最大值）{
max=d；
}
如果（cif (first > second) { 
  int t = first; first = second; second = t; 
}

if (third > fourth) { 
  int t = third; third = fourth; fourth = t; 
}

/* Now 'first' and 'third' are candidates for the smallest,
   while 'second' and 'fourth' are candidates for the largest */

int min = first < third ? first : third;
int max = second > fourth ? second : fourth;

#include <stdio.h>

int main(int argc, char **argv) {
    int a, b, c, d;
    printf("Enter four integers (separated by space): ");
    scanf("%d %d %d %d", &a, &b, &c, &d);

    int max, min;
    if (a > b) {
       max = a;
       min = b;
    }
    else {
       max = b;
       min = a;
    }

    if (c > d) {
       if (c > max) {
          max = c;
       }
       if (d < min) {
          min = d;
       }
    }
    else {
       if (d > max) {
          max = d;
       }
       if (c < min) {
          min = c;
       }
    }
    printf("max = %d, min = %d\n", max, min);
    return 0;
}

#include <stdio.h>

int main()
{
    int num, max, min;

    printf ("Enter four numbers: ");
    scanf ("%d", &num);
    max = min = num;

    for (int i = 0; i < 3; i++)
    { 
        scanf ("%d", &num);
        if (max < num)
            max = num;
        else if (min > num)
            min = num;
    }

    printf ("The smallest and largest of given four numbers are %d and %d respectively.\n", min,  max);
    return 0;
}

#include <stdio.h>
int main(){

  int num , max, min;

  printf("Enter four numbers: ");
  scanf("%d", &num);
  max = min = num;

  for(int i = 0; i < 3; i++)
  { 
    scanf("%d", &num);
    max = max * (1 - ( (max-num) >> 31) )
        + num *      ( (max-num) >> 31);
    min = min * (1 - ( (num-min) >> 31) )
        + num *      ( (num-min) >> 31);
  }

  printf("\n%d %d", max, min);
  return 0;
}

#include <stdio.h>


    int main() {
        int a, b, c, d, temp;
        printf("Enter four digits: ");
        scanf("%d %d %d %d", &a, &b, &c, &d);
        if ( a > b){
            temp = a; a = b ; b = temp;
        }
        if ( c > d){
            temp = c; c = d ; d = temp;
        }
        if ( b > d ){
            temp = b; b = d; d = temp;
        }
        if ( a > c){
            temp = a; a = c ; c = temp;
        }
        printf("Max %d\nMin %d\n", d, a);

        return 0;
    }

 Please have at the following    

 private int GetLargerValue(int num1, int num2, int num3, int num4)
            {
                int largeValue = 0;
                if (num1 > num2)
                {
                    if (num1 > num3)
                        largeValue = (num1 > num4) ? num1 : num4;
                    else
                        largeValue = (num3 > num4) ? num3 : num4;

                }
                else if (num2 > num3)
                    largeValue = (num2 > num4) ? num2 : num4;
                else
                    largeValue = (num3 > num4) ? num3 : num4;

                return largeValue;
            }

int max_of_four(int a, int b, int c, int d){
        int res=a;
        if(b/res)
            res=b;
        if(c/res)
            res=c;
        if(d/res)
            res=d;
        return res;
    }
int main() {
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    int ans = max_of_four(a, b, c, d);
    printf("%d", ans);

    return 0;
}

        // min = a b c d
        // max = a b c d
        if (a <= b)
        {
            // min = a c d
            // max = b c d
            if ( c <= d){
                // min = a c
                // max = b d
                min = a <= c ? a : c;
                max = b > d ? b : d;
            }else{
                // min = a d
                // max = b c
                min = a <= d ? a : d;
                max = b > c ? b : c;
            }
        }
        else
        {
            // min = b c d
            // max = a c d
            if ( c <= d){
                // min = b c
                // max = a d
                min = b < c ? b : c;
                max = a > d ? a : d;
            }else{
                // min = b d
                // max = a c
                min = b < d ? b : d;
                max = a > c ? a : c;
            }
        }

#include<stdio.h>
void main()
{
int a,b,c,d;
printf("Enter four numbers of your choice");
scanf("%d%d%d%d",&a,&b,&c,&d);
a>b&&a>c?a>d?printf("%d",a):printf("%d" ,d):(b>c&&b>d)?printf("%d",b):c>d?printf("%d", c):printf("%d",d);
}

int max(int a, int b) {
    return a > b ? a : b;    
}

int max_of_four(int a, int b, int c, int d) {
    return max(a, max(b, max(c, d)));
}

int main() {
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    int ans = max_of_four(a, b, c, d);
    printf("%d", ans);

    return 0;
}

#include <stdio.h>

int int_1, int_2, int_3, int_4;
int pair_1_largest = 0, pair_1_smallest = 0;
int pair_2_largest = 0, pair_2_smallest = 0;
int quartet_largest = 0, quartet_smallest = 0;

printf("Example: 15 38 8 21\n");

printf("\nEnter four integers: ");
scanf("%d %d %d %d", &int_1, &int_2, &int_3, &int_4);

if(int_1 > int_2)
{
    pair_1_largest = int_1;
    pair_1_smallest = int_2;
}
else
{
    pair_1_largest = int_2;
    pair_1_smallest = int_1;
}

if(int_3 > int_4)
{
    pair_2_largest = int_3;
    pair_2_smallest = int_4;
}
else
{
    pair_2_largest = int_4;
    pair_2_smallest = int_3;
}

if(pair_1_largest > pair_2_largest)
    quartet_largest = pair_1_largest;
else
    quartet_largest = pair_2_largest;

if(pair_1_smallest < pair_2_smallest)
    quartet_smallest = pair_1_smallest;
else
    quartet_smallest = pair_2_smallest;

printf("The largest number is: %d\n", quartet_largest);
printf("The smallest number is: %d\n", quartet_smallest);

return 0;

int max_of_four(int a,int b,int c,int d){
    int max=a;
    if(b>max) max=b;
    if(c>max) max=c;
    if(d>max) max=d;
    return max;
}

int max_of_four(int a, int b, int c, int d) {
    return ((a > b && a > c && a > d) ? a: ((b > c && b > d) ? b : (c > d ? c : d)));
}

int max,max1,max2,min,min1,min2;
max = (max1 = a>b?a:b)>(max2 = c>d?c:d)?max1:max2 ;
min = (min1 = a<b?a:b)<(min2 = c<d?c:d)?min1:min2 ;

#include <stdio.h>

int max_of_four(int a, int b, int c, int d){
    int mx_A_B = (a > b) * a + (a <= b) * b;
    int mx_C_D = (c > d) * c + (c <= d) * d;

    return (mx_A_B > mx_C_D) * mx_A_B + (mx_A_B <= mx_C_D) * mx_C_D;
}


int main() {
    int a, b, c, d;
    scanf("%d %d %d %d", &a, &b, &c, &d);
    int ans = max_of_four(a, b, c, d);
    printf("%d", ans);
    
    return 0;
}

#include <stdio.h>

int main(void)
{
  int i, j, k, l, t, max, min;

  printf("Enter four integers: ");
  scanf("%d%d%d%d", &i, &j, &k, &l);

  if (i < j) {
    t = i;
    i = j;
    j = t;
  }
  if (k < l) {
    t = k;
    k = l;
    l = t;
  }
  max = (i >= k) ? i : k;
  min = (j <= l) ? j : l;

  printf("Largest: %d\n", max);
  printf("Smallest: %d", min);

  return 0;
}