+-------------+---------+
| Column Name | Type |
+-------------+---------+
| id | int |
| num | varchar |
+-------------+---------+
id is the primary key for this table.
Write an SQL query to find all numbers that appear at least three times consecutively.
Return the result table inany order.
The query result format is in the following example.
입출력 예
Example 1:
Input:
Logs table:
+----+-----+
| id | num |
+----+-----+
| 1 | 1 |
| 2 | 1 |
| 3 | 1 |
| 4 | 2 |
| 5 | 1 |
| 6 | 2 |
| 7 | 2 |
+----+-----+
Output:
+-----------------+
| ConsecutiveNums |
+-----------------+
| 1 |
+-----------------+
Explanation: 1 is the only number that appears consecutively for at least three times.
Oracle Query
SELECT DISTINCT
l1.Num As ConsecutiveNums
FROM Logs l1
JOIN Logs l2 ON l1.Id = l2.Id-1
JOIN Logs l3 ON l2.Id = l3.Id-1
WHERE l1.Num = l2.Num
AND l2.Num = l3.Num;
* 참고 링크 : https://leetcode.com/problems/consecutive-numbers/discuss/185886/Self-Join-Twice-(681-ms-faster-than-100.00-of-Oracle-online-submissions-for-Consecutive-Numbers.)
Given an integer arraynums, returnthe number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
제한 사항
1 <= nums.length <= 1000
0 <= nums[i] <= 1000
입출력 예
Example 1:
Input: nums = [2,2,3,4]
Output: 3
Explanation: Valid combinations are:
2,3,4 (using the first 2)
2,3,4 (using the second 2)
2,2,3
Example 2:
Input: nums = [4,2,3,4]
Output: 4
Python 코드
Python code
class Solution(object):
def triangleNumber(self, nums):
nums, count, n = sorted(nums, reverse=1), 0, len(nums)
for i in range(n):
j, k = i + 1, n - 1
while j < k:
if nums[j] + nums[k] > nums[i]:
count += k - j
j += 1
else:
k -= 1
return count
class Solution {
public:
int triangleNumber(vector<int>& nums) {
if(nums.size() < 3) return 0;
sort(nums.begin(), nums.end(), greater<int>());
int res = 0;
int n = nums.size();
for(int a = 0; a < n-2; ++a){
int b = a+1;
int c = n-1;
while(b < c){
if(nums[b] + nums[c] > nums[a]){
res = res + c - b;
++b;
}
else
--c;
}
}
return res;
}
};
A peak element is an element that is strictly greater than its neighbors.
Given an integer arraynums, find a peak element, and return its index. If the array contains multiple peaks, return the index toany of the peaks.
You may imagine thatnums[-1] = nums[n] = -∞.
You must write an algorithm that runs in O(log n)time.
제한 사항
1 <= nums.length <= 1000
-231<= nums[i] <= 231- 1
nums[i] != nums[i + 1]for all validi.
입출력 예
Example 1:
Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and your function should return the index number 2.
Example 2:
Input: nums = [1,2,1,3,5,6,4]
Output: 5
Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.
Python 코드
Python code
class Solution:
def findPeakElement(self, nums: List[int]) -> int:
left = 0
right = len(nums)-1
# left가 커지고 right가 작아지는 경우 left와 right가 같아질 수 있다.
# 그 때 원한느 값을 찾은 경우이므로 left와 right가 같아지면 반복문 종료
while left < right:
mid = (left + right) // 2 # 가운데 지점
if nums[mid] < nums[mid+1]: # 현재 값이 오른쪽 값보다 작다면
left = mid+1
else: # 현재 값이 오른쪽 값보다 크다면
right = mid
return left # 반복문이 종료되면 left가 정답
class Solution {
public:
int findPeakElement(vector<int>& nums) {
int left = 0;
int right = nums.size() - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] > nums[mid + 1]) {
right = mid;
}
else {
left = mid + 1;
}
}
return left;
}
};
We are playing the Guess Game. The game is as follows:
I pick a number from1ton. You have to guess which number I picked.
Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.
You call a pre-defined APIint guess(int num), which returns three possible results:
-1: Your guess is higher than the number I picked (i.e.num > pick).
1: Your guess is lower than the number I picked (i.e.num < pick).
0: your guess is equal to the number I picked (i.e.num == pick).
Returnthe number that I picked.
제한 사항
1 <= n <= 231- 1
1 <= pick <= n
입출력 예
Example 1:
Input: n = 10, pick = 6
Output: 6
Example 2:
Input: n = 1, pick = 1
Output: 1
Example 3:
Input: n = 2, pick = 1
Output: 1
Python 코드
Python code
# The guess API is already defined for you.
# @param num, your guess
# @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
# def guess(num: int) -> int:
class Solution:
def guessNumber(self, n: int) -> int:
left, right = 1, n
while True:
middle_num = int((left + right) / 2)
if guess(middle_num) == 1:
left = middle_num + 1
elif guess(middle_num) == -1:
right = middle_num - 1
else:
return middle_num
//Runtime: 0 ms, faster than 100.00% of C++ online submissions for Guess Number Higher or Lower.
//Memory Usage: 7.3 MB, less than 100.00% of C++ online submissions for Guess Number Higher or Lower.
// Forward declaration of guess API.
// @param num, your guess
// @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
int guess(int num);
class Solution {
public:
int guessNumber(int n) {
int left = 1, right = n, cur = left+(right-left)/2;
while(true){
switch(guess(cur)){
case -1:
right = cur-1;
cur = left+(right-left)/2;
break;
case 1:
left = cur+1;
cur = left+(right-left)/2;
break;
case 0:
return cur;
}
}
return 0;
}
};
숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.
입력
첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
출력
첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.
예제 입출력
Python 코드
from sys import stdin
from collections import Counter
# 1. n 입력
n = int(stdin.readline())
# 2. n개의 정수
arr = list(map(int, stdin.readline().split()))
# 3. m 입력
m = int(stdin.readline())
# 4. m개의 정수
find = list(map(int, stdin.readline().split()))
# 5. counter 함수 활용
count = Counter(arr)
# print(count)
print(' '.join(str(count[x]) if x in count else '0' for x in find ))
한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.
각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.
제한 사항
numbers는 길이 1 이상 7 이하인 문자열입니다.
numbers는 0~9까지 숫자만으로 이루어져 있습니다.
"013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.
입출력 예
number
return
"17"
3
"011"
2
Python 코드
from itertools import permutations
def solution(numbers):
# 소수 판별할 리스트 만들기
num_list = [] # 전체 순열 넣어줄 리스트
for i in range(1,len(numbers)+1) :
test_list = permutations(numbers,i)
for j in test_list :
num_list.append(int("".join(j)))
num_list = set(num_list) # 중복과 0, 1 제외
if 0 in num_list :
num_list.remove(0)
if 1 in num_list :
num_list.remove(1)
# 소수 판별
answer = len(num_list) # 모든 수가 소수라 가정하고 시작
for i in num_list :
if i != 2 :
for j in range(2,int(i**0.5)+1) :
if i % j== 0 :
answer -=1
break
return answer
