刷题 ------ 排序

news2024/9/25 19:17:38

文章目录

  • 1.K 次取返后最大化的数组和（堆）
  • 2.数组的相对排序（桶）
  • 3.最小绝对差
  • 4.根据数字二进制下1的数目排序（qsort）
  • 5.有多少小于当前数字的数字
  • 6.非递增顺序的最小子序列
  • 7.按照频率将数组升序排序（qsort）
  • 8.将句子排序
  • 9.找到最大长度为 k 的子序列（双排序）
  • 10.对奇偶下标分别排序
  • 11. 按身高排序
  • 12. 最小和分割
  • 13.大于等于顺序前缀和的最小缺失整数
  • 14.文物朝代判断

基于上篇的排序算法，本篇刷了一下leetcode上的关于排序算法的题，因为我是点的排序标签刷的，所以有些题排完序答案就出来了，就没有写题解了。

1.K 次取返后最大化的数组和（堆）

在这里插入图片描述

看完题目，首先得知道的就是，我们应该尽量把全部的负数去取反，因为最小的负数取反之后就会很大，所以到全部的负数都取反，不能再取之后，或者说是k次取完了。

  • 如果k次取完了，那正好，直接返回当前数组的和就好了.
  • 如果负数变更完了，k 还有偶数次，负负得正 所以你就可以一直取同样的一个数，所以还是可以返回当前数组的和就好了。
  • 但是还有有一种情况，就是说，负数变更完了，而k是奇数次，变更那个最小的数就好了。
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int largestSumAfterKNegations(int* nums, int numsSize, int k)
{
    qsort(nums,numsSize,sizeof(int),cmp_int);
    int i = 0, sum = 0;
    //先将负数全部反正
    while(i < numsSize && k > 0 && nums[i] <= 0)
    {
        nums[i] = -nums[i];
        i++;
        k--;
    }
    //判断剩下的k是否为奇数。
    if(k % 2 != 0)
    {
        //再排序
        qsort(nums,numsSize,sizeof(int),cmp_int);
        nums[0] = -nums[0];
    }
    for (i = 0; i < numsSize; i++)
    {   
        sum += nums[i];
    }

    return sum;
}

还有一种思路是：选出最小的那一个数据，然后取反，之后接着选最小的数据，直到k次全部完毕。

  • 可以用选择排序的方法，每次进行选择。
  • 还可以建立一个小顶堆出来，然后将堆顶的数据去反后，再维护此堆。
void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void Heapify(int* nums, int numsSize, int i)
{
    int minIndx = i, lc = i * 2 + 1, rc = i * 2 + 2;
    if(lc < numsSize && nums[lc] < nums[minIndx])
    {
        minIndx = lc;
    }
    if(rc < numsSize && nums[rc] < nums[minIndx])
    {
        minIndx = rc;
    }
    if(minIndx != i)
    {
        Swap(&nums[i],&nums[minIndx]);
        Heapify(nums,numsSize,minIndx);
    }
}


int largestSumAfterKNegations(int* nums, int numsSize, int k)
{
    int i,sum = 0;
    //创建一个小顶堆
    for (i = (numsSize - 1) / 2; i >= 0; i--)
    {
        Heapify(nums,numsSize,i);
    }
    while(k > 0)
    {
        //将最小值拿出来后取反
        nums[0] = -nums[0]; 
        //维护堆,""
        Heapify(nums,numsSize,0);
        k--;
    }
    for (i = 0; i < numsSize; i++)
    {
        sum += nums[i];
    }

    return sum;
}

2.数组的相对排序（桶）

在这里插入图片描述
这道题可以用桶排序来做。

  • 首先把arr1中所有出现的数字按照放入桶（哈希表）中。
  • 然后遍历arr2中的对应的元素，放入ans中，即实现以arr2的形式排序arr1
  • 最后将桶中还未取来的，依次放入ans中就好了。
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* relativeSortArray(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize)
{
    int* bucket = (int*)calloc(1001,sizeof(int));
    int* ans = (int*)malloc(sizeof(int) * arr1Size);
    int size = 0,i,maxnum = 0;
    //桶排序
    for (i = 0; i < arr1Size; i++)
    {
        bucket[arr1[i]]++;
        if(maxnum < arr1[i])
        {
            maxnum = arr1[i];
        }
    }
    //按照arr2的顺序取出
    for (i = 0; i < arr2Size; i++)
    {
        while(bucket[arr2[i]] != 0)
        {
            ans[size++] = arr2[i];
            bucket[arr2[i]]--;
        }
    }
    
    //将arr1中剩余的按照升序放入ans中
    for (i = 0; i <= maxnum; i++)
    {
        while(bucket[i] >= 1)
        {
            ans[size++] = i;
            bucket[i]--;
        }
    }
    *returnSize = size;
    return ans;
}

3.最小绝对差

在这里插入图片描述

这道题就是让我们首先知道最小绝对差是多少，然后选出是最小绝对差的两个下标就好了。

  • 首先给数组排序，相邻两个数的绝对差肯定是小的。
  • 然后找处最小的。
  • 最后再遍历一遍，选出符合最小绝对差的下标。
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}


int** minimumAbsDifference(int* arr, int arrSize, int* returnSize, int** returnColumnSizes)
{
    int** ans = (int**)malloc(sizeof(int*) * (arrSize - 1));
    *returnColumnSizes = (int*)malloc(sizeof(int*) * (arrSize - 1));
    int i,gap,size = 0;
    for (i = 0; i < (arrSize - 1); i++)
    {
        ans[i] = (int*)malloc(sizeof(int) * 2);
        (*returnColumnSizes)[i] = 2;
    }
    qsort(arr,arrSize,sizeof(int),cmp_int);
    //求最小绝对差值
    gap = abs(arr[0] - arr[1]);
    for (i = 1; i < arrSize - 1; i++)
    {
        if(abs(arr[i] - arr[i+1]) < gap)
        {
            gap = abs(arr[i] - arr[i+1]);
        }
    }
    for (i = 0; i < arrSize - 1; i++)
    {
        if(abs(arr[i] - arr[i+1]) == gap)
        {
            ans[size][0] = arr[i];
            ans[size++][1] = arr[i+1];
        }
    }
    *returnSize = size;
    return ans;
}

4.根据数字二进制下1的数目排序（qsort）

在这里插入图片描述
这道题，让我对qsort函数有了一个新的认知。
在这里插入图片描述

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int GetBinaryDigitSum(int n)
{
    int* nums = (int*)malloc(sizeof(int) * 32);
    int size = 0;
    while(n != 0)
    {
        nums[size++] = n % 2;
        n /= 2;
    }   
    int i, sum = 0;
    for (i = 0; i < size; i++)
    {
        sum += nums[i];
    }

    return sum;
}

int cmp_sum(const void* x, const void* y)
{
    int numx = *(int*)x,numy = *(int*)y;
    //求出二进制1的位置
    int c = GetBinaryDigitSum(numx),d = GetBinaryDigitSum(numy);
    //如果二进制1的位数相同，那么去利用原来数的大小去排序
    return c == d ? numx - numy : c - d;
}


int* sortByBits(int* arr, int arrSize, int* returnSize)
{
    qsort(arr,arrSize,sizeof(int),cmp_sum);
    *returnSize = arrSize;
    return arr;
}

5.有多少小于当前数字的数字

在这里插入图片描述

就对于每个数进行挨个求，直接用暴力就能解决，同业也可以用排序的方式来解决

  • 首先需要将当前的这个数和下标存在一起，然后对数进行排序，这样子就会得到一个这样的数组
    在这里插入图片描述
  • 最后遍历data数组，用prev记录着上一个比自己小的数就好了.
int cmp_val(const void* x, const void* y)
{
    return ((int**)x)[0][0] - ((int**)y)[0][0];
}

int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
{
    //data 里面存放的是数据和下标
    int** data = (int**)malloc(sizeof(int*) * numsSize);
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    *returnSize = numsSize;
    int i;
    for (i = 0; i < numsSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = nums[i];
        data[i][1] = i;
    }

    //给data以val进行排序
    qsort(data,numsSize,sizeof(data),cmp_val);
    int prev = -1;
    for (i = 0; i < numsSize; i++)
    {
        if(i == 0 || data[i][0] != data[i-1][0])
        {
            prev = i;
        }
        ans[data[i][1]] = prev;
    }

    return ans;
}

6.非递增顺序的最小子序列

在这里插入图片描述

看完题之后，应该先排序，然后分别求出其前缀和与后缀和，拿当前数的后缀和与前一个数的前缀和去比较，像这个样子,
在这里插入图片描述
下面是代码：
在这里插入图片描述

  • 所以我写的时候全部求出来了。官方题解，也就是这个意思，但是人家不用挨个全部求出来。
  • 只要先计算出总共的和，然后从后往前遍历的时候本来就能算出后缀和，拿sum-后缀和，不就是前缀和吗？
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int* minSubsequence(int* nums, int numsSize, int* returnSize)
{
    int sum = 0;
    //先排序
    qsort(nums,numsSize,sizeof(int),cmp_int);
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    int size = 0;
    int i,suffixsum = 0;
    for (i = 0; i < numsSize; i++)
    {
        sum += nums[i];
    }

    for (i = numsSize - 1; i >= 0; i--)
    {
        suffixsum += nums[i];
        ans[size++] = nums[i];
        if(sum - suffixsum < suffixsum)
        {
            break;
        }
    }

    *returnSize = size;
    return ans;
}

7.按照频率将数组升序排序（qsort）

在这里插入图片描述

优先考虑频率的排序，如果频率相同的话，再将其值按照降序的排序。

  • 保证整个数组是有序，使重复的数在一起。
  • 然后利用二维数组记录出每个数出现的次数。
  • data[1][0] 表示1出现的次数
  • data[1][1] 表示-1出现的次数
  • 利用qsort对数组进行频率排序，频率相同的话，再将其值按照降序的排序.


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define ROW 101
#define COL 2

int data[ROW][COL];

int GetFreq(x)
{
    if(x >= 0)
    {
        return data[x][0];
    }
    else
    {
        return data[-x][1];
    }
}
 //按照频率排序
int cmp_freq(const void* x, const void* y)
{
    int numx = *(int*)x, numy = *(int*)y;
    int frex = GetFreq(numx), frey = GetFreq(numy);
    //如果频率相同，去比较值的大小。
    return frex == frey ? y - x : frex - frey;
}       

int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}


int* frequencySort(int* nums, int numsSize, int* returnSize)
{
    int i,j;
    //重置二维数组
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            data[i][j] = 0;
        }
    }
    for (i = 0; i < numsSize; i++)
    {
        if(nums[i] >= 0)
        {
            //正数出现的次数
            data[nums[i]][0]++;
        }
        else
        {
            //负数出现的次数
            data[-nums[i]][1]++;
        }
    }
    qsort(nums,numsSize,sizeof(int),cmp_int);
    qsort(nums,numsSize,sizeof(int),cmp_freq);
    *returnSize = numsSize;
    return nums;
}

8.将句子排序

在这里插入图片描述

遍历一所给字符串，然后将其隐射到哈希中去。
就比如下图这个样子
在这里插入图片描述

  • 然后整个哈希进行遍历，不为NULL依次放入ans中就好了
#define WORD_LEN 201

char * sortSentence(char * s)
{
    int i = 0,j = 0,len = strlen(s);
    char** words = (char**)malloc(sizeof(char*) * 11);
    char* ans = (char*)malloc(sizeof(char) * len);
    int pos = 0;
    for (i = 0; i < 11; i++)
    {
        words[i] = NULL;
    }
    //i记录起点
    i = 0;
    while(i < len)
    {
        //tmp 里面存放着单词
        char* tmp = (char*)malloc(sizeof(char) * WORD_LEN);
        //找数字
        while(j < len && !(s[j] >= '0' && s[j] <= '9'))
        {
            j++;
        }
        //在对应的索引处进行插入字符串
        int index = s[j] - '0';
        s[j] = '\0';
        strcpy(tmp,s + i);
        words[index] = tmp;
        //跳过空格
        j += 2;
        //i记录起点
        i = j;
    }

    //按照顺序拿出来就好了
    for (i = 0; i < 11; i++)
    {
        if(words[i] != NULL)
        {
            int size = strlen(words[i]);
            memcpy(ans + pos,words[i],sizeof(char) * size);
            pos += size;
            ans[pos++] = ' ';
        }
    }
    //调整最后一个字符
    ans[--pos] = '\0';
    return ans;
}

9.找到最大长度为 k 的子序列（双排序）

在这里插入图片描述

题目中不允许改变元素顺序，但是呢，要想得到最大的子序列，其子序列中的数据肯定还是原数组中最大的那几个数，于是我们可以排序两次，选出最大值后，再按照原来的顺序取回去就好了，如下图：
在这里插入图片描述

  • 建立一个二维数组出来，data[i][0]放val data[i][1] 放其所对应的索引。
  • 首先对二维数组data进行值的排序，选出k个最大的值。
  • 再选出来的数组进行下标排序。[begin,numsSize].
  • 最后拷贝到ans中就好了


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp_val(const void* x,const void* y)
{
    return ((int**)x)[0][0] - ((int**)y)[0][0];
}
int cmp_index(const void* x,const void* y)
{
    return ((int**)x)[0][1] - ((int**)y)[0][1];
}


int* maxSubsequence(int* nums, int numsSize, int k, int* returnSize)
{   
    if(numsSize == k)
    {
        *returnSize = k;    
        return nums;
    }
    int i;
    int** data = (int**)malloc(sizeof(int*) * numsSize);
    int* ans = (int*)malloc(sizeof(int) * k);
    int size = 0;
    for (i = 0; i < numsSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = nums[i];
        data[i][1] = i;
    }
    //先按照值排序
    qsort(data,numsSize,sizeof(data[0]),cmp_val);
    int begin = numsSize - k;
    //再将选中的那些按照原先的位置排序[begin,k]
    qsort(data + begin,k,sizeof(data[0]),cmp_index);
    //拷贝即可[begin,numsSize]
    for (i = begin; i < numsSize; i++)
    {
        ans[size++] = data[i][0];
    }
    *returnSize = k;
    return ans;
}

10.对奇偶下标分别排序

在这里插入图片描述

  • 构造两个数组，分别放偶数下标所对应的数，和奇数下标所对应的数。
  • 然后将偶数数组升序排序，奇数数组降序排序
  • 最后交叉放回数组中即可。
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

//升序
int Asc_cmp_int(const void* x,const void* y)
{
    return *(int*)x - *(int*)y;
}
//降序
int Des_cmp_int(const void* x,const void* y)
{
    return *(int*)y - *(int*)x;
}


int* sortEvenOdd(int* nums, int numsSize, int* returnSize)
{
    int* eveni = (int*)malloc(sizeof(int) * (numsSize / 2 + 1));
    int* oddi = (int*)malloc(sizeof(int) * (numsSize / 2 + 1));
    int i,eSize = 0,oSize = 0;
    for (i = 0; i < numsSize; i++)
    {
        if(i % 2 == 0)
        {
            eveni[eSize++] = nums[i];
        }
        else
        {
            oddi[oSize++] = nums[i];
        }
    }
    //偶数下标按照升序
    qsort(eveni,eSize,sizeof(int),Asc_cmp_int);
    //奇数下标按照降序
    qsort(oddi,oSize,sizeof(int),Des_cmp_int);
    int size = 0;
    for (i = 0; i < eSize; i++)
    {
        nums[size] = eveni[i];
        size += 2;
    }
    size = 1;
    for (i = 0; i < oSize; i++)
    {
        nums[size] = oddi[i];
        size += 2;
    }

    *returnSize = numsSize;
    return nums;
}
// 4 1 2 3

// 4  2 
// 1 3

// 2 4 
// 3 1
// 2 3 4 1

11. 按身高排序

在这里插入图片描述

这跟上面的9题是很类似的，同样也是利用一个二维数组，一个存身高，然后另一个存下标
在这里插入图片描述

  • 看上面图中，先将身高按照降序排序，然后依次按找下标取字符串就好了.
int cmp_hight(const void* x, const void* y)
{
    return ((int**)y)[0][0] - ((int**)x)[0][0];
}


char** sortPeople(char** names, int namesSize, int* heights, int heightsSize, int* returnSize)
{
    char** ans = (char**)malloc(sizeof(char*) * namesSize);
    int size = 0;
    int** data = (int**)malloc(sizeof(int*) * namesSize);
    int i;
    for (i = 0; i < namesSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = heights[i];
        data[i][1] = i; //存放下标
    }
    qsort(data,namesSize,sizeof(data[0]),cmp_hight);

    for (i = 0; i < namesSize; i++)
    {
        ans[size++] = names[data[i][1]];
    }

    *returnSize = size;
    return ans;
}

12. 最小和分割

在这里插入图片描述
这道题，首先得知道一个理论把，就是一堆有序的数里面，将他平均分隔组成的两个数。
要想和最小，那么一定得是间隔的去取，就比如下图，是135 + 24
在这里插入图片描述
知道这一点，这道题就好办了。

void GetDigit(int* nums,int* size,int num)
{
    *size = 0;
    while(num != 0)
    {
        nums[(*size)++] = num % 10;
        num /= 10;
    }
}

int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int splitNum(int num)
{
    int* nums = (int*)malloc(sizeof(int) * 10);
    int size = 0;
    GetDigit(nums,&size,num);
    qsort(nums,size,sizeof(nums[0]),cmp_int);
    int i, x = 0, y = 0;
    for (i = 0; i < size; i++)
    {
        if(i % 2 == 0)
        {
            x = x * 10 + nums[i];
        }
        else
        {
            y = y * 10 + nums[i];
        }
    }

    printf("x = %d ,y = %d \n",x,y);
    return x + y;
}

13.大于等于顺序前缀和的最小缺失整数

在这里插入图片描述

  • 首先计算出顺序前缀和。
  • 然后将数组中所有的数放入桶（哈希表中），同时求出最大值来。
  • 如果前缀和大于最大值，说明前缀和肯定没有出现，如果小于取哈希表中查出现过没有，如果没出现过，返回整个前缀和就好了。
  • 如果出现过，就在桶（哈希表）中从它的下一个位置去找，找到第一次未出现的数就是。
int missingInteger(int* nums, int numsSize)
{
    int* map = (int*)calloc(52,sizeof(int));
    int i,prefix = 0;
    //先求出顺序前缀
    for (i = 0; i < numsSize; i++)
    {
        prefix += nums[i];
        if(i+1 < numsSize && nums[i] + 1 != nums[i+1])
        {
            break;
        }
    }

    //统计每个数是否出现，同时求出最大值
    int max = 0;
    for (i = 0; i < numsSize; i++)
    {
        map[nums[i]] = 1;
        if(nums[i] > max)
        {
            max = nums[i];
        }
    }

    //如果说前缀和 比最大值都大，就证明里面肯定没有， || prefix 没有出现过
    if(prefix > max || map[prefix] == 0)
    {
        //满足条件直接返回就好了
        return prefix;
    }

    //说明prefix 出现在数组中，取找它的下一个没有出现过的。
    for (i = prefix + 1; i <= 52; i++)
    {
        if(map[i] == 0)
        {
            return i;
        }
    }

    return -1;
}

14.文物朝代判断

在这里插入图片描述
扑克牌？顺子？癞子？ 0 代表癞子？
这道题就是说给你个数组，数组里面的数字你随便排组合，如果能连起来就好了。

  • 首先统计出癞子的个数（0的个数），然后再算出缺失数字的个数。
  • 如果癞子的个数 >= 缺失的个数就能构成顺子。
int cmp_int(const void* x,const void* y)
{
    return *(int*)x - *(int*)y;
}

bool checkDynasty(int* places, int placesSize)
{
    qsort(places,placesSize,sizeof(int),cmp_int);
    int i = 0,zero = 0,miss = 0;
    //计算出0有多少个
    while(i < placesSize && places[i] == 0)
    {
        i++;
        zero++;
    }
    //去找缺失的数字的个数
    for (i; i < placesSize - 1; i++)
    {
        if(places[i+1] == places[i])
        {
            return false;
        }
        miss += places[i+1] - places[i] - 1;
    }
    return zero >= miss ? true : false;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1403586.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

unity 2021 发布安卓版本，谷歌限流国内，报错CommandInvokationFailure: Gradle build failed

unity 2021 发布安卓版本，谷歌限流国内，报错CommandInvokationFailure: Gradle build failed

在使用 Unity 2022 打包安卓项目时&#xff0c;遇到 gradle 无法访问或下载超级慢最终超时出错的问题解决 解决方案&#xff1a; 1. 在 Build Settings 左下角打开 Player Settings&#xff0c;在 Android 平台图标选项卡下找到 Publishing Settings 区域 勾选 2. 从国内…
阅读更多...
​《WebKit 技术内幕》学习之九（3）： JavaScript引擎

​《WebKit 技术内幕》学习之九（3）： JavaScript引擎

3　JavaScriptCore引擎 3.1　原理 JavaScriptCore引擎是WebKit中的默认JavaScript引擎&#xff0c;也是苹果在开源WebKit项目之后&#xff0c;开源的另外一个重要的项目。同其他很多引擎一样&#xff0c;在刚开始的时候它的主要部分是一个基于抽象语法树的解释器&#xff0c;这…
阅读更多...
【数据库原理】（38）数据仓库

【数据库原理】（38）数据仓库

数据仓库&#xff08;Data Warehouse, DW&#xff09;是为了满足企业决策分析需求而设计的数据环境&#xff0c;它与传统数据库有明显的不同。 一.数据库仓库概述 定义: 数据仓库是一个面向主题的、集成的、相对稳定的、反映历史变化的数据集合&#xff0c;用于支持企业管理和…
阅读更多...
成都爱尔胡建斌院长提醒视网膜脱离到底有多危险？！

成都爱尔胡建斌院长提醒视网膜脱离到底有多危险？！

视网膜脱离是视网膜神经上皮层与色素上皮层的分离。 视网膜脱离之危险&#xff0c;在与视网膜脱离后外层视网膜得不到脉络膜的血液供应&#xff0c;如不及时复位&#xff0c;视网膜感光细胞会发生凋亡&#xff0c;视力就不易恢复。 就症状来说&#xff0c;患者发病初期眼前多有…
阅读更多...
0122-1-JavaScript高级程序设计11-27章

0122-1-JavaScript高级程序设计11-27章

前言 通过阅读这本书写下的一些笔记 《JavaScript高级程序设计》 第11章——期约与异步函数 11.2 期约&#xff08;promise&#xff09;:是对 尚不存在结果 的一个替身。 /*** 期约与异步函数* 什么是Promise?* &#xff08;1&#xff09;从语法上来说&#xff1a;Promis…
阅读更多...
np.argsort排序问题(关于位次)-含GitHub上在numpy项目下提问的回复-总结可行方案

np.argsort排序问题(关于位次)-含GitHub上在numpy项目下提问的回复-总结可行方案

np.argsort 与获取位相关问题 位次: 数组中的数据在其排序之后的另一个数组中的位置 [1,0,2,3] 中 0的位次是1 1的位次是2 2的位次是3 3的位次是4 这里先直接给出结论&#xff0c;np.argsort()返回的索引排序与实际位次在确实在某些情况下会出现一致&#xff0c;但后来numpy的开…
阅读更多...
HubSpot SEO功能好用吗？

HubSpot SEO功能好用吗？

HubSpot对于SEO&#xff08;搜索引擎优化&#xff09;提供了全面的工具和功能&#xff0c;帮助用户优化其网站以在搜索引擎中取得更好的排名。以下是关于HubSpot SEO的一些关键方面&#xff1a; 内容优化&#xff1a; HubSpot的内容工具允许用户创建并优化吸引人的内容。通过关…
阅读更多...
pikachu验证码绕过第三关攻略

pikachu验证码绕过第三关攻略

打开pikachu靶场第三关&#xff1a; 挂上代理&#xff0c;随便输入账户密码&#xff1a; 返回bp。进行放包发现显示token错误。 每一次登录的返回包会带有token相关数据用于下一次的登录认证&#xff1a; 进行替换token值&#xff1a; 替换完成开始进行检点的爆破&#xff1a;…
阅读更多...
s3fs挂载minio集群到本地目录

s3fs挂载minio集群到本地目录

转载说明&#xff1a;如果您喜欢这篇文章并打算转载它&#xff0c;请私信作者取得授权。感谢您喜爱本文&#xff0c;请文明转载&#xff0c;谢谢。 1. 前言 MinIO 是一款高性能的对象存储&#xff0c;与 Amazon S3 云存储服务兼容&#xff0c;并且号称是世界上最快的对象存储服…
阅读更多...
LLM RAG 多种方式装载LLM的实践

LLM RAG 多种方式装载LLM的实践

一、大模型系统中检索增强生成&#xff08;RAG&#xff09;的意义 当前大模型在处理特定领域或者高度专业化的查询时表现出知识缺失&#xff0c;当所需信息超出模型训练数据范围或需要最新数据时&#xff0c;大模型可能无法提供准确答案。基于行业SOP、行业标准、互联网实时信…
阅读更多...
中间件-缓存、索引、日志

中间件-缓存、索引、日志

文章目录 缓存中间件本地缓存中间件分布式缓存中间件全文索引中间件分布式日志中间件小结 缓存中间件 缓存是性能优化的一大利器 我们先一起来看一个用户中心查询用户信息的基本流程 这时候&#xff0c;如果查找用户信息这个 API 的调用频率增加&#xff0c;并且在整个业务流…
阅读更多...
强化学习（四）动态规划——1

强化学习（四）动态规划——1

动态规划算法&#xff08;DP&#xff09;&#xff1a;在马尔可夫决策过程&#xff08;MDP&#xff09;的完美环境模型下计算最优策略。但其在强化学习中实用性有限&#xff0c;其一是它是基于环境模型已知&#xff1b;其二是它的计算成本很大。但它在理论伤仍然很重要&#xff…
阅读更多...
Vscode 顶部Menu(菜单)栏消失如何恢复

Vscode 顶部Menu(菜单)栏消失如何恢复

Vscode 顶部Menu(菜单)栏消失如何恢复&#xff1f; 首先按一下 Alt按键&#xff0c;看一下是否恢复了菜单栏如果恢复了想了解更进一步的设置&#xff0c;或是没能恢复菜单栏&#xff0c;可以看后续。 1.首先点击左下角 齿轮&#xff0c;打开settings; 或者 直接 ctrl 逗号 …
阅读更多...
如何本地搭建Splunk Enterprise数据平台并实现任意浏览器公网访问

如何本地搭建Splunk Enterprise数据平台并实现任意浏览器公网访问

文章目录 前言1. 搭建Splunk Enterprise2. windows 安装 cpolar3. 创建Splunk Enterprise公网访问地址4. 远程访问Splunk Enterprise服务5. 固定远程地址 前言 本文主要介绍如何简单几步&#xff0c;结合cpolar内网穿透工具实现随时随地在任意浏览器&#xff0c;远程访问在本地…
阅读更多...
java SSM项目预算生成管理系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

java SSM项目预算生成管理系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

一、源码特点 java SSM项目预算生成管理系统是一套完善的web设计系统&#xff08;系统采用SSM框架进行设计开发&#xff0c;springspringMVCmybatis&#xff09;&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的 源代码和数据库&#xff0c;系统主…
阅读更多...
《WebKit 技术内幕》学习之十（1）： 插件与JavaScript扩展

《WebKit 技术内幕》学习之十（1）： 插件与JavaScript扩展

虽然目前的浏览器的功能很强 &#xff0c;但仍然有其局限性。早期的浏览器能力十分有限&#xff0c;Web前端开发者希望能够通过一定的机制来扩展浏览器的能力。早期的方法就是插件机制&#xff0c;现在流行次啊用混合编程&#xff08;Hybird Programming&#xff09;模式。插件…
阅读更多...
小微企业科技创新之策略：人才、投入、模式、技术、支持四管齐下

小微企业科技创新之策略：人才、投入、模式、技术、支持四管齐下

对于小微企业来说&#xff0c;搞科技创新需要从多个方面入手。以下是一些可供参考的方法&#xff1a; 明确创新方向&#xff1a;首先&#xff0c;企业需要明确自己的创新方向和目标&#xff0c;这有助于聚焦资源&#xff0c;避免盲目投入。同时&#xff0c;企业需要对市场进行…
阅读更多...
charles使用指南

charles使用指南

一、什么是charles Charles 是一个http代理、管理以及反向代理工具&#xff0c;它允许开发者查看本地机器和互联网之间的关于http、https的所有通信&#xff0c;包含请求、响应以及他们的请求头、响应头。 它的主要功能包含&#xff1a; 1、SSL代理 2、带宽限制 3、ajax断…
阅读更多...
如何查看Linux CPU占有率

如何查看Linux CPU占有率

目录 1、top 2、htop 3、vmstat 4、mpstat 5、iostat 查看嵌入式设备CPU占有率是评估系统资源使用情况的重要方式。 在Linux系统中&#xff0c;有多种方法可以查看CPU占有率&#xff0c;这里介绍几种常用的命令行工具。 1、top 这是最常用的命令之一&#xff0c;它提供了…
阅读更多...
go语言（十三）-----interface

go语言（十三）-----interface

一、Interface 通用万能类型 空接口int&#xff0c;string&#xff0c;float&#xff0c;struct都实现了interface都可以用interface{}类型,引用任意的数据类型 package mainimport "fmt"//interface()是万能数据类型 func myFunc(arg interface{}) {fmt.Println(&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023