평균 구하기

 

 문제 설명

 

N개의 마을로 이루어진 나라가 있습니다. 이 나라의 각 마을에는 1부터 N까지의 번호가 각각 하나씩 부여되어 있습니다. 각 마을은 양방향으로 통행할 수 있는 도로로 연결되어 있는데, 서로 다른 마을 간에 이동할 때는 이 도로를 지나야 합니다. 도로를 지날 때 걸리는 시간은 도로별로 다릅니다. 현재 1번 마을에 있는 음식점에서 각 마을로 음식 배달을 하려고 합니다. 각 마을로부터 음식 주문을 받으려고 하는데, N개의 마을 중에서 K 시간 이하로 배달이 가능한 마을에서만 주문을 받으려고 합니다. 다음은 N = 5, K = 3인 경우의 예시입니다.

위 그림에서 1번 마을에 있는 음식점은 [1, 2, 4, 5] 번 마을까지는 3 이하의 시간에 배달할 수 있습니다. 그러나 3번 마을까지는 3시간 이내로 배달할 수 있는 경로가 없으므로 3번 마을에서는 주문을 받지 않습니다. 따라서 1번 마을에 있는 음식점이 배달 주문을 받을 수 있는 마을은 4개가 됩니다.
마을의 개수 N, 각 마을을 연결하는 도로의 정보 road, 음식 배달이 가능한 시간 K가 매개변수로 주어질 때, 음식 주문을 받을 수 있는 마을의 개수를 return 하도록 solution 함수를 완성해주세요.

 

 제한 사항

 

 

  • 마을의 개수 N은 1 이상 50 이하의 자연수입니다.
  • road의 길이(도로 정보의 개수)는 1 이상 2,000 이하입니다.
  • road의 각 원소는 마을을 연결하고 있는 각 도로의 정보를 나타냅니다.
  • road는 길이가 3인 배열이며, 순서대로 (a, b, c)를 나타냅니다.
    • a, b(1 ≤ a, b ≤ N, a != b)는 도로가 연결하는 두 마을의 번호이며, c(1 ≤ c ≤ 10,000, c는 자연수)는 도로를 지나는데 걸리는 시간입니다.
    • 두 마을 a, b를 연결하는 도로는 여러 개가 있을 수 있습니다.
    • 한 도로의 정보가 여러 번 중복해서 주어지지 않습니다.
  • K는 음식 배달이 가능한 시간을 나타내며, 1 이상 500,000 이하입니다.
  • 임의의 두 마을간에 항상 이동 가능한 경로가 존재합니다.
  • 1번 마을에 있는 음식점이 K 이하의 시간에 배달이 가능한 마을의 개수를 return 하면 됩니다.

 

 

 입출력 예

 

N arr K result
5 [[1,2,1], [2,3,3], [5,2,2], [1,4,2], [5,3,1], [5,4,2]] 3 4
6 [[1,2,1], [1,3,2], [2,3,2], [3,4,3], [3,5,2], [3,5,3], [5,6,1]] 4 4

 

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
주어진 마을과 도로의 모양은 아래 그림과 같습니다.


1번 마을에서 배달에 4시간 이하가 걸리는 마을은 [1, 2, 3, 5] 4개이므로 4를 return 합니다.

 

 Python 코드

 

플로이드워셜

def solution(N, road, K):
    INF = 1000000000
    answer = 0
    graph = [[INF] * (N + 1) for _ in range(N + 1)]
 
    for i in range(1, N + 1):
        for j in range(1, N + 1):
            if i == j:
                graph[i][j] = 0
 
    for r in road:
        a, b, c = r[0], r[1], r[2]
        if graph[a][b] > c:
            graph[a][b] = c
            graph[b][a] = c
 
    for i in range(1, N + 1):
        for j in range(1, N + 1):
            for k in range(1, N + 1):
                graph[j][k] = min(graph[j][k], graph[j][i] + graph[i][k])
 
    for j in range(1, N + 1):
        if graph[1][j] <= K:
            answer += 1
 
    return answer

다익스트라 

from queue import PriorityQueue
 
 
def solution(N, road, K):
    INF = 1000000000
    answer = 0
    distance = [INF] * (N + 1)
 
    q = PriorityQueue()
    q.put([1, 0])
    distance[1] = 0
    while not q.empty():
        now, now_cost = q.get()
 
        if now_cost > distance[now]: continue
        for start, dest, cost in road:
            next_cost = now_cost + cost
            if start == now and next_cost < distance[dest]:
                distance[dest] = next_cost
                q.put([dest, next_cost])
            elif dest == now and next_cost < distance[start]:
                distance[start] = next_cost
                q.put([start, next_cost])
 
    for i in range(1, N + 1):
        if distance[i] <= K:
            answer += 1
 
    return answer

* 참고 링크 : https://foameraserblue.tistory.com/86

 

 C++ 코드

 

#include <vector>
#include <queue>
using namespace std;
 
vector<pair<int,int>> V[55];
vector<int> Dist;
 
int Min(int A, int B) { if (A < B) return A; return B; }
 
void Dijkstra(int N)
{
    priority_queue<pair<int, int>> PQ;
    PQ.push(make_pair(0, 1));
    Dist[1] = 0;
 
    while (PQ.empty() == 0)
    {
        int Cost = -PQ.top().first;
        int Cur = PQ.top().second;
        PQ.pop();
 
        for (int i = 0; i < V[Cur].size(); i++)
        {
            int Next = V[Cur][i].first;
            int nCost = V[Cur][i].second;
 
            if (Dist[Next] > Cost + nCost)
            {
                Dist[Next] = Cost + nCost;
                PQ.push(make_pair(-Dist[Next], Next));
            }
        }
    }
}
 
int solution(int N, vector<vector<int> > road, int K)
{
    Dist.resize(N + 1, 2e9);
    for (int i = 0; i < road.size(); i++)
    {
        int N1 = road[i][0];
        int N2 = road[i][1];
        int Dist = road[i][2];
 
        V[N1].push_back(make_pair(N2, Dist));
        V[N2].push_back(make_pair(N1, Dist));
    }
 
    Dijkstra(N);
    int answer = 0;
    for (int i = 1; i <= N; i++)
    {
        if (Dist[i] <= K) answer++;
    }
 
    return answer;
}

* 참고 링크 : https://yabmoons.tistory.com/633

 출처

 

https://programmers.co.kr/learn/courses/30/lessons/12978

Contains Duplicate 

 

 문제 설명

 

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

 

 제한 사항

 

 

  • 1 <= nums.length <= 105
  • -109 <= nums[i] <= 109

 

 

 입출력 예

 

Example 1:

Input: nums = [1,2,3,1]
Output: true

Example 2:

Input: nums = [1,2,3,4]
Output: false

Example 3:

Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true

 

 

 Python 코드

 

Python code 

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return len(set(nums)) != len(nums)

* 참고 링크 : https://leetcode.com/problems/contains-duplicate/discuss/1159570/Python-99.25-faster

https://leetcode.com/problems/contains-duplicate/discuss/471215/Python-sol-by-native-set-and-length.-run-time-90%2B

 

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
    	hashset = set()
        
        for n in nums:
        	if n in hashset:
            	    return True
        	hashset.add()
        return False

* 참고 링크 : https://www.youtube.com/watch?v=3OamzN90kPg 

 

 C++ 코드

 

C ++ code

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int,bool> map;
        for(size_t i = 0;i<nums.size();++i)
        {
            if(map[nums[i]]==true)
                return true;
            map[nums[i]]=true;
        }
        return false;
    }
};

* 참고 링크 : https://kkminseok.github.io/posts/leetcode_Contains_Duplicate/

 

 출처

 

https://leetcode.com/problems/contains-duplicate/

Prime Number of Set Bits in Binary Representation

 

 문제 설명

 

Given two integers left and right, return the count of numbers in the inclusive range [left, right] having a prime number of set bits in their binary representation.

Recall that the number of set bits an integer has is the number of 1's present when written in binary.

  • For example, 21 written in binary is 10101, which has 3 set bits.
왼쪽과 오른쪽 두 개의 정수가 주어지면 이진 표현에 소수의 세트 비트를 갖는 포함 범위[좌, 우]의 숫자 카운트를 반환합니다.

정수가 갖는 세트 비트의 수는 이진수로 쓸 때 존재하는 1의 수라는 것을 기억하라.

예를 들어, 이진법으로 작성된 21은 10101이고, 3개의 세트 비트를 가지고 있다.

 

 제한 사항

 

  • 1 <= left <= right <= 106
  • 0 <= right - left <= 104

 

 입출력 예

 

Example 1:

Input: left = 6, right = 10
Output: 4
Explanation:
6  -> 110 (2 set bits, 2 is prime)
7  -> 111 (3 set bits, 3 is prime)
8  -> 1000 (1 set bit, 1 is not prime)
9  -> 1001 (2 set bits, 2 is prime)
10 -> 1010 (2 set bits, 2 is prime)
4 numbers have a prime number of set bits.

Example 2:

Input: left = 10, right = 15
Output: 5
Explanation:
10 -> 1010 (2 set bits, 2 is prime)
11 -> 1011 (3 set bits, 3 is prime)
12 -> 1100 (2 set bits, 2 is prime)
13 -> 1101 (3 set bits, 3 is prime)
14 -> 1110 (3 set bits, 3 is prime)
15 -> 1111 (4 set bits, 4 is not prime)
5 numbers have a prime number of set bits.

 

 Python 코드

 

Python code 

class Solution:
    def countPrimeSetBits(self, L: int, R: int) -> int:
        return sum(bin(i).count('1') in [2,3,5,7,11,13,17,19] for i in range(L, R+1))

bin(i).count('1') # 이진 표현에서 1의 수가 소수인 경우

bin(i).count('1') in [2, 3, 4, 5, 7, 11, 13, 17, 19]  

# 이진 표현에서 1의 수가 [2, 3, 4, 5, 7, 11, 13, 17, 19]에 빈도가 있는 경우

sum(bin(i).count('1') in [2, 3, 5, 7, 11, 13, 17, 19] for i in range(L, R+1))

# sum( ) 함수를 이용하여 count를 증가시킨다.

 

* 참고 링크 1 : https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/discuss/801535/Python-3-One-Line

 

 

 C++ 코드

 

C ++ code

// c++ code
#include <cmath>
class Solution {
public:
    int countPrimeSetBits(int L, int R) {
        int res = 0;
        for (int num = L; num <= R; num++) {
            int count = countOne(num);
            if (isPrime(count))
                res++;
        }
        return res;
    }
    
    bool isPrime(int num) {
        if (num <= 3)
            return num > 1;
        
        int square_root = sqrt(num);
        for (int i = 2; i <= square_root; i++) {
            if (num % i == 0)
                return false;
        }
        return true;
    }
    
    int countOne(int num) {
        vector<int> bin = dec2bin(num);
        int count = 0;
        for (auto i = bin.begin(); i < bin.end(); i++) {
            if (*i == 1)
                count++;
        }
        return count;
    }
    
    vector<int> dec2bin(int num) {
        vector<int> bin;
        while (num != 0) {
            bin.push_back(num % 2);
            num /= 2;
        }
        reverse(bin.begin(), bin.end());
        return bin;
    }
};

* 참고 링크 : https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/discuss/376499/C%2B%2B-and-Python-3-bad-performance-need-to-improve

 

 출처

 

https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/

Power of Four

 

 문제 설명

 

Given an integer n, return true if it is a power of four. Otherwise, return false.

An integer n is a power of four, if there exists an integer x such that n == 4x.

 

 제한 사항

 

  • -231 <= n <= 231 - 1

 

 입출력 예

 

Example 1:

Input: n = 16
Output: true

Example 2:

Input: n = 5
Output: false

Example 3:

Input: n = 1
Output: true

 

 

 Python 코드

 

Python code 

class Solution:
    def isPowerOfFour(self, n: int) -> bool:
        return math.log(n, 1/4) % 1 == 0 if n > 0 else False

* 참고 링크 : https://leetcode.com/problems/power-of-four/discuss/637372/Python-3-Single-line

  • math.log( ) 함수 이용 // loops(반복문) 또는 recursion(재귀)를 피하는 방법 중 하나// x : 필수의 로그를 계산할 값을 지정// base : 선택적으로 사용할 로그 베이스 (Default 값 : e)
  • ( 값이 0 또는 음수이면 ValueError 반환, 값이 숫자가 아니면 TypeError를 반환)
  • math.log(x, base)

 

 C++ 코드

 

C ++ code

class Solution {
public:
    bool isPowerOfFour(int num) {
        return num > 0 && (num & (num - 1)) == 0 && (num - 1) % 3 == 0;
    }
};

* 참고 링크 : https://leetcode.com/problems/power-of-four/discuss/80460/1-line-C%2B%2B-solution-without-confusing-bit-manipulations

 

 출처

 

https://leetcode.com/problems/power-of-four/

Consecutive Numbers

 

 문제 설명

 

Table: Logs

+-------------+---------+
| 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 in any 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.)

 

 출처

 

https://leetcode.com/problems/consecutive-numbers/

Valid Triangle Number

 

 문제 설명

 

Given an integer array nums, return the 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

* 참고 링크 : https://leetcode.com/problems/valid-triangle-number/discuss/104177/O(N2)-solution-for-C%2B%2B-and-Python

 

 C++ 코드

 

C ++ code

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;
    }
};

* 참고 링크 : https://www.programmerall.com/article/1415760413/

 

 출처

 

https://leetcode.com/problems/valid-triangle-number/

Find Peak Element

 

 문제 설명

 

A peak element is an element that is strictly greater than its neighbors.

Given an integer array nums, find a peak element, and return its index. If the array contains multiple peaks, return the index to any of the peaks.

You may imagine that nums[-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 valid i.

 

 입출력 예

 

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가 정답

* 참고 링크 : https://velog.io/@hrpp1300/LeetCode-162.-Find-Peak-Element

 

 C++ 코드

 

C ++ code

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; 
    }
};

* 참고 링크 : https://myeongcs.tistory.com/80

 

 출처

 

https://leetcode.com/problems/find-peak-element/submissions/

Same Tree

 

 문제 설명

 

We are playing the Guess Game. The game is as follows:

I pick a number from 1 to n. 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 API int 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).

Return the 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

* 참고 링크 : https://somjang.tistory.com/entry/leetCode-374-Guess-Number-Higher-or-Lower-Python

 

 C++ 코드

 

C ++ code

//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;
    }
};

* 참고 링크 : https://github.com/keineahnung2345/leetcode-cpp-practices/blob/master/374.%20Guess%20Number%20Higher%20or%20Lower.cpp

 

 출처

 

https://leetcode.com/problems/guess-number-higher-or-lower/

숫자 카드 2

 

 문제 설명

 

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 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 ))

* 참고 링크 : https://0equal2.tistory.com/62

 

 C++ 코드

 

#include <iostream> 
#include <vector> 
#include <algorithm> 

using namespace std; 

int n,m; 
vector<int> arr; 
vector<int> target; 

int main() { 
	ios_base :: sync_with_stdio(false); 
	cin.tie(NULL); cout.tie(NULL); 
	cin >> n; 
	
	int count[n]={0,}; 
	for(auto i = 0;i<n;i++) { 
		int x; 
		cin >> x; 
		arr.push_back(x); 
	} 
	
	sort(arr.begin(),arr.end()); 
	
	cin >> m; 
	for(auto i =0; i<m;i++) { 
		int x; 
		cin >> x; 
		
		cout << upper_bound(arr.begin(),arr.end(),x) - lower_bound(arr.begin(),arr.end(),x)<< " "; 
	} 
}

* 참고 링크 : https://tooo1.tistory.com/126

 출처

 

https://www.acmicpc.net/problem/10816

소수찾기

 

 문제 설명

 

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 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

* 참고 링크 : https://mentha2.tistory.com/8

 

 C++ 코드

 

#include<string>
#include<vector>
#include<cmath>
 
using namespace std;
 
bool Visit[10000000];
bool Select[10];
int Answer;
 
bool IsPrime(int N)
{
    if (N == 0 || N == 1) return false;
 
    for (int i = 2; i <= sqrt(N); i++)
    {
        if (N % i == 0) return false;
    }
    return true;
}
 
void DFS(int Cnt, string S, string Res)
{
    if(Res != "" && Visit[stoi(Res)] == false)
    {
        int Num = stoi(Res);
        Visit[Num] = true;
        if (IsPrime(Num) == true) Answer++;
    }
 
    for (int i = 0; i < S.length(); i++)
    {
        if (Select[i] == true) continue;
        Select[i] = true;
        DFS(Cnt + 1, S, Res + S[i]);
        Select[i] = false;
    }
}
 
int solution(string S)
{
    DFS(0, S, "");
    return Answer;
}

* 참고 링크 : https://yabmoons.tistory.com/336

 출처

 

https://programmers.co.kr/learn/courses/30/lessons/42839

모의고사

 

 문제 설명

 

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 

 제한 사항

 

  • 시험은 최대 10,000 문제로 구성되어있습니다.
  • 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
  • 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

 

 입출력 예

 

answers return
[1, 2, 3, 4, 5] [1]
[1, 3, 2, 4, 2] [1, 2, 3]

 

 Python 코드

 

def solution(answers):
    
    answer = []
    # 패턴정의
    first = [ 1,2,3,4,5 ]
    second = [ 2,1,2,3,2,4,2,5 ]
    third = [ 3,3,1,1,2,2,4,4,5,5 ]
    
    # 점수정의
    first_count = 0
    second_count = 0
    third_count = 0
    
    # 정답확인
    for number in range(len(answers)):
        if answers[ number ] == first[ number % 5 ]:
            first_count += 1
        if answers[ number ] == second[ number % 8 ]:
            second_count += 1
        if answers[ number ] == third[ number %10 ]:
            third_count += 1
    pre_answer = [ first_count,second_count,third_count ]   
    
    # 가장 많이 맞힌 사람
    for person, score in enumerate(pre_answer):
        if score == max(pre_answer):
            answer.append(person + 1)
    return answer

* 참고 링크 : https://sinsomi.tistory.com/entry/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EB%AA%A8%EC%9D%98%EA%B3%A0%EC%82%AC

 

 C++ 코드

 

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int test1[5] = {1, 2, 3, 4, 5};
int test2[8] = {2, 1, 2, 3, 2, 4, 2, 5};
int test3[10] = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

vector<int> solution(vector<int> answers) {
    vector<int> answer;
    int score[3] = {0, };
    int max_score = 0;
    for (int i = 0; i < answers.size(); i++){
        if (answers[i] == test1[i % 5]) score[0] += 1;
        if (answers[i] == test2[i % 8]) score[1] += 1;
        if (answers[i] == test3[i % 10]) score[2] += 1;
    }
    max_score = max(max(score[0], score[1]), score[2]);
    for (int i = 0; i < 3; i++){
        if (score[i] == max_score)
            answer.push_back(i + 1);
    }
    return answer;
}

 

* 참고 링크 : https://rile1036.tistory.com/28

 

 출처

 

https://programmers.co.kr/learn/courses/30/lessons/42840

Design Circular Queue

 

 문제 설명

 

Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".

One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.

Implementation the MyCircularQueue class:

  • MyCircularQueue(k) Initializes the object with the size of the queue to be k.
  • int Front() Gets the front item from the queue. If the queue is empty, return -1.
  • int Rear() Gets the last item from the queue. If the queue is empty, return -1.
  • boolean enQueue(int value) Inserts an element into the circular queue. Return true if the operation is successful.
  • boolean deQueue() Deletes an element from the circular queue. Return true if the operation is successful.
  • boolean isEmpty() Checks whether the circular queue is empty or not.
  • boolean isFull() Checks whether the circular queue is full or not.

You must solve the problem without using the built-in queue data structure in your programming language. 

 

 제한 사항

 

  • 1 <= k <= 1000
  • 0 <= value <= 1000
  • At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull.

 

 입출력 예

 

Example 1:

Input
["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
Output
[null, true, true, true, false, 3, true, true, true, 4]

Explanation
MyCircularQueue myCircularQueue = new MyCircularQueue(3);
myCircularQueue.enQueue(1); // return True
myCircularQueue.enQueue(2); // return True
myCircularQueue.enQueue(3); // return True
myCircularQueue.enQueue(4); // return False
myCircularQueue.Rear();     // return 3
myCircularQueue.isFull();   // return True
myCircularQueue.deQueue();  // return True
myCircularQueue.enQueue(4); // return True
myCircularQueue.Rear();     // return 4

 

 Python 코드

 

Python code 

class MyCirculurQueue:
    def __init__(self, k):
        self.q = [None] * k
        self.maxlen = k
        self.p1 = 0
        self.p2 = 0

    # enQueue(): rear 포인터 이동
    def enQueue(self, value):
        if self.q[self.p2] is None:
            self.q[self.p2] = value
            self.p2 = (self.p2 + 1) % self.maxlen
            return True
        else:
            return False

    # deQueue(): front 포인터 이동
    def deQueue(self):
        if self.q[self.p1] is None:
            return False
        else:
            self.q[self.p1] = None
            self.p1 = (self.p1 + 1) % self.maxlen
            return True

    def Front(self):
        return -1 if self.q[self.p1] is None else self.q[self.p1]

    def Rear(self):
        return -1 if self.q[self.p2 - 1] is None else self.q[self.p2 - 1]

    def isEmpty(self):
        return self.p1 == self.p2 and self.q[self.p1] is None

    def isFull(self):
        return self.p1 == self.p2 and self.q[self.p1] is not None

* 참고 링크 : https://deep-learning-study.tistory.com/480

 

 C++ 코드

 

C ++ code


class MyCircularQueue {
public:
  MyCircularQueue(int k): q_(k) {}
  
  bool enQueue(int value) {
    if (isFull()) return false;
    q_[(head_ + size_) % q_.size()] = value;    
    ++size_;
    return true;
  }
  
  bool deQueue() {
    if (isEmpty()) return false;
    head_ = (head_ + 1) % q_.size();
    --size_;
    return true;
  }
 
  int Front() { return isEmpty() ? -1 : q_[head_]; }
 
  int Rear() { return isEmpty() ? -1 : q_[(head_ + size_ - 1) % q_.size()]; }
 
  bool isEmpty() { return size_ == 0; }
 
  bool isFull() { return size_ == q_.size(); }
private:
  vector<int> q_;
  int head_ = 0;
  int size_ = 0;
};

* 참고 링크 : https://zxi.mytechroad.com/blog/desgin/leetcode-622-design-circular-queue/

 

 출처

 

https://leetcode.com/problems/design-circular-queue/

+ Recent posts