exp_blog

작성하는 순서 

: SELECT -> FROM -> WHERE -> GROUP BY -> HAVING -> ORDER BY

기본 SQL 문법 처리 및 실행 순서

: FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY 

문제

배열을 정렬하는 것은 쉽다. 수가 주어지면, 그 수의 각 자리수를 내림차순으로 정렬해보자.

입력

첫째 줄에 정렬하고자하는 수 N이 주어진다. N은 1,000,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 자리수를 내림차순으로 정렬한 수를 출력한다.

예제 입력 1 복사

2143

예제 출력 1 복사

4321

알고리즘

메모리 29285KB

시간      64ms

코드길이 115B

array = input()
for i in range(9, -1, -1):
    for j in array:
        if int(j) == i:
            print(i, end='')

437239
974332

루프문을 통해 문제를 풀면 값이 제대로 나오는지 확인하기 위해 사용해야한다.

가로로 출력

print('variable',variable,end='')

end = '' : 그다음 출력문이 오른쪽에 이어서 표시 

공백, 콤마 등으로 구분하고 싶으면 end = ' '  나 end = ',' 처럼 문자열을 지정해준다.

, 대신 +를 쓰면 문자끼리는 공백없이 이어져서 출력되고 , 숫자끼리는 합산된다.

>>>var_char = "A"

>>>var_num = 1
>>>var_num2 = 2
>>>print('This is string :' + var_char, 'This is number :', var_num+var_num2)

This is string :A This is number : 3

여러 항목 출력1

print('{0} and {1}'.format('spam', 'eggs'))
print('{1} and {0}'.format('spam', 'eggs'))
 
num1=1;num2=2
print('{0} {1}'.format(num1,num2))

.format 사용하여 값을 여러 개 주고, 중괄호로 읽어온다

여러 항목 출력2

print('Text %s'%var_char)
print('Number %d'%var_num)

	
print('This is text %s This is number %d'%(var_char,num1))
#괄호로 묶어서 출력해준다

출력문 안쪽에 %s %d %f를 써주고, 출력구문 바로 %뒤에 변수명이나 값을 써준다.

(%s:문자열 %d:정수 %f:부동소수점)

for _ in range(5):
	print('hi')

 변수 _ 가 0, 1, 2, 3, 4 값을 가지고 반복을 수행한다

실제 사용되지는 않기 때문에  " _ " 를 사용함

=> dummy variable 

1. 인터프리터에서 마지막 값을 저장하고 싶을 때
2. 값을 무시하고 싶을 때
3. 변수나 함수 명에 특별한 의미 부여하고 싶을 때
4. 숫자 리터럴 값의 자릿수 구분을 위한 구분자로 사용할 때

1 번 사용법

 : 인터프리터에 마지막 값 저장하고 싶을 때 사용 ( _ => 20이 저장되어 있다)

>>>_ = 20
>>>print(_)
20

>>>_*3
60

>>>_/2
10.0

2번 사용법 

: 값을 무시하고 싶을 때 사용 

>>>x, _, y = 1, 2, 3

>>>x
1
>>>y
3

>>> x, *_ , y = 1, 2, 3, 4, 5
#여러 개의 값을 무시하려면 *를 붙여서 사용한다 
#index 가 필요없는 for 문을 작성할 경우 사용 가능 

>>>x
1

>>>y
5

for _ in range(n):
	print("test")

_ 를 인덱스로 사용할 수 있다.

3번 사용법

: 특별한 의미를 부여하고 싶을 때

• 폴더
  • __init__.py 라는 파일이 있으면 그 폴더를 패키지로 만들 수 있다
• 메소드 
  • '_' 가 앞4.에 붙으면 외부 사용자는 사용하지 말라는 권유 문법
  • '__'가 붙은 메소드는 
    • 매직 메소드 : 클래스 작성 시 사용하는 " __init__, __str__' 등의 메소드
    • 맹글링 : 컴파일러, 인터프리터가 변수나 함수명을 일정한 규칙에 의해 변형시키는 것 의미
  • 메소드의 맹글링 규칙은 메소드 앞에 _ClassName 을 붙이는 것으로 맹글링

class A:
	def __double_method(self):
    	pass
class B:
	def __double_method(self):
    	pass

print(dir(A()))
print(dir(B()))

4번 사용법

숫자, 문자값의 자릿수 구분 위한 구분자 

dec_base = 1_000_000

print(dec_base)
>>> 1000000

요소를 추가/삭제하거나, 정보를 조회하는 메서드 제공

for 문과 결합하여 연속적이고 반복되는 값을 손쉽게 처리 

1. 리스트에 요소 추가하기(삽입)

• append : 요소 하나 추가
• extend : 리스트를 연결하여 확장
• insert :  특정 인덱스에 요소 추가 

    1) append : 리스트 끝에 요소 하나 추가  / 빈 리스트에서 값 추가 가능 

>>>  a = [10, 20, 30]
>>>  a.append(500)
>>>  a
[10, 20, 30, 500]
>>>  len(a)
4

     - 리스트 안에 리스트도 추가 가능 

>>> a = [10, 20, 30]
>>> a.append([500, 600])
>>> a
[10, 20, 30, [500, 600]]
>>> len(a)
4

  2) extend : 리스트 확장하기 / 리스트 끝에 다른 리스트를 연결하여 리스트 확장 (리스트 + 리스트 연결한 모양)

>>> a = [10, 20, 30]
>>> a.extend([500, 600])
>>> a
[10, 20, 30, 500, 600]
>>> len(a)
5

  3) insert : 리스트의 특정 인덱스에 요소 하나 추가 

• insert(0, 요소): 리스트의 맨 처음에 요소를 추가
• insert(len(리스트), 요소): 리스트 끝에 요소를 추가

>>> a = [10, 20, 30]
>>> a.insert(0, 500)
>>> a
[500, 10, 20, 30]

>>> a = [10, 20, 30]
>>> a.insert(len(a), 500)
>>> a
[10, 20, 30, 500]

insert 안에 리스트 넣으면 append 처럼 리스트 안에 리스트가 삽입

>>> a = [10, 20, 30]
>>> a.insert(1, [500, 600])
>>> a
[10, [500, 600], 20, 30]

슬라이스에 요소 할당 : 리스트 중간에 요소 여러개 추가 할 때

>>> a = [10, 20, 30]
>>> a[1:1] = [500, 600]
>>> a
[10, 500, 600, 20, 30]

2. 리스트에서 요소 삭제하기

• pop: 마지막 요소 또는 특정 인덱스의 요소를 삭제
• remove: 특정 값을 찾아서 삭제

   1) pop() : 리스트의 마지막 요소를 삭제한 뒤, 삭제한 요소 반환(=del)

>>> a = [10, 20, 30]
>>> a.pop()
30
>>> a
[10, 20]

>>> a = [10, 20, 30]
>>> a.pop(1)
20
>>> a
[10, 30]

   2) remove : 리스트에서 원하는 값 찾아 삭제

>>> a = [10, 20, 30, 20]
>>> a.remove(20)
>>> a
[10, 30, 20]

3. 특정 값 개수 구하기

• count : 리스트에서 특정 값 개수 구함

>>> a = [10, 20, 30, 15, 20, 40]
>>> a.count(20)
2

4. 리스트 순서 뒤집기

• reverse : 리스트 요소 순서를 반대로 뒤집음

>>> a = [10, 20, 30, 15, 20, 40]
>>> a.reverse()
>>> a
[40, 20, 15, 30, 20, 10]

5. 리스트 요소 정렬

• sort() 또는 sort(reverse=False): 리스트의 값을 작은 순서대로 정렬(오름차순)
• sort(reverse=True): 리스트의 값을 큰 순서대로 정렬(내림차순)
• sorted : 정렬된 새 리스트 생성

>>> a = [10, 20, 30, 15, 20, 40]
>>> a.sort()    # a의 내용을 변경하여 정렬
>>> a
[10, 15, 20, 20, 30, 40]
>>> b = [10, 20, 30, 15, 20, 40]
>>> sorted(b)    # 정렬된 새 리스트를 생성
[10, 15, 20, 20, 30, 40]

6. 리스트 모든 요소 삭제

• clear : 리스트 모든 요소 삭제

>>> a = [10, 20, 30]
>>> a.clear()
>>> a
[]

7. 리스트 슬라이스 조작

• a[len(a):] => 시작 인덱스 len(a)로 지정 , 리스트의 마지막 인덱스보다 1이 더 큰 상태 / 리스트 끝에서 부터 시작 

>>> a = [10, 20, 30]
>>> a[len(a):] = [500]
>>> a
[10, 20, 30, 500]

>>> a = [10, 20, 30]
>>> a[len(a):] = [500, 600]
>>> a
[10, 20, 30, 500, 600]

#리스트 a 끝에 다른 리스트를 연결 (=extend)

## 리스트 비어 있는지 확인하기 

if not seq:    # 리스트가 비어 있으면 True
if seq:        # 리스트에 내용이 있으면 True

>>> seq = [10, 20, 30]
>>> seq[-1]
30

문제

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)
        

정렬 알고리즘에서 많이 쓰이는 swap 사용법

두 변수의 값을 바꾸는 방법

예시) a = 3, b = 'abc'를 a = 'abc', b = 3

a = 3
b = 'abc'

a, b = b, a 

1. 삽입 정렬?

• 삽입 정렬은 두 번째 인덱스부터 시작
• 해당 인덱스(key 값) 앞에 있는 데이터(B)부터 비교해서 key 값이 더 작으면, B값을 뒤 인덱스로 복사
• 이를 key 값이 더 큰 데이터를 만날때까지 반복, 그리고 큰 데이터를 만난 위치 바로 뒤에 key 값을 이동

2. 패턴 찾기

• 처음은 항상 인덱스(0)+1 에서 시작
• data_list = [9, 3, 2, 5]
  • 1회 : key 값 (9) , 인덱스(0) -1 보다 작으므로 => [9,3,2,5]
  • 2회 : key 값 (3) , key -1 값(9) 이 3보다 작으므로 => [3,9,2,5]
  • 3회 : key 값(2) , key -1 값(9) 보다 작고 -> key -2 값(2) 이 더 작으므로 => [2,3,9,5]
  • 4회 : key 값(5), 9보다 작고, 3보다 크므로 => [2,3,5,9]

1. for stand in range(len(data_list)) 로 반복
2. key = data_list[stand]
3. for num in range(stand, 0, -1) 반복
    - 내부 반복문 안에서 data_list[stand] < data_list[num - 1] 이면,
    - data_list[num - 1], data_list[num] = data_list[num], data_list[num - 1]

3. 알고리즘

def insertion_sort(data):
    for index in range(len(data) - 1):
        for index2 in range(index + 1, 0, -1):
            if data[index2] < data[index2 - 1]:
                data[index2], data[index2 - 1] = data[index2 - 1], data[index2]
            else:
                break
    return data

import random

data_list = random.sample(range(20), 10)
print (insertion_sort(data_list))

>>[0, 3, 4, 5, 11, 12, 14, 17, 18, 19]

rand_data_list = [3, 5, 1, 2]

def insertion_sort(data_list):
    for stand in range(len(data_list)):
        key = data_list[stand]
        for num in range(stand, 0, -1):
            if key < data_list[num - 1]:
                data_list[num - 1], data_list[num] = data_list[num], data_list[num - 1]
            else:
                break
    return data_list

print (insertion_sort(rand_data_list))

4. 알고리즘 분석

• 반복문이 두 개 O(𝑛2)
  • 최악의 경우, 𝑛∗(𝑛−1)2
• 완전 정렬이 되어 있는 상태라면 최선은 O(n)