-
2023.7.26.수요일TIL( Today I Learned) 2023. 7. 26. 23:24
7.26.수요일 .
- 피자 나눠 먹기 (2)
문제 설명
머쓱이네 피자가게는 피자를 여섯 조각으로 잘라 줍니다. 피자를 나눠먹을 사람의 수 n이 매개변수로 주어질 때, n명이 주문한 피자를 남기지 않고 모두 같은 수의 피자 조각을 먹어야 한다면 최소 몇 판을 시켜야 하는지를 return 하도록 solution 함수를 완성해보세요.
제한사항
1 ≤ n ≤ 100
입출력 예
n result 6 1 10 5 4 2 def solution(n):
answer = 0
a =[]
for i in range(1,100):#100 - 피자 판수
if (i*6) %n ==0:
a.append(i)
answer = a[0]
return answer
이해가 안돼????
def solution(n):
i=1
while(1):
if (6*i)%n==0:
return i
i+=1
주어진 Python 코드는 solution(n)이라는 함수를 정의합니다. 이 함수는 양의 정수 n을 입력으로 사용하고 (6*i)의 결과가 n으로 나누어지는 가장 작은 양의 정수 i를 찾으려고 시도합니다. 코드를 단계별로 분석해 보겠습니다.
def solution(n):
i = 1 # Initialize a variable i to 1
while True: # Start an infinite loop
if (6 * i) % n == 0: # Check if (6 * i) is divisible by n
return i # If true, return the current value of i
i += 1 # Increment i by 1 for the next iteration
- 함수 solution(n)은 하나의 양의 정수 n을 인수로 취합니다.
- 변수 i를 1로 초기화합니다. 이 변수는 조건을 만족하는 가장 작은 양의 정수를 찾는 데 사용됩니다.
- 코드는 while True:를 사용하여 무한 루프에 들어갑니다. 이 루프는 루프의 조건이 충족되고 함수가 값을 반환할 때까지 계속 실행됩니다.
- 루프 내에서 코드는 모듈러스 연산자 '%'를 사용하여 (6 * i)가 n으로 나누어지는지 확인합니다. (6 * i) % n의 결과가 0이면 (6 * i)가 n으로 균등하게 나누어지고 조건이 만족됨을 의미합니다.
- 조건이 참이면 함수는 i의 현재 값을 반환하고 루프를 종료합니다.
- 조건이 참이 아니면 코드는 i += 1을 사용하여 i를 1씩 증가시키고 루프는 i의 다음 값을 확인하기 위해 다음 반복을 계속합니다.
- (6 * i)를 n으로 나눌 수 있는 가장 작은 i를 찾을 때까지 프로세스가 계속되고 함수는 해당 값을 반환합니다.
본질적으로 이 코드는 (6 * i)가 입력 n으로 나누어지는 가장 작은 양의 정수 i를 계산하고 이 값을 반환합니다. 그러한 i가 없으면 루프가 무한정 실행됩니다. 그러나 입력 n은 양의 정수로 보장되므로 항상 해가 있을 것이며 함수는 무한 루프에 빠지지 않습니다.
def solution(n):
answer = 1
while 6 * answer % n:
answer += 1
return answer
def solution(n):
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
return n // gcd(n, 6)
주어진 Python 코드는 solution(n)이라는 함수를 정의하고 있습니다. 이 함수는 n이라는 양의 정수를 입력으로 받습니다. 이 함수는 입력된 n과 6의 최대공약수(GCD, Greatest Common Divisor)를 구하여 n을 그 최대공약수로 나눈 결과를 반환하는 것으로 보입니다.
- solution(n) 함수는 하나의 양의 정수 n을 인자로 받습니다.
- 함수 내부에 또 다른 함수 gcd(a, b)가 정의되어 있습니다. 이 함수는 두 개의 정수 a와 b를 인자로 받아 그들의 최대공약수(GCD)를 구하는 함수입니다. 최대공약수를 구하기 위해 유클리드 호제법을 사용합니다.
- 함수 gcd(a, b)는 a와 b가 0보다 클 때까지 반복합니다. 반복하는 동안 a에는 b의 값으로, b에는 a를 b로 나눈 나머지 값으로 갱신합니다. 이렇게 반복하면 b가 0이 되었을 때 a에는 최대공약수가 저장됩니다.
- 함수 solution(n)은 n과 6의 최대공약수를 구하여 n을 그 최대공약수로 나눈 결과를 반환합니다. 최대공약수를 구하기 위해 gcd(n, 6) 함수를 호출하고, n을 이 최대공약수로 나누기 위해 n // gcd(n, 6)를 사용합니다. // 연산자는 정수 나눗셈을 수행합니다.
이 함수는 입력 n과 6의 최대공약수를 구하여 n을 그 최대공약수로 나누는 기능을 수행합니다. 최대공약수는 두 수의 공통된 약수 중 가장 큰 수를 의미하며, 이 함수를 통해 n과 6의 최대공약수를 빠르게 구할 수 있습니다.
a, b = b, a % b 이것은 무슨 뜻이야?
Python에서 a, b = b, a % b 줄은 튜플 압축 해제를 사용하여 두 변수 a와 b의 값을 교환하는 속기 방법입니다.
단계별로 분석해 보겠습니다.
- a와 b는 일부 값을 보유하는 두 개의 변수입니다.
- a % b는 a를 b로 나눈 나머지(modulo)를 계산합니다.
- (b, a % b)는 b의 값과 a % b의 결과를 포함하는 튜플을 만듭니다.
- a, b = (b, a % b)는 오른쪽에 있는 튜플의 압축을 풀고 그 값을 a와 b에 각각 할당합니다.
a = 10
b = 5
a, b = b, a % b
print(a) # Output: 5
print(b) # Output: 0
이 예제에서 처음에는 a는 10이고 b는 5입니다. a, b = b, a % b 라인을 실행한 후 a와 b의 값이 서로 바뀝니다. 이제 a는 5가 되고 b는 0이 되므로 10 % 5의 결과입니다.
튜플 압축 해제를 사용하는 이 교환 기술은 임시 변수를 사용하지 않고 두 변수의 값을 교환하는 간결한 방법입니다. 일반적이고 우아한 Python 관용구입니다.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- 가까운 1 찾기//틀렸다//???
문제 설명
정수 배열 arr가 주어집니다. 이때 arr의 원소는 1 또는 0입니다. 정수 idx가 주어졌을 때, idx보다 크면서 배열의 값이 1인 가장 작은 인덱스를 찾아서 반환하는 solution 함수를 완성해 주세요.
단, 만약 그러한 인덱스가 없다면 -1을 반환합니다.
제한사항
- 3 ≤ arr의 길이 ≤ 100'000
입출력 예
arr idx result [0, 0, 0, 1] 1 3 [1, 0, 0, 1, 0, 0] 4 -1 [1, 1, 1, 1, 0] 3 3 남의 해답
def solution(arr, idx):
answer = 0
try:
answer = arr.index(1, idx)
except:
answer = -1
return answer
- solution' 함수는 입력 정수 배열인 'arr'과 주어진 정수 인덱스인 'idx'라는 두 개의 인수를 입력으로 받습니다.
- 'answer' 변수는 0 값으로 초기화됩니다. 이 변수는 배열에서 주어진 색인 'idx' 다음에 나오는 '1'의 색인을 저장하는 데 사용됩니다.
- 이 코드는 try-except 블록을 사용하여 arr 목록에서 index() 메서드를 사용할 때 발생할 수 있는 예외를 처리합니다. index() 메서드는 목록에서 지정된 요소가 처음 나타나는 인덱스를 반환합니다. 검색할 요소와 검색할 시작 인덱스이것 포함라는 두 개의 인수를 사용합니다.
- 'answer = arr.index(1, idx)' 행은 주어진 색인 'idx'에서 시작하여 목록 'arr'에서 다음에 나타나는 '1'의 색인을 찾으려고 시도합니다. 주어진 인덱스 뒤에 1이 없으면 ValueError 예외가 발생합니다.
- index() 메소드가 다음 1 항목을 성공적으로 찾으면 해당 항목의 인덱스로 answer 변수를 업데이트합니다.
- index() 메서드가 ValueError 예외를 발생시키는 경우(즉, 주어진 인덱스 다음에 1이 발견되지 않음) 코드는 except 블록에 들어가고 answer 변수가 설정됩니다. -1로.
- 마지막으로 이 함수는 배열에서 주어진 idx 다음에 나타나는 1의 인덱스를 나타내는 answer 값을 반환합니다. 해당 항목이 없으면 -1을 반환합니다.
answer = arr.index(1, idx)
이 코드는 리스트 arr에서 값이 1인 첫 번째 요소의 인덱스를 반환합니다.
idx는 검색을 시작할 인덱스(이 말은 idx 포함해서다 ***굉장히 주의 할것 괭장히)를 나타내며, 생략하면 리스트의 첫 번째 요소부터 시작합니다.
arr에 값이 1인 요소가 없으면 ValueError가 발생합니다.
반환된 인덱스는 answer 변수에 할당됩니다.
answer = arr.index(1, idx) 줄을 분해하여 자세히 이해
- arr: 이것은 함수에 주어진 입력 배열입니다.
- idx: 이것은 검색을 위한 시작 인덱스를 나타내는 함수에 전달되는 두 번째 인수입니다. index() 메서드는 이 idx에서 시작하여 배열 arr에서 다음에 나타나는 1을 검색합니다.
이제 상황은 다음과 같습니다.
- index() 메서드는 검색할 요소(이 경우 1)와 검색을 위한 시작 인덱스(idx)라는 두 개의 인수를 사용하여 배열 arr에서 호출됩니다.
- index() 메서드는 주어진 인덱스 idx에서 시작하여 배열 arr에서 요소 1을 찾기 시작합니다.
- 주어진 인덱스 idx 다음에 1이 발생하면 해당 인덱스를 반환합니다.
- 주어진 인덱스 idx 다음에 1이 발견되지 않으면 index() 메서드는 ValueError 예외를 발생시킵니다.
- 'answer' 변수는 'index()' 메서드에 의해 반환된 인덱스로 업데이트됩니다. 인덱스는 주어진 'idx' 다음에 나오는 '1'의 인덱스를 나타냅니다.
예, answer = arr.index(1, idx) 행은 arr 배열에서 주어진 idx 뒤에 나오는 다음 1의 인덱스를 찾습니다. idx 뒤에 오는 1이 있으면 해당 1의 인덱스가 answer 변수에 저장됩니다. idx 뒤에 1이 없으면 index() 메서드는 ValueError를 발생시키고 answer 변수는 except 블록에 지정된 대로 -1로 설정됩니다.
또다른 남의 답
def solution(arr, idx):
for i in range(idx, len(arr)):
if arr[i] == 1:
return i
return -1
def solution(arr, idx):
return "".join(map(str,arr)).find("1",idx)
def solution(arr, idx):
i = ''.join(map(str, arr[idx:])).find('1')
return i if i==-1 else idx+i
def solution(arr, idx):
answer = -1
for i in range(idx,len(arr)):
if arr[i]==1:
answer = i
break
return answer
def solution(arr, idx):
answer = 0
for i in range(idx, len(arr)):
if arr[i] == 1:
return i
return -1
- 특별한 이차원 배열 1//틀렸다
문제 설명
정수 n이 매개변수로 주어질 때, 다음과 같은 n × n 크기의 이차원 배열 arr를 return 하는 solution 함수를 작성해 주세요.
- arr[i][j] (0 ≤ i, j < n)의 값은 i = j라면 1, 아니라면 0입니다.
제한사항
- 1 ≤ n ≤ 100
입출력 예
n result 3 [[1, 0, 0], [0, 1, 0], [0, 0, 1]] 6 [[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]] 1 [[1]] def solution(n):
answer = [[]]
for i in range(1,n+1):
an[i]
answer.append(i)
return answer
def solution(n):
answer=[[0]*n for i in range(n)]
for i in range(n): answer[i][i]=1
return answer
- 약수 구하기
-
문제 설명
정수 n이 매개변수로 주어질 때, n의 약수를 오름차순으로 담은 배열을 return하도록 solution 함수를 완성해주세요.
제한사항
- 1 ≤ n ≤ 10,000
입출력 예
n result 24 [1, 2, 3, 4, 6, 8, 12, 24] 29 [1, 29] def solution(n):
answer = []
for i in range(1,n+1):
if n%i ==0:
answer.append(i)
return answer
def solution(n):
answer = [i for i in range(1,n+1) if n%i == 0]
return answer
- 369게임
문제 설명
머쓱이는 친구들과 369게임을 하고 있습니다. 369게임은 1부터 숫자를 하나씩 대며 3, 6, 9가 들어가는 숫자는 숫자 대신 3, 6, 9의 개수만큼 박수를 치는 게임입니다. 머쓱이가 말해야하는 숫자 order가 매개변수로 주어질 때, 머쓱이가 쳐야할 박수 횟수를 return 하도록 solution 함수를 완성해보세요.
제한사항
- 1 ≤ order ≤ 1,000,000
입출력 예
order result 3 1 29423 2 def solution(order):
answer = 0
order = str(order)
for i in order:
if i in ['3','6','9']:
answer +=1
return answer
?? Lambda 아직 약하다
def solution(order):
return sum(map(lambda x: str(order).count(str(x)), [3, 6, 9]))
차근 차근 람다와 count 함수 공부해야 한다
def solution(order):
answer = 0
order = str(order)
return order.count('3') + order.count('6') + order.count('9')
def solution(order):
answer = len([1 for ch in str(order) if ch in "369"])
return answer
- 숫자 찾기//틀렸어//?? 왜
문제 설명
정수 num과 k가 매개변수로 주어질 때, num을 이루는 숫자 중에 k가 있으면 num의 그 숫자가 있는 자리 수를 return하고 없으면 -1을 return 하도록 solution 함수를 완성해보세요.
제한사항
- 0 < num < 1,000,000
- 0 ≤ k < 10
- num에 k가 여러 개 있으면 가장 처음 나타나는 자리를 return 합니다.
입출력 예
num k result 29183 1 3 232443 4 4 123456 7 -1 내오답
def solution(num, k):
answer = 0
for i in str(num):
answer += 1
if i == k:
break
else:
anser = -1
return answer
내 오답 2
def solution(num, k):
num = str(num)
for i, nstr in enumerate(num):
if nstr == k: str(k)
answer = i+1. —> return i+1 이렇게 ㅂㄲㅇ
else: x
answer = -1 x
return answer. -> return -1
위엣것 수정본
def solution(num, k):
num = str(num)
for i, nstr in enumerate(num):
if nstr == str(k):
return i+1 ——> 바로 돌고 있는 것을 멈추는 구나
return -1
def solution(num, k):
str_num = str(num)
for i in range(len(str_num)):
if str_num[i] == str(k):
return i+1
return -1
위치 중요 들여쓰기의 중요
def solution(num, k):
return -1 if str(k) not in str(num) else str(num).find(str(k)) + 1 왜 마지막 에 +1 ? -> 이유는 find(str(k)) 가 출력하는 것이 인덱스 니까
def solution(num, k):
for i, n in enumerate(str(num)):
if str(k) == n:
return i + 1
return -1
def solution(num, k):
try:
return str(num).index(str(k)) + 1
except ValueError:
return -1
- 문자열 정렬하기 (2)
문제 설명
영어 대소문자로 이루어진 문자열 my_string이 매개변수로 주어질 때, my_string을 모두 소문자로 바꾸고 알파벳 순서대로 정렬한 문자열을 return 하도록 solution 함수를 완성해보세요.
제한사항
- 0 < my_string 길이 < 100
입출력 예
my_string result "Bcad" "abcd" "heLLo" "ehllo" "Python" "hnopty" 내 답
def solution(my_string):
answer = ''
an = my_string.lower()
an1 =list(an)
an1.sort()
an2 =''.join(an1)
answer = an2
return answer
남의 답
def solution(my_string):
return ''.join(sorted(my_string.lower()))
- 합성수 찾기// 난 어려웠어
문제 설명
약수의 개수가 세 개 이상인 수를 합성수라고 합니다. 자연수 n이 매개변수로 주어질 때 n이하의 합성수의 개수를 return하도록 solution 함수를 완성해주세요.
제한사항
- 1 ≤ n ≤ 100
입출력 예
n result 10 5 15 8 남의 답
def solution(n):
def is_composite(num):
count = 0
for i in range(1, num + 1):
if num % i == 0:
count += 1
return count >= 3
count = 0
for i in range(4, n + 1):
if is_composite(i):
count += 1
return count
- is_composite(num): 이 함수는 주어진 수 num이 소수인지 아닌지를 판별합니다. 함수 내부에서는 count 변수를 사용하여 num의 약수의 개수를 세어봅니다. 이를 위해 for 루프를 사용하여 1부터 num까지의 숫자를 순회하면서 num을 해당 숫자로 나누었을 때 나머지가 0인 경우, 즉, num을 해당 숫자로 나누어 떨어지는 경우를 찾습니다. 만약 나누어 떨어지는 경우, count를 1 증가시킵니다. 이후 count의 값이 1보다 크거나 같으면 num은 소수가 아니라고 판단하고 True를 반환합니다.
- count = 0: 이는 solution() 함수 내에서 소수가 아닌 수의 개수를 세기 위한 변수입니다. 처음에 count를 0으로 초기화합니다.
- for i in range(4, n + 1): 이는 4부터 n까지의 모든 수를 순회하는 for 루프입니다.
- if is_composite(i): 이는 is_composite() 함수를 사용하여 i가 소수인지 아닌지를 판별하는 조건문입니다. is_composite() 함수가 True를 반환하면, 즉 i가 소수가 아니라면, count를 1 증가시킵니다.
- return count: 이는 최종적으로 count를 반환하여 n을 기준으로 4부터 n까지의 소수가 아닌 수의 개수를 반환합니다.
이 코드는 주어진 수 n을 기준으로 4부터 n까지의 모든 수를 순회하면서 각 수가 소수인지 아닌지 판별하는 방법으로 소수가 아닌 수의 개수를 세어주는 코드입니다. 하지만, 문제의 요구사항은 소수가 아닌 수가 아닌 "합성수"의 개수를 구하는 것이기 때문에, 이 코드로는 정확한 결과를 얻을 수 없습니다. 이를 고려하여 문제를 해결하시기 바랍니다.
def solution(n):
output = 0
for i in range(4, n + 1):
for j in range(2, int(i ** 0.5) + 1):
if i % j == 0:
output += 1
break
return output
def get_divisors(n):
return list(filter(lambda v: n % v ==0, range(1, n+1)))
def solution(n):
return len(list(filter(lambda v: len(get_divisors(v)) >= 3, range(1, n+1))))
def solution(n):
return len([i for i in range(2, n + 1) if not all(i % j for j in range(2, i))])
def solution(n):
answer = 0
for i in range(3,n+1) :
temp = 1
for j in range(1,i) :
if i % j == 0 :
temp += 1
if temp > 2 :
answer += 1
return answer
def solution(n):
numbers = set([])
for i in range(2, n+1):
for j in range(2, i+1):
num = i*j
if num > n:
break
try:
numbers.add(num)
except ValueError:
pass
return len(numbers)
def solution(n):
def is_composite_num(num):
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return True
return False
return len([x for x in range(1, n + 1) if is_composite_num(x)])
def solution(n):
answer = 0
for i in range(1, n + 1):
if isprime(i) == False:
answer += 1
return answer
def isprime(num):
count = 0
for d in range(1, num + 1):
if num % d == 0:
count += 1
if count > 2:
return False
return True
def solution(n):
prim = [0]*(n+1)
answer = 0
idx = 2
p_inx = 0
p_target = 0
for i in range(2,n+1):
if prim[i] == 0:
p_inx = 2
p_target = i*p_inx
while p_target < n+1:
prim[p_target] = 1
p_inx += 1
p_target = i*p_inx
prim = prim[1:]
answer = prim.count(1)
return answer
def solution(n):
answer = n
for i in range(1, n + 1):
for j in range(2, i):
if i % j == 0:
answer -= 1
break
return n - answer
'TIL( Today I Learned)' 카테고리의 다른 글
2023.7.28.금요일, index() 함수 & 문제풀이 (0) 2023.07.28 2023.7.27.목요일 (1) 2023.07.27 2023.7.25.화요일 (0) 2023.07.25 2023.7.24.월요일. 100개 (0) 2023.07.24 2023.7.23.일요일 D-8, "Forward, 8 days left" 96 to ? (0) 2023.07.23