Welcome to MDGSF's Blog!

This is my github blog

[GO] 简单的TCP Server实现

2016-12-26

package main

import (
    "flag"
    "fmt"
    "net"
    "syscall"
)

const maxRead = 25

func main() {
    flag.Parse()
    if flag.NArg() != 2 {
        panic("usage: host port")
    }
    hostAndPort := fmt.Sprintf("%s:%s", flag.Arg(0), flag.Arg(1))
    listener := initServer(hostAndPort)
    for {
        conn, err := listener.Accept()
        checkError(err, "Accept: ")
        go connectionHandler(conn)
    }
}

func initServer(hostAndPort string) *net.TCPListener {
    serverAddr, err := net.ResolveTCPAddr("tcp", hostAndPort)
    checkError(err, "Resolving address:port failed: '"+hostAndPort+"'")
    listener, err := net.ListenTCP("tcp", serverAddr)
    checkError(err, "ListenTCP: ")
    println("Listening to: ", listener.Addr().String())
    return listener
}

func connectionHandler(conn net.Conn) {
    connFrom := conn.RemoteAddr().String()
    println("Connection from: ", connFrom)
    sayHello(conn)
    for {
        var ibuf []byte = make([]byte, maxRead+1)
        length, err := conn.Read(ibuf[0:maxRead])
        ibuf[maxRead] = 0
        switch err {
        case nil:
            handleMsg(length, err, ibuf)
        case syscall.Errno(0xb):
            continue
        default:
            goto DISCONNECT
        }
    }
DISCONNECT:
    err := conn.Close()
    println("Closed connection: ", connFrom)
    checkError(err, "Close: ")
}

func sayHello(to net.Conn) {
    obuf := []byte{'L', 'e', 't', '\'', 's', ' ', 'G', 'o', '!', '\n'}
    wrote, err := to.Write(obuf)
    checkError(err, "Write: wrote "+string(wrote)+" bytes.")
}

func handleMsg(length int, err error, msg []byte) {
    if length > 0 {
        print("<", length, ":")
        for i := 0; ; i++ {
            if msg[i] == 0 {
                break
            }
            fmt.Printf("%c", msg[i])
        }
        print(">\n")
    }
}

func checkError(err error, info string) {
    if err != nil {
        panic("ERROR: " + info + " " + err.Error())
    }
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
    "time"
)

func main() {
    conn, err := net.Dial("tcp", "localhost:50000")
    if err != nil {
        fmt.Println("Error dialing", err.Error())
        return
    }

    inputReader := bufio.NewReader(os.Stdin)
    fmt.Println("First, what is your name?")
    clientName, _ := inputReader.ReadString('\n')
    trimmedClient := strings.Trim(clientName, "\n")

    for {
        //fmt.Println("What to send to the server? Type Q to quit.")
        //input, _ := inputReader.ReadString('\n')
        //trimmedInput := strings.Trim(input, "\n")
        //if trimmedInput == "Q" {
        // return
        //}
        //_, err = conn.Write([]byte(trimmedClient + " says: " + trimmedInput))
        _, err = conn.Write([]byte(trimmedClient + " says: " + "Hello"))

        time.Sleep(1000000000)
    }
}

Read All

[C/C++] 队列O(1)求最大元素

2016-12-26

C/C++

CMaxStack.h

#ifndef CMAX_STACK_HJ
#define CMAX_STACK_HJ

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <stack>
using namespace std;

class CMaxStack
{
public:
    CMaxStack();
    ~CMaxStack();

    void m_vPush(int i);
    void m_vPop();
    int m_iMaxElement();
    bool m_bEmpty();
    int m_iTop();

private:
    stack<int> m_oStack;
    stack<int> m_MaxValueStack;
};


#endif

CMaxStack.cpp

#include "CMaxStack.h"

CMaxStack::CMaxStack()
{
}

CMaxStack::~CMaxStack()
{
}

void
CMaxStack::m_vPush(int i)
{
    m_oStack.push(i);

    if(m_MaxValueStack.empty() || i >= m_MaxValueStack.top())
    {
        m_MaxValueStack.push(i);
    }
}

void
CMaxStack::m_vPop()
{
    if(m_MaxValueStack.top() == m_oStack.top())
    {
        m_MaxValueStack.pop();
    }

    m_oStack.pop();
}

int
CMaxStack::m_iMaxElement()
{
    return m_MaxValueStack.top();
}

bool CMaxStack::m_bEmpty()
{
    return m_oStack.empty() ? true : false;
}

int CMaxStack::m_iTop()
{
    return m_oStack.top();
}

CMaxQueue.h

#ifndef CMAX_QUEUE_HJ
#define CMAX_QUEUE_HJ

#include "CMaxStack.h"

class CMaxQueue
{
public:
    CMaxQueue();
    ~CMaxQueue();

    void m_vPush(int i);
    void m_vPop();
    int m_iMaxElement();
    bool m_bEmpty();

private:
    CMaxStack m_oPushStack;
    CMaxStack m_oPopStack;
};

#endif

CMaxQueue.cpp

#include "CMaxQueue.h"

CMaxQueue::CMaxQueue()
{
}

CMaxQueue::~CMaxQueue()
{
}

void
CMaxQueue::m_vPush(int i)
{
    m_oPushStack.m_vPush( i );
}

void
CMaxQueue::m_vPop()
{
    if( m_oPopStack.m_bEmpty() )
    {
        while ( ! m_oPushStack.m_bEmpty() )
        {
            m_oPopStack.m_vPush( m_oPushStack.m_iTop() );
            m_oPushStack.m_vPop();
        }
        if( m_oPopStack.m_bEmpty() )
        {
            return ;
        }
    }

    m_oPopStack.m_vPop();
}

int
CMaxQueue::m_iMaxElement()
{
    if(!m_oPushStack.m_bEmpty() && !m_oPopStack.m_bEmpty())
    {
        int iPushMax = m_oPushStack.m_iMaxElement();
        int iPopMax = m_oPopStack.m_iMaxElement();
        return iPushMax > iPopMax ? iPushMax : iPopMax;
    }
    else if(m_oPushStack.m_bEmpty() && !m_oPopStack.m_bEmpty())
    {
        return m_oPopStack.m_iMaxElement();
    }
    else if(!m_oPushStack.m_bEmpty() && m_oPopStack.m_bEmpty())
    {
        return m_oPushStack.m_iMaxElement();
    }
}

bool
CMaxQueue::m_bEmpty()
{
    return (m_oPushStack.m_bEmpty() && m_oPopStack.m_bEmpty()) ? true : false;
}

main.cpp

#include "CMaxQueue.h"

int main()
{
    printf("Hello World!\n");

    CMaxQueue oQueue;

    int i;
    for (i = 0; i < 10; i++)
    {
        oQueue.m_vPush( i );
    }
    for (i = 10; i > 0; i--)
    {
        oQueue.m_vPush( i );
    }

    if(!oQueue.m_bEmpty()) {
        printf("oQueue.m_iMaxElement() = %d\n", oQueue.m_iMaxElement());
    }

    for (i = 0; i < 11; i++)
    {
        oQueue.m_vPop();
    }

    if(!oQueue.m_bEmpty()) {
        printf("oQueue.m_iMaxElement() = %d\n", oQueue.m_iMaxElement());
    }

    return 0;
}

Read All

[C/C++] 字符串相似度

2016-12-23

C/C++

以下叙述摘自编程之美一书：
许多程序会大量使用字符串。对于不同的字符串，我们希望能够有办法判断其相似程序。我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为：
1.修改一个字符（如把“a”替换为“b”）;　　
2.增加一个字符（如把“abdd”变为“aebdd”）;
3.删除一个字符（如把“travelling”变为“traveling”）;
比如，对于“abcdefg”和“abcdef”两个字符串来说，我们认为可以通过增加/减少一个“g”的方式来达到目的。上面的两种方案，都仅需要一 次 。把这个操作所需要的次数定义为两个字符串的距离，而相似度等于“距离+1”的倒数。也就是说，“abcdefg”和“abcdef”的距离为1，相似度 为1/2=0.5。
给定任意两个字符串，你是否能写出一个算法来计算它们的相似度呢？
原文的分析与解法　　
　　 不难看出，两个字符串的距离肯定不超过它们的长度之和（我们可以通过删除操作把两个串都转化为空串）。虽然这个结论对结果没有帮助，但至少可以知道，任意两个字符串的距离都是有限的。我们还是就住集中考虑如何才能把这个问题转化成规模较小的同样的子问题。如果有两个串A=xabcdae和B=xfdfa，它们的第一个字符是 相同的，只要计算A[2,...,7]=abcdae和B[2,...,5]=fdfa的距离就可以了。但是如果两个串的第一个字符不相同，那么可以进行 如下的操作（lenA和lenB分别是A串和B串的长度）。
1.删除A串的第一个字符，然后计算A[2,...,lenA]和B[1,...,lenB]的距离。
2.删除B串的第一个字符，然后计算A[1,...,lenA]和B[2,...,lenB]的距离。
3.修改A串的第一个字符为B串的第一个字符，然后计算A[2,...,lenA]和B[2,...,lenB]的距离。
4.修改B串的第一个字符为A串的第一个字符，然后计算A[2,...,lenA]和B[2,...,lenB]的距离。
5.增加B串的第一个字符到A串的第一个字符之前，然后计算A[1,...,lenA]和B[2,...,lenB]的距离。
6.增加A串的第一个字符到B串的第一个字符之前，然后计算A[2,...,lenA]和B[1,...,lenB]的距离。
在这个题目中，我们并不在乎两个字符串变得相等之后的字符串是怎样的。所以，可以将上面的6个操作合并为：
1.一步操作之后，再将A[2,...,lenA]和B[1,...,lenB]变成相字符串。
2.一步操作之后，再将A[2,...,lenA]和B[2,...,lenB]变成相字符串。
3.一步操作之后，再将A[1,...,lenA]和B[2,...,lenB]变成相字符串。
通过以上1和6,2和5，3和4的结合操作，最后两个字符串每个对应的字符会相同，但是这三种操作产生的最终的两个字符串是不一样的。我们不知道通过上述的三种结合那种使用的操作次数是最少的。所以我们要比较操作次数来求得最小值。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int iMin(int a, int b, int c)
{
    int min = a < b ? a : b;
    if(c < min)
    {
        min = c;
    }
    return min;
}

int iDistance(
        const char * pcStrA, int iAStart, int iAEnd,
        const char * pcStrB, int iBStart, int iBEnd,
        int ** ppiResult)
{
    printf("iAStart=%d,iAEnd=%d, iBStart=%d, iBEnd=%d\n", iAStart, iAEnd, iBStart, iBEnd);
    if(iAStart > iAEnd && iBStart > iBEnd) {
        return 0;
    }
    if(iAStart > iAEnd) {
        return iBEnd - iBStart + 1;
    }
    if(iBStart > iBEnd) {
        return iAEnd - iAStart + 1;
    }

    if(ppiResult[iAStart][iBStart] != 0) {
        return ppiResult[iAStart][iBStart];
    }

    if(pcStrA[iAStart] == pcStrB[iBStart])
    {
        int iRet = iDistance(pcStrA, iAStart+1, iAEnd, pcStrB, iBStart+1, iBEnd, ppiResult);
        if(iRet != 0) ppiResult[iAStart+1][iBStart+1] = iRet;
        return iRet;
    }

    int a = iDistance(pcStrA, iAStart+1, iAEnd, pcStrB, iBStart+1, iBEnd, ppiResult);
    int b = iDistance(pcStrA, iAStart+1, iAEnd, pcStrB, iBStart, iBEnd, ppiResult);
    int c = iDistance(pcStrA, iAStart, iAEnd, pcStrB, iBStart+1, iBEnd, ppiResult);
    printf("[%d][%d] = %d, [%d][%d] = %d, [%d][%d] = %d\n",
            iAStart+1, iBStart+1, a,
            iAStart+1, iBStart, b,
            iAStart, iBStart+1, c);
    if(a != 0) ppiResult[iAStart+1][iBStart+1] = a;
    if(b != 0) ppiResult[iAStart+1][iBStart] = b;
    if(c != 0) ppiResult[iAStart][iBStart+1] = c;

    ppiResult[iAStart][iBStart] = iMin(a, b, c) + 1;

    return ppiResult[iAStart][iBStart];
}

double dSimilarity(const char * pcStrA, const char * pcStrB)
{
    int iLenA = strlen(pcStrA);
    int iLenB = strlen(pcStrB);

    int ** ppiResult = (int**)malloc(sizeof(int*) * (iLenA+1));
    for (int i = 0; i < iLenA+1; i++)
    {
        ppiResult[i] = (int*)malloc(sizeof(int) * (iLenB+1));
        memset(ppiResult[i], 0, sizeof(int) * (iLenB+1));
    }

    int iDis = iDistance(pcStrA, 0, iLenA - 1, pcStrB, 0, iLenB - 1, ppiResult);
    printf("iDis = %d\n", iDis);
    return 1.0/(iDis + 1);
}

int main()
{
    char acStrA[] = "abc";
    char acStrB[] = "aef";

    printf("similarity = %lf\n", dSimilarity(acStrA, acStrB));

    return 0;
}

Read All

[Windows] 远程桌面控制

2016-12-21

Windows

Windows

Read All
[Windows] putty 颜色配置

2016-12-21

Windows

Windows

Read All
[测试][Bugfree] Fix bug时的解决方案选择

2016-12-21

tester

Tester Bugfree

By Design：这不是个bug，就是这么设计的

Duplicate：重复的bug

External：外部原因，机器原因，操作原因等待

Fixed：已解决

Not Repro：无法重现

Postponed：推迟解决

Won’t Fix：我知道这是个bug，但是不打算解决，要说明原因

Read All