C. Permute Digits

本文介绍了一个算法问题:如何通过重新排列一个数字串的数字,在不超过另一个数字串的前提下使其尽可能大。文章提供了一种高效的解决方案,并附带了源代码。

C. Permute Digits

time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given two positive integer numbers a and b. Permute (change order) of the digits of a to construct maximal number not exceeding b. No number in input and/or output can start with the digit 0.

It is allowed to leave a as it is.
Input

The first line contains integer a (1 ≤ a ≤ 1018). The second line contains integer b (1 ≤ b ≤ 1018). Numbers don’t have leading zeroes. It is guaranteed that answer exists.
Output

Print the maximum possible number that is a permutation of digits of a and is not greater than b. The answer can’t have any leading zeroes. It is guaranteed that the answer exists.

The number in the output should have exactly the same length as number a. It should be a permutation of digits of a.
Examples
Input

123
222

Output

213

Input

3921
10000

Output

9321

Input

4940
5000

Output

4940

题意:

给你2串数字a,b 然后要你重组数字串a 令它在小于串b的前提下尽可能大

思路:

很明显有一种穷举法,利用STL里面的next_permutation可实现,但复杂度为18!,不现实,所以我们可以换一种思路,关键词有什么?尽可能大,小于b,我们还是可以枚举,但是换了一种方式,首先如果串a的长度是小于b的,很明显我们只要排一下序,然后再倒一下,就是答案了,如果长度相等的时候,我们可以这样来做,首先给a串排个序,然后我们来枚举每个i位置的数,要从大到小来枚举,然后再给i+1到后面排一个序,这是为什么呢?因为我们答案要尽可能大,所以如果每一个位置尽可能大,必然是符合提示的,然后排序后如果是小于b的可以继续下一个位置,如果>b,就说明在这个数在这个位置并且是最小的情况下并不符合条件,自然要换一个数.

code:

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<string.h>
#include<set>
#include<stdlib.h>
#define INF 0x3f3f3f
using namespace std;
int main()
{
    string a, b, c;
    cin >> a >> b;
    sort(a.begin(), a.end());
    reverse(a.begin(), a.end());
    if (a.length() < b.length())
        cout << a << endl;
    else
    {
        reverse(a.begin(), a.end());
        for (int i = 0; i < a.length(); i++)
        {
            c = a;
            for (int j = a.length() - 1; j >= i; j--)
            {
                char temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                sort(a.begin() + i + 1, a.end());
                if (a > b)
                {
                    a = c;
                }
                else
                    break;
            }
        }
        cout << a << endl;
    }
    return 0;
}
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_blobs n_samples = 1500 random_state = 170 transformation = [[0.60834549, -0.63667341], [-0.40887718, 0.85253229]] X, y = make_blobs(n_samples=n_samples, random_state=random_state) X_aniso = np.dot(X, transformation) # Anisotropic blobs X_varied, y_varied = make_blobs( n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state ) # Unequal variance X_filtered = np.vstack( (X[y == 0][:500], X[y == 1][:100], X[y == 2][:10]) ) # Unevenly sized blobs y_filtered = [0] * 500 + [1] * 100 + [2] * 10fig, axs = plt.subplots(2, 2, figsize=(6, 6)) axs[0, 0].scatter(X[:, 0], X[:, 1], c=y) axs[0, 0].set_title("Mixture of Gaussian Blobs") axs[0, 1].scatter(X_aniso[:, 0], X_aniso[:, 1], c=y) axs[0, 1].set_title("Anisotropically Distributed Blobs") axs[1, 0].scatter(X_varied[:, 0], X_varied[:, 1], c=y_varied) axs[1, 0].set_title("Unequal Variance") axs[1, 1].scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_filtered) axs[1, 1].set_title("Unevenly Sized Blobs") plt.suptitle("Ground truth clusters").set_y(0.95)K-Means 算法基于这样一个观念:一个簇 () 中的每个点都应该靠近该簇的中心。 它的工作原理如下:首先我们选择 k,即我们希望在数据中找到的簇的数量。然后,以某种方式初始化这些 k 个簇的中心,这些中心被称为质心 (Centroid)。 算法然后分为两个交替进行的部分进行: 在 重新分配数据点 步骤中,我们将数据中的每个点分配给其质心最近的簇。 在 更新质心 步骤中,我们重新计算每个质心的位置,作为分配给其簇的所有点的均值(中心)。 然后我们重复这些步骤,直到质心停止移动,或者等价地,直到点停止切换簇。 首先,我们实现一个 K_MeansClustering 的类:class K_MeansClustering: def __init__(self, k, dataPoint, randInitFlg=False, **kwargs): ''' Initialize parameters and centroids ''' self.k = k self.dataPoint = dataPoint self.rowNum = self.dataPoint.shape[0] self.centroidList = [] if randInitFlg: self.randomInitialization(kwargs.get('randSeed', 0)) else: for i in range(self.k): self.centroidList.append(self.dataPoint[i, :]) # the centroid is chosen from the first k data points. self.lastCentroidList = None self.distanceMatrix = np.empty((self.rowNum, self.k)) self.centroidList = np.asarray(self.centroidList, dtype=np.float32) def randomInitialization(self, randSeed=0): ''' 随机初始化 ''' pass def calculateCentroidDistance(self, x, c): ''' Calculate the distance between the whole data points and one centroid ''' pass def computeJe(self): ''' 计算聚类准则 ''' # TODO ## ----------- 输入代码,计算聚类准则 ----------- ## pass def __call__(self): ''' Iteratively find the optimal centroids ''' pass随机初始化函数def randomInitialization(self, randSeed=0): ''' 随机初始化 ''' # TODO ## ----------- 输入代码,完成随机初始化 ----------- ## np.random.seed(randSeed) pass计算每一个点到质心的距离def calculateCentroidDistance(self, x, c): ''' Calculate the distance between the whole data points and one centroid ''' # TODO ## ----------- 输入代码,完成点到质心距离的计算 ----------- ## passdef computeJe(self): ''' 计算聚类准则 ''' self.Je = 0.0 # TODO ## ----------- 输入代码,计算聚类准则 ----------- ## passdef iteration_func(self): ''' Iteratively find the optimal centroids ''' while True: # TODO ## ----------- 输入代码,K-Means迭代设计 ----------- ## #loop through the data points pass # 重新分配数据点 ## array of indexes self.nearestCentroids = None # 终止条件 pass # 更新质心 ## calculate the mean of a cluster and reassign the value of the centroids pass #keep track of centroid values pass return self.nearestCentroids, self.centroidList K_MeansClustering.randomInitialization = randomInitialization K_MeansClustering.calculateCentroidDistance = calculateCentroidDistance K_MeansClustering.computeJe = computeJe K_MeansClustering.__call__ = iteration_funcfig, axs = plt.subplots(nrows=2, ncols=2, figsize=(8, 8)) y_pred, centroidList = K_MeansClustering(k=2, dataPoint=X)() axs[0, 0].scatter(X[:, 0], X[:, 1], c=y_pred) axs[0, 0].set_title("Non-optimal Number of Clusters") y_pred, centroidList = K_MeansClustering(k=3, dataPoint=X_aniso)() axs[0, 1].scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred) axs[0, 1].set_title("Anisotropically Distributed Blobs") y_pred, centroidList = K_MeansClustering(k=3, dataPoint=X_varied)() axs[1, 0].scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred) axs[1, 0].set_title("Unequal Variance") y_pred, centroidList = K_MeansClustering(k=3, dataPoint=X_filtered)() axs[1, 1].scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_pred) axs[1, 1].set_title("Unevenly Sized Blobs") plt.suptitle("Unexpected KMeans clusters").set_y(1.02)首先,我们在数据 X 下测试出不同的质心 (Centroid) 数据对聚类结果的影响。由下图可以看到,合适的质心数目对获得满意的聚类效果至关重要。fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(10, 4)) kmeans1 = K_MeansClustering(k=2, dataPoint=X) y_pred1, centroidList1 = kmeans1() kmeans1.computeJe() axs[0].scatter(X[:, 0], X[:, 1], c=y_pred1) axs[0].set_title(f"k=2, Je={kmeans1.Je:.2f}") # TODO ## ----------- 输入代码,完成k=3的聚类 ----------- ## kmeans2 = None y_pred2, centroidList2 = None, None axs[1].scatter(X[:, 0], X[:, 1], c=y_pred2) axs[1].set_title(f"k=3, Je={kmeans2.Je:.2f}") # TODO ## ----------- 输入代码,完成k=4的聚类 ----------- ## kmeans3 = None y_pred3, centroidList3 = None, None axs[2].scatter(X[:, 0], X[:, 1], c=y_pred3) axs[2].set_title(f"k=4, Je={kmeans3.Je:.2f}") plt.suptitle("KMeans clusters with different # of centroids").set_y(1.03)kList = [2, 3, 4, 5, 6] jeList = [] # TODO ## ----------- 输入代码,计算jeList ----------- ## pass fig, ax = plt.subplots(figsize=(4, 4)) ax.plot(kList, jeList, marker='o', markersize=4, color='k') ax.set_xlabel('# of centroids (k)') ax.set_ylabel('Je');从上图可以看出,在 k=3 是 Je 曲线的拐点,Je 曲线的下降率在 k=3 之后迅速减小,说明 k=3 适合这个数据集 fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 4)) # TODO ## ----------- 输入代码,对比不同的初始化策略 ----------- ## pass from sklearn.datasets import make_moons twoArcsX, twoArcsy = make_moons(200, noise=.05, random_state=0) # TODO ## ----------- 输入代码,采用 K-Means 对双曲线数据聚类 ----------- ## ta_kmeans = None labels, cenList = None, None from sklearn.cluster import SpectralClustering model = SpectralClustering(n_clusters=2, affinity='nearest_neighbors', assign_labels='kmeans') labels = model.fit_predict(twoArcsX) fig, ax = plt.subplots(figsize=(3.5, 3.5)) plt.scatter(twoArcsX[:, 0], twoArcsX[:, 1], c=labels, s=50, cmap='viridis');epsilon_list = [0.3, 0.6, 1] min_samples_list = [5, 7, 9] from sklearn.cluster import DBSCAN fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(10, 10)) for eps in epsilon_list: for min_samples in min_samples_list: dbscan = DBSCAN(eps=eps, min_samples=min_samples) labels = dbscan.fit_predict(X) ax = axes[epsilon_list.index(eps), min_samples_list.index(min_samples)] ax.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis') ax.set_title(f"eps={eps}, min_samples={min_samples}") ## TODO ## ----------- 参考4.1的代码,寻找最适合X_aniso数据集的DBSCAN参数 ----------- ## ## ----------- 请在以下补全代码 ----------- ## epsilon_list = None min_samples_list = None dataPath = 'images/tiger.png' imgData = plt.imread(dataPath)[:, :, :3] fig, ax = plt.subplots(figsize=(4, 3)) plt.imshow(imgData[:, :, :3]);print(f'The shape of the tiger image: {imgData.shape}')pixelValues = imgData.reshape((-1, 3)) fig = plt.figure(figsize=(4, 4)) ax = plt.axes(projection='3d') ax.scatter3D(pixelValues[:, 0], pixelValues[:, 1], pixelValues[:, 2], c=pixelValues[:, 2], cmap='plasma');k = 3 # 选择 3 个质心 # TODO ## ----------- 输入代码,k=3 的 K-Means 对图片聚类 ----------- ## kmeans = None centroidIndices, centroidList = None, None fig = plt.figure(figsize=(4, 4)) ax = plt.axes(projection='3d') ax.scatter3D(pixelValues[:, 0], pixelValues[:, 1], pixelValues[:, 2], c=centroidIndices, cmap='plasma');newPixels = np.zeros((imgData.shape[0] * imgData.shape[1], 3)) # TODO ## ----------- 输入代码,对newPixels各点赋予各类的质心的值 ----------- ## pass segmentedImage = np.reshape(newPixels, imgData.shape) fig, axes = plt.subplots(1, 2, figsize=(8, 4)) axes[0].imshow(imgData) axes[1].imshow(segmentedImage);from sklearn.datasets import load_digits digits = load_digits() digits.data.shape# 绘制随机16个数字 indices = np.random.choice(digits.data.shape[0], 16) fig, axes = plt.subplots(4, 4, sharex=True, sharey=True, figsize=(6, 6)) for ax, ind in zip(axes.flatten(), indices): digData = digits.data[ind].reshape((8, 8)) ax.imshow(digData, interpolation='nearest', cmap=plt.cm.binary) ax.set(xticks=[], yticks=[])from sklearn.cluster import KMeans # TODO ## ----------- 输入代码,对数字集的聚类 ----------- ## k = 10 kmeans = None clusters = Nonefig, ax = plt.subplots(2, 5, figsize=(8, 3)) centers = kmeans.cluster_centers_.reshape(10, 8, 8) for axi, center in zip(ax.flat, centers): axi.set(xticks=[], yticks=[]) axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)from scipy.stats import mode labels = np.zeros_like(clusters) for i in range(10): mask = (clusters == i) labels[mask] = mode(digits.target[mask])[0]from sklearn.metrics import accuracy_score accuracy_score(digits.target, labels)from sklearn.metrics import confusion_matrix import seaborn as sns mat = confusion_matrix(digits.target, labels) sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False, cmap='Blues', xticklabels=digits.target_names, yticklabels=digits.target_names) plt.xlabel('true label') plt.ylabel('predicted label');from sklearn.manifold import TSNE # Project the data: this step will take several seconds tsne = TSNE(n_components=2, init='random', learning_rate=0.1,random_state=0) digits_proj = tsne.fit_transform(digits.data) # TODO ## ----------- 输入代码,使用 K-Means 对TSNE的特征聚类 ----------- ## # Compute the clusters kmeans = None clusters = None # Permute the labels labels = np.zeros_like(clusters) pass # Compute the accuracy accuracy_score(digits.target, labels)帮我填充代码
最新发布
01-01
#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> #include <stdbool.h> #include <stdlib.h> #include <math.h> #include <ctype.h> #include <limits.h> //宏定义与类型别名 #define EPS 1e-9 #define MOD 100000000 #define in int #define ll long long #define fl float #define db double #define ch char #define vd void #define pr printf #define sc scanf #define pr_in(x) pr("%d", x) #define pr_ll(x) pr("%lld", x) #define pr_st(x) pr("%s", x) #define pr_inn(x) pr("%d\n", x) #define pr_lln(x) pr("%lld\n", x) #define pr_stn(x) pr("%s\n", x) #define feq(a, b) (fabs((a) - (b)) < EPS) //函数声明:库函数模拟 //求在参数str所指向的字符串的前n个字节中检索第一次出现字符c的位置 vd* memchr_exp(const vd* str, in c, size_t n); //函数声明:输入输出辅助 //要求快速输入 in fast_read(); //要求数组输入 vd scan_arr(in arr[], in n); //要求数组输出 vd print_arr(in arr[], in n); //函数声明:数学计算 //求某个数的阶乘(非递归) ll factorial1(in n); //求某个数的阶乘(递归) ll factorial2(in n); //求斐波那契数列第某个数(非递归) ll fibonacci1(in n); //求斐波那契数列第某个数(递归) ll fibonacci2(in n); //求斐波那契数列第某个数(递归+优化) ll fibonacci2_memo(in n); //求排列数P(n数,排k) ll permute(in n, in k); //求组合数C(n数,组k) ll combine(in n, in k); //求快速幂(模幂运算) ll pow_mod(ll base, ll exp); //求两个数的最大公因数 in gcd(in a, in b); //求两个数的最小公倍数 in lcm(in a, in b); //求某个数是否为素数 in is_prime(in n); //求10进制转<10进制(待拓展) in digit_change(in n, in digit2); //求2进制数转10进制数 in bin_to_dec(in bin); //求某个数字的反向输出 in turn_digits(in n); //函数声明:字符串处理 //求某个数(字符串形式)是否为回文 in is_palindrome(const ch* s); //求某数是否含某数字(一般数) in contains_digit1(in n, in p); //求某数是否含某数字(超大数,%s输入num_str) in contains_digit2(const ch* num_str, in p); //求给定字符串出现频次 vd string_frequency(const ch* str); //函数声明:数组操作 //求某十进制数的各位数 vd extract_digits(in num, in digits[]); //函数声明:排序与搜索 //要求两个整数交换 vd swap(in* a, in* b); //要求升序排列(冒泡排序) vd bubble_sort(in* arr, size_t n); //要求升序排列(快速排序1到r) vd quick_sort(in arr[], in l, in r); //要求全排数组(start到end) vd permute(in arr[], in start, in end); //要求翻转数组 vd reverse_arr(in arr[], in n); //求数组各元素的和 in sum_arr(in arr[], in n); //求数组最大元素下标 in max_index(in arr[], in n); //求数组某元素的位置(升序,n元,二分找x) in binary_search(in arr[], in n, in x); //函数声明:几何计算 //求平面上两点的距离 db distance_2d(db x1, db y1, db x2, db y2); //求三角形的面积(2倍) ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3); //求凸多边形面积(2倍) ll n_triangle_area_2(in n, ll x[], ll y[]); //函数声明:时间日期 //求某年是否为闰年 in is_leap(in year); //求某年某月的天数 in get_days_of_month(in year, in month); //求某年某月某日为星期几 in get_week_day(in year, in month, in day); int main() { } //函数实现:库函数模拟 vd* memchr_exp(const vd* str, in c, size_t n) { const unsigned ch* ptr = (const unsigned ch*)str; unsigned ch uc = (unsigned ch)c; for (size_t i = 0; i < n; i++) { if (ptr[i] == uc) { return (vd*)(ptr + i); } } return NULL; } //in main() //{ // ch str[] = "Hello, world!"; // ch* result = (ch*)memchr_exp(str, 'w', sizeof(str)); // if (result != NULL) // { // pr("字符'w'首次出现在索引:%d\n", result - str); // pr("子字符串:%s\n", result); // } // else // { // pr("未找到字符'w'\n"); // } // result = (ch*)memchr_exp(str, 'x', sizeof(str)); // if (result == NULL) // { // pr("字符'x'未找到\n"); // } // return 0; //} //函数实现:输入输出辅助 //要求快速输入 in fast_read() { in x = 0, f = 1; ch c = getchar(); while (c < '0' || c > '9') { if (c == '-') f = -f; c = getchar(); } while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); } return x * f; } //要求数组输入 vd scan_arr(in arr[], in n) { for (in i = 0; i < n; i++) { sc("%d", &arr[i]); } } //要求数组输出 vd print_arr(in arr[], in n) { for (in i = 0; i < n; i++) { pr("%d ", arr[i], " \n"[i == n - 1]); } } //函数实现:数学计算 //求某个数的阶乘(非递归) ll factorial1(in n) { if (n < 0) return -1; if (n > 20) return -1; ll result = 1; for (in i = 2; i <= n; i++) { result *= i; } return result; } //求某个数的阶乘(递归) ll factorial2(in n) { if (n <= 1) { return 1; } return n * factorial2(n - 1); } //求斐波那契数列第某个数(非递归) ll fibonacci1(in n) { if (n == 0) return 0; if (n == 1) return 1; ll prev = 0; ll curr = 1; ll next; for (in i = 2; i <= n; i++) { next = prev + curr; prev = curr; curr = next; } return curr; } //求斐波那契数列第某个数(递归) ll fibonacci2(in n) { if (n == 1 || n == 2) { return 1; } return fibonacci2(n - 1) + fibonacci2(n - 2); } //求斐波那契数列第某个数(递归+优化) ll memo[1000] = { 0 }; ll fibonacci2_memo(in n) { if (n == 1 || n == 2) { return 1; } if (memo[n] != 0) { return memo[n]; } memo[n] = fibonacci2_memo(n - 1) + fibonacci2_memo(n - 2); return memo[n]; } //求排列数P(n数,排k) ll permute(in n, in k) { if (k < 0 || n < 0 || k > n) { return -1; } ll result = 1; for (in i = n - k + 1; i <= n; i++) { result *= i; } return result; } //求组合数C(n数,组k) ll combine(in n, in k) { if (k < 0 || n < 0 || k > n) { return -1; } if (k > n - k) { k = n - k; } ll result = 1; for (in i = 0; i < k; i++) { result = result * (n - i) / (i + 1); } return result; } //求快速幂(模幂运算) ll pow_mod(ll base, ll exp) { ll result = 1; while (exp > 0) { if (exp & 1) { result = (result * base) % MOD; } base = (base * base) % MOD; exp >>= 1; } return result; } //求两个数的最大公因数 in gcd(in a, in b) { if (a < 0) a = -a; if (b < 0) b = -b; while (b != 0) { in temp = b; b = a % b; a = temp; } return a; } //求两个数的最小公倍数 in lcm(in a, in b) { return a / gcd(a, b) * b; } //求某个数是否为素数 in is_prime(in n) { if (n <= 1) { return 0; } else if (n <= 3) { return 1; } else if (n % 2 == 0 || n % 3 == 0) { return 0; } for (in i = 5; i * i <= n; i += 6) { if (n % i == 0 || n % (i + 2) == 0) { return 0; } } return 1; } //求10进制转<10进制(待拓展) in digit_change(in n, in digit2) { in rem = n; in mod[100]; in i = 0; while (rem > 0) { mod[i] = rem % digit2; rem = rem / digit2; i++; } in result = 0; in ten = 1; for (in j = 0; j < i; j++) { result += mod[j] * ten; ten = 10 * ten; } return result; } //求2进制数转10进制数 in bin_to_dec(in bin) { if (bin == 0) { return 0; } if (bin < 0) { return -1; } in decimal = 0; in base = 1; while (bin > 0) { in digit = bin % 10; if (digit != 0 && digit != 1) { return -1; } decimal += digit * base; base *= 2; bin /= 10; } return decimal; } //求某个数字的反向输出 in turn_digits(in n) { in digits[10] = { 0 }; in i = 0; in num = n; while (num > 0) { digits[i++] = num % 10; num /= 10; } in ans = 0; for (in j = 0; j < i; j++) { ans = ans * 10 + digits[j]; } return ans; } //函数实现:字符串处理 //求某个数(字符串形式)是否为回文 in is_palindrome(const ch* s) { if (s == NULL) { return 0; } in left = 0; in right = strlen(s) - 1; while (left < right) { if (tolower(s[left]) != tolower(s[right])) { return 0; } left++; right--; } return 1; } //求某数是否含某数字(一般数) in contains_digit1(in n, in p) { ch str[50]; ch target = '0' + p; sprintf(str, "%d", n); for (in i = 0; str[i] != '\0'; i++) { if (str[i] == target) { return 1; } } return 0; } //求某数是否含某数字(超大数,%s输入num_str) in contains_digit2(const ch* num_str, in p) { ch target = '0' + p; for (in i = 0; num_str[i] != '\0'; i++) { if (num_str[i] < '0' || num_str[i] > '9') { continue; } if (num_str[i] == target) { return 1; } } return 0; } //求给定字符串出现频次 vd string_frequency(const ch* str) { in freq[128] = { 0 }; for (in i = 0; str[i] != '\0'; i++) { unsigned ch c = str[i]; if (c == ' ' || isprint(c)) { freq[c]++; } } int count = 0; for (in i = 0; i < 128; i++) { if (freq[i] > 0) { count++; if (i == ' ') { pr("blank: %d\n", freq[i]); } else { pr("'%c': %d\n", i, freq[i]); } } } } //函数实现:数组操作 //求某十进制数的各位数 vd extract_digits(in num, in digits[]) { if (num == 0) { digits[0] = 0; digits[1] = -1; return; } in i = 0; while (num > 0) { digits[i++] = num % 10; num /= 10; } } //函数实现:排序与搜索 //要求两个整数交换 vd swap(in* a, in* b) { in temp = *a; *a = *b; *b = temp; } //要求升序排列(冒泡排序) vd bubble_sort(in* arr, size_t n) { if (arr == NULL || n < 2) { return; } for (size_t i = 0; i < n - 1; i++) { in swapped = 0; for (size_t j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { in temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; swapped = 1; } } if (!swapped) { break; } } } //要求升序排列(快速排序1到r) vd quick_sort(in arr[], in l, in r) { if (l >= r) { return; } in i = l, j = r; in pivot = arr[(l + r) / 2]; while (i <= j) { while (arr[i] < pivot) i++; while (arr[j] > pivot) j--; if (i <= j) { swap(&arr[i], &arr[j]); i++; j--; } } quick_sort(arr, l, j); quick_sort(arr, i, r); } //要求全排数组(start到end) vd permute_arr(in arr[], in start, in end) { if (start == end) { for (in i = 0; i <= end; i++) { pr("%d ", arr[i]); } pr("\n"); } else { for (in i = start; i <= end; i++) { swap(&arr[start], &arr[i]); permute(arr, start + 1, end); swap(&arr[start], &arr[i]); } } } //要求翻转数组 vd reverse_arr(in arr[], in n) { for (in i = 0; i < n / 2; i++) { in t = arr[i]; arr[i] = arr[n - 1 - i]; arr[n - 1 - i] = t; } } //求数组某元素的位置(升序,n元,二分找x) in binary_search(in arr[], in n, in x) { in left = 0, right = n - 1; while (left <= right) { in mid = (left + right) / 2; if (arr[mid] == x) { return mid; } else if (arr[mid] < x) { left = mid + 1; } else right = mid - 1; } return -1; } //求数组各元素的和 in sum_arr(in arr[], in n) { in s = 0; for (in i = 0; i < n; i++) { s += arr[i]; } return s; } //求数组最大元素下标 in max_index(in arr[], in n) { in idx = 0; for (in i = 1; i < n; i++) { if (arr[i] > arr[idx]) { idx = i; } } return idx; } //函数实现:几何计算 //求平面上两点的距离 db distance_2d(db x1, db y1, db x2, db y2) { db dx = x2 - x1; db dy = y2 - y1; return sqrt(dx * dx + dy * dy); } //求三角形的面积(2倍) ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) { ll area_2 = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1); return area_2 < 0 ? -area_2 : area_2; } //求凸多边形面积(2倍) ll n_triangle_area_2(in n, ll x[], ll y[]) { ll area_2 = 0; for (in i = 0; i < n; i++) { in j = (i + 1) % n; area_2 += x[i] * y[j] - x[j] * y[i]; } return area_2 > 0 ? area_2 : -area_2; } //函数实现:时间日期 //求某年是否为闰年 in is_leap(in year) { return (year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0); } //求某年某月的天数 in get_days_of_month(in year, in month) { in days = 0; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 4: case 6: case 9: case 11: days = 30; break; case 2: days = is_leap(year) ? 29 : 28; break; } return days; } //求某年某月某日为星期几 in get_week_day(in year, in month, in day) { in century, weekday; if (month < 3) { year--; month += 12; } century = year / 100; year %= 100; weekday = (year + year / 4 + century / 4 - 2 * century + (26 * (month + 1)) / 10 + day - 1) % 7; if (weekday < 0) { weekday += 7; } return weekday; }怎么样,检验正误
10-29
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值