教程参考
2023.3申请github copilot x 学生认证以及Jetbrain专业版学生教育免费教程

1：修改个人信息

Github右上角头像点击 Your profile
Name：改成你的英文名字，例如 Li Mingtian
Bio：I am Li Mingtian, a student in xxx university. I want to study in Github and try to make some contributions to the community.
Company：Xxx University
Location：Xxx University
image.png

2：准备材料

image.png
image.png

3：提交材料

  • 用手机（不要用电脑）打开Github学生认证网址https://education.github.com/discount_requests/application（注意千万不要科学上网！！！）
  • 然后这样填：
    • 邮箱：随便选一个
    • 学校：直接中文输入你的学校名字，然后选择弹出来的学校信息
    • 理由：I want to study in Github and try to make some contributions to the community.
    • 选continue，允许获取位置
  • 手机选上传照片，上传step2的jpeg图片
  • type选transcript，提交

注意：期间要多次拍照尝试
image.png

4：等待邮箱结果

Screenshot_2023-05-03-23-42-09-914_com.tencent.an.jpg
Screenshot_2023-05-03-23-42-28-944_com.tencent.an.jpg

5：Github Copilot

  1. 打开https://github.com/features/copilot
  2. 点击Start my free trial
  3. 安装vscode github copilot插件，登录验证就可以用了~

image.png
image.png

6：使用技巧

写注释回车即可
【Github Copilot 使用】
点击查看【bilibili】

  1. class test {
  3.     // 写一个冒泡排序
  4.     public int[] effervescence(int arr[]) {
  5.         int temp = 0;
  6.         for (int i = 0; i < arr.length; i++) {
  7.             for (int j = 0; j < arr.length - i - 1; j++) {
  8.                 if (arr[j] > arr[j + 1]) {
  9.                     temp = arr[j];
  10.                     arr[j] = arr[j + 1];
  11.                     arr[j + 1] = temp;
  12.                 }
  13.             }
  14.         }
  16.         return arr;
  17.     }
  19.     // 写一个选择排序
  20.     public int[] select(int arr[]) {
  21.         int temp = 0;
  22.         int minIndex = 0;
  23.         for (int i = 0; i < arr.length; i++) {
  24.             minIndex = i;
  25.             for (int j = i; j < arr.length; j++) {
  26.                 if (arr[minIndex] > arr[j]) {
  27.                     minIndex = j;
  28.                     temp = arr[minIndex];
  29.                     arr[minIndex] = arr[i];
  30.                     arr[i] = temp;
  31.                 }
  32.             }
  33.         }
  35.         return arr;
  36.     }
  38.     // 写一个插入排序
  39.     public int[] insert(int arr[]) {
  40.         int temp = 0;
  41.         int insertIndex = 0;
  42.         for (int i = 1; i < arr.length; i++) {
  43.             insertIndex = i - 1;
  44.             temp = arr[i];
  45.             while (insertIndex >= 0 && temp < arr[insertIndex]) {
  46.                 arr[insertIndex + 1] = arr[insertIndex];
  47.                 insertIndex--;
  48.             }
  49.             arr[insertIndex + 1] = temp;
  50.         }
  52.         return arr;
  53.     }
  55.     // 写一个希尔排序
  56.     public int[] shell(int arr[]) {
  57.         int temp = 0;
  58.         int insertIndex = 0;
  59.         for (int gap = arr.length / 2; gap > 0; gap /= 2) {
  60.             for (int i = gap; i < arr.length - gap; i++) {
  61.                 insertIndex = i - gap;
  62.                 temp = arr[i];
  63.                 while (insertIndex >= 0 && temp < arr[insertIndex]) {
  64.                     arr[insertIndex + gap] = arr[insertIndex];
  65.                     insertIndex -= gap;
  66.                 }
  67.                 arr[insertIndex + gap] = temp;
  68.             }
  69.         }
  71.         return arr;
  72.     }
  74.     // 写一个快速排序
  75.     public int[] quick(int arr[], int left, int right) {
  76.         int l = left;
  77.         int r = right;
  78.         int pivot = arr[(left + right) / 2];
  79.         int temp = 0;
  80.         while (l < r) {
  81.             while (arr[l] < pivot) {
  82.                 l++;
  83.             }
  85.             while (arr[r] > pivot) {
  86.                 r--;
  87.             }
  89.             if (l >= r) {
  90.                 break;
  91.             }
  93.             temp = arr[l];
  94.             arr[l] = arr[r];
  95.             arr[r] = temp;
  97.             if (arr[l] == pivot) {
  98.                 r--;
  99.             }
  101.             if (arr[r] == pivot) {
  102.                 l++;
  103.             }
  104.         }
  106.         if (l == r) {
  107.             l++;
  108.             r--;
  109.         }
  111.         if (left < r) {
  112.             quick(arr, left, r);
  113.         }
  115.         if (right > l) {
  116.             quick(arr, l, right);
  117.         }
  119.         return arr;
  120.     }
  122.     // 写一个归并排序
  123.     public int[] merge(int arr[], int left, int right) {
  124.         if (left < right) {
  125.             int mid = (left + right) / 2;
  126.             merge(arr, left, mid);
  127.             merge(arr, mid + 1, right);
  128.             mergeSort(arr, left, mid, right);
  129.         }
  131.         return arr;
  132.     }
  134.     // 归并排序的合并
  135.     public void mergeSort(int arr[], int left, int mid, int right) {
  136.         int temp[] = new int[right - left + 1];
  137.         int l = left;
  138.         int r = mid + 1;
  139.         int index = 0;
  140.         while (l <= mid && r <= right) {
  141.             if (arr[l] < arr[r]) {
  142.                 temp[index] = arr[l];
  143.                 l++;
  144.                 index++;
  145.             } else {
  146.                 temp[index] = arr[r];
  147.                 r++;
  148.                 index++;
  149.             }
  150.         }
  152.         while (l <= mid) {
  153.             temp[index] = arr[l];
  154.             l++;
  155.             index++;
  156.         }
  158.         while (r <= right) {
  159.             temp[index] = arr[r];
  160.             r++;
  161.             index++;
  162.         }
  164.         for (int i = 0; i < temp.length; i++) {
  165.             arr[left + i] = temp[i];
  166.         }
  167.     }
  169.     // 写一个基数排序
  170.     public int[] radix(int arr[]) {
  171.         int max = arr[0];
  172.         for (int i = 0; i < arr.length; i++) {
  173.             if (max < arr[i])
  174.                 max = arr[i];
  175.         }
  177.         int maxLength = (max + "").length();
  178.         int bucket[][] = new int[10][arr.length];
  179.         int bucketElementCounts[] = new int[10];
  180.         int index = 0;
  181.         for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
  182.             for (int j = 0; j < arr.length; j++) {
  183.                 index = arr[j] / n % 10;
  184.                 bucket[index][bucketElementCounts[index]] = arr[j];
  185.                 bucketElementCounts[index]++;
  186.             }
  188.             int k = 0;
  189.             for (int j = 0; j < bucketElementCounts.length; j++) {
  190.                 if (bucketElementCounts[j] != 0) {
  191.                     for (int l = 0; l < bucketElementCounts[j]; l++) {
  192.                         arr[k] = bucket[j][l];
  193.                         k++;
  194.                     }
  195.                 }
  196.                 bucketElementCounts[j] = 0;
  197.             }
  198.         }
  200.         return arr;
  201.     }
  203.     // 写一个堆排序
  204.     public int[] heap(int arr[]) {
  205.         int temp = 0;
  206.         for (int i = arr.length / 2 - 1; i >= 0; i--) {
  207.             heapSort(arr, i, arr.length);
  208.         }
  210.         for (int i = arr.length - 1; i > 0; i--) {
  211.             temp = arr[i];
  212.             arr[i] = arr[0];
  213.             arr[0] = temp;
  214.             heapSort(arr, 0, i);
  215.         }
  217.         return arr;
  218.     }
  220.     // 堆排序的调整
  221.     public void heapSort(int arr[], int i, int length) {
  222.         int temp = arr[i];
  223.         for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
  224.             if (k + 1 < length && arr[k] < arr[k + 1]) {
  225.                 k++;
  226.             }
  228.             if (arr[k] > temp) {
  229.                 arr[i] = arr[k];
  230.                 i = k;
  231.             } else {
  232.                 break;
  233.             }
  234.         }
  236.         arr[i] = temp;
  237.     }
  239.     // 写一个计数排序
  240.     public int[] count(int arr[]) {
  241.         int max = arr[0];
  242.         int min = arr[0];
  243.         for (int i = 0; i < arr.length; i++) {
  244.             if (max < arr[i])
  245.                 max = arr[i];
  247.             if (min > arr[i])
  248.                 min = arr[i];
  249.         }
  251.         int count[] = new int[max - min + 1];
  252.         for (int i = 0; i < arr.length; i++) {
  253.             count[arr[i] - min]++;
  254.         }
  256.         int index = 0;
  257.         for (int i = 0; i < count.length; i++) {
  258.             while (count[i] > 0) {
  259.                 arr[index] = i + min;
  260.                 index++;
  261.                 count[i]--;
  262.             }
  263.         }
  265.         return arr;
  266.     }
  268.     // 写一个希尔排序
  269.     public int[] shell(int arr[]) {
  270.         int temp = 0;
  271.         for (int gap = arr.length / 2; gap > 0; gap /= 2) {
  272.             for (int k = gap; k < arr.length; k++) {
  273.                 for (int i = k - gap; i >= 0; i -= gap) {
  274.                     if (arr[i] > arr[i + gap]) {
  275.                         temp = arr[i];
  276.                         arr[i] = arr[i + gap];
  277.                         arr[i + gap] = temp;
  278.                     }
  279.                 }
  280.             }
  281.         }
  283.         return arr;
  284.     }
  286.     // 写一个桶排序
  287.     public int[] bucket(int arr[]) {
  288.         int max = arr[0];
  289.         int min = arr[0];
  290.         for (int i = 0; i < arr.length; i++) {
  291.             if (max < arr[i])
  292.                 max = arr[i];
  294.             if (min > arr[i])
  295.                 min = arr[i];
  296.         }
  298.         int bucketSize = 5;
  299.         int bucketCount = (max - min) / bucketSize + 1;
  300.         ArrayList<ArrayList<Integer>> bucket = new ArrayList<ArrayList<Integer>>();
  301.         for (int i = 0; i < bucketCount; i++) {
  302.             bucket.add(new ArrayList<Integer>());
  303.         }
  305.         for (int i = 0; i < arr.length; i++) {
  306.             bucket.get((arr[i] - min) / bucketSize).add(arr[i]);
  307.         }
  309.         int index = 0;
  310.         for (int i = 0; i < bucket.size(); i++) {
  311.             Collections.sort(bucket.get(i));
  312.             for (int j = 0; j < bucket.get(i).size(); j++) {
  313.                 arr[index] = bucket.get(i).get(j);
  314.                 index++;
  315.             }
  316.         }
  318.         return arr;
  319.     }
  321.     // 写一个基数排序
  322.     public int[] effervescence(int arr[]) {
  323.         int temp = 0;
  324.         boolean flag = false;
  325.         for (int i = 0; i < arr.length - 1; i++) {
  326.             flag = false;
  327.             for (int k = 0; k < arr.length - 1 - i; k++) {
  328.                 if (arr[k] > arr[k + 1]) {
  329.                     temp = arr[k];
  330.                     arr[k] = arr[k + 1];
  331.                     arr[k + 1] = temp;
  332.                     flag = true;
  333.                 }
  334.             }
  336.             if (!flag)
  337.                 break;
  338.         }
  340.         return arr;
  341.     }
  343.     public static void main(String[] args){
  344.         int[] name = new int[5];
  345.         name[0] = 1;
  346.         name[1] = 54325;
  347.         name[2] = 7474;
  348.         name[3] = 546;
  349.         name[4] = 77;
  351.         test test = new test();
  352.         int[] effervescence = test.effervescence(name);
  354.         for(int i = 0; i < effervescence.length; i++){
  355.             System.out.println(effervescence[i]);
  356.         }
  357.         System.out.println("Hello World");
  358.     }
  359. }

IDEA
image.png
重启IDEA
image.png

image.png