2023.7.27.목요일

7.27

 

• 가까운 수

 

문제 설명

정수 배열 array와 정수 n이 매개변수로 주어질 때, array에 들어있는 정수 중 n과 가장 가까운 수를 return 하도록 solution 함수를 완성해주세요.

 

제한사항

• 1 ≤ array의 길이 ≤ 100
• 1 ≤ array의 원소 ≤ 100
• 1 ≤ n ≤ 100
• 가장 가까운 수가 여러 개일 경우 더 작은 수를 return 합니다.

 

입출력 예

array	n	result
[3, 10, 28]	20	28
[10, 11, 12]	13	12

 

내오답

def solution(array, n):

    answer = 0

    an =[]

    array.sort()

    for i in array:

        k = abs(i-n)

        an.append(k)

    if an   

    answer = min(an) + n 

    return answer

 

쳇거 

def solution(array, n):

    closest= array[0]

    diff = abs(n - closest)

 

    for num in array[1:]:

        current_diff = abs(n - num)

        if current_diff < diff or (current_diff == diff and num < closest):

            closest = num

            diff = current_diff

 

    return closest

 

• solution 함수는 두 개의 매개변수를 받습니다: array (정수 배열)와 n (정수).
• closest는 배열의 첫 번째 원소인 array[0]로 초기화되며, diff는 n과 첫 번째 원소와의 절대 차이로 초기화됩니다. 이 변수들은 현재 가장 가까운 숫자와 해당 차이를 추적합니다.
• 그 다음 함수는 for 루프를 사용하여 배열의 원소를 하나씩 반복합니다 (첫 번째 원소는 제외합니다).
• 배열의 각 원소 num에 대해 n과 num 사이의 절대 차이를 계산하고 current_diff에 저장합니다.
• if 문을 사용하여 두 가지 조건을 체크합니다:
• 루프는 배열의 모든 원소를 처리할 때까지 계속됩니다. 루프가 끝나면 closest에는 배열의 원소들 중 n에 가장 가까운 숫자가 저장되고, diff에는 n과 해당 가장 가까운 숫자의 차이가 저장됩니다.
• 마지막으로, 함수는 closest 값을 반환합니다.

 

 

 

 

 

 

 

 

 

 

• A로 B 만들기// 틀렷다//오답
•  

문제 설명

문자열 before와 after가 매개변수로 주어질 때, before의 순서를 바꾸어 after를 만들 수 있으면 1을, 만들 수 없으면 0을 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 0 < before의 길이 == after의 길이 < 1,000
• before와 after는 모두 소문자로 이루어져 있습니다.

 

입출력 예

before	after	result
"olleh"	"hello"	1
"allpe"	"apple"	0

 

내 오답

def solution(before, after):

    an1 =[]

    an =[]

    for i in before:

        an.append(i)

    an.sort()

    for i in after:

        an1.append(i)

    an1.sort()

    k = zip(an,an1)

    for i in range(len(before)):

        if an[i]==an1[i] : #### and set(an)==set(an1): 오류 그런데 set()이용해서는 안될까?

            return 1

        else:

            return 0

 

 나의 답  내가 수정한거

부분만 같은게 아니다 전체가 다 같아야 한다는 것은 if an1 ==an: return 1 이런식이어야한다 

가까스로 맞춘답 그러나 너무 답답하다

def solution(before, after):

    an1 =[]

    an =[]

    for i in before:

        an.append(i)

    an.sort()

    for i in after:

        an1.append(i)

    an1.sort()

    if an ==an1:

        return 1

    else: 

        return 0

        

       남의 답

def solution(before, after):

    before=sorted(before)

    after=sorted(after)

    if before==after:

        return 1

    else:

        return 0

 

  

 

• 팩토리얼//x ??
•  

문제 설명

i팩토리얼 (i!)은 1부터 i까지 정수의 곱을 의미합니다. 예를들어 5! = 5 * 4 * 3 * 2 * 1 = 120 입니다. 정수 n이 주어질 때 다음 조건을 만족하는 가장 큰 정수 i를 return 하도록 solution 함수를 완성해주세요.

• i! ≤ n

 

제한사항

• 0 < n ≤ 3,628,800

 

입출력 예

n	result
3628800	10
7	3

 

 

def solution(n):

    def factorial(i):

        if i == 0 or i == 1:

            return 1

        return i * factorial(i - 1)

 

    i = 0

    while factorial(i) <= n:

        i += 1

 

    return i - 1

 

이 코드는 주어진 수 `n`보다 작은 가장 큰 정수 `i`를 찾는 문제를 해결하는 함수입니다.

 

함수 `factorial`은 재귀적으로 `i`의 팩토리얼을 계산하는 함수입니다. 이 함수는 `i`가 0 또는 1인 경우 1을 반환하고, 그렇지 않은 경우 `i`와 `factorial(i-1)`의 곱을 반환합니다.

 

`solution` 함수는 `factorial(i)`가 `n`보다 작거나 같은 가장 큰 `i`를 찾습니다. 이를 위해 `i`를 0으로 초기화하고, `factorial(i)`가 `n`보다 작거나 같은 경우에만 `i`를 1씩 증가시킵니다. 마지막으로, `i - 1`을 반환하여 `n`보다 작은 가장 큰 정수 `i`를 출력합니다.

 

예를 들어, `solution(3628800)`의 경우, 10! = 3628800이므로 결과는 10이 출력됩니다. 또한, `solution(7)`의 경우, 3! = 6이며, 4! = 24이므로 결과는 3이 출력됩니다.

 

 

 

def solution(n):

    # 재귀적으로 i의 팩토리얼을 계산하는 함수

    def factorial(i):

        if i == 0 or i == 1:

            return 1

        return i * factorial(i - 1)

 

    def find_largest_i(i):

        if factorial(i) > n:

            return i - 1

        return find_largest_i(i + 1)

 

    return find_largest_i(0)

 

# Test cases

print(solution(3628800))  # 3628800의 경우, 10! = 3628800 이므로 결과는 10이 출력됩니다.

print(solution(7))         # 7의 경우, 3! = 6이며, 4! = 24이므로 결과는 3이 출력됩니다.

 

이 코드는 `solution(n)` 함수를 재귀적으로 구현하여, `n`보다 작은 가장 큰 정수 `i`를 찾는 문제를 해결합니다.

 

`factorial(i)` 함수는 이전 코드와 동일하게 재귀적으로 `i`의 팩토리얼을 계산합니다.

 

`find_largest_i(i)` 함수는 `factorial(i)`가 `n`보다 큰 경우에 `i-1`을 반환하고, 그렇지 않은 경우에는 `i+1`을 인자로 하여 자기 자신을 재귀적으로 호출합니다. 이를 통해 `n`보다 작은 가장 큰 정수 `i`를 찾습니다.

 

`solution(n)` 함수는 `find_largest_i(0)`을 호출하여 `n`보다 작은 가장 큰 정수 `i`를 반환합니다.

 

예를 들어, `solution(3628800)`의 경우, 10! = 3628800이므로 결과는 10이 출력됩니다. 또한, `solution(7)`의 경우, 3! = 6이며, 4! = 24이므로 결과는 3이 출력됩니다.

 

solution(n) 함수는 find_largest_i(0)을 호출하여 n보다 작은 가장 큰 정수 i를 반환합니다.-- 이것이 무슨 뜻이야? 

find_largest_i(0)을 호출한다는 건 무슨 뜻이야?

 

`solution(n)` 함수는 `find_largest_i(0)` 함수를 호출하여 `n`보다 작은 가장 큰 정수 `i`를 반환합니다. 

 

`find_largest_i(0)` 함수는 `i`를 인자로 받아 `factorial(i)`가 `n`보다 큰 경우에 `i-1`을 반환하고, 그렇지 않은 경우에는 `i+1`을 인자로 하여 자기 자신을 재귀적으로 호출합니다. 

 

따라서 `find_largest_i(0)`을 호출하면, `i`를 0으로 초기화하고, `factorial(i)`가 `n`보다 큰 경우에 `i-1`을 반환하고, 그렇지 않은 경우에는 `i+1`을 인자로 하여 자기 자신을 재귀적으로 호출합니다. 이를 반복하여 `n`보다 작은 가장 큰 정수 `i`를 찾습니다.

 

즉, `solution(n)` 함수는 `find_largest_i(0)` 함수를 호출하여 `n`보다 작은 가장 큰 정수 `i`를 찾아 반환합니다.

• 모스부호 (1)// x 틀린 문제//오답 
•  

문제 설명

머쓱이는 친구에게 모스부호를 이용한 편지를 받았습니다. 그냥은 읽을 수 없어 이를 해독하는 프로그램을 만들려고 합니다. 

문자열 letter가 매개변수로 주어질 때, letter를 영어 소문자로 바꾼 문자열을 return 하도록 solution 함수를 완성해보세요.
모스부호는 다음과 같습니다.

 

morse = { 

    '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

    '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

    '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

    '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

    '-.--':'y','--..':'z'

}

제한사항

• 1 ≤ letter의 길이 ≤ 1,000
• return값은 소문자입니다.
• letter의 모스부호는 공백으로 나누어져 있습니다.
• letter에 공백은 연속으로 두 개 이상 존재하지 않습니다.
• 해독할 수 없는 편지는 주어지지 않습니다.
• 편지의 시작과 끝에는 공백이 없습니다.

입출력 예

letter	result
".... . .-.. .-.. ---"	"hello"
".--. -.-- - .... --- -."	"python"

 

".... . .-.. .-.. ---"

쳇것

def solution(letter):

    morse = {'.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

             '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

             '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

             '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

             '-.--':'y','--..':'z'}

    words = letter.split(' ')

    result = ''

    for word in words:

        chars = word.split('/')

        for char in chars:

            result += morse[char]

        result += ' '

    return result.strip().replace(' ', '')

 

 

 

def solution(letter):

    morse = {

        '.-':'a','-...':'b','-.-.':'c','-..':'d',  '.' :'e','..-.':'f',

        '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

        '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

        '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

        '-.--':'y','--..':'z'

    }

 

    return ''.join([morse[i] for i in letter.split(' ')])

 

def solution(letter):

    answer = ''

 

    morse = { 

        '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

        '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

        '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

        '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

        '-.--':'y','--..':'z'

    }   

 

    letter_ls = letter.split()

    for l in letter_ls:

        answer += morse[l]

 

    return answer

 

morse = { 

    '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

    '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

    '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

    '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

    '-.--':'y','--..':'z'

}

 

def solution(letter):

    return "".join(map(lambda w: morse[w], letter.split()))

 

 

 

def solution(letter):

    answer = ''

    letter = letter.split()

    morse = { 

    '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

    '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

    '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

    '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

    '-.--':'y','--..':'z'

    }

    for c in letter:

        answer += morse[c]

 

    return answer

 

 

def solution(letter):

    answer = ''

    morse = { 

    '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

    '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

    '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

    '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

    '-.--':'y','--..':'z'

}

    split_letter = letter.split()

    for key, value in morse.items():

        for i in range(len(split_letter)):

            if split_letter[i] == key:

                split_letter[i] = value

 

    for i in split_letter:

        answer += i

 

 

 

    return answer

 

def solution(letter):

    answer = ''

    morse = { 

        '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

        '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

        '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

        '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

        '-.--':'y','--..':'z'

    }

    code = letter.split(' ')

    for c in code:

        answer += morse[c]

    return answer

 

def solution(letter):

 

    morse = { 

    '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',

    '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',

    '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',

    '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',

    '-.--':'y','--..':'z'}

 

    temp = letter.split(' ')

    answer = ''

 

    for text in temp:

        answer += morse[text]

 

    return answer

 

 

 

• 중복된 문자 제거

 

문제 설명

문자열 my_string이 매개변수로 주어집니다. my_string에서 중복된 문자를 제거하고 하나의 문자만 남긴 문자열을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 1 ≤ my_string ≤ 110
• my_string은 대문자, 소문자, 공백으로 구성되어 있습니다.
• 대문자와 소문자를 구분합니다.
• 공백(" ")도 하나의 문자로 구분합니다.
• 중복된 문자 중 가장 앞에 있는 문자를 남깁니다.

 

입출력 예

my_string	result
"people"	"peol"
"We are the world"	"We arthwold"

 

내답

def solution(my_string):

    answer = ''

    for i,val in enumerate( my_string):

        if val in answer:

            pass

        else:

            answer += val

    return answer

 

 

 네답

def solution(my_string):

    answer = ''

    for i in my_string:

        if i not in answer:

            answer+=i

    return answer

 

def solution(my_string):

    return ''.join(dict.fromkeys(my_string))

 

def solution(my_string):

    answer = []

    for i in my_string :

        if answer.count(i) == 0 :

            answer.append(i)

    return ''.join(answer)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2차원으 2차원으로 만들기 //x??

 

 

문제 설명

정수 배열 num_list와 정수 n이 매개변수로 주어집니다. num_list를 다음 설명과 같이 2차원 배열로 바꿔 return하도록 solution 함수를 완성해주세요.

num_list가 [1, 2, 3, 4, 5, 6, 7, 8] 로 길이가 8이고 n이 2이므로 num_list를 2 * 4 배열로 다음과 같이 변경합니다. 2차원으로 바꿀 때에는 num_list의 원소들을 앞에서부터 n개씩 나눠 2차원 배열로 변경합니다.

num_list	n	result
[1, 2, 3, 4, 5, 6, 7, 8]	2	[[1, 2], [3, 4], [5, 6], [7, 8]]

제한사항

• num_list의 길이는 n의 배 수개입니다.
• 0 ≤ num_list의 길이 ≤ 150
• 2 ≤ n < num_list의 길이

 

입출력 예

num_list	n	result
[1, 2, 3, 4, 5, 6, 7, 8]	2	[[1, 2], [3, 4], [5, 6], [7, 8]]
[100, 95, 2, 4, 5, 6, 18, 33, 948]	3	[[100, 95, 2], [4, 5, 6], [18, 33, 948]]

 

내오답

 

def solution(num_list, n):

    answer = [[]]

    for i,val in enumerate(mum_list):

        

        answr[x][y] = divmod(i,n) = val[i]

        answer +=[answer[x][y]]

    

    return answer

 

중요

a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

b=[]

c=[a[i : i+2] for i in range(0,len(a),2)]

print(c)

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16], [17, 18], [19, 20]]

 

 

def solution(num_list, n):

    result = [num_list[i:i+n] for i in range(0, len(num_list), n)]

    return result

 

 

(0, len(num_list), n)]=> 두개씩 가령 4개 왜 ? 8/2= 4개 

 

# Test cases

print(solution([1, 2, 3, 4, 5, 6, 7, 8], 2))  # Output: [[1, 2], [3, 4], [5, 6], [7, 8]]

print(solution([100, 95, 2, 4, 5, 6, 18, 33, 948], 3))  # Output: [[100, 95, 2], [4, 5, 6], [18, 33, 948]]