Posts tagged as “gcd”

花花酱 LeetCode 1447. Simplified Fractions

By zxi on May 17, 2020

Given an integer n, return a list of all simplified fractions between 0 and 1 (exclusive) such that the denominator is less-than-or-equal-to n. The fractions can be in any order.

Example 1:

Input: n = 2
Output: ["1/2"]
Explanation: "1/2" is the only unique fraction with a denominator less-than-or-equal-to 2.

Example 2:

Input: n = 3
Output: ["1/2","1/3","2/3"]

Example 3:

Input: n = 4
Output: ["1/2","1/3","1/4","2/3","3/4"]
Explanation: "2/4" is not a simplified fraction because it can be simplified to "1/2".

Example 4:

Input: n = 1
Output: []

Constraints:

1 <= n <= 100

Solution: GCD

if gcd(a, b) == 1 then a/b is a simplified frication.

std::gcd is available since c++17.

Time complexity: O(n^2logn)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<string> simplifiedFractions(int n) {

vector<string> ans;

for (int i = 1; i < n; ++i)

for (int j = i + 1; j <= n; ++j)

if (gcd(i, j) == 1)

ans.push_back(to_string(i) + "/" + to_string(j));

return ans;

}

};

花花酱 LeetCode 365. Water and Jug Problem

By zxi on March 9, 2020

You are given two jugs with capacities x and y litres. There is an infinite amount of water supply available. You need to determine whether it is possible to measure exactly z litres using these two jugs.

If z liters of water is measurable, you must have z liters of water contained within one or both buckets by the end.

Operations allowed:

Fill any of the jugs completely with water.
Empty any of the jugs.
Pour water from one jug into another till the other jug is completely full or the first jug itself is empty.

Example 1: (From the famous “Die Hard” example)

Input: x = 3, y = 5, z = 4
Output: True

Example 2:

Input: x = 2, y = 6, z = 5
Output: False

Solution: Math

special case 1: x == z or y == z or x + y == z: return True
special case 2: x + y < z: return False
normal case: z must be a factor of gcd(x, y)

Time complexity: O(log(min(x, y))
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

bool canMeasureWater(int x, int y, int z) {

if (x == z || y == z || x + y == z) return true;

if (x + y < z) return false;

return z % gcd(x, y) == 0;

}

};

花花酱 LeetCode 1250. Check If It Is a Good Array

By zxi on November 8, 2019

Given an array nums of positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers. The array is said to be good if you can obtain a sum of 1 from the array by any possible subset and multiplicand.

Return True if the array is good otherwise return False.

Example 1:

Input: nums = [12,5,7,23]
Output: true
Explanation: Pick numbers 5 and 7.
5*3 + 7*(-2) = 1

Example 2:

Input: nums = [29,6,10]
Output: true
Explanation: Pick numbers 29, 6 and 10.
29*1 + 6*(-3) + 10*(-1) = 1

Example 3:

Input: nums = [3,6]
Output: false

Constraints:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9

Solution: Math

Bézout’s lemma: b[1] * A[1] + b[2] * A[2] + …. + b[n] * A[n] = 1 <==> gcd(A[1], A[2], …, A[n]) = 1 <=> at least two numbers are co-prime

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

bool isGoodArray(vector<int>& nums) {

int g = nums[0];

for (int x : nums)

g = gcd(g, x);

return g == 1;

}

};

花花酱 LeetCode 1201. Ugly Number III

By zxi on September 22, 2019

Write a program to find the n-th ugly number.

Ugly numbers are positive integers which are divisible by a or b or c.

Example 1:

Input: n = 3, a = 2, b = 3, c = 5
Output: 4
Explanation: The ugly numbers are 2, 3, 4, 5, 6, 8, 9, 10... The 3rd is 4.

Example 2:

Input: n = 4, a = 2, b = 3, c = 4
Output: 6
Explanation: The ugly numbers are 2, 3, 4, 6, 8, 9, 12... The 4th is 6.

Example 3:

Input: n = 5, a = 2, b = 11, c = 13
Output: 10
Explanation: The ugly numbers are 2, 4, 6, 8, 10, 11, 12, 13... The 5th is 10.

Example 4:

Input: n = 1000000000, a = 2, b = 217983653, c = 336916467
Output: 1999999984

Constraints:

1 <= n, a, b, c <= 10^9
1 <= a * b * c <= 10^18
It’s guaranteed that the result will be in range [1, 2 * 10^9]

Solution: Binary Search

Number of ugly numbers that are <= m are:

m / a + m / b + m / c – (m / LCM(a,b) + m / LCM(a, c) + m / LCM(b, c) + m / LCM(a, LCM(b, c))

Time complexity: O(logn)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int nthUglyNumber(int n, long a, long b, long c) {

long l = 1;

long r = INT_MAX;

long ab = lcm(a, b);

long ac = lcm(a, c);

long bc = lcm(b, c);

long abc = lcm(a, bc);

while (l < r) {

long m = l + (r - l) / 2;

long k = m / a + m / b + m / c - m / ab - m / ac - m / bc + m / abc;

if (k >= n) r = m;

else l = m + 1;

}

return l;

}

};

花花酱 LeetCode 914. X of a Kind in a Deck of Cards

By zxi on September 30, 2018

Problem

n a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

Each group has exactly X cards.
All the cards in each group have the same integer.

Example 1:

Input: [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4]

Example 2:

Input: [1,1,1,2,2,2,3,3]
Output: false
Explanation: No possible partition.

Example 3:

Input: [1]
Output: false
Explanation: No possible partition.

Example 4:

Input: [1,1]
Output: true
Explanation: Possible partition [1,1]

Example 5:

Input: [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2]

Note:

1 <= deck.length <= 10000
0 <= deck[i] < 10000

Solution 1: HashTable + Brute Force

Try all possible Xs. 2 ~ deck.size()

Time complexity: ~O(n)

Space complexity: O(1)

C++

// Author: Huahua, 16 ms

class Solution {

public:

bool hasGroupsSizeX(vector<int>& deck) {

unordered_map<int, int> counts;

for (int card : deck) ++counts[card];

for (int i = 2; i <= deck.size(); ++i) {

if (deck.size() % i) continue;

bool ok = true;

for (const auto& pair : counts)

if (pair.second % i) {

ok = false;

break;

}

if (ok) return true;

}

return false;

}

};

Solution 2: HashTable + GCD

Time complexity: O(nlogn)

Space complexity: O(1)

C++

// Author: Huahua, 16 ms

class Solution {

public:

bool hasGroupsSizeX(vector<int>& deck) {

unordered_map<int, int> counts;

for (int card : deck) ++counts[card];

int X = deck.size();

for (const auto& p : counts)

X = __gcd(X, p.second);

return X >= 2;

}

};

Java

// Author: Somebody

class Solution {

public boolean hasGroupsSizeX(int[] deck) {

HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

for (int i=0; i<deck.length; i++) {

int curr = deck[i];

if (map.containsKey(curr)) {

map.put(curr, map.get(curr) + 1);

} else {

map.put(curr, 1);

}

// O(nLogn)

int gcd = 0;

for(Integer key: map.keySet()) {

gcd = findGCDOfTwoNumbers(map.get(key), gcd);

}

return gcd >= 2;

}

// O(Log n)

public static int findGCDOfTwoNumbers (int a, int b) {

if (b == 0) {

return a;

}

return findGCDOfTwoNumbers(b, a%b);

}