2. 평균 구하기

https://programmers.co.kr/learn/courses/30/lessons/12944

코딩테스트 연습 - 평균 구하기

 

파이썬

for를 이용한 가장 흔한 풀이입니다. 

def solution(arr):
    total, count = 0, 0
    for i in arr:
        total += i
        count += 1
    return total / count

테스트 1 〉	통과 (0.04ms, 10.8MB)
테스트 2 〉	통과 (0.04ms, 10.7MB)
테스트 3 〉	통과 (0.04ms, 10.6MB)
테스트 4 〉	통과 (0.07ms, 10.7MB)
테스트 5 〉	통과 (0.04ms, 10.7MB)
테스트 6 〉	통과 (0.04ms, 10.7MB)
테스트 7 〉	통과 (0.04ms, 10.6MB)
테스트 8 〉	통과 (0.04ms, 10.7MB)
테스트 9 〉	통과 (0.04ms, 10.7MB)
테스트 10 〉	통과 (0.04ms, 10.7MB)
테스트 11 〉	통과 (0.04ms, 10.8MB)
테스트 12 〉	통과 (0.04ms, 10.8MB)
테스트 13 〉	통과 (0.04ms, 10.8MB)
테스트 14 〉	통과 (0.04ms, 10.7MB)
테스트 15 〉	통과 (0.04ms, 10.7MB)
테스트 16 〉	통과 (0.04ms, 10.7MB)

파이썬의 변수 스코프를 사용한 코드입니다.

for문 외(리턴)에서 i 변수를 보니 이상합니다.
좋은 코드는 아닌 것 같습니다.

def solution(arr):
    total = 0
    for i in range(len(arr)):
        total += arr[i]
    return total / (i + 1)

enumerate를 써보면 나름 깔끔해집니다. 

def solution(arr):
    total = 0
    for index, value in enumerate(arr):
        total += value
    return total / (index + 1)

내장 함수를 이용하면 더 짧고 가독성 좋고 빠른 코드를 만들 수 있습니다. 

def solution(arr):
    return sum(arr)/len(arr)

테스트 1 〉	통과 (0.04ms, 10.7MB)
테스트 2 〉	통과 (0.04ms, 10.7MB)
테스트 3 〉	통과 (0.04ms, 10.7MB)
테스트 4 〉	통과 (0.04ms, 10.8MB)
테스트 5 〉	통과 (0.03ms, 10.7MB)
테스트 6 〉	통과 (0.05ms, 10.8MB)
테스트 7 〉	통과 (0.03ms, 10.7MB)
테스트 8 〉	통과 (0.04ms, 10.7MB)
테스트 9 〉	통과 (0.04ms, 10.6MB)
테스트 10 〉	통과 (0.03ms, 10.7MB)
테스트 11 〉	통과 (0.04ms, 10.7MB)
테스트 12 〉	통과 (0.04ms, 10.7MB)
테스트 13 〉	통과 (0.04ms, 10.7MB)
테스트 14 〉	통과 (0.04ms, 10.8MB)
테스트 15 〉	통과 (0.03ms, 10.7MB)
테스트 16 〉	통과 (0.04ms, 10.6MB)

자바스크립트

함수형으로 풀어보았습니다.

function solution(arr) {
    return arr.reduce((prev, curr)=>prev+curr)/arr.length;
}

자바

class Solution {
  public double solution(int[] arr) {
      double answer = 0;
      for(int each:arr){
          answer += each;
      }
      return answer / arr.length;
  }
}

import java.util.Arrays;

class Solution {
    public double solution(int[] arr) {
        return Arrays.stream(arr).reduce(0, (a, b) -> a + b) / (double) arr.length;
    }
}

고

i 변수를 for 문 밖으로 빼낼 수도 있습니다. 

흔한 형태가 아니라 가독성이 좋지 않습니다. 

func solution(arr []int) float64 {
    var sum, i int
    for ; i < len(arr); i++ { 
        sum += arr[i] 
    } 
    return float64(sum) / float64(i) 
}

for range로 작성해 봅니다. 
깔끔(?)하네요. 

func solution(arr []int) float64 {
	var count, num, sum int
	for count, num = range arr {
		sum += num
	}
	return float64(sum) / float64(count+1)
}

일반적으로... 

func solution(arr []int) float64 {
	sum := 0
	for _, v := range arr {
		sum += v
	}
	return float64(sum) / float64(len(arr))
}

 

코틀린

class Solution { 
    fun solution(arr: IntArray): Double { 
        var sum = 0 
        for (num in arr){ 
            sum += num 
        } 
        return sum / arr.size.toDouble()
    } 
}

함수형

class Solution {
    fun solution(arr: IntArray) = arr.asSequence().reduce { a, b -> a + b } / arr.size.toDouble()
}

내장함수

class Solution {
    fun solution(arr: IntArray) = arr.average()
}

C#

public class Solution
{
    public double solution(int[] arr)
    {
        double sum = 0;
        foreach (int num in arr)
        {
            sum += num;
        }
        return sum / arr.Length;
    }
}

using System.Linq;

public class Solution
{
    public double solution(int[] arr)
    {
        return arr.Average();
    }
}

using System.Linq;

public class Solution
{
    public double solution(int[] arr) => arr.Average();
}

DART

double solution(arr) {
  int sum = 0;
  for (int each in arr) {
    sum += each;
  }
  return sum / arr.length;
}

SWIFT

func solution(_ arr:[Int]) -> Double {
    return Double(arr.reduce(0){$0 + $1}) / Double(arr.count)
}

RUST

fn solution(nums: Vec<i32>) -> f64 {
    let mut s = 0;
    for num in &nums {
        s = s + num;
    }
    s as f64 / nums.len() as f64
}

fn main() {
    assert_eq!(solution(vec![1, 2, 3, 4, 5]), 3.0);
    println!("{}", solution(vec![1, 2, 3, 4, 5]));
}

fn solution(nums: Vec<i32>) -> f64 {
    let s: i32 = nums.iter().sum();
    s as f64 / nums.len() as f64
}

fn solution(nums: Vec<i32>) -> f64 {
    nums.iter().sum::<i32>() as f64 / nums.len() as f64
}