n = int(input())
number_list = []
for _ in range(n):
k = int(input())
number_list.append(k)
f = {} #최빈값을 저장할 딕셔너리
for n in number_list:
if n in f: #키값이 이미 딕셔너리에 존재한다면, 기존에 있는 거에서 1증가
f[n] += 1
else:
f[n] = 1
max_count = max(f.values()) #가장 많이 나온 빈도수
modes = []
m_result = 0
for key, value in f.items():
if value == max_count:
modes.append(key)
if len(modes) == 1:
m_result = modes[0]
else:
modes.sort()
m_result = modes[1]
avg = round(sum(number_list) / len(number_list))
number_list.sort()
median = number_list[len(number_list) // 2]
number_range = max(number_list) - min(number_list)
print(avg)
print(median)
print(m_result)
print(number_range)
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 입력 개수
int n = sc.nextInt();
int[] num = new int[n];
// 배열에 숫자 입력
for (int i = 0; i < n; i++) {
num[i] = sc.nextInt();
}
// 정렬
Arrays.sort(num);
// 정렬된 배열 출력
for (int i : num) {
System.out.println(i);
}
}
}
n = int(input())
arrays = []
for _ in range(n):
x, y = map(int, input().split())
arrays.append((x, y))
arrays.sort(key=lambda p: (p[1], p[0]))
for x, y in arrays:
print(x, y)
Sort
sort의 기본 -> 오름차순 정렬
key는 정렬 기준을 반환하는 함수
lambda : 인수1, 인수2, ...: 반환값
key : [(3, 1), (2, 2), (1, 2), (2, 3), (1, 3)] -> 각각 생성된 key값에 의해서 오름차순으로 정렬되는 것
자바
e1[0] = 1, e2[0] = 2일 때:
e1[0] - e2[0]은 1 - 2 = -1
-1은 음수이므로, e1이 e2보다 작다고 판단하고, e1이 먼저 오도록 정렬
e1[0] = 2, e2[0] = 1일 때:
e1[0] - e2[0]은 2 - 1 = 1
1은 양수이므로, e1이 e2보다 크다고 판단하고, e2가 먼저 오도록 정렬
자바의 Arrays.sort() 구현 원리
기본적으로 오름차순 정렬을 할 때:
비교 함수가 -1을 반환하면 첫 번째 요소가 더 작은 것으로 간주되어 앞에 옴
비교 함수가 1을 반환하면 두 번째 요소가 더 작은 것으로 간주되어 앞에 옴
0을 반환하면 두 요소가 같으므로 순서를 그대로 유지
Comparator 인터페이스에서의 compare() 메서드는 두 객체를 비교한 후, -1, 0, 1 중 하나를 반환:
-1: 첫 번째 객체가 두 번째 객체보다 작다 (즉, 앞에 오게 됨)
1: 첫 번째 객체가 두 번째 객체보다 크다 (즉, 뒤에 오게 됨)
0: 두 객체가 같다 (순서를 변경하지 않음)
자바의 Arrays.sort()는 기본적으로 비교값이 음수일 때 첫 번째 값이 더 작은 것으로 간주하여 먼저 오게 하고, 양수일 때는 두 번째 값이 더 작은 것으로 간주하여 먼저 오게 함 -> 자바의 오름차순 정렬에 대한 표준적인 방식
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int[][] arr = new int[N][2];
// 점 좌표 입력 받기
for (int i = 0; i < N; i++) {
arr[i][0] = in.nextInt(); // x 좌표
arr[i][1] = in.nextInt(); // y 좌표
}
// 정렬: y 좌표가 같으면 x 좌표를 비교
Arrays.sort(arr, new Comparator<int[]>() {
@Override
public int compare(int[] e1, int[] e2) {
if (e1[1] == e2[1]) {
return e1[0] - e2[0]; // y 값이 같으면 x 값을 비교
} else {
return e1[1] - e2[1]; // y 값으로 오름차순 정렬
}
}
});
// 정렬된 점 출력
for (int i = 0; i < N; i++) {
System.out.println(arr[i][0] + " " + arr[i][1]);
}
}
}
람다로 변경시에 compare의 메서드를 오버라이딩 한 것이라는 걸 아는 이유
람다를 사용하면 객체를명시적으로 선언하지 않고도 인터페이스 메서드를 구현 가능 -> 람다는 익명 클래스처럼 동작
자바에서는 Comparator 인터페이스를 구현하는 람다 표현식이 필요할 때 자동으로 그 타입을 추론
즉, Comparator가 필요한 자리에 람다를 넣으면 자바 컴파일러가 이를 Comparator의 구현으로 자동 인식
그래서 처음에는 pop을 할 때 리스트를 순회해서 같은 수가 있는 경우를 체크 한 후, 음수가 루트보다 아래에 있다면 교환하는 방법으로 구현을 했다
def pop(self):
if len(self.heap) == 0:
return 0
if len(self.heap) == 1:
return self.heap.pop()
minimum = self.heap[0]
idx = 0
for h in self.heap:
if abs(h) == abs(minimum) and minimum > h:
self.heap[0], self.heap[idx] = self.heap[idx], self.heap[0]
minimum = self.heap[0]
break
idx += 1
self.heap[0] = self.heap.pop()
self.down(0)
return minimum
하지만 이렇게 하니 시간초과가 떴다 🫣(당연할 지도...)
gpt에게 물어보니 체크하는 경우를 삽입을 할 때 하는 경우로 바꾸라고 해서 수정 후에 시간초과가 뜨지 않게 되어서 해결!
class AbsoluteHeap:
def __init__(self):
self.heap = []
def push(self, value):
self.heap.append(value)
self.up_heap(len(self.heap) - 1)
def pop(self):
if len(self.heap) == 0:
return 0
if len(self.heap) == 1:
return self.heap.pop()
# 절댓값이 가장 작은 값을 반환
min_value = self.heap[0]
self.heap[0] = self.heap.pop() # 마지막 요소를 루트로 이동
self.down_heap(0)
return min_value
def up_heap(self, index):
parent = (index - 1) // 2
if index > 0 and self.compare(self.heap[index], self.heap[parent]):
self.heap[index], self.heap[parent] = self.heap[parent], self.heap[index]
self.up_heap(parent)
def down_heap(self, index):
left = 2 * index + 1
right = 2 * index + 2
smallest = index
if left < len(self.heap) and self.compare(self.heap[left], self.heap[smallest]):
smallest = left
if right < len(self.heap) and self.compare(self.heap[right], self.heap[smallest]):
smallest = right
if smallest != index:
self.heap[index], self.heap[smallest] = self.heap[smallest], self.heap[index]
self.down_heap(smallest)
def compare(self, left, smallest):
# 절댓값을 우선 비교, 같으면 실제 값 비교
if abs(left) == abs(smallest):
# 위 : -4, 왼쪽아래 : 4 라면 바꿀 필요가 없음 -> false
return left < smallest
return abs(left) < abs(smallest)
absolute_heap = AbsoluteHeap()
n = int(input())
input_list = []
for _ in range(n):
input_list.append(int(input()))
for i in input_list:
if i == 0:
print(absolute_heap.pop())
else:
absolute_heap.push(i)
class Solution {
public boolean solution(int x) {
boolean answer = false;
int firstNumber = x;
int numberSum = 0;
while (x > 0) {
numberSum += x % 10;
x = x / 10;
}
if(firstNumber % numberSum == 0){
answer = true;
}
return answer;
}
}
두 정수 사이의 합
class Solution {
public long solution(int a, int b) {
long answer = 0;
if (a > b){
int temp = a;
a = b;
b = temp;
}
for (int i = a; i <= b; i++){
answer += i;
}
return answer;
}
}
콜라츠 추측
class Solution {
public int solution(long num) {
int answer = 1;
if (num == 1) return 0;
for(; answer < 502; answer++){
if(num % 2 == 0){
num = num / 2;
} else {
num = num * 3 + 1;
}
if (num == 1){
break;
}
}
if (answer == 502){
return -1;
} else {
return answer;
}
}
}
서울에서 김서방 찾기
class Solution {
public String solution(String[] seoul) {
int idx = 0;
String answer = "";
for (String s : seoul){
if(s.equals("Kim")){
break;
}
idx++;
}
answer = "김서방은 " + idx + "에 있다";
return answer;
}
}
나누어 떨어지는 숫자 배열
import java.util.*;
class Solution {
public int[] solution(int[] arr, int divisor) {
ArrayList<Integer> arrList = new ArrayList<Integer>();
for (int a : arr){
if (a % divisor == 0){
arrList.add(a);
}
}
Collections.sort(arrList);
if(arrList.size() == 0){
int[] answer = {-1};
return answer;
}
int[] answer = new int[arrList.size()];
for (int i = 0; i < arrList.size(); i++){
answer[i] = arrList.get(i);
}
return answer;
}
}
class Solution {
public int solution(String s) {
int answer = Integer.parseInt(s);
return answer;
}
}
정수 제곱근 판별
class Solution {
public long solution(long n) {
long answer = 0;
for (long i = 1; i < 50000000; i++){
if (n / i == i && n % i == 0){
return (i+1) * (i+1);
}
}
return -1;
}
}
정수 내림차순으로 배치하기
앞으로 문제를 풀 때는 import java.util.*; 하기!
import java.util.ArrayList;
class Solution {
public Long solution(long n) {
long answer = 0;
ArrayList<Long> list = new ArrayList<Long>();
while(n > 0){
list.add(n % 10);
n /= 10;
}
for(int i = 0; i < list.size(); i++){
for(int j = i + 1; j < list.size(); j++){
if(list.get(i) < list.get(j)){
long temp = list.get(j);
list.set(j, list.get(i));
list.set(i, temp);
}
}
}
int idx = 1;
for (int i = list.size() - 1; i >= 0; i--){
answer = answer + (list.get(i) * idx);
idx = idx * 10;
}
return answer;
}
}
다른 사람의 풀이 1
string을 순회하는 방법 : String s = str.substring(i, i+1);
class Solution {
public long solution(long n) {
String answer = "";
String str = Long.toString(n);
int[] arr = new int[str.length()];
//long타입의 숫자를 Int배열로 올긴다.
for(int i = 0; i < str.length(); i++) {
String s = str.substring(i, i+1);
arr[i] = Integer.parseInt(s);
}
//내림차순 정렬
for(int j = 0; j < str.length()-1; j++){
for(int i = 0; i < str.length()-1; i++) {
if (arr[i] < arr[i+1]) {
int tmp = arr[i+1];
arr[i+1] = arr[i];
arr[i] = tmp;
}
}
}
for(int i = 0; i < str.length(); i++){
answer += arr[i];
}
return Long.parseLong(answer);
}
}
다른 사람 풀이 2
import java.util.*;
class Solution {
public long solution(long n) {
String[] list = String.valueOf(n).split("");
Arrays.sort(list);
StringBuilder sb = new StringBuilder();
for (String aList : list) sb.append(aList);
return Long.parseLong(sb.reverse().toString());
}
}
