[알고리즘] 230408 완주하지 못한 선수 collection.Counter() / return의 성질

완주하지 못한 선수

내 코드

def solution(participant, completion):
    #<1> 정렬을 하여 두 값의 순서를 일치시킨다. 순서가 불일치하는 순간에 완주못한선수가 있다. 
    p = sorted(participant) #가독성을 위해 sorted함수사용하며 객체에 담음 
    c = sorted(completion)  #가독성을 위해 sorted함수사용하며 객체에 담음
    result = p[-1] #<2>모두 일치한다면 불일치하는 요소가 마지막에 있다.
    for i in range(len(c)):
        if p[i] != c[i]: #<3> 일치하지 않을 때
            result = p[i] #<3> 그 순간이 완주못한선수의 이름이다.
            break #<3> 시간복잡도를 고려하여 불필요한 연산을 막고 for문 종료
    return result

---

흠..터레스팅 코드

#1번 collections 모듈의 Counter사용
import collections

def solution(participant, completion):
    answer = collections.Counter(participant) - collections.Counter(completion)
    return list(answer.keys())[0]

#2번 나와 같은 로직이지만 불필요한 값들을 생략하였다. break대신 return의 성질 사용!
def solution(participant, completion):
    participant.sort()
    completion.sort()
    for i in range(len(completion)):
        if participant[i] != completion[i]:
            return participant[i]	#return은 반환 즉시 함수를 종료하므로 for문이 더 돌지 않는다.
    return participant[len(participant)-1] # participant[-1] 이렇게하는 것이 더 직관적이고 효율적이다.

---

새로 알게된 것

1번 collections 모듈

collections.Counter(<hashable items>)
정의 | collections 모듈의 클래스
사용법 | collections.Counter(<카운터할 객체>)
결과 | 객체의 유니크(unique)값을 key로 하고, 각 갯수를 value로 하는 dict 형태의 인스턴스를 생성한다.
Type | <class 'collections.Counter'>

Counter 인스턴스는 ± 연산이 가능하다. value가 0이 되면 인스턴스의 item에서 제외된다.
위 1번의 코드에서는 이를 이용하여 리스트의 차집합을 간단히 구현하였다.

1번에서 활용한 순서

# Counter의 docs
class Counter(dict):
    '''Dict subclass for counting hashable items.  Sometimes called a bag
    or multiset.  Elements are stored as dictionary keys and their counts
    are stored as dictionary values.

    >>> c = Counter('abcdeabcdabcaba')  # count elements from a string

    >>> c.most_common(3)                # three most common elements
    [('a', 5), ('b', 4), ('c', 3)]
    >>> sorted(c)                       # list all unique elements
    ['a', 'b', 'c', 'd', 'e']
    >>> ''.join(sorted(c.elements()))   # list elements with repetitions
    'aaaaabbbbcccdde'
    >>> sum(c.values())                 # total of all counts
    15

    >>> c['a']                          # count of letter 'a'
    5
    >>> for elem in 'shazam':           # update counts from an iterable
    ...     c[elem] += 1                # by adding 1 to each element's count
    >>> c['a']                          # now there are seven 'a'
    7
    >>> del c['b']                      # remove all 'b'
    >>> c['b']                          # now there are zero 'b'
    0

    >>> d = Counter('simsalabim')       # make another counter
    >>> c.update(d)                     # add in the second counter
    >>> c['a']                          # now there are nine 'a'
    9

    >>> c.clear()                       # empty the counter
    >>> c
    Counter()

    Note:  If a count is set to zero or reduced to zero, it will remain
    in the counter until the entry is deleted or the counter is cleared:

    >>> c = Counter('aaabbc')
    >>> c['b'] -= 2                     # reduce the count of 'b' by two
    >>> c.most_common()                 # 'b' is still in, but its count is zero
    [('a', 3), ('c', 1), ('b', 0)]

    '''​

▼위에서 사용한 Counter 설명을 위한 테스트 코드

#Counter테스트 코드
import os

os.system("cls")


# 1번 collections 모듈의 Counter사용
import collections


def solution(participant, completion):
    cp = collections.Counter(participant)
    cc = collections.Counter(completion)
    print('["a", "b", "e", "c", "d"] ▶▶▶  Counter사용 ▶▶▶ ', cp)
    print('["a", "b", "c", "d"]      ▶▶▶  Counter사용 ▶▶▶ ', cc)
    answer = cp - cc
    print(" 빼기 연산 후             ▶▶▶ ", answer)
    print(".key()를 이용해 key 분리  ▶▶▶ ", answer.keys())
    print("list()로 list화           ▶▶▶ ", list(answer.keys()))
    print("[0]으로 string 출력       ▶▶▶ ", list(answer.keys())[0])


p = ["a", "b", "e", "c", "d"]
c = ["a", "b", "c", "d"]
solution(p, c)

---

2번 return의 성질

return <반환할 값>
return은 함수에서 반환하고 싶은 값을 특정함으로써 함수가 원하는 구동을 하도록한다.
함수는 return을 만나게 되면 return이후 과정을 무시하고 값을 반환하며 함수를 종료하게 된다.
즉, while&for문에서 break를 만나면 반복문을 빠져나오듯
     함수에서 return을 만나면 함수를 빠져나온다.
만약 함수에서 return이 없다면 함수는 임의로 None을 return해준다.