[FGISC。Nanro] 未來開端

/*此篇適合給有一點水平的孩子，不適合純新手*/
ACM呢，是一個非常適合人們鍛鍊程式技巧的地方
從簡單到難的題目這裡都有
簡單的可以很簡單 程式碼不用寫十行
難的就可以很難 難到你想數個月都想不出來
寫程式的訓練，除了程式技巧
最重要的就是思考
初階的題目思考和程式技巧的比例大致相等
到後來思考會加重
思考加重的時候，穩定的程式技巧就很重要
所以兩者是相輔相成
你多寫，就會多進步
我在升高二暑假沒有朝深入演算法發展
但是做到了解決了被 一個叫做Lucky貓的ACM園地的網站https://luckycat.kshs.kh.edu.tw/
歸類成一星的中譯題目全部OVER掉
這一年來也是斷斷續續練一些沒有太複雜技巧的題目
這個暑假開始學難的東西
上手和撰寫便很快地可以接軌
一個星期多來已經寫了過去一年的分量XD
好 廢話不多說
入手的話
首先就來推薦簡單的題目

Lucky貓網站就請大家自行研究
在這裡就開列推薦的入手題清單
先開列Lucky貓一星題清單
----------------------------------------
題目編號    題目名稱
100　    The 3n+1 problem　
　　最多人拿來當示範的題目 需要一定的基礎
　　可以用這題來重新審視自己對寫程式概念的清楚與否
272　    TeX Quotes
　　可訓練字串讀入讀出技巧　這裡的技巧是逐字讀入後處理 馬上讀出
458　    The Decoder
　　需要對於ASCII碼的了解　需要看ASCII碼可以去https://www.asciitable.com/
476　    Points in Figures: Rectangles
　　數學題目 請善用座標判斷
477　    Points in Figures: Rectangles and Circles
　　接續上題 並且增加圓的部份 請善用距離公式
//478也是接續 但是更困難　可以想想怎麼做XD
488　    Triangle Wave
　　有很多種作法的題目 可以直觀輸出就好 以後有機會多練一點會發現這題可以用的方法 會影響程式執行效率很多XD
　　有許多PE問題 要注意
494　    Kindergarten Counting Game
　　善用ASCII判斷 注意不一定是用空白分隔
579　    Clock Hands
　　//我當年的第一題>/////<
　　角度計算 屬於數學 有>180的情況要處理
591　    Box of Bricks
　　嗯 也是數學 不難想的題目 觀察兩圖形 自己想一下XD
913　    Joana and the Odd Numbers
　　請愛用等差級數公式Sn=2a1+(n-1)*d
10018　    Reverse and Add
　　作法可用字串處理 亦可用數字處理
　　看個人啦 這題用陣列是比較好的
10035　    Primary Arithmetic
　　數學 應該不難 自己模擬一下做加法的過程
　　我手寫我口～
10038　    Jolly Jumpers
　　要處理的題目 請善用abs()~
10055　    Hashmat the brave warrior
　　這個題目相當單純。
　　陷阱就在於　他的數很大
　　請使用long long變數型態 格式為%lld
　　另外如果要在DEVC作測試 請用%I64d
　　傳出去時要改回來！
10062　    Tell me the frequencies!
　　一樣是ASCII 請開陣列處理
10071　    Back to High School Physics
　　物理公式 自己導一下 最後的答案會簡單的很可愛ˇ
10082　    WERTYU
　　可用switch() 直接暴力吧！
10107　    What is the Median?
　　//本題使用插入排序法為最佳 如果不瞭解者請跳過 或另想解決方式
10141　    Request for Proposal
　　字元字串處理 有些麻煩的 善用函式
10209　    Is This Integration ?
　　數學題 有學過三角應該知道
　　另外pi=2.0*acos(0.0)
　　可以用define操作　(#define pi 2.0*acos(0.0))
10222　    Decode the Mad man
　　同10082 暴力吧！
10300　    Ecological Premium
　　數學　就照著文字敘述去計算 要有點耐心看完
10340　    All in All
　　一樣是字串處理 可採用字元比對 計算長度
{
      今天經過學妹的測試  發現了一些要注意的地方
  　第一點strlen()是跑很慢的函式
　 如果要使用在迴圈 請用變數儲存後再使用 以免TLE
  　另外break;指令跳出迴圈時
  　i++,j++這一類寫在for最後面的指令並不會被執行
 　要記得這樣XD
}
10370　    Above Average
　　數學again 簡單的算平均 應該沒問題
10473　    Simple Base Conversion
　　進位轉換　不懂的網路google一下
10499　    The Land of Justice
　　1是例外，其他直接推規律吧=w=/　不過%要用printf("%%")才輸的出去
10550　    Combination Lock
　　我手寫我口 就照著做吧 注意一些角度上的問題就是了
10589　    Area
　　和10209很像的圖XD
　　不過要輸出的面積是用估計的 請自行閱讀題目～
10673　    Play with Floor and Ceil
　　floor()和ceil()是include在math.h的兩個函數
　　前者是傳回小於引數的最大整數 後者是傳回大於引數的最小整數     (20090202註記：之前寫錯了!!!)
　　剩下的請自行處理～
10696　    f91
　　會寫遞迴吧？就寫成函式 秒殺～
10783　    Odd Sum
　　暴力法，謝謝。
10789　    Prime Frequency
　　字元處理 請用ASCII 並且判斷質數 應該不難
10812　    Beat the Spread!
　　很簡單的數學題 要注意他的判斷和輸出
10878　    Decode the tape
　　有點難度的字串處理XD
　　上面標示的空白是0 圈圈是1
　　二進位數字的處理～
-----
BY 雄中 Eric學長當年跟我講的
對每一行來說, 只需要寫成這樣
　　d=0;
　　for(i=1;i<10;i++){
　　　　if(i==6)　　　　//中間隔著的 '.'
　　　　　　continue;
　　　　d<<=1;　　　　　//把 d 左移一格
　　　　if(s[i]=='o')　 //如果這一格是圈圈
　　　　　　d|=1;　　　 //把 d 的最右邊一格寫成 1
　　}
　　printf("%c",d);
-----
<<=是二進位處理
就是像i=3(00000011)
用i<<=2後
i就會變成12(=00001100)
|=則是位元OR指定運算子
d|=1就是將d和右邊的值做or運算
然後將那個值放回d
-----
10903　    Rock-Paper-Scissors
　　國中機率問題～沒什麼好說的
10924　    Prime Words
　　ASCII+質數問題 如果有用到i<=sqrt()記得#include<math.h>
10929　    You can say 11
　　簡單的數學問題～不過注意它會耍詐用0011之類的
　　請到迴圈中判斷字串的第一個字和第二個字如果為...(自己想吧XD)
　　就跳出
10963　    The Swallowing Ground
　　請不要想太多 比對距離 如果皆相同 就對 不同 就不行
　　別想太多 真的
11059　    Maximum Product
　　我用了long long 就乾脆地迴圈暴力乘吧！
11172　    Relational Operators
　　簡單的關係式 請愛用if
11185　    Ternary
　　一樣是換進位問題 應該很容易 請自尋google方法
----------------------------------------------------
其實這些就很夠寫了XD
下一次再往外擴張　來貼一些其他地方容易上手的題目
或是稍有難度的題目
好啦　各位加油XD

/*  ACM Q10679 - I Love Strings!! */
/*  559    8100892    2.396    ANSI C    2010-07-15 14:46:26  */
/*  KMP  */ 

#include <stdio.h>

#include <string.h>

#define PSIZE 1005

#define TSIZE 100005

void preproc( char *str, int len, int *z )
{
    /*
        z[i] = t <==> 代表從第i個字元再加上往前 t 個字元和
                      pattern本身的前 t + 1 個字元相等 
        z[i] = -1 <==> 往前沒有符合上面的case，本身也和字串首不同，設為-1 
    */ 
    int i;
    int k = z[0] = -1; /*  初始化，k: 當前字元往前已和前綴success比對的字元數，初始設-1  */    
    for ( i = 1 ; i < len ; i++ )
    {
        /*  從第二個字元(i=1)開始預處理，因將字串首和自己做比對是沒意義的。  */    
        while ( k >= 0 && str[k + 1] != str[i] )  /*  如果前綴的下個字元和當前字元不同  */
            k = z[k];    /*  把k降回當前位置往前success比對的長度，嘗試去往下比，如果不行就繼續砍  */ 
                        /*  會跳兩次的例子：ababac  */ 
        /*  可以往下比了  */ 
        if ( str[k + 1] == str[i] )
            k++;    /*  success比對長度+1  */
        z[i] = k;  /* 記錄當前位置往前最長比對長度 */
    }
}
int KMP( char *T, char *P)
{
    int i, k;
    int z[PSIZE];
    int tlen = strlen(T);
    int plen = strlen(P);
    preproc( P, plen, z );
    k = -1;
    for ( i = 0 ; i < tlen ; i++ )
    {
        while ( k >= 0 && P[k + 1] != T[i] )
            k = z[k];
        if ( P[k + 1] == T[i] )
            k++;
        if ( k + 1 == plen )
        {
            /* 如果還要往下繼續比，就降回當前位置往前最大成功比較字元
               k = z[k] 
             */
            return 1;
        }
    }    
    return 0;
}
int main()
{
    char T[TSIZE], P[PSIZE];
    int N, m;
    scanf("%d", &N);
    while( N-- )
    {
        scanf("%s", T);
        scanf("%d", &m);
        while ( m-- )
        {
            scanf("%s", P);
            if ( KMP(T, P) )
                puts("y");
            else
                puts("n");    
        }
    }
    return 0;
}

C++ Class版大數
可處理 + - * with負數


/*  Date: 2009.06.14  */
/*  BigInt + - * with Negative version */ 
#include <iostream>

#include <cstring>

#include <algorithm>

using namespace std;
class BigInt
{
    public:
        static const int size = 100;
        bool sign;
        BigInt();
        BigInt(const char *n);
        BigInt invert() const;
        friend ostream& operator << (ostream& os, BigInt t);
        friend bool operator > (const BigInt& tl, const BigInt& tr);    
        friend bool operator < (const BigInt& tl, const BigInt& tr);    
        friend BigInt operator + (const BigInt& tl, const BigInt& tr);
        friend BigInt operator += (BigInt& tl, const BigInt& tr);
        friend BigInt operator - (const BigInt& tl, const BigInt& tr);
        friend BigInt operator * (const BigInt& tl, const BigInt& tr);        
        
    private:
        void initialize();    
        int num[size];
        int len;
};
void BigInt::initialize()
{
    sign = true;
    len = 1;
    memset(num, 0, sizeof(num));    // fill num with 0

}
BigInt::BigInt()
{
    initialize();
}
BigInt::BigInt(const char *n)
{
    initialize();
    int check = 0;
    if(n[0] == '-')    // check if it is negative

    {
        sign = false;
        check++;
    }
    else if(n[0] == '+') // eliminate + symbol

        check++;
    len = strlen(n);
    for(int i=check; i<len ;i++)
    {
        if(n[i] == '0')
            check++;
        else
            break;
    }
    for(int i=len-1, j=0; i>=check; i--, j++)
    {
        num[j] = n[i] - '0';    // turn it to int

    }
    len -= check;
    if(len == 0)    // if empty

    {
        num[0] = 0;
        len = 1;    
    }
}
BigInt BigInt::invert() const    // return its invert sign num    

{
    BigInt tmp(*this);
    tmp.sign = !tmp.sign;
    return tmp;    
}
ostream& operator << (ostream& os, BigInt t)
{
    char tmp[BigInt::size];
    int len = 0;
    if(t.sign == false)
    {
        tmp[0] = '-';
        len++;
    }
    for(int i=t.len-1; i>=0; i--)
    {
        tmp[len] = t.num[i] + '0';    
        len++;
    }
    tmp[len] = '\0';
    os << tmp;
    return os;
}
bool operator > (const BigInt& tl, const BigInt& tr)
{
    if(tl.sign == true && tr.sign == true)
    {
        if(tl.len > tr.len) return true;
        else if(tl.len < tr.len) return false;
        else
        {
            for(int i=tl.len-1; i>=0; i--)
            {
                if(tl.num[i] > tr.num[i]) return true;
                else if(tl.num[i] < tr.num[i]) return false;
                else continue;    
            }
            return false;
        }    
    }
    else if(tl.sign == true && tr.sign == false)
        return true;
    else if(tl.sign == false && tr.sign == true)
        return false;
    else if(tl.sign == false && tr.sign == false)
    {
        return tr.invert() > tl.invert();    
    }
}
bool operator < (const BigInt& tl, const BigInt& tr)
{
    return (tr > tl);    
}
BigInt operator + (const BigInt& tl, const BigInt& tr)
{
    BigInt ans;
    if(tl.sign == false && tr.sign == true)
    {
        return tr - tl.invert();    
    }
    else if(tl.sign == true && tr.sign == false)
    {
        return tl - tr.invert();    
    }
    else if(tl.sign == false && tr.sign == false)
    {
        ans.sign = false;
    }
    ans.len = (tl.len > tr.len) ? tl.len : tr.len;
    for(int i=0; i<ans.len; i++)
    {
        ans.num[i] += tl.num[i] + tr.num[i];    
        if(ans.num[i] >= 10)            // check carry

        {
            ans.num[i + 1] += (ans.num[i] / 10);
            ans.num[i] %= 10;    
        }
    }
    if(ans.num[ans.len] != 0 )
    {
        ans.len++;    
    }
    return ans;
}
BigInt operator += (BigInt& tl, const BigInt& tr)
{
    tl = tl + tr;
    return tl;
}
BigInt operator - (const BigInt& tl, const BigInt& tr)
{
    BigInt ans;
    if(tl.sign == true && tr.sign == false)
    {
        return tl + tr.invert();    
    }    
    else if(tl.sign == false && tr.sign == true)
    {
        return tl + tr.invert();    
    }
    else if(tl.sign == false && tl.sign == false)
    {
        return tr.invert() - tl.invert();
    }
    else
    {
        if(tl < tr)
        {
            ans = tr - tl;
            ans.sign = false;
            return ans;
        }    
        else
        {
            ans.len = tl.len;    
            for(int i=0; i<ans.len; i++)
            {
                if( (ans.num[i] + tl.num[i]) >= tr.num[i] )
                {
                    ans.num[i] += (tl.num[i] - tr.num[i]);
                }    
                else
                {
                    ans.num[i + 1] -= 1;
                    ans.num[i] += 10 + (tl.num[i] - tr.num[i]);
                }
            }
            for(int i=tl.len-1; i>=0; i--, ans.len--)
            {
                if(ans.num[i] != 0)    
                    break;
            }
            if(ans.len == 0)
            {
                ans.len = 1;
                ans.num[0] = 0;
            }
            return ans;
        }
    }
}
BigInt operator * (const BigInt& tl, const BigInt& tr)
{
    BigInt ans;
    ans.sign = !(tl.sign ^ tr.sign);
    ans.len = tl.len + tr.len;
    for(int i=0; i<tl.len; i++)
    {
        for(int j=0; j<tr.len; j++)
        {
            ans.num[i + j] += (tl.num[i] * tr.num[j]);
        }    
    }
    for(int i=0; i<ans.len; i++)
    {
        if(ans.num[i] >= 10)    // check carry

        {
            ans.num[i + 1] += (ans.num[i] / 10);
            ans.num[i] %= 10;    
        }    
    }
    if(ans.num[ans.len - 1] == 0)
    {
        ans.len--;    
    }
    return ans;
}
int main()
{
    char str1[100], str2[100];
    while( cin >> str1 >> str2 )
    {
        BigInt a(str1);
        BigInt b(str2);
        cout << "+ :" << a + b << endl;
        cout << "- :" << a - b << endl;
        cout << "* :" << a * b << endl;
        cout << "< :" << (a < b) << endl;
        cout << "> :" << (a > b) << endl;
        cout << "+=:" << (a += b) << endl;
        cout << a << ", " << b << endl;
    }
    return 0;
}

‧成員函數的定義：
   1. 定義在Class中
   2. 定義在外部，但是函數名稱前要加上"類別名稱::"
   小易說後面的比較好，不然萬一有互相呼叫的就會打架了
‧呼叫同一個物件的成員函數只需要函數名稱
   呼叫不同物件的成員函數則需要"物件名稱."

‧如果要取回main()的return值：

轉自  https://www.wretch.cc/blog/Geniusking/7263728
※ 使用方式
gcc [option] filename
※ 選項
-c : 只做編譯(不做連結)
-S : 輸出組譯碼
-E : 將預處理結果顯示
-o filename : 指定輸出檔名
-ansi : 程式要求依據ansi c標準
-Dmacro : 使定義巨集(marco)為有效
-Dmarco=defn : 使定義巨集(marco)為defn
-Wa,option : 將選項(option)傳給組譯器
-wl,option : 將選項(option)傳給連結器
-I : 追加include檔案的搜尋路徑
-L : 追加library檔案的搜尋路徑
-l : 指定連結的函式庫
-Wall : 顯示所有的警告訊息
-g : 編入除錯資訊(要使用GDB除錯一定要加)
-O2 : 做最佳化
※ 使用範例
Example:
gcc -o file a.c b.c c.c
gcc -Wall -g -o test test.c
gcc -Iinclude -Llibrary -lmy_lib -o test1 test1.c
gcc -DDEBUG_ON -o test2 test2.c
gcc -c -o test3 test.c

當初學做網頁的時候，還是Web1.0的時代。
那個時候沒有學得很好，能力也沒有隨著時代進步，而高中時Web2.0卻已經震盪網路世界

所以當初所學的傳統做網頁能力漸漸落伍，CSS是什麼整個是傻傻搞不懂

把草地的那四個按鈕成功拿掉了(笑)
不過方法不是很標準地用CSS調位置:P

我的作法是，找到CSS中，#navigation的這一段

咳，距離上次更新真的是有夠久的XD
痞客邦也有了頗大的變化呢，我剛剛研究了很久才找到辦法
讓我的部落格側邊欄位設定變成新版的XD
應該是太久沒有更新的關係:P

非反轉向右對齊版
Code 線上版 https://src.wtgstudio.com/?ZU3l4n
Code下載 https://aikosenoo.googlepages.com/bignum_add.c
反轉版本
Code 線上版 https://src.wtgstudio.com/?ujs7CF

應學妹們正要複習陣列與開始運用字串
整理的講義～
沒有寫太多太深的東西，但是基本的東西都在了
應該是很好的參考資料:)
(而且是彩色編排的版本唷:P)

適合服用：[初階]→[入門]→[進階]
感謝sa提供初始清單～

字串