n = [2,3,1,5,4]
for i in range(len(n)):
    min_idx = i
    for j in range(i+1, len(n)):
        if n[i]>n[j]:
            min_idx = j
    if min_idx != i:
        n[i], n[min_idx] = n[min_idx], n[i]

print('제일 큰 값은', n[-1], '입니다.')  
print('제일 작은 값은', n[0], '입니다.')    
print('중간값은', n[int(len(n)/2)], '입니다.')    

초보라...선택정렬을 이용하였고 중간값은 리스트내 원소수가 짝수인경우 애매하지만 n/2한 값으로 했습니다.... 파이썬 고수님이 나타나 더 깔끔하게 정리해주시리라 초보는 믿고 기다립니다 ^^;;

int[] arr = new int[5];

        for(int i=0;i<5;i++) {
            arr[i] = (int)(Math.random()*100+1);

            for(int k=0;k<i;k++) {
                if(arr[i] == arr[k]) {
                    i--; 
                    break;
                }
            }
        }//for

        Arrays.sort(arr);

        for(int n : arr) {
            System.out.print(n+" ");
        }

        System.out.println("\n가장 큰 수는 "+arr[4]+"입니다.");
        System.out.println("가장 작은 수는 "+arr[0]+"입니다.");
        System.out.println("중간값은 "+arr[2]+"입니다.");

java로 작성, 배열에 들어가는 수는 랜덤으로 했습니다. 초보학생이 작성했으니 너그럽게 봐주세요

Arrays.sort(array);
System.out.println("max: "+array[array.length-1]);
System.out.println("min: "+array[0]);
System.out.println("middle: "+array[array.length/2]);

[Go] for문과 if,else문만 사용해서 제일 큰값, 제일 작은값, 중간값

package main

import (
    "fmt"
)

func main() {
    array := []int{7, 2, 10, 0, 1}
    max := array[0]
    min := array[0]
    mid := array[0]

    for i := 0; i < len(array); i++ {
        for j := 0; j < i; j++ {
            if array[i] < array[j] {
                array[i], array[j] = array[j], array[i]
            }
        }
    }
    max = array[len(array)-1]
    min = array[0]
    mid = array[len(array)/2]

    fmt.Println(array)
    fmt.Println("제일 큰 값은", max, "입니다.")
    fmt.Println("제일 작은 값은", min, "입니다.")
    fmt.Println("중간값은", mid, "입니다.")
}

public class NumEx1 {

public static void main(String [] args ) {
    int max =0;
    int min =0;
    int aver=0;
    int temp=0;
    int i=0;
    int j=0;
    int[] arry= {2,1,5,3,4};

    for ( i=0;i<arry.length-1;i++) {
   min=arry[i];
      max=arry[i+1];  
      if (min<max) {

      }
      else {
        temp = min;
            min  = max;
            max=temp;
        arry[i] =min;
        arry[i+1]= max;

      }//else
    }//for
    System.out.println("최소값은:"+arry[0]);
    System.out.println("최대값은:"+arry[4]);
    System.out.println("중간값은:"+arry[2]);

}//main

}//class

//자바로 했습니다

C입니다.

#include <stdio.h>
#include <math.h>

int main() {
        int array[] = {1,2,3,4,5};
        //int array[] = {3,4,5,1,2};
        //int array[] = {3,5,4,1,2,6};
        //int array[] = {1,4,1,2,6,7};

        int n = sizeof(array) / sizeof(int);
        int tmp;

        for(int i=0; i < n - 1; i++){
                for(int j=0; j < n - 1 - i; j++) {
                        if (array[j] > array[j + 1]) {
                                tmp = array[j];
                                array[j] = array[j + 1];
                                array[j + 1] = tmp;
                        }
                }
        }

        printf("정렬한 배열: ");
        for (int k=0; k < n; k++) {
                printf("%d ", array[k]);
        }
        printf("\n");

        printf("제일 큰 값은 %d 입니다.\n", array[n - 1]);
        printf("제일 작은 값은 %d입니다.\n", array[0]);

        if(n % 2 == 1) {
                printf("중간값은 %d입니다.\n", array[(n / 2)]);
        } else {
                float median;
                median = (array[n / 2 - 1] + array[n / 2]) * 1.0 / 2.0;
                if(floor(median) == median) {
                        printf("중간값은 %d입니다~\n", (int)median);
                } else {
                        printf("중간값은 %.1f입니다!\n", median);
                }
        }
}

def find_min_max_mid(lst):
    lst.sort()
    mid = (len(lst) -1) / 2
    a = lst[0], lst[-1], lst[int(mid)]
    return a

array = [1,2,3,4,5]

for i in array:
    if i == max(array):
        print("제일 큰 값은 %s입니다." % i)

for i in array:
    if i == min(array):
        print("제일 작은 값은 %s입니다." % i)

for arr in array:
    if i == int(sum(array)/len(array)):
        print("중간 값은 %s입니다." % i)

# max와 min method를 사용하지 않는 버젼

array = [1,2,3,4,5]

maxValue = array[0]
for i in range(1, len(array)):
    if maxValue < array[i]:
        maxValue = array[i]

minValue = array[0]
for i in range(1, len(array)):
    if minValue > array[i]:
        minValue = array[i]

midValue = int(sum(array)/len(array))

print("제일 큰 값은 %s입니다." % maxValue)
print("제일 작은 값은 %s입니다." % minValue)
print("중간 값은 %s입니다." % midValue)

N = list(map(int,input().split()))
print("Max:",max(N))
print("Min:",min(N))
print("Middle:",N[int((len(N)-1)/2)] if len(N) % 2 == 1 else (N[int((len(N)/2)-1)] + N[int(len(N)/2)])/2)

#원소 갯수가 홀수일때와 짝수일때를 다 처리할수 있게 만들었습니다
#이렇게 하면 될지 모르겠네요

def func(a):

    print (a)

    for i in range (len(a)-1):
        for j in range (len(a)-1):
            if a[j]>a[j+1]:
                temp=a[j]
                a[j]=a[j+1]
                a[j+1]=temp

    print ('최소값 : %d' %a[0])
    print ('최대값 : %d' %a[len(a)-1])
    if len(a)%2==1:
        print ('중간값 : %d' %a[int(len(a)/2)])
    else:
        print ('중간값 : %d %d' %(a[int(len(a)/2)-1],a[int(len(a)/2)]))


func([3,4,5,1,2])

func([3,4,5,1,2,9])

list1 = [56, 3, 78, 6, 4]


for i in range(len(list1)):
    min_val = min(list1[i:])
    min_inx = list1.index(min_val)
    list1[i], list1[min_inx] = list1[min_inx], list1[i]
print(f'최소값은 {list1[0]} 입니다.')
print(f'최대값은 {list1[-1]} 입니다.')

if (len(list1)) % 2 == 0:
    mid_inx = (len(list1)/2)
    mid_value = list1[int(mid_inx)]
    print(f'중간 값은 {mid_value} 입니다.')
else:
    mid_inx = int(len(list1)/2)
    mid_value = list1[int(mid_inx)]
    print(f'중간 값은 {mid_value} 입니다.')

import numpy as np

a_num = np.array([1,2,3,4,5])

np.max(a_num)
np.min(a_num)
np.min(a_num)
np.median(a_num)

print ("최소값 :" , np.min(a_num), " ",   "최대값 : ", np.max(a_num), " ", "중간값 :", np.median(a_num))

def maxminmiddle(x):

    def min(x):
        def mino(a,b):
            if a>=b:
                return b
            else:
                return a
        i=0
        x1=mino(x[0],x[1])
        while i<len(x):
            x1=mino(x1,x[i])
            i=i+1
        return x1

    def max(x):
        def maxo(a,b):
            if a>=b:
                return a
            else:
                return b
        i=0
        x1=maxo(x[0],x[1])
        while i<len(x):
            x1=maxo(x1,x[i])
            i=i+1

        return x1
    print("최댓값은 {0}입니다. \n최솟값은 {1}입니다.".format(max(x),min(x)))

    if len(x)%2==0:
        while len(x)>2:
            x.remove(max(x))
            x.remove(min(x))
        return "중간값은 {0} 아니면 {1}입니다.".format(x[0],x[1])
    else:
        while len(x)>2:
            x.remove(max(x))
            x.remove(min(x))
        return "중간값은 {0}입니다.".format(x[0])

print(maxminmiddle([1,2,3,4,5]))

# 입력 예시: 1,2,3,4,5 (띄어쓰기 없음)
array = input("배열에 들어갈 숫자를 입력하세요: ").split(',')

max_val = 0
min_val = 0
for i in range(len(array)):
    if array[i] == min(array):
        min_val = int(array[i])
    elif array[i] == max(array):
        max_val = int(array[i])

print(f"제일 큰 값은 {max_val}입니다.")
print(f"제일 작은 값은 {min_val}입니다.")

array.sort()
if len(array) % 2 == 0:
    mid1 = array[len(array)//2]
    mid2 = array[len(array)//2 + 1]
    print(f"중간값은 {mid1}와 {mid2}입니다.")
elif len(array) % 2 != 0:
    mid = array[len(array)//2]
    print(f"중간값은 {mid}입니다.")

• max, min 내장함수 없이 최대값/최소값 구하는 코드 추가하기
• 중간값을 구하기 위한 다른 방법은?

array = [1,2,3,4,5]
import statistics
print("제일 큰 값은 {0}입니다.\n 제일 작은 값은 {1}입니다.\n 중간값은 {2}입니다.".format(max(array),min(array),statistics.median(array)))

def max_min_median(array: list) -> tuple:
    """Calculate a max, a min, and a median
    using only if, for, else"""

    ordered_array = []

    if len(array) < 2:
        ordered_array = array
        median = ordered_array[0]
    else:
        # Sort an array
        for i, element in enumerate(array):

            if i == 0:
                ordered_array.append(element)
            else:
                idx = 0
                for j, new_element in enumerate(ordered_array):
                    if element >= new_element:
                        idx += 1
                    else:
                        idx = j
                        break

                ordered_array.insert(idx, element)

        print(ordered_array)
        length = len(ordered_array)
        median_index = int(length / 2)

        # Calculate a median
        if length % 2 == 0:
            median_1 = ordered_array[median_index - 1]
            median_2 = ordered_array[median_index]
            median = (median_1 + median_2) / 2
        else:
            median = ordered_array[median_index]

    # Calculate a max and a min
    maximum = ordered_array[-1]
    minimum = ordered_array[0]

    return maximum, minimum, median

import random

value = []
#리스트 갯수 정하기, 홀수로..
count = random.randint(1,10)
if count % 2 == 0:
    count += 1
else :
    pass

print("count : ", count)

#리스트 값 정하기
for n in range(count):
    value.append(random.randint(1,100)) 
print("최초 리스트 : ", value)

count = len(value)
for k in range(len(value)-1):# 비교 반복 횟수
   #옆 숫자와 비교 하여 sorting 하기
    for i in range(len(value)-1):
        if value[i] > value[i+1]:
            temp = value[i]
            value[i] = value[i+1]
            value[i+1] = temp
        else :
            continue
print("sorting value :", value)

# 해당 값 출력
min_value = value[0]
max_value = value[len(value)-1]
mean_value = value[int(len(value)/2)]

print("최소값 : ", min_value)
print("최대값 : ", max_value)
print("중간값 : ", mean_value)

_max=array[0] #가장 첫번쨰 값을 최대, 최소값이라고 가정하기 for i in array: if i>_max: _max=i print("가장 큰 값은 %d입니다."%_max)

_min=array[0] #가장 첫번쨰 값을 최대, 최소값이라고 가정하기 for i in array: if i<_min: _min=i print("가장 작은값은 %d입니다."%_min)

_mid=array[0] for i in array: if int(len(array)/2+1)>_mid: _mid=i print("중간값은 %d입니다."%_mid)

으아..........전 멍청인가 봐요 ㅋ

public class DojangEx2 {
    // working variable
    int size;
    // constructor
    public DojangEx2(int[] sampleData) {
        size = sampleData.length;
        recusiveSorting(sampleData);
        printResult(sampleData);
    }

    // sorting
    public int[] recusiveSorting(int[] sampleData) {
        for(int i=0; i<size; i++)
            for(int j=i; j<size; j++)
                if(sampleData[i]>sampleData[j])
                    swapData(i, j, sampleData);
        return sampleData;
    }
    private void swapData(int i, int j, int[] sampleData) {
        int temp = sampleData[i];
        sampleData[j] = sampleData[i];
        sampleData[i] = temp;
    }

    // print result
    public void printResult(int[] sampleData) {
         System.out.println("최대값: "+sampleData[size-1]);
         System.out.println("최소값: "+sampleData[0]);

         if(size%2==0)
             System.out.println("중간값: "+sampleData[size/2-1]+ ", "+sampleData[size/2]);
         else
             System.out.println("중간값: "+sampleData[size/2]);
    }

    public static void main(String[] args) {
        int[] sampleData = { 1, 2, 3, 4, 5, 6, 7, 8 };
        new DojangEx2(sampleData); // 생성자 호출
    }

}

파이썬 3.8.10으로 작성되었습니다.

import math
arr = [68, 24, 34, 2, 31, 39, 53, 3245, 5244, 534, 43, 34254]
num_data = len(arr)
temp = 0

for i in range(1, num_data):
    for j in range(num_data - i):
        if arr[j] > arr[j + 1]:
            arr[j], arr[j+1] = arr[j+1], arr[j]
print(arr)
print(f'제일 큰 값은 {arr[-1]}입니다.\n' + f'제일 작은 값은 {arr[0]}입니다.\n' +
      '중간값은 {0}입니다.'.format(arr[math.ceil(num_data/2)] if num_data % 2 == 1 else (arr[math.ceil(num_data/2)] + arr[math.ceil(num_data/2) - 1])/2))

귀찮아서 그냥 sort 씁니다

n = [2,3,1,5,4]
n.sort()
print("최대 : {}".format(n[len(n)-1]))
print("최소 : {}".format(n[0]))
print("중간 : {}".format(n[len(n)//2]))

C#

using System.Linq;

namespace 배열의최대값최소값중간값을출력해보기
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] inputArray = { 1, 2, 3, 4, 5 };
            var rst = GetAnswer(inputArray);
            System.Console.WriteLine($"min: {rst.Item1}\nmid: {rst.Item2}\nmax: {rst.Item3}");
        }

        static (int, int, int) GetAnswer(int[] anArray)
        {
            BubbleSort(anArray);
            int minVal = anArray[0];
            int maxVal = anArray.Last();
            int midVal = anArray[anArray.Length / 2];
            return (minVal, midVal, maxVal);
        }

        // for, if 문을 사용하여 배열 소트
        static void BubbleSort(int[] anArray)
        {
            int len = anArray.Length;
            for (int i = 0; i < len - 1; i++)
            {
                for (int j = 0; j < len - i - 1; j++)
                {
                    if (anArray[j] > anArray[j + 1])
                    {
                        int tmp = anArray[j];
                        anArray[j] = anArray[j + 1];
                        anArray[j + 1] = tmp;
                    }
                }
            }
        }

    }
}

numlist = [3,5,2,1,4]
numlist.sort() 
print("max = %d , min = %d , mid = %d" %(numlist[-1], numlist[0], numlist[(len(numlist)-1)//2]))

import numpy as np

array_size = np.random.randint(1,10)
rand_list = np.random.randint(1,100,size=array_size)
sorted_rand_list = np.sort(rand_list)
min_val = sorted_rand_list[0]
max_val = sorted_rand_list[-1]
med_pos = round(array_size/2)
med_val = sorted_rand_list[med_pos]

print("제시된 숫자형 배열: {}".format(rand_list))
print("최소값: {}\n최대값: {}\n중간값: {}".format(min_val,max_val,med_val))

array = [1,2,3,4,5]
a = array[0]
b = array[0]
count = 0
for i in array:
    count += 1
    if a < i:
        a = i
    elif b > i:
        b = i
c = round(count/2)
print("제일 큰 값은",a,"입니다")
print("제일 작은 값은",b,"입니다")
print("중간값은",array[c],"입니다")

l=[1,2,3,4,5]
max,min,med,val1,val2=l[0],l[0],l[0],0,0
for i in l:
    if i>max: max=i
    if i<min: min=i
    for j in l:
        if j>i: val1+=1
        elif j<i: val1-=1
    if val1<0: val1=-val1
    if val1<val2: med=i
    val2,val1=val1,0
print(f"제일 큰 값은 {max}입니다.\n\n제일 작은 값은 {min}입니다.\n\n중간값은 {med}입니다.")

아무 함수도 안 쓰고 for문이랑 if문만 써서 만드려니까 쉽지 않네요...

arr= [1,2,3,4,5]

def sort (arr):
    for i in range(len(arr)):
        for k in range(len(arr)-1):
            if arr[k]>arr[k+1]:
                temp=arr[k]
                arr[k]=arr[k+1]
                arr[k+1]=temp 
    return arr

sort_arr = sort(arr)

print('제일 큰 값은 %d 입니다.' % sort_arr[-1])
print('제일 작은 값은 %d 입니다.' % sort_arr[0])
print('중간값은 %d 입니다.' % sort_arr[len(sort_arr)//2])

// Rust

// 전체 정렬 없이 중간값을 찾을 수는 없으므로, 정렬(오름차순 또는 내림차순)되어 있다고 가정하면...

fn max_min_med() {

let input = [1, 2, 3, 4, 5];

let l = input.len();
let mut min = input[0];
let mut max = input[l-1];
if min > max {
    let t = min;
    min = max;
    max = t;
}
let med;
if l % 2 != 0 { med = input[l/2]; }
else { med = (input[l/2] + input[l/2-1]) / 2; }

println!("max: {}, min: {}, med: {}", max, min, med);

}

package org.javaturotials.ex;
import java.util.*;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Arrays.sort(arr);
        int min = arr[0];
        int max = arr[arr.length-1];
        int avg = arr[(arr.length-1)/2];
        System.out.println(min + " " + avg + " " + max);

            }
    }

def test(n):
    max = 0
    min = 0
    mid = 0
    for i in range(len(n)):
        if n[i] > n[max]:
            max = i
        elif n[i] < n[min]:
            min = i
        mid = n[max] // 2
    return n[max], n[min], n[mid]

print(test([1,2,3,4,5]))

arr = [1,2,3,4,5] arr = sorted(arr) print("제일 큰 값은 %d 입니다.", arr[4]) print("제일 작은 값은 %d 입니다.", arr[0]) print("중간값은 %d 입니다.", arr[2])

array = {1, 2, 3, 4, 5,1}
array=list(array)
array.sort()
print(array[0],array[len(array)//2], array[-1])
``````{.python}
array = {1, 2, 3, 4, 5,1}
array=list(array)
array.sort()
print(array[0],array[len(array)//2], array[-1])

자바로 풀어 봤습니다. 임의의 N개의 숫자를 입력 받은 뒤, 최대, 최소, 중간 값을 출력합니다.

import java.util.Scanner;
import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<Integer> numbers = new ArrayList<>();
        String inputData;
        int max, storage = 0;

        while(true) {
            System.out.println("숫자 입력하시오: (그만 입력하고 싶으면 !를 입력하시오.)");
            inputData = scan.next();

            if(inputData.equals("!")) {
                break;
            }else {
                numbers.add(Integer.parseInt(inputData));
            }
        }

        for(int i=0; i<numbers.size(); i++) {
            max = numbers.get(i);

            for(int j=i+1; j<numbers.size(); j++) {
                if(numbers.get(j)>max) {
                    storage = j;
                    max = numbers.get(j);
                }               
            }

            numbers.set(storage, numbers.get(i));
            numbers.set(i, max);
        }

        System.out.println("\n내림차순 정리 결과는 다음과 같다.\n"+numbers);
        System.out.printf("제일 큰 값은 %d입니다.\n", numbers.get(0));
        System.out.printf("제일 작은 값은 %d입니다.\n", numbers.get(numbers.size()-1));

        int mid = numbers.size()/2;

        if(numbers.size()%2==1) {
            System.out.printf("중간 값은 %d입니다.\n", numbers.get(mid));
        }else {
            System.out.printf("중간 값은 %d or %d입니다.\n", numbers.get(mid-1), numbers.get(mid));
        }
    }
}

public static void main(String[] args) {
        HashSet<Integer> hs = new HashSet<>();

        while (true) {
            int num = (int) (Math.random() * 50) + 1;
            hs.add(num);
            if (hs.size() == 5)
                break;
        }

        int[] array = new int[hs.size()];
        int z = 0;
        for (Integer arr : hs) {
            array[z] = arr;
            z++;
        }
        int max = 0;
        int min = 100;
        int mid = 0;

        for (int j = 0; j < array.length; j++) {
            if (array[j] > max)
                max = array[j];
            if (array[j] < min)
                min = array[j];
        }
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[i];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
        System.out.println(hs);
        System.out.println(max);
        System.out.println(min);
        System.out.println(array[2]);
    }
}

array=[1,2,3,4,5]
minArray=array[0]
maxArray=array[0]
meanArray=0
sumNum=0
count=0
for i in array:
    if i<=minArray:
        minArray=i

for i in array:
    if i>=maxArray:
        maxArray=i

for i in array:
    count+=1
    sumNum+=i

meanArray=sumNum/count

print(minArray,maxArray,meanArray)

import random

array = []
max_len = 11

while(1):
    ran_num = random.randrange(0, 30)
    if ran_num not in array:
        array.append(ran_num)

    if len(array) == max_len:
        break

array.sort()
print(array)

mid = array.pop(int(len(array)/2))
big = array.pop()
small = array.pop(0)

print(big)
print(mid)
print(small)

array = [2, 5, 4, 1, 3]
N = len(array)
isDone = False

while not isDone:
    isDone = True
    for j in range(N - 1):
        if array[j] > array[j + 1]:
            array[j], array[j + 1] = array[j + 1], array[j]
            isDone = False

print('제일 큰 값은 {0} 입니다.'.format(array[-1]))
print('제일 작은 값은 {0}입니다.'.format(array[0]))
print('중간값은 {0}입니다.'.format(array[N // 2]))

ex_int = [1,2,3,4,5]
x = 0
maximum = ex_int[0]
minimum = ex_int[0]
median = ex_int[0]
for i in range(len(ex_int)):
   if maximum < ex_int[i]:
      maximum = ex_int[i]
   else:
      minimum > ex_int[i]
      minimum = ex_int[i]
print("MAX:",maximum)
print("MIN:",minimum)

x = float(len(ex_int)%2

if x == 0:
   a = int(len(ex_int)/2)
   b = a +1
   avt = (ex_int[a] + ex_int[b])/2
   print("Median:",avg)
else:
   median = ex_int[len(ex_int)//2]
   print("Median:",median)