반응형
시간 제한 메모리 제한 제출 정답 맞은 사람 정답 비율
1 초 128 MB 46130 25876 18387 57.906%

문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 절댓값이 1,000보다 작거나 같은 정수이다. 수는 중복되지 않는다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

 

입력

5 5 2 3 4 1

출력

1 2 3 4 5

 

 

알고리즘

메모리 : 29440KB

시간 : 172ms

언어 : python 3

코드 길이 302B

 

n = int(input())
array = list()

for _ in range(n):
    array.append(int(input()))

for i in range(n):
    lowest = i
    for j in range(i+1, n):
        if array[lowest] > array[j]:
            lowest = j
    array[i], array[lowest] = array[lowest], array[i]
    
for i in array:
    print(i)
        

 

반응형

'Algorithm Study > Baekjoon' 카테고리의 다른 글

2747.피보나치 수  (0) 2020.01.09
10989.수 정렬하기3  (0) 2020.01.09
10814.나이순 정렬  (0) 2020.01.09
11650. 좌표 정렬하기  (0) 2020.01.07
1427. 소트인사이드  (0) 2020.01.05
반응형

1. 정렬이란?

  • 어떤 데이터들이 주어졌을 때, 정해진 순서대로 나열하는 것
  • 다양한 정렬 알고리즘 이해를 통해 동일한 문제에 대한 다양한 알고리즘이 고안될 수 있고, 각 알고리즘 간 성능 비교를 통해 알고리즘 성능 분석도 이해할 수 있음

2. 버블 정렬(bubble sort)

  • 두 인접한 데이터를 비교하여 앞에 있는 데이터가 뒤에 있는 데이터보다 크면, 자리를 바꾸는 정렬 알고리즘

## https://visualgo.net/en 사이트에서 보면 쉽게 그림으로 이해할 수 있다. 

 

3. 패턴 찾기

  • 데이터가 4개 일 때 
    • data_list = [1,9.3.2]
      • 1차 로직
        • 1 vs 9 => X
        • 9 vs 3 => [1, 3, 9, 2]
        • 9 vs 2 => [1, 3, 2, 9]
      • 2차 로직
        • 1 vs 3 => X
        • 3 vs 2 => [1, 2, 3, 9]
        • 3 vs 9 => X
      • 3차 로직
        • 1 vs 2 => X
        • 2 vs 3 => X
        • 3 vs 9 => X

==> N 개의 리스트가 있는 경우 N-1 로직을 적용한다

==> 로직을 1번 적용할 때마다, 가장 큰 수가 뒤에서부터 1개씩 결정된다 

==> 로직이 일찍 끝날 수도 있다 

        => 로직을 적용 시,  한 번도 데이터가 교환되지 않는다면 이미 정렬된 상태므로 더 이상 로직을 반복 적용할

             필요가 없다 

==> 로직 한 회 끝날 때 마다 가장 큰 숫자가 뒤에서 1개씩 결정된다

리스트 1회 2회 3회 4회
1, 9, 3, 2 1, 3, 2, 9 1, 2, 3, 9    
9, 7, 5, 3, 1 7, 5, 3, 1, 9 5, 3, 1, 7, 9 3, 1, 5, 7, 9 1, 3, 5, 7, 9

 

4. 알고리즘

<프로토 타입>
1. for num in range(len(data_list)) 반복
2. swap = false // 교환되어있는지 확인,  false 가 기본값이여야 아래 for문에서 swap 이 멈춰야 알고리즘 종료

3. 반복문 안에서 , for index in range(len(data_list) - num - 1) 를 n-1번 반복해야한다 
    //num 을 빼는 이유는  data_list에서 로직이 돌면 맨 뒤에 가장 큰 값이 고정되기 때문에 
4. 반복문안의 반복문 안에서, if data_list[index] > data_list[index + 1]  이면
5. swap 시켜야한다
6. 더이상 swap 되지 않고 false 값이 나오면 break
def bubblesort(data):
    for index in range(len(data) - 1):
        swap = False
        for index2 in range(len(data) - index - 1):
            if data[index2] > data[index2 + 1]:
                data[index2], data[index2 + 1] = data[index2 + 1], data[index2]
                swap = True
        
        if swap == False:
            break
    return data
import random

data_list = random.sample(range(50), 20)
bubblesort(data_list)

>>[3, 5, 10, 11, 18, 19, 20, 21, 24, 26, 28, 29, 31, 33, 34, 38, 39, 44, 46, 49]

5. 분석

  • 반복문이 두개  :  O(𝑛2)
    • 최악 : 𝑛∗(𝑛−1)2
  • 완전 정렬 되어 있으면 최선 : O(n)
반응형
반응형

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

  1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
  2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
  3. 2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 

제한사항

  • array의 길이는 1 이상 100 이하입니다.
  • array의 각 원소는 1 이상 100 이하입니다.
  • commands의 길이는 1 이상 50 이하입니다.
  • commands의 각 원소는 길이가 3입니다.

입출력 예

array commands return
[1,5,2,6,3,7,4] [2,5,3],[4,4,1],[1,7,3] [5,6,3]

 

입출력 설명
[1, 5, 2, 6, 3, 7, 4]를 2번째부터 5번째까지 자른 후 정렬합니다. [2, 3, 5, 6]의 세 번째 숫자는 5입니다.
입출력 예 설명

[1, 5, 2, 6, 3, 7, 4]를 4번째부터 4번째까지 자른 후 정렬합니다. [6]의 첫 번째 숫자는 6입니다.
[1, 5, 2, 6, 3, 7, 4]를 1번째부터 7번째까지 자릅니다. [1, 2, 3, 4, 5, 6, 7]의 세 번째 숫자는 3입니다.

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

 

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

  1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
  2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
  3. 2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 

제한사항

  • array의 길이는 1 이상 100 이하입니다.
  • array의 각 원소는 1 이상 100 이하입니다.
  • commands의 길이는 1 이상 50 이하입니다.
  • commands의 각 원소는 길이가 3입니다.

내가 푼 코드

 

import java.util.Arrays;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];
        int[] tmp = {};
        
        for(int i = 0; i < commands.length; i++){
            tmp = Arrays.copyOfRange(array, commands[i][0]-1,  commands[i][1]);
            /*Arrays.copyOfRange(a,b,c) : arrays 에 들어있는 a[] 배열을 b부터 c까지 복사 하는 함수*/
            Arrays.sort(tmp);
            //tmp 에 옮겨진 부분에 대하여 정렬하고 k번째 숫자를 답으로 담음
            
            answer[i] = tmp[commands[i][2]-1];
            /*배열의 index가 0부터 시작하기 떄문에 -1을 해준다.*/
        }
        return answer;
    }
}

 

다른사람이 푼 코드(라이브러리 사용하지 않고 ... 대단..)

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int n = 0;
        int[] ret = new int[commands.length];

        while(n < commands.length){
            int m = commands[n][1] - commands[n][0] + 1;

            if(m == 1){
                ret[n] = array[commands[n++][0]-1];
                continue;
            }

            int[] a = new int[m];
            int j = 0;
            for(int i = commands[n][0]-1; i < commands[n][1]; i++)
                a[j++] = array[i];

            sort(a, 0, m-1);

            ret[n] = a[commands[n++][2]-1];
        }

        return ret;
    }

    void sort(int[] a, int left, int right){
        int pl = left;
        int pr = right;
        int x = a[(pl+pr)/2];

        do{
            while(a[pl] < x) pl++;
            while(a[pr] > x) pr--;
            if(pl <= pr){
                int temp = a[pl];
                a[pl] = a[pr];
                a[pr] = temp;
                pl++;
                pr--;
            }
        }while(pl <= pr);

        if(left < pr) sort(a, left, pr);
        if(right > pl) sort(a, pl, right);
    }
}
반응형

'Algorithm Study > Programmers' 카테고리의 다른 글

두 정수 사이의 합 / java  (0) 2019.08.28
2016년/java  (0) 2019.08.28
가장 큰 수 / java / 정렬  (0) 2019.08.17
체육복/java/탐욕법 알고리즘  (0) 2019.08.15
완주하지 못한 선수 / JAVA / Hash  (0) 2019.07.24
반응형
def fibonacci(n):

    answer = [0,1]    #list의 초기값을 0,1로 지정

 

    for i in range(2,n+1):#i= list의 주소를 뜻함

        answer.append(answer[i-1]+answer[i-2])#list에 추가

    #print(answer)  # 피보나치 list를 출력위해

    #print(i)       #리스트 주소가 잘 돌고있는지 확인

    return answer[-1]    #리스트에서 가장 마지막것만 출력해줌

 

$print(fibonacci(30))

832040

초기에 python으로 해결하려 하였으나 실패ㅜㅜ 시간 계산 함수가 따로있다고 하는데 조금 더 찾아보고싶었지만 노타임.. 노열정..

 

<python 으로 반복문 사용하여 피보나치 계산> -> 아 잘되는데 시간 계산 .....



<java 피보나치 합 /시간 계산>

 

import java.util.Scanner;
 
public class recursionVsIteration {
 
    public static void main(String[] args) {
 
        Scanner sc = new Scanner(System.in);
 
        //원하는 숫자 입력
 
        System.out.print("Enter the last element of Fibonacci sequence: ");
 
        long n = sc.nextInt();
 
        //반복문 출력
 
        System.out.println("Fibonacci iteration:");
 
        long start = System.currentTimeMillis();
 
        System.out.printf("Fibonacci sequence(element at index %d) = %d \n", n, fibIteration(n));
 
        System.out.printf("Time: %d ms\n", System.currentTimeMillis() - start);
 
        //재귀함수 출력
 
        System.out.println("Fibonacci recursion:");
 
        start = System.currentTimeMillis();
 
        System.out.printf("Fibonacci sequence(element at index %d) = %d \n", n, fibRecursion(n));
 
        System.out.printf("Time: %d ms\n", System.currentTimeMillis() - start);
 
    }
 
    //반복문 method
 
    static long fibIteration(long n) {
 
        long x = 0, y = 1, z = 1;
 
        for (long i = 0; i < n; i++) {
 
            x = y;
 
            y = z;
 
            z = x + y;
 
        }
 
        return x;
 
    }
 
    //재귀 method
 
    static long fibRecursion(long  n) {
 
        if ((n == 1) || (n == 0)) {
 
            return n;
 
        }
 
        return fibRecursion(n - 1) + fi

 

 

 


<피보나치 수열>

1

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

 

 

<피보나치 수열의 호출 방법>

1. 재귀 호출 

-함수 호출 횟수가 너무 큼                                                     -> 해결책 : recursive를 한겹만 쓰면 확실히 줄어들 것

-stack 깊이가 너무 깊어져서 컴퓨터 터짐..(stack overhead)-> 해결책 : stack을 쓰되 새로 만들지말고 누적해서 재사용하자

 

-대신 적은 코드 사용해 효율적으로 처리                              -> 종료하는 지점 정의해줬을 때 얘기이다..

 

2. 반복 호출 

- 반복 할 때마다 나온 계산 값을 어딘가에 저장해 두고 그 다음 반복에서는 앞 단계에서 저장된 값에 새로운 값 내용 누적 시킨다.

- 매개변수 리스트 보관(메모리 영역) / 메소드 실행공간(복사 공간) 필요하다

 

3. 꼬리 재귀(tail-recursion)

-재귀가 느려지는 이유(작업 끝마쳐도 해야할 일 남아)를 보완해서 함수의 꼬리 부분에 호출하여 원래 시점으로 돌아갔을 때 해야할 일 이 없게 만드는 호출

 


 

-참고 블로그 : https://nittaku.tistory.com/81

 

 

 

 

 

 

반응형

+ Recent posts