2011年4月14日

如何打造最小化的能运行 UCloner 的镜像文件？

目标：打造最小化的能运行 UCloner 的镜像文件

UCloner 不多解释了，相当于 Windows 下的 Ghost

1. 从 http://code.google.com/p/ucloner/ 下载 UCloner，放在C盘上

2. 最小化安装 Ubuntu 10.10 Alternative，过程略

3. 启动后，在命令行界面下载安装 UCloner 依赖的包
  sudo apt-get install squashfs-tools casper python-gtk2 python-vte python-glade2 xinit

4. 配置成启动后自动加载图形界面
  echo "startx -maximized" >> ~/.profile

5. 重新启动到图形界面

5. mount C盘
  sudo mount /dev/sda1 /media/cdrom

把 UCloner 拷贝到主目录中，解压，运行，制作镜像文件保存到 /media/cdrom，制作成功的镜像文件只有250M左右。

 

posted @ 2011-04-14 10:42 庄冠华 阅读(71) 评论(0) 编辑

2010年10月27日

One example of STL map

代码
#include <map>
#include <iostream>
#include <string.h> //for memcmp
using namespace std;

typedef struct{
    int connId;
    int ueRef;
    int rncId;
}UEREF_RNCID;

struct classcomp {
    bool operator() (const UEREF_RNCID & l, const UEREF_RNCID & r) const
    {
        return memcmp(&l, &r, sizeof(UEREF_RNCID)) < 0;
    }
};

UEREF_RNCID assignKey(int connId, int ueRef, int rncId)
{
    UEREF_RNCID tempKey;
    tempKey.connId = connId;
    tempKey.ueRef = ueRef;
    tempKey.rncId = rncId;
    return tempKey;
}

int main(int argc, char **argv)
{
    map<UEREF_RNCID, int, classcomp> m;
    map<UEREF_RNCID, int, classcomp>::iterator it;
    UEREF_RNCID key1, key2;
    key1 = assignKey(-1,1,1);
    key2 = assignKey(-1,2,1);
    m[key1] = 0; //index is 0
    m[key2] = 1; //index is 1
    it = m.find(key1);
    cout << it->second << endl; //will print 1
    return 0;
}

 

posted @ 2010-10-27 12:33 庄冠华 阅读(6) 评论(0) 编辑

2010年7月12日

strcpy

 

char *strcpy(char *dest, char *src) {
    char *s = src, *d = dest;
    do {
    } while (*(d++) = *s++);

    return dest;
}

 

 

posted @ 2010-07-12 16:25 庄冠华 阅读(2) 评论(0) 编辑

glibc 中的 strlen 高效实现

 

代码
#include <string.h>
#include <stdlib.h>

#undef strlen

/* Return the length of the null-terminated string STR.  Scan for
   the null terminator quickly by testing four bytes at a time.  */
size_t strlen(const char *str) {
    const char *char_ptr;
    const unsigned long int *longword_ptr;
    unsigned long int longword, himagic, lomagic;

    /* Handle the first few characters by reading one character at a time.
       Do this until CHAR_PTR is aligned on a longword boundary.  */
    for (char_ptr = str; ((unsigned long int) char_ptr
            & (sizeof (longword) - 1)) != 0;
            ++char_ptr)
        if (*char_ptr == '\0')
            return char_ptr - str;

    /* All these elucidatory comments refer to 4-byte longwords,
       but the theory applies equally well to 8-byte longwords.  */

    longword_ptr = (unsigned long int *) char_ptr;

    /* Bits 31, 24, 16, and 8 of this number are zero.  Call these bits
       the "holes."  Note that there is a hole just to the left of
       each byte, with an extra at the end:

       bits:  01111110 11111110 11111110 11111111
       bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD

       The 1-bits make sure that carries propagate to the next 0-bit.
       The 0-bits provide holes for carries to fall into.  */
    himagic = 0x80808080L;
    lomagic = 0x01010101L;
    if (sizeof (longword) > 4) {
        /* 64-bit version of the magic.  */
        /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
        himagic = ((himagic << 16) << 16) | himagic;
        lomagic = ((lomagic << 16) << 16) | lomagic;
    }
    if (sizeof (longword) > 8)
        abort();

    /* Instead of the traditional loop which tests each character,
       we will test a longword at a time.  The tricky part is testing
       if *any of the four* bytes in the longword in question are zero.  */
    for (;;) {
        longword = *longword_ptr++;

        if (((longword - lomagic) & ~longword & himagic) != 0) {
            /* Which of the bytes was the zero?  If none of them were, it was
               a misfire; continue the search.  */

            const char *cp = (const char *) (longword_ptr - 1);

            if (cp[0] == 0)
                return cp - str;
            if (cp[1] == 0)
                return cp - str + 1;
            if (cp[2] == 0)
                return cp - str + 2;
            if (cp[3] == 0)
                return cp - str + 3;
            if (sizeof (longword) > 4) {
                if (cp[4] == 0)
                    return cp - str + 4;
                if (cp[5] == 0)
                    return cp - str + 5;
                if (cp[6] == 0)
                    return cp - str + 6;
                if (cp[7] == 0)
                    return cp - str + 7;
            }
        }
    }
}
/* 说明
(1) 一次判断一个字符直到内存对齐，如果在内存对齐之前就遇到'\0'则直接return，否则到(2)；
(2) 一次读入并判断一个DWORD，如果此DWORD中没有为0的字节，则继续下一个DWORD，否则到(3)；
(3) 到这里则说明DWORD中至少有一个字节为0，剩下的就是找出第一个为0的字节的位置然后return。
*/
 


 

 

posted @ 2010-07-12 15:34 庄冠华 阅读(31) 评论(0) 编辑

面试遇到的题目：strstr 子串查找

 

代码
char *strstr(char *buf, char *sub) 

{
    char *bp, *sp;
    if (!*sub)
        return buf;
    while (*buf) {
        bp = buf;
        sp = sub;
        do {
            if (!*sp)
                return buf;
        } while (*bp++ == *sp++);
        buf += 1;
    }
    return 0;
}
更加高效的算法还有KMP算法

KMP是字符串匹配的高效算法。

它的基本思路是，对于模式串建立一个“失败转移表”(fail transform table)。设模式串为B，原串为A，也就是说，当A[i]!=B[j]的时候，A[i]可能与B[P[j]]匹配。P可以在事先对B进行一次“自匹配”以计算出来。

 

 

 

 

posted @ 2010-07-12 15:28 庄冠华 阅读(76) 评论(0) 编辑

2010年7月1日

魔方层先法简明图解，最少记6个公式即可完成魔方六面

关于魔方层先法这里不多介绍了，自己google，百度一下。

此处图解简明扼要，只需要记最少6个公式即可完成魔方六面。

posted @ 2010-07-01 15:13 庄冠华 阅读(1300) 评论(0) 编辑

批处理：自动进入当前批处理文件所在的目录

 

@echo off
pushd  "%~d0%~p0"

:: do something

popd

 

 

posted @ 2010-07-01 14:42 庄冠华 阅读(62) 评论(0) 编辑

n! 的二进制表示中最低位1的位置

  1. //n! 的二进制表示中最低位1的位置   
  2. int posFact(int n)   
  3. {   
  4.     int ret = 0;   
  5.     while (n)   
  6.     {   
  7.         n >>= 1; //本质上与n!的末尾有多少个0的问题一致，此处等同于 n/=2;   
  8.         ret += n;   
  9.     }   
  10.     return ret;   
  11. }  

posted @ 2010-07-01 14:41 庄冠华 阅读(37) 评论(0) 编辑

cont char *p 和 char* const p 区别及记忆方法

  1. /*  
  2.  
  3. cont char *p 和 char* const p 区别及记忆方法  
  4.  
  5. const char *p = "hello"; 和 char const *p = "hello"; 等价  
  6. 保护的是内容（即这段buffer只读， 记忆：const 在*p前， *p是取内容，保护内容）  
  7.    
  8. char* const p = new (char[20]);  
  9. 保护的是指针 （记忆：const 在p前， p是个指针，保护指针）  
  10. */  

posted @ 2010-07-01 14:41 庄冠华 阅读(28) 评论(0) 编辑

微软面试题：某水王的发帖数超过总贴数的一半，找出之

 



//某水王的发帖数超过总贴数的一半，找出之   
int find(int *ID, int N)   
{   
    int candidate;   
    int nTimes, i;   
    for (i = nTimes = 0; i < N; i++)   
    {   
        if (nTimes == 0)   
        {   
            candidate = ID[i];   
            nTimes = 1;   
        }   
        else if (candidate == ID[i])   
        {   
            nTimes++;   
        }   
        else  
        {   
            nTimes--;   
        }   
    }   
    return candidate;   
}  



 

 

posted @ 2010-07-01 14:40 庄冠华 阅读(28) 评论(0) 编辑

仅列出标题  下一页

导航

<2012年2月>
日一二三四五六
2930311234
567891011
12131415161718
19202122232425
26272829123
45678910

公告

昵称：庄冠华
园龄：2年11个月
粉丝：1
关注：0

搜索

 
 

常用链接

我的标签

随笔档案

所有链接

最新评论

阅读排行榜

评论排行榜

推荐排行榜