FLAMEc隨手記

一陣風飄過~~~

0%

發表於 更新於

之前學習Unreal 5的時候有製作小遊戲~

那時候主要目的是測試DataTable~

那時候有微軟的Excel可以輸出csv檔案~

編輯起來很方便~

但是回到家裡後沒有Excel可以用!!

整個改資料就很麻煩，相對麻煩~

後來在UE商店有看到直接使用Google Sheet資料的影片~

就決定找方法把Google Sheet資料抓下來填充!!

先從Unreal的Module開始研究起~

Win11點uproject右鍵要先用左鍵點選，再點右鍵才會出現Generate Virsual Studio project file

然後決定使用plugin來製作~

最後成果 Unreal5GoogleSheetDataTable

這個方法是直接共享sheet，更好方法需使用google私密金鑰!!之後再研究~

發表於 更新於

是leetcode的題目，題目如下(直接複製的)：

Given an array of integers nums, sort the array in ascending order and return it.

You must solve the problem without using any built-in functions in O(nlog(n)) time complexity and with the smallest space complexity possible.

心得：

簡單說大概就是自己寫排序不要用已經有的排序吧!!

一開始我是用較常用的排序法QuickSort就上了!!!

結果超時!!!!!!!!!

結果超時!!!!!!!!!

猜測大概是會排序到對QuickSort來說最壞狀況的陣列，剛好超時吧!?

所以稍微找了一下更快的排序法~

  1. MergeSort 合併排序法
  2. TimSort Tim排序法

研究後發現兩者有一定關係，TimSort像是MergeSort優化版本，或著說加強版。

TimSort會將數列分割成一定大小，然後先用InsertSort排序，之後才開始用MergerSort合併。

最後實作如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
class Solution {
public:
    //插入排序法，小數量很穩
    void insertSort(vector<int>& nums,int left , int right)
    {
        for(int i = left + 1; i <= right; i++)
        {
            int val = nums[i];
            int j = i - 1;
            while(j >= left && nums[j] > val)
            {
                nums[j+1] = nums[j];
                j--;
            }
            nums[j+1] = val;
        }
    }

    //MergeSort，看網上TimSort資料這邊也有優化，似乎把一個一個檢查改成跳幾個檢查
    void merge(vector<int>& nums,vector<int>& cpyBuff,int left , int mid , int right)
    {
        int leftn = 0,rightn;
        for(int i = left; i <= mid; i++)
        {
            cpyBuff[leftn] = nums[i];
            leftn++;
        }

        int len = mid - left;
        leftn = 0;
        rightn = mid + 1;
        //兩個排序數列找小的放前面
        while(leftn <= len && rightn <= right)
        {
            if(cpyBuff[leftn] > nums[rightn])
            {
                nums[left] = nums[rightn];
                rightn++;
                left++;

            }
            else
            {
                nums[left] = cpyBuff[leftn];
                leftn++;
                left++;
            }
        }

        while(leftn <= len)
        {
            nums[left] = cpyBuff[leftn];
            leftn++;
            left++;
        }

        while(rightn <= right)
        {
            nums[left] = nums[rightn];
            rightn++;
            left++;
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        int run = 32; //分割大小，稱為Run
        for(int i = 0 ; i < n; i += run)
            insertSort(nums,i,std::min(n - 1 , i + run - 1));

        int cpySize = run;
        while(cpySize < n)
        {
            cpySize *= 2;
        }
        cpySize = cpySize >> 1;
        std::vector<int> cpyBuff(cpySize);
        for(int size = run; size < n ; size *= 2)
        {
            for(int i = 0; i < n; i += size * 2)
            {
                int mid = i + size - 1;
                if(mid >= n)
                    continue;
                int right = std::min(n - 1 , mid + size);

                merge(nums,cpyBuff,i,mid,right);
            }
        }

        return nums;
    }
};

發表於 更新於

是leetcode的題目，題目如下(直接複製的)：

You are given two arrays rowSum and colSum of non-negative integers where rowSum[i] is the sum of the elements in the ith row and colSum[j] is the sum of the elements of the jth column of a 2D matrix. In other words, you do not know the elements of the matrix, but you do know the sums of each row and column.

Find any matrix of non-negative integers of size rowSum.length x colSum.length that satisfies the rowSum and colSum requirements.

Return a 2D array representing any matrix that fulfills the requirements. It’s guaranteed that at least one matrix that fulfills the requirements exists.

Example 1:

Input: rowSum = [3,8], colSum = [4,7]
Output: [[3,0],
[1,7]]
Explanation:
0th row: 3 + 0 = 3 == rowSum[0]
1st row: 1 + 7 = 8 == rowSum[1]
0th column: 3 + 1 = 4 == colSum[0]
1st column: 0 + 7 = 7 == colSum[1]
The row and column sums match, and all matrix elements are non-negative.
Another possible matrix is: [[1,2],
[3,5]]
Example 2:

Input: rowSum = [5,7,10], colSum = [8,6,8]
Output: [[0,5,0],
[6,1,0],
[2,0,8]]

心得：

看來看去這一題主要是要知道這個問題的解法，就像魔術方塊有公式解，
這個問題應該也有類似的公式解，應該不是考推導而是考公式解如何轉化成Code。

一開始我是沒碰過這個問題的，所以卡了一下，要推導出公式還是有點難度的QQ
所以看了一下Hint，Hint中提到大概做法，可能是公式之一吧，其實也是有點懷疑真的嗎XD?

Hint 1
Find the smallest rowSum or colSum, and let it be x. Place that number in the grid, and subtract x from rowSum and colSum. Continue until all the sums are satisfied.

一步一步測試後確認可行。就像魔術方塊公式解也有多種，應該也是有更簡化的方法的，這邊就不繼續研究了。

最後如下；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Solution {
public:
    vector<vector<int>> restoreMatrix(vector<int>& rowSum, vector<int>& colSum) {
        vector<vector<int>> ans(rowSum.size(), vector<int>(colSum.size(),0));


        int minRor = 0;
        int minCol = 0;

        while(true)
        {
            minRor = 0;
            minCol = 0;

            //找最小值
            for(int i = 1 ; i < rowSum.size(); i++)
            {
                if((rowSum[i] > 0 && rowSum[i] < rowSum[minRor]) || rowSum[minRor] == 0)
                {
                    minRor = i;
                }
            }

            //找最小值
            for(int i = 1 ; i < colSum.size(); i++)
            {
                if((colSum[i] > 0 && colSum[i] < colSum[minCol]) || colSum[minCol] == 0)
                {
                    minCol = i;
                }
            }

            //都是0結束
            if(rowSum[minRor] == 0 && colSum[minCol] == 0)
                break;

            //塞結果和更新值
            if(rowSum[minRor] > colSum[minCol])
            {
                ans[minRor][minCol] = colSum[minCol];
                rowSum[minRor] -= colSum[minCol]; //這邊就是一開始我最懷疑地方，直接改不會沒算出來嗎XD?結果沒事!!
                colSum[minCol] = 0;
            }
            else
            {
                ans[minRor][minCol] = rowSum[minRor];
                colSum[minCol] -= rowSum[minRor]; //這邊就是一開始我最懷疑地方，直接改不會沒算出來嗎XD?結果沒事!!
                rowSum[minRor] = 0;
            }
        }


        return ans;
    }
};

發表於 更新於

最近正在研究android新跨平台開發套件 Flutter use android studio

先不說能跨多少平台，在建專案的時候就有兩個選擇!!

1.Jave
2.kotlin

一個新的名稱!! 所以特別去google查了一下狀況~~~如下!!

Kotlin 是針對Java 優化的一種語言(雖然語法稍有不同?)

Kotlin 最大的特色就是 100% 和 JAVA 配合，使用者可以不用在Kotlin與Java 之間猶豫二選一，需要的時候再使用Kotlin 即可。

順便提一下語言差別~~~

靜態語言

需要在宣告型別時定義變數的型別

String hello = ‘hello’;

動態語言

不用事先宣告型別的語言

var a = 0;

直譯式語言

程式碼不用編譯成執行檔直接用直譯器執行

編譯式語言

程式碼會先編譯成下兩種之一
1.執行檔 => 直接執行
2.中間檔 => 平台環境執行器轉譯執行

發表於 更新於

今天研究好久Vuejs…

目前發現Javascript的import和export很重要吧!!!

因為可以管理好資料!!

Vue部分：

使用方法大概兩種：

  1. 使用Cdn上面的js檔案
  2. 完整安裝整個開發環境(npm create vue@latest)

因為這邊使用了hexo就沒再裝環境了，所以使用1.

目標想要做SliderImage之類，剛好發現一個Vue外掛吧!!

Swiper: 可以很方便做一些Slider功能

使用方法大概兩種：

  1. 使用Cdn
  2. 完整安裝(npm install swiper)，但是估計要裝在Vue環境下…

目前只弄了一個Demo：

FLAMEc Demo