2018年1月31日 星期三

[412] Fizz Buzz

被結束字元整的亂七八糟的..........
為什麼會這樣呢XD

從一印到n, 是三的倍數的時候印FIZZ
是五的倍數的時候印BUZZ,
是三&五的倍數印FIZZBUSS

412. Fizz Buzz

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
char** fizzBuzz(int n, int* returnSize) {
    char **ret = malloc(sizeof(char *)*n);
    char five[]="Buzz";
    char three[]="Fizz";
    char both[]="FizzBuzz";

    *returnSize = n;
    int i=0;
    for (i=1;i<=n;i++)
    {
        if(i%3==0 && i%5==0)
        {
            ret[i-1] = malloc(sizeof(char)*9);
            memset(ret[i-1],0,9);
            memcpy(ret[i-1],both,8);
        }
        else if(i%3==0)
        {
            ret[i-1] = malloc(sizeof(char)*5);
            memset(ret[i-1],0,5);
            memcpy(ret[i-1],three,4);
        }
        else if(i%5==0)
        {
            ret[i-1] = malloc(sizeof(char)*5);
            memset(ret[i-1],0,5);
            memcpy(ret[i-1],five,4);          
        }
        else
//        if(i%3!=0 && i%5 !=0)
        {
            char num[100];
            memset(num,"",100);
            sprintf(num,"%d",i);
            ret[i-1] = malloc(sizeof(char)*strlen(num));
            strcpy(ret[i-1], num);
        }
    }
       
    return ret;
}

精簡版 QQ
然後再次驗證在測資不多或是數目少的時候
快慢根本是看心情的啊啊啊啊啊~~~
傷心QQ

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
char** fizzBuzz(int n, int* returnSize) {
    char **ret = malloc(sizeof(char *)*n);
    for (int i=1;i<=n;i++)
    {
        ret[i-1] = malloc(sizeof(char)*9);

        if(i%3==0 && i%5==0)
        {
            sprintf(ret[i-1],"%s","FizzBuzz");
        }
        else if(i%3==0)
        {
            sprintf(ret[i-1],"%s","Fizz");
        }
        else if(i%5==0)
        {
            sprintf(ret[i-1],"%s","Buzz");          
        }
        else
        {
            sprintf(ret[i-1],"%d",i);
        }
    }
    *returnSize = n;      
    return ret;
}

20230819 再次更新
因為聽說有人考這個所以回來寫一下
哦再次感受到我進步了 XD
char ** fizzBuzz(int n, int* returnSize){
char **ret = malloc (sizeof(char*)*n);
for (int i=1;i<=n;i++)
{
int three = i%3;
int five = i%5;
if (three == 0 && five ==0)
{
ret[i-1] = malloc(sizeof(char)*8);
ret[i-1] = "FizzBuzz";
}
else if (three==0)
{
ret[i-1] = malloc(sizeof(char)*4);
ret[i-1] = "Fizz";
}
else if (five==0)
{
ret[i-1] = malloc(sizeof(char)*4);
ret[i-1] = "Buzz";
}
else
{
ret[i-1] = malloc(sizeof(char)*5);
sprintf(ret[i-1], "%d", i);
}
}
*returnSize = n;
return ret;
}

不過這個行數還是讓人心生不忍,只好還是暴力先給它最大size  XD
char ** fizzBuzz(int n, int* returnSize){
char **ret = malloc (sizeof(char*)*n);
for (int i=1;i<=n;i++)
{
ret[i-1] = malloc(sizeof(char)*8);
if (i%3 == 0 && i%5 ==0)
ret[i-1] = "FizzBuzz";
else if (i%3==0)
ret[i-1] = "Fizz";
else if (i%5==0)
ret[i-1] = "Buzz";
else
sprintf(ret[i-1], "%d", i);
}
*returnSize = n;
return ret;
}

[125] Valid Palindrome

判斷是不是回文
大小寫不計,只看字母跟數字
如果完全沒有符合字母跟數字的也算是YES
(為什麼要這樣定義為什麼~~~搖作者肩膀)
題意不難可是一堆corner case
(是說這跟special case 有什麼不一樣嗎XD)
覺得瑣碎 QQ

Valid Palindrome

bool isAlphanumeric(char *pL)
{
    if (pL[0]<48 || (pL[0]>57 && pL[0] <65)  || (pL[0]>90 && pL[0]<97) || (pL[0] >122))
        return false;
    return true;
}

bool isPalindrome(char* s) {
    if(s==NULL)
        return true;
    char *pL=s;
    char *pR = s+strlen(s) -1;

    while(pL<pR)
    {
        if (!isAlphanumeric(pL))
            pL++;
        else if (!isAlphanumeric(pR))
            pR--;
        else if (strncasecmp(pL++,pR--,1)!=0)
            return false;
    }    
    return true;
}

[70] Climbing Stairs

用遞迴寫會超時 囧
所以就是DP的精髓!(嗎XD)
費波那西數列(Fibonacci)
重點是前面算過的存起來給下一個用
就不用再算一次, 可以加速.

Climbing Stairs
int climbStairs(int n) {
    int ret=0;
    if (n==1)
        return 1;
    if(n==2)
        return 2;
    int f1,f2,f3;
    f1=1;
    f2=2;
    for(int i =3;i<=n;i++)
    {
        f3 = f1+f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

20220124更新:也可以用一整個array 存每個值

int climbStairs(int n){
int *stairs=calloc(45,sizeof(int));
stairs[0]=1; //n=1
stairs[1]=2; //n=2
for (int i=2;i<n;i++)
stairs[i]=stairs[i-1]+stairs[i-2];
return stairs[n-1];
}

[189] Rotate Array

廢到不知道該說自己什麼, 呵呵.
給一個array, 往右shift 移k個
存回原本的array裡

Rotate Array
無腦慢慢移 囧
void rotate(int* nums, int numsSize, int k) {
    if (nums == NULL || numsSize <1 || k%numsSize==0)
        return;
    if (k>=numsSize)
        k=k%numsSize;
 
    int i = 0,j=0;
    for (i=0; i<k; i++)
    {
        int tmp=nums[numsSize-1];
        for (j=0; j <= numsSize-2; j++)      
        {
            nums[numsSize-1-j]=nums[numsSize-1-j-1];
        }
        if(k==1& numsSize==2)
            nums[1]=nums[0];
        nums[0] = tmp;
    }
}

切兩段法
void rotate(int* nums, int numsSize, int k) {
    if (nums == NULL || numsSize <1 || k%numsSize==0)
        return;
    if (k>=numsSize)
        k=k%numsSize;
    int *p = malloc(sizeof(int)*numsSize);
    memcpy(p,nums+(numsSize-k),sizeof(int)*k);
    memcpy(p+k,nums,sizeof(int)*(numsSize-k));
    memcpy(nums,p,sizeof(int)*numsSize);

}

取餘數法
void rotate(int* nums, int numsSize, int k) {
    if (nums == NULL || numsSize <1 || k%numsSize==0)
        return;
    if (k>=numsSize)
        k=k%numsSize;
    int *tmp = malloc (sizeof(int)*numsSize);
    memcpy(tmp,nums,sizeof(int)*numsSize);
    for (int i=0;i<numsSize;i++)
    {
        nums[i] = tmp[(numsSize+(i-k))%numsSize];
     
    }
}

2018年1月29日 星期一

[66] Plus One

給一個存在array的數字, (312三百一十二存成 3,1,2這樣)
加一之後回傳新的array,
要注意的應該就是進位的部分吧
因為是easy等級大概只要注意寫對就可以了?
自以為加速的把確定不會進位的先做好像只是自做聰明XD
anyway.


Plus One
/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* plusOne(int* digits, int digitsSize, int* returnSize) {
    *returnSize = digitsSize;
    int *ret ;
    if(digits ==NULL || digitsSize==0)
        return ret;

    if(digits[digitsSize-1]<9)
    {
        digits[digitsSize-1] += 1;
        ret = malloc (sizeof(int)*(digitsSize));
        memcpy(ret,digits,sizeof(int)*(digitsSize));
        return ret;
    }
    int i,tenflag=1;
    digits[digitsSize-1] = 0;
    for(i=digitsSize-2;i>=0;i--)
    {
        if(digits[i]+tenflag >= 10)
        {
            digits[i] = 0;
            tenflag = 1;
        }
        else
        {
            digits[i] = digits[i]+tenflag--;
//            tenflag=0;
            break;
        }
    }  
    if (tenflag)
    {
        ret = malloc (sizeof(int)*(digitsSize+1));
        ret[0] = 1;
        memcpy(ret+1, digits, sizeof(int)*(digitsSize));
        *returnSize = digitsSize+1;
    }
    else
    {
        ret = malloc (sizeof(int)*(digitsSize));
        memcpy(ret,digits,sizeof(int)*(digitsSize));
    }

    return ret;
}

[26] Remove Duplicates from Sorted Array

糾結半天想想還是紀錄在一起吧.
只能算是練練語法的吸加加QQ

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.size()<1)
            return NULL;
        //        for(auto c : nums)
        int i, index = 0;
        for (i=0;i<nums.size()-1;i++)
            if (nums[i]!=nums[i+1])
            {
                nums[index++] = nums[i];
            }
        nums[index++] = nums[nums.size()-1];
        return index;
    }
};

***分隔線C跟++分隔線***

跟前一題很像(比樓下)
其實是可以放在一起
給一個sorted array, 要把一樣的拿掉.

Remove Duplicates from Sorted Array
int removeDuplicates(int* nums, int numsSize) {
    if (nums== NULL || numsSize==0)
        return 0;
    int i,index=1;

    for(i=1;i<numsSize;i++)
    {
        if(nums[i-1] != nums[i])
        {
            nums[index++]=nums[i];
        }
    }
    return index;
}

[27] Remove Element

Remove Duplicates from Sorted Array
給一串數字&指定一個值
需要拿掉所有的這個值
並向前排列......
結果把它想的太難了 囧
好笨 T_____T

void swap(int *a , int *b){
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

int removeElement(int* nums, int numsSize, int val) {
    int head,back,ret=numsSize;
    for (head=0,back=numsSize-1;head<back;)
    {
        if(nums[back]==val)
        {  
            back--;
            ret--;
        }
        if(nums[head]!=val)
        {
            head++;
        }
        if (head>=back)
            break;
        if(nums[head]==val && nums[back]!=val)
        {  
            swap(&nums[head],&nums[back]);
        }
    }
    if(head == back && nums[head]==val)
        ret--;
     
    return ret;
}


其實只要這樣就好了:
int removeElement(int* nums, int numsSize, int val) {
    int i,index=0;
    for(i=0;i<numsSize;i++)
    {
        if(nums[i]!=val)
            nums[index++] = nums[i];
    }
    return index;
}

2018年1月28日 星期日

[1] Two Sum

因為前一個hard搞錯題意覺得太打擊信心了
就找了個easy的來做
姑且不論我之前才在說執行時間不準的事
因為這次執行起來算是快的XD
覺得溫馨~~~~~
暴力法萬歲~~~~~(這也好意思拿出來講XD?!)

Two Sum
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target) {
    int i,j;
    int *ret = malloc((sizeof(int))*2);
    for (i=0;i<numsSize;i++)
        for(j=i+1;j<numsSize;j++)
            if(nums[i]+nums[j] == target)
            {
                ret[0]= i;
                ret[1]= j;
                return ret;
            }
    return ret;
}

照例看看討論區又有應該要唸的東西了 XD
TBC here...

UPDATE!
就討論區說要用hash 做Orz
不知道為什麼寫起來怎麼看怎麼醜Orz
而且沒有一邊執行看結果來回推的話我根本就寫不出來 T口T
完了一個蛋......

不過輸入量大的時候, hash比暴力法快好多喔...
4ms跟97ms的差異 囧
怎麼辦覺得自己沒天份 QQ

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target) {
    int i,j;
    int max=0;
    int min=0;
    for(i=0;i<numsSize;i++)
    {
        if(nums[i]>0 && nums[i]>max)
            max = nums[i];
        if(nums[i]<0 && nums[i]<min)
            min = nums[i];
    }
    int hashSize;
    hashSize = (max - min) +1;
    hashSize = (hashSize > target)? hashSize: target;

    int *hash = malloc(sizeof(int)*hashSize);
    memset(hash,0,hashSize);
    for(i=0;i<numsSize;i++)
    {
        hash[nums[i]-min] ++;
    }
 
    int *ret = malloc(sizeof(int)*2);
    ret[0]=-1;
    ret[1]=-1;

    int v1,v2;
    for(i=0;i<hashSize;i++)
    {    
        v1=0;
        v2=0;
        if(hash[i]>0)
        {
            int diff = target - (i+min);
            if (diff < hashSize && hash[diff-min] >0)
            {
                v1=i+min;
                v2=diff;
                break;
            }
        }
    }
    for(i=0;i<numsSize;i++)
    {
        if (v1 == nums[i] && ret[0] <0)
            ret[0] =i ;
        else if(v2==nums[i] && ret[1] <0)
            ret[1] = i;
    }
    return ret;
}
如果hash裡面再做linked list的話,
應該可以不要有最後一個迴圈去找v1跟v2的index ?
因為index就可以直接存在hash的欄位裡了
照理說會再加速一些些~

是說又要考慮負數, 又要考慮有同樣的數字在不同的index也太煩了吧!!!(顯示為爆炸)

[4] Median of Two Sorted Arrays (TBC)

兩個sorted array, 取其中位數.
還是array比較清新~
這題是hard難度倒是令人有點意外(?)
該不會我漏掉了什麼重要的東西XD?!

Median of Two Sorted Arrays
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
 
    int *sorted = malloc((sizeof(int))*(nums1Size+nums2Size));
    int i,j,k;
    int total = nums1Size+nums2Size;
    for (i=0,j=0,k=0;k<total;k++)
    {
        if(i<nums1Size && j<nums2Size)
            sorted[k] = (nums1[i]<nums2[j])?(nums1[i++]):(nums2[j++]);
        else if (i<nums1Size)
            sorted[k]=nums1[i++];
        else if (j<nums2Size)
            sorted[k]=nums2[j++];
    }

    if ((total)%2 == 0)
        return ((double)(sorted[(total)/2] + sorted[(total)/2-1])/2);
    else
        return (double)sorted[(total)/2];      
}
看看討論區果然搞錯了XD
what is O(log(M+N))  XD
O(M+N)不可以嗎XDDDDDDD
完全囧, 這題之後再回來寫吧 XD

[88] Merge Sorted Array

給兩個sorted array,
要把第二個merge進第一個,
讓第一個變成兩個組起來的sorted array.
可假定第一個array有足夠空間把第二個存進去.

寫完第一版, 看執行時間並不快,
想說難道是要把第二個先全部接到第一個的尾端,
然後再把新array丟去sort, 這樣會比較快嗎?!
明明我就看到兩個for XD 我還只有一個耶 !

後來發現LeetCoce上面寫的時間只能參考,
我copy執行 0ms的下來跑, 結果跑的比我的還慢啊= =
原來一切都是幻覺 QQ
那我就貼我的版本就好了cc
不用refine了反正我沒有天份~(奔入雨中)

Merge Sorted Array
void merge(int* nums1, int m, int* nums2, int n) {
    if (n==0)
        return;
     
    int i=m-1;
    int j=n-1;
    while(i>=0 && j>=0)
    {
        if(nums1[i] < nums2[j])
            nums1[i+j+1] = nums2[j--];
        else
            nums1[i+j+1] = nums1[i--];
    }
    if (i<0)
    {
        for(int q=0;q<=j;q++)
            nums1[q]=nums2[q];
        return;      
    }
    if (j<0)  //可以直接回傳了, 這段其實可以拿掉
    {
        return;
    }
}

[278] First Bad Version

說真的我不知道我在寫什麼........
怎麼會弱成這樣呢 ?!(哭倒萬里長城)
為什麼我寫的跟別人寫的都長的不一樣XD
難道我是百年難得一見的蓋世奇才(x)世紀大笨蛋(o)嗎?!
用了超多次的isBadVersion, 但是竟然沒有超過執行時間啊哈哈哈
一定是哪裡搞錯了, 我要去複習一下binary search......(倒)

假設1到n的版本號, 原本都是正確的, 某一版改壞了,
需找出第一個被改壞的版本, 改壞之後的版本也會全部都是壞的,
提供isBadVersion這支API來檢查版本是對的還是錯的.

以下我的版本太丟臉了,  懇請大家關掉視窗不要看(遮眼睛)
我自己都不忍卒睹啊啊啊啊啊啊啊~~~~(崩潰)
是不是要改一下try&error的試誤法的習慣,
好好的想想題目到底要妳幹嘛呢 ?!傷心QQ

First Bad Version
// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

bool needReturn(int n)
{
    if(isBadVersion(n) && !isBadVersion(n-1))
        return true;
    return false;
}  

int findIndex(int start, int end)
{
    if (needReturn(end))
        return end;
    if (start==end)
        return -1;

    int diff =  end-start+1;
    int index = start+((diff%2==0)?diff/2: diff/2+1)-1;
    if (needReturn(index))
        return index;
 
    if(isBadVersion(index))
        return findIndex(start, index);
    else
        return findIndex(index,end);
}

int firstBadVersion(int n) {
    if (n<1)
        return -1;
    else if (n==1 && isBadVersion(n))
        return n;
    return findIndex(1,n);
}

改良版....................
我的腦子一定是壞了............
// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

int firstBadVersion(int n) {
    int start= 1;
    int end = n;
    int mid;
    while (start < end)
    {
        mid = start + (end-start) /2;
        if (isBadVersion(mid))
            end = mid;
        else
            start = mid+1;
    }
//    if (isBadVersion(start))
        return start;
//    return -1;
}
最後面直接retuen start也是可以的......(為什麼呢XD 難道不用再檢查一下嗎XD)

[2] Add Two Numbers

繼續覺得自己廢= =+
Add Two Numbers
有兩個數字
每個數字用倒過來的linked list表示,
比方說 23二十三就是 先3 -> 2
然後要把這兩個數字相加,
加完再存成一個倒過來的linked list
要注意的是10的進位部份
和兩個list長度不同的時候~~~
舉例來說,
12+ 23 = 35,
輸入是 2->1 跟 3-> 2
輸出是 5->3
輸入是5,5的話, 輸出是 0->1
(我真的需要寫這麼細嗎XD~)

小廢廢我的版本:
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* createNode(int val)
{
    struct ListNode *node = malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

void appendQList(struct ListNode **head, struct ListNode *node)
{
    if (*head == NULL)
    {
        (*head) = node;
        return;
    }
    struct ListNode *tmp = (*head);
    for (tmp = *head;tmp->next!=NULL;tmp=tmp->next)
        ;
    tmp->next = node;
    return;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode *result=NULL,*p1,*p2;
    bool tenflag = 0;
    for(p1=l1,p2=l2;(p1 != NULL || p2 != NULL);)
    {
        int v1 = (p1== NULL)? 0:p1->val;
        int v2 = (p2== NULL)? 0:p2->val;    
        int sum = v1+v2 + tenflag;
        tenflag = (sum < 10) ? 0:1;
        sum = (tenflag)? sum - 10: sum;
        appendQList(&result,createNode(sum));

        if(p1!=NULL)
            p1=(p1->next ==NULL)? NULL:(p1->next);
        if(p2!=NULL)
            p2=(p2->next ==NULL)? NULL:(p2->next);
     
    }
 
    if (tenflag)
    {
        appendQList(&result,createNode(tenflag));
        tenflag = 0;
    }

    return result;
}

寫完看了一下別人的, 覺得進位的地方似乎有更好的寫法
但是懶得想了 XD 先這樣吧QQ 我要前進下一題屋屋.
一開始在appendList的地方卡好久
完全就是call by address和call by value沒學好QQ
順便附上兩年前複習的時候的內心吶喊吧哈哈哈哈哈
====================================================
1.剛剛才發現,原來call by addresscall by reference 是不一樣的。
2.我一直以為只有call by value call by reference兩種 囧
3.我根本不知道C沒有call by referenceC++才有。 (!)
4.拿出C語言課本想證明我的記憶沒有錯,發現相關章節的標題旁邊,我本人的字跡寫著:「C沒有call by reference」(WTF XD)

5.有一種根本沒寫過C++fu,我吃屎好了我面試個屁 T—T(大哭奔入雨中)


2018年1月27日 星期六

[21] Merge Two Sorted Lists

真是世界廢Orz
初版長這樣
晚點再想怎麼修... Orz

Merge Two Sorted Lists
題意就是字面上的意思XD
請不要問我為什麼那個head好像有點多餘
我也說不上來啊啊啊啊啊啊~~~~
我還是喝西北風吧(奔入雨中)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* p1 = l1;
    struct ListNode* p2 = l2;
    struct ListNode* new, *head;
    if (p1 == NULL)
        return p2;
    if (p2 == NULL)
        return p1;
 
    if (p1->val < p2->val)
    {
        head = p1;
        p1 = p1->next;
    }
    else
    {
        head = p2;
        p2 = p2->next;
    }
    new = head;
    for(;;)
    {
        if (p1 == NULL)
        {
            new->next= p2;
            break;
        }
        if (p2 == NULL)
        {
            new->next= p1;
            break;
        }      

     
        if (p1->val < p2->val)
        {
            new->next = p1;
            p1 = p1->next;
            new = new->next;
        }
        else
        {
            new->next = p2;
            p2 = p2->next;
            new = new->next;
        }      
    }  
 
    return head;
}

update:
看到別人說可以用recursive寫法
但是比較慢啊XD
降子有比較好嗎@__@?!
update 2:
後來發現我多做了幾步贅步XD
其實根本沒想懂吧哈哈哈哈哈哈哈(奔入雨中)
但是有跑過recursive快也有慢的時候,
是個快慢很看系統的寫法?! (sensitive~~~~~)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* head, *tmp;
    if (l1 == NULL)
        return l2;
    if (l2 == NULL)
        return l1;
#if 0        //別人的簡潔版
    if (l1->val < l2->val)
    {
        l1->next = mergeTwoLists(l1->next,l2);
        return l1;
    }
    else
    {
        l2->next = mergeTwoLists(l1,l2->next);
        return l2;
    }
#else    //我的贅步版XD
    if (l1->val < l2->val)
    {
        head = l1;
        tmp = mergeTwoLists(l1->next,l2);
    }
    else
    {
        head = l2;
        tmp = mergeTwoLists(l1,l2->next);      
    }
    head->next = tmp;
    return head;
#endif  
}

20230829 再次更新
沒想到被考這題XD 總覺得開頭的head 很贅步,想把它加進while 裡,
發現加進去以後的code 也是蠻醜的 XD 
好吧那我比較想要把它擺在開頭,有種 initialize 的感覺!!!

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
if (list1== NULL)
return list2;
if (list2==NULL)
return list1;
struct ListNode *p1,*p2, *head,*ptr;
head = NULL;
p1=list1;
p2=list2;
while (p1!=NULL && p2 != NULL)
{
if (p1->val < p2->val)
{
if (head == NULL)
{
head = p1;
ptr = p1;
}
else
{
ptr->next = p1;
ptr=ptr->next;
}
p1=p1->next;
}
else
{
if (head == NULL)
{
head = p2;
ptr = p2;
}
else
{
ptr->next =p2;
ptr=ptr->next;
}
p2=p2->next;
}
}
if (p1==NULL)
ptr->next=p2;
else
ptr->next=p1;
return head;
}

20230901 更新
最終~過了兩天再寫了一次revursive版本XD
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
if (list1 ==NULL)
return list2;
if (list2 == NULL)
return list1;

if (list1->val < list2->val)
{
list1->next = mergeTwoLists(list1->next, list2);
return list1;
}
else
{
list2->next = mergeTwoLists(list1, list2->next);
return list2;
}
}

[28] Implement strStr()

嗯~這個題目~
可以用strstr()嗎? (被打)
但還是偷偷用了strncmp XDDDDDD
後來良心不安再寫了一個沒有用strncmp的版本
但看討論好像跟什麼KMP有關 (不是KMT國民黨XD)
好懶得動腦喔可以不要管它嗎~~(滾來滾去滾來滾去)

Implement strStr()
int strStr(char* haystack, char* needle) {
    if (haystack == NULL || needle == NULL)
        return -1;

    int length = strlen(haystack);
    int lengthIn = strlen(needle);

    if(length < lengthIn)
        return -1;
    else if (length == 0 && lengthIn ==0)
        return 0;
     
    int i;
    for(i=0;i<=length - lengthIn;i++)
    {
        printf("[%d][%s]\n",i,haystack+i);
#if 1      
        int j;
        for (j=0;j<lengthIn;j++)
        {
// printf("[%d][%d][%c][%c]\n",i,j,haystack[i+j],needle[j]);
            if(haystack[i+j]!=needle[j])
                break;
        }
        if (j==lengthIn)
            return i;
#else
        if (strncmp(haystack+i,needle,lengthIn)==0)
            return i;
#endif
    }
    return -1;
}

[48] 好的開始?!Rotate Image

嗯~雖然它本來不是給我這樣用的XD
但是估且用之吧XD
今天的題目是Rotate Image
沒有要追求最佳解
所以認真魔人不要砲我XD
純粹方便記錄, The End.

Rotate Image:矩陣轉90度,不能直接alloc一個全新的塞進去(可惡XD!)

一開始的想法是這樣(哪樣 XD),沒想到index完全大錯亂 囧
最後花了一整天才寫好 = =+
雖然中間有去吃飯鬼混抱怨咖啡店的隔壁桌太吵之類的  XD

從最外圈往裡面一層一層轉進去, 每次需要搬四個item,它們會形成A要搬去B,B要搬去C, C要搬去 D, D要搬去A的迴路,最難的大概是找每個對應item的index (其實是因為我太廢了屋屋屋)
花了我一天精神時光屋, 明明用講的都很簡單, 哭

void rotate(int** matrix, int matrixRowSize, int *matrixColSizes) {
    int i,j,tmp,range;
    range = matrixRowSize;
    for(i=0; i<matrixRowSize/2; i++)
    {
        range = matrixRowSize-2*i;
        for(j=i;j<i+range-1;j++)
        {
            tmp = matrix[i][j];
            matrix[i][j] = matrix[matrixRowSize-j-1][i];
            matrix[matrixRowSize-j-1][i] = matrix[matrixRowSize - i -1][matrixRowSize-j-1];
            matrix[matrixRowSize - i -1][matrixRowSize-j-1] =matrix[j][matrixRowSize - i -1];
            matrix[j][matrixRowSize - i -1] = tmp;
        }
    }
}

中間一度崩潰有去偷看了一下別人的解法
說可以先反轉再swap, 為什麼可以想到這種兩步偷吃步的方法呢為什麼!
但是不得不說知道IDEA 之後就沒什麼難度了,
大概幾分鐘就KO掉了 QQ
(最難的就是那個IDEA啊啊啊啊啊啊~~~~~抱頭)

void swap(int *a , int *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

void rotate(int** matrix, int matrixRowSize, int *matrixColSizes)
{
    int i , j , tmp;
    for (i = 0; i<matrixRowSize/2 ; i++)
    {
        for(j=0; j<matrixRowSize; j++)
        {
            swap(&matrix[i][j], &matrix[matrixRowSize-i-1][j]);
        }
     
    }
 
    for (i = 0; i<matrixRowSize ; i++)
    {
        for(j=i;j<matrixRowSize;j++)
                swap(&matrix[i][j],&matrix[j][i]);      
    }
}

但總而言之第一天開始LeetCode, 至少有解出來 (要被各方大神笑死了屋屋屋)
用24小時解一題,我看我還是喝西北風好了哈哈哈哈哈哈.........

2018年1月16日 星期二

[?/365] what the...

寫了幾天之後覺得頓失靈感 XD
雖然硬擠好像也可以擠出一點什麼
但是有意義嗎XD
改成隨意update好啦~(或者根本就cancel不是更快嗎 hahaha)

就這樣吧
(快逃)

2018年1月11日 星期四

[11/365] 天窗

哎呀!開天窗真是一件容易達成的事呀XD
睏意來襲的時候
一扇天窗已為您敞開?! XD
上帝為你開一扇天窗,就會再開另外一扇,
天窗們相連到天邊~~~(搭肩搖)

好累
沒做什麼事卻覺得極累
連吃太飽也累XD
what should I say today ?
讓我們點播一首
Let it be ~~~~~~

2018年1月10日 星期三

[9/365] 好的開始?!

什麼?我還有一個東西叫做365嗎?XD

回家包便當的感覺真是溫馨
雖然媽媽應該覺得很困擾吧哈哈哈
猜拳輸的洗碗結果我輸了

下次還是直接推給別人洗吧噗

中午跑去找阿思玩
順便在星巴克買了外帶的荷蘭小鬆餅
感覺不錯!
但是附贈的焦糖醬為什麼在快吃光了的時候才浮現在杯底呢威什麼~~~
不甘心沒完整吃到它只好硬食焦糖醬
覺得甜XD
明天直接去內用好了(誤)(是嫌錢太多嗎一份90ㄟXD)

今天還聽說了驚人的消息
時機未到暫時不提
咱們下次見

2018年1月8日 星期一

[8/365] 千金難買早知道

這兩天的感想就是...
costco的草莓大福真好吃 XD

坐在客廳
用airplay投了音樂播放
許多裝置不是我弄的
大概也是原本的我不會買的
但是
這一兩個月來真的覺得很傷心很低潮的時候
蓋著毛毯窩在沙發上聽歌
我擁有的仍然很多很多
不是嗎

就算是很小 很小的事情
我都記著
因為我不想要忘記
那每一個 曾經有替我著想的心意

然後呢(跳一下)
我不算計人
不代表別人不會算計我啊
說好的世界大同呢!
為誰辛苦為誰忙啊
我當真傻!!!
不管講幾遍
都沒有辦法原諒我自己讓這樣的事情發生在我身上
真!的!傻!!!
好氣我自己真的好氣!!!(跺腳踏地)

2018年1月7日 星期日

[7/365] 我們要飛到那遙遠地方看一看

立刻開天窗的365 XD 覺得鳥 XD
一時昏迷然後就天亮了,就算了XD
許多感想,但過了好像就忘了~噗
並不想要變成閃光文系列
但確實蠻多心得都是感情方面的
雖然年紀大了已經不能說是閃光文
是一種老人文吧XD
有"啊原來是這樣啊"的感覺
說不上來,很難形容

所謂的照顧是什麼
陪伴是什麼
微妙啊~(微妙的是妳的不知所云吧XD!)

出發的時候雖然因為工作的事情心情很差
但仍然有"我要去度假了!!!"的期待感
在淡淡的氛圍下很想點播張懸的張三的歌

我要帶著因為工作受傷的我自己,到遠方看一看
然後
感謝一直陪在我身旁(打電動)的人(XD)

即使只是去到了火車一兩個小時內就能抵達的地方
即使整整兩天都是在下雨
即使什麼景點都沒有去
即使只是看第四台電影,打寶可夢佔道館耍廢
即使各做各的
還是很好

有一種好就是希望對方好,希望自己也好,希望一起好
其實真的是在一個很不錯的狀態
就是除了工作以外XD 哭哭 XD

2018年1月6日 星期六

[5/365] 晚安

今天出門玩兒,晚安 :)

2018年1月4日 星期四

[4/365] 「慌!!!」(OOO語氣)

才第四天
感覺已經要鳥掉XD
並不是沒有內心OS
而是又開始擔心起寫這個會不會不好
那個可以寫嗎
會不會被意料之外的人看見? (誰?! XD)
總有很多顧慮
那還要不要寫呢XD
疑手疑腳的感覺實在傷當不痛快啊!!!

想要紀錄下每一件小事
讓自己可以記得
生活中並不是沒有好事發生
只是有時候負能量實在太過強大了哈

碳之家碳烤三明治久仰大名
濃濃的花生醬,嫩而不柴、調味適中的豬肉片,
真的有烤熱的土司,(沒烤熱還碳烤什麼呢?我絕對沒有在說園區的某家XP)
切成兩半的一人一半(感情不會散XD!),
在等雪腐的煲的時候就在路邊嗑光了,
滿分給推!
只是為什麼回家查食記,以前的土司好像是三片呀是不是我的幻覺XD

至於雪腐,加點的高麗菜感覺很少QQ
個人感覺而已XD
難得有人看到有加珍珠的冰想點
什麼時候再拐去吃冰呢哈哈哈

雖然看起來這裡不去那裡嫌遠的
但有時候還是假裝很不經意的移動了
換個方向擺的毛拖鞋,著實是一種惡趣味。
「電燈測試!」
然後就忘記了早一點的時後,
總覺得有人心情不好實在是很無趣的事情。
That's so called life.

2018年1月3日 星期三

[3/365] 一點Pam

早上看到她和朋友們跨年的大合照
"男友也去嗎?" 我問
"有啊我沒給妳看過照片嗎?" 同時傳來一張,兩個人都笑的很燦爛的合照
很有夫妻臉
"應該很多人說過了吧?" 我說
"超多!"

晚上去健身房的時候,突然想起曾寫給她的一段短文
我說我記得低潮時和她相約午餐,漫漫走過的那一條街
我說我的徬徨
她總給我建議
離職的那一天
朝她遞出了還沒用完也沒打算帶走的舒潔
怕眼淚潰堤於是趕快逃跑了
接到她的電話的夜晚,傳來"祝妳生日快樂~祝妳生日快樂~
祝妳生日快樂~兒~祝妳生日快樂~~~"的歌聲

"我們公司有缺,妳要不要來?" 二話不說就這麼問著,
"妳值得更好的對待。"
"這是我朋友,她要去環遊世界了!"
時間拉回到那一天,又到了現在,很快閃過的許多片段,
突然覺得眼睛有點熱,有點什麼直衝胸口,
心裡感覺酸酸的,
真希望我可以爭氣一點
希望下次見到妳,我有更多的好事可以分享
希望至少是笑中帶淚,不再是苦中作樂了
我加油.

2018年1月2日 星期二

[2/365] 妳怎麼可以不生氣?

2018第一個上班日, 很痛苦.
就算放了三天的假,
腦海中盤旋不去的仍然是為什麼, 為什麼這樣對我, 我做錯了什麼, 都是我的錯嗎?
啞巴吃黃蓮.
怎麼想都覺得很衰.

提不起勁
到底該怎麼辦QQ

回家的時候,
發現開水燒好了,垃圾都丟了,溫馨。

還不知道的是昨天半夜起來喝水的時候,
有一隻小強突然出現在杯子裡。
我也不知道是熱水壺沖下來的,還是本來就在杯子裡的,
於是倒去了流理台,擠了兩坨洗碗精,
然後就像什麼事都發生過的滾回去睡覺,
只除了嚇得半死的心有餘悸。

也就是說濾網裡其實還倒著一隻小強。
強!



2018年1月1日 星期一

[1/365] 2017 881

部落格感覺年久失修XD
什麼版面跑掉啦
圖片超大張啦
弄不出來(或者看不順眼又弄掉)的各種網誌小工具
都讓它們跟2017隨風而去吧

決定開始個365
希望多噴點內心OS可以治療內心的小女孩兒
她最近實在太受傷了
需要有個地方盡情的靠夭 XD

首先就是要跟2017年好好的(?)道別
2017年的第一天我非常的悲傷
2017年的最後一天我非常的憤怒XD
究竟是一個什麼樣的年呢 XD

很多不願意回想起的東西
還是散散去好了XD
寫到這裡
不禁覺得我都寫了些什麼呢 XDDDDD
不管啦我要365
365好像很厲害我也要365
希望我可以好好的完成它
好, 第一篇就降!See u tomorrow (揮手)