feat: add solutions to lc problem: No.1175

No.1175.Prime Arrangements

Author: yanglbme

solution/0100-0199/0172.Factorial Trailing Zeroes/README.md

@@ -51,14 +51,16 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-题目实际上是求 1~n 中有多少个 5 的因数。
+**方法一：数学**
 
-我们以 130 为例来分析：
+题目实际上是求 $[1,n]$ 中有多少个 $5$ 的因数。
 
-1. 第 1 次除以 5，得到 26，表示存在 26 个包含因数 5 的数；
-1. 第 2 次除以 5，得到 5，表示存在 5 个包含因数 5² 的数；
-1. 第 3 次除以 5，得到 1，表示存在 1 个包含因数 5³ 的数；
-1. 累加得到从 1~n 中所有 5 的因数的个数。
+我们以 $130$ 为例来分析：
+
+1. 第 $1$ 次除以 $5$，得到 $26$，表示存在 $26$ 个包含因数 $5$ 的数；
+1. 第 $2$ 次除以 $5$，得到 $5$，表示存在 $5$ 个包含因数 $5^2$ 的数；
+1. 第 $3$ 次除以 $5$，得到 $1$，表示存在 $1$ 个包含因数 $5^3$ 的数；
+1. 累加得到从 $[1,n]$ 中所有 $5$ 的因数的个数。
 
 <!-- tabs:start -->
 

solution/0200-0299/0263.Ugly Number/README.md

@@ -63,12 +63,9 @@ class Solution:
     def isUgly(self, n: int) -> bool:
         if n < 1:
             return False
-        while n % 2 == 0:
-            n //= 2
-        while n % 3 == 0:
-            n //= 3
-        while n % 5 == 0:
-            n //= 5
+        for x in [2, 3, 5]:
+            while n % x == 0:
+                n //= x
         return n == 1
 ```
 
@@ -137,6 +134,22 @@ var isUgly = function (n) {
 };
 ```
 
+### **Go**
+
+```go
+func isUgly(n int) bool {
+	if n < 1 {
+		return false
+	}
+	for _, x := range []int{2, 3, 5} {
+		for n%x == 0 {
+			n /= x
+		}
+	}
+	return n == 1
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0263.Ugly Number/README_EN.md

@@ -51,12 +51,9 @@ class Solution:
     def isUgly(self, n: int) -> bool:
         if n < 1:
             return False
-        while n % 2 == 0:
-            n //= 2
-        while n % 3 == 0:
-            n //= 3
-        while n % 5 == 0:
-            n //= 5
+        for x in [2, 3, 5]:
+            while n % x == 0:
+                n //= x
         return n == 1
 ```
 
@@ -123,6 +120,22 @@ var isUgly = function (n) {
 };
 ```
 
+### **Go**
+
+```go
+func isUgly(n int) bool {
+	if n < 1 {
+		return false
+	}
+	for _, x := range []int{2, 3, 5} {
+		for n%x == 0 {
+			n /= x
+		}
+	}
+	return n == 1
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0263.Ugly Number/Solution.go

@@ -0,0 +1,11 @@
+func isUgly(n int) bool {
+	if n < 1 {
+		return false
+	}
+	for _, x := range []int{2, 3, 5} {
+		for n%x == 0 {
+			n /= x
+		}
+	}
+	return n == 1
+}

solution/0200-0299/0263.Ugly Number/Solution.py

@@ -2,10 +2,7 @@ class Solution:
     def isUgly(self, n: int) -> bool:
         if n < 1:
             return False
-        while n % 2 == 0:
-            n //= 2
-        while n % 3 == 0:
-            n //= 3
-        while n % 5 == 0:
-            n //= 5
+        for x in [2, 3, 5]:
+            while n % x == 0:
+                n //= x
         return n == 1

solution/1100-1199/1175.Prime Arrangements/README.md

@@ -39,22 +39,151 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：数学**
+
+先统计 $[1,n]$ 范围内的质数个数，我们记为 $cnt$。然后求 $cnt$ 以及 $n-cnt$ 阶乘的乘积得到答案，注意取模操作。
+
+这里我们用“埃氏筛”统计质数。
+
+如果 $x$ 是质数，那么大于 $x$ 的 $x$ 的倍数 $2x$,$3x$,… 一定不是质数，因此我们可以从这里入手。
+
+我们设 $primes[i]$ 表示数 $i$ 是不是质数，如果是质数则为 $true$，否则为 $false$。从小到大遍历每个数，如果这个数为质数，则将其所有的倍数都标记为合数（除了该质数本身），即 $false$，这样在运行结束的时候我们即能知道质数的个数。
+
+时间复杂度 $O(nloglogn)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def numPrimeArrangements(self, n: int) -> int:
+        def count(n):
+            cnt = 0
+            primes = [True] * (n + 1)
+            for i in range(2, n + 1):
+                if primes[i]:
+                    cnt += 1
+                    for j in range(i + i, n + 1, i):
+                        primes[j] = False
+            return cnt
+
+        cnt = count(n)
+        ans = factorial(cnt) * factorial(n - cnt)
+        return ans % (10**9 + 7)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private static final int MOD = (int) 1e9 + 7;
+
+    public int numPrimeArrangements(int n) {
+        int cnt = count(n);
+        long ans = f(cnt) * f(n - cnt);
+        return (int) (ans % MOD);
+    }
+
+    private long f(int n) {
+        long ans = 1;
+        for (int i = 2; i <= n; ++i) {
+            ans = (ans * i) % MOD;
+        }
+        return ans;
+    }
+
+    private int count(int n) {
+        int cnt = 0;
+        boolean[] primes = new boolean[n + 1];
+        Arrays.fill(primes, true);
+        for (int i = 2; i <= n; ++i) {
+            if (primes[i]) {
+                ++cnt;
+                for (int j = i + i; j <= n; j += i) {
+                    primes[j] = false;
+                }
+            }
+        }
+        return cnt;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+using ll = long long;
+const int MOD = 1e9 + 7;
+
+class Solution {
+public:
+    int numPrimeArrangements(int n) {
+        int cnt = count(n);
+        ll ans = f(cnt) * f(n - cnt);
+        return (int) (ans % MOD);
+    }
+
+    ll f(int n) {
+        ll ans = 1;
+        for (int i = 2; i <= n; ++i) ans = (ans * i) % MOD;
+        return ans;
+    }
+
+    int count(int n) {
+        vector<bool> primes(n + 1, true);
+        int cnt = 0;
+        for (int i = 2; i <= n; ++i)
+        {
+            if (primes[i])
+            {
+                ++cnt;
+                for (int j = i + i; j <= n; j += i) primes[j] = false;
+            }
+        }
+        return cnt;
+    }
+};
+```
 
+### **Go**
+
+```go
+func numPrimeArrangements(n int) int {
+	count := func(n int) int {
+		cnt := 0
+		primes := make([]bool, n+1)
+		for i := range primes {
+			primes[i] = true
+		}
+		for i := 2; i <= n; i++ {
+			if primes[i] {
+				cnt++
+				for j := i + i; j <= n; j += i {
+					primes[j] = false
+				}
+			}
+		}
+		return cnt
+	}
+
+	mod := int(1e9) + 7
+	f := func(n int) int {
+		ans := 1
+		for i := 2; i <= n; i++ {
+			ans = (ans * i) % mod
+		}
+		return ans
+	}
+
+	cnt := count(n)
+	ans := f(cnt) * f(n-cnt)
+	return ans % mod
+}
 ```
 
 ### **...**