2. 程式人生 > >一道考驗你設計能力的C++程式設計題

一道考驗你設計能力的C++程式設計題

阿新 • • 發佈：2018-11-26

看到這道題，我們就開始設計這個影象類了，按照面向物件“依賴倒置”的設計原則，我們站在客戶的立場，來考慮我們這個類該提供哪些介面，很快我們設計瞭如下一個類: 

class CSimplePicture
{
public:
    CSimplePicture(char* init[], int nCount); 
    CSimplePicture(CSimplePicture& p1, CSimplePicture& p2, bool bVerCat);

    void Frame();
    void Print(std::ostream& os) const
 
;
protected:
    std::vector<std::string> m_arData;
};

CSimplePicture(char* init[], int nCount);
根據字串陣列構造一幅影象.

CSimplePicture(CSimplePicture& p1, CSimplePicture& p2, bool bVerCat);
根據兩幅影象構造一幅影象，bVerCat表明是縱聯接還是橫聯接.

void Frame();
給影象物件加框

void Print(std::ostream& os) const;
列印輸出影象

std::vector<std::string> m_arData;
儲存影象資料的字串陣列

下面來考慮具體實現，這個對於有一定開發的經驗的人來說還是很容易的，就不具體寫了，
CSimplePicture(char* init[], int nCount)無非是資料的拷貝，CSimplePicture(CSimplePicture& p1, CSimplePicture& p2, bool bVerCat)就是把2幅圖片的資料連線，合在一起，void Frame()修改裡面的資料加上邊框，void Print(std::ostream& os) const遍歷字串陣列輸出。


根據上面的設計和實現，應該已經滿足我們這個題目的要求了。
但是客戶的需求是多變的，現在客戶又有一個新的需求，要求把一幅圖片去掉邊框。
另外客戶覺得我們這個圖片類的效能太差了，每次加框或是合成圖片都要大量的記憶體拷貝。

這時我們傻眼了，該死的客戶，根據我們上面的設計，根本不支援這些新功能，因為我們儲存的是影象的內部的字串資料，根本不知道它是不是加框過的，另外我們的影象資料本身就是不支援共享的。

 

接下來我們就要重新考慮設計了，如何讓我們的影象物件支援UnFrame(去邊框)操作，關鍵是要建立我們的影象型別層次，這樣就可以判斷是否是加框的類物件，於是有了如下的類層次：
//圖象介面基類
class CPic_Base 
{};

//字串影象類
class CPic_String: public CPic_Base
{};

//加框影象類
class CPic_Frame: public CPic_Base
{}

//縱聯接影象類
class CPic_VCat: public CPic_Base
{};

//橫聯接影象類
class CPic_HCat: public CPic_Base
{};

然後我們考慮如何共享影象資料，這就要用到智慧指標了，智慧指標在C++裡一般有2種實現，一種是STL 裡的auto_ptr，還有一種就是基於引用計數。auto_ptr的本質是擁有關係，也就是你擁有了這物件後，別人就不能擁有了，所以這裡不符合我們的要求。引用計數是個好東西，對於共享物件特別有用，COM裡的IUnknow介面就是基於這個技術的，還有很多指令碼語言裡變數自動銷燬，實際上都是基於引用計數的技術。這裡分享一個基於引用計數的智慧指標類。

class CRefCountBase
{
public:
    CRefCountBase()
    {
        m_nRefCount = 0;
    }

    int GetRefCount() const
    {
        return m_nRefCount;
    }

    int AddRefCount()
    {
        return ++m_nRefCount;
    }

    int SubRefCount()
    {
        return --m_nRefCount;
    }

    void ResetRefCount()
    {
        m_nRefCount = 0;
    }

private:
    int    m_nRefCount;
};

template<typename T>
class CRefPtr
{
public:
    T* operator->() const
    {
        return m_pRawObj;
    }

    T& operator()() const
    {
        return *m_pRawObj;
    }

    T& operator*() const
    {
        return *m_pRawObj;
    }

    T* GetPtr() const
    {
        return m_pRawObj;
    }

    bool IsNull() const
    {
        return m_pRawObj == NULL;
    }

    CRefPtr()
    {
        m_pRawObj = NULL;
    }

    CRefPtr(T* p)
    {
        m_pRawObj = p;
        if(p != NULL)
        {
            p->AddRefCount();
        }
    }

    CRefPtr(const CRefPtr& ref)
    {
        m_pRawObj = ref.m_pRawObj;
        if(m_pRawObj != NULL)
        {
            m_pRawObj->AddRefCount();
        }
    }

    ~CRefPtr()
    {
        if(m_pRawObj != NULL && m_pRawObj->SubRefCount() == 0)
        {
            delete m_pRawObj;
        }
    }

    CRefPtr& operator = (const CRefPtr& ref)
    {
        if(this != &ref)
        {
            if(m_pRawObj != NULL
                && m_pRawObj->SubRefCount() == 0)
            {
                delete m_pRawObj;
            }

            m_pRawObj = ref.m_pRawObj;

            if(m_pRawObj != NULL)
            {
                m_pRawObj->AddRefCount();
            }
        }

        return *this;
    }

    bool operator == (const CRefPtr& ref) const
    {
        return m_pRawObj == ref.m_pRawObj;
    }

    CRefPtr<T> Copy()
    {
        if(m_pRawObj != NULL)
        {
            T* p = new T(*m_pRawObj);
            p->ResetRefCount();

            return p;
        }
        else
        {
            return NULL;
        }
    }

private:
    T* m_pRawObj;
};

這樣使用這個類:

class A: public CRefCountBase
{
Public:
    Void fun1();
};

CRefPtr<A> p = new A;
p->fun1();

重新設計我們的CPic_Base,

class CPic_Base: public CRefCountBase
{
public:
    virtual ~CPic_Base() {}

    //列印輸出影象
    void Print(std::ostream& os) const;

    //返回影象寬度
    virtual int GetWidth() const = 0;

    //返回影象高度
    virtual int GetHeight() const = 0;

    //返回某行的影象字串資料
    virtual std::string GetLineData(int nLineIndex) const = 0;

    //返回去掉邊框的物件
    virtual CRefPtr<CPic_Base> GetUnFrame() const { return NULL; }
};

這裡Print方法實現就很簡單了：

void CPic_Base::Print(std::ostream& os) const
{
    for(int i=0; i<GetHeight(); ++i)
    {
        os << GetLineData(i);
        os << "\n";
    } 
}

然後考慮實現CPic_String

class CPic_String: public CPic_Base
{
public:
    CPic_String(char* p[], int nCount);

    virtual int GetWidth() const;
    virtual int GetHeight() const;
    virtual std::string GetLineData(int nLineIndex) const;


protected:
    std::vector<std::string> m_arData;
};

這個類裡儲存真正的字串影象資料，裡面方法的實現也很簡單，和最開始的的第一種實現類似，就不詳寫了。

再考慮實現CPic_Frame

class CPic_Frame: public CPic_Base
{
public:
    CPic_Frame(CRefPtr<CPic_Base>& pic);

    virtual int GetWidth() const;
    virtual int GetHeight() const;
    virtual std::string GetLineData(int nLineIndex) const; 

    virtual CRefPtr<CPic_Base> GetUnFrame() const { return m_pic; }

protected:
    CRefPtr<CPic_Base> m_pic;
};

可以看到這裡我們引用了一個其他的影象資料，而不是真正儲存這些資料，方法實現也很簡單, 主要依賴於m_pic所指向的影象類，同時m_pic是個基於引用計數的智慧指標， 所以賦值時也沒有記憶體拷貝， 注意GetUnFrame這個方法只有這裡返回非NULL，表示只有這種物件支援去邊框。

CPic_Frame::CPic_Frame(CRefPtr<CPic_Base>& pic)
: m_pic(pic)
{
    _ASSERTE(!m_pic.IsNull());
}

int CPic_Frame::GetWidth() const
{
    return m_pic->GetWidth() + 2;
}

int CPic_Frame::GetHeight() const
{
    return m_pic->GetHeight() + 2;
}

string CPic_Frame::GetLineData(int nLineIndex) const
{
    int nWidth = GetWidth();
    int nHeight = GetHeight();

    _ASSERTE(nLineIndex < nHeight && nLineIndex >= 0); 

    if(nLineIndex == 0 //first line and last line
        || nLineIndex == nHeight - 1)
    {
        int nPadding = nWidth - 2;
        return string("+") + string(nPadding, '-') + string("+");
    }
    else
    {
        return string("|") + m_pic->GetLineData(nLineIndex - 1) + string("|");
    }
}

再考慮實現CPic_VCat

class CPic_VCat: public CPic_Base
{
public:
    CPic_VCat(CRefPtr<CPic_Base>& pic1, CRefPtr<CPic_Base>& pic2);

    virtual int GetWidth() const;
    virtual int GetHeight() const;
    virtual std::string GetLineData(int nLineIndex) const;

protected:
    CRefPtr<CPic_Base> m_pic1;
    CRefPtr<CPic_Base> m_pic2;
};

他裡面儲存了上下2個影象物件，方法實現是也不復雜，就不具體寫了。

另外CPic_HCat也是類似：

class CPic_HCat: public CPic_Base
{
public:
    CPic_HCat(CRefPtr<CPic_Base>& pic1, CRefPtr<CPic_Base>& pic2);

    virtual int GetWidth() const;
    virtual int GetHeight() const;
    virtual std::string GetLineData(int nLineIndex) const;

protected:
    CRefPtr<CPic_Base> m_pic1;
    CRefPtr<CPic_Base> m_pic2;
};

有了上面的實現，現在我們可以這麼實現我們需要的功能了：

Int main()
{
    char* init1[] = {"Paris", "in the", "Spring"};
    CRefPtr<CPic_Base> p1 = new CPic_String(init, 3); 

    CRefPtr<CPic_Base> p2 = new CPic_Frame(p1);

    CRefPtr<CPic_Base> p3 = new CPic_VCat(p1, p2);

    P3->Print(cout);
    CRefPtr<CPic_Base> p4 = p2->GetUnFrame();
}

這時我們發現這樣對於客戶呼叫很不友好，因為我們內部實現的類層次都暴露給客戶了，而這些資訊對客戶來說應該都是透明的，我們應該再封裝一個更簡單的介面類給客戶。

於是有了如下的設計，其實介面類似我們的第一種實現。

class CPicture
{
public:
    CPicture(char* p[], int nCount);
    CPicture(CPicture& p1, CPicture& p2, bool bVerCat);

    void Frame();
    bool UnFrame();

    friend std::ostream& operator << (std::ostream& os, const CPicture& pic);

protected:
    CRefPtr<CPic_Base> m_pic;
};

std::ostream& operator << (std::ostream& os, const CPicture& pic);

這樣對客戶來說他們只需要和CPicture打交道，根本不用關心內部的實現。
這個類的實現也很簡單:

CPicture::CPicture(char* p[], int nCount)
{
    m_pic = new CPic_String(p, nCount);
}

CPicture::CPicture(CPicture& pic1, CPicture& pic2, bool bVerCat)
{
    if(!bVerCat)
    {
        m_pic = new CPic_HCat(pic1.m_pic, pic2.m_pic);
    }
    else
    {
        m_pic = new CPic_VCat(pic1.m_pic, pic2.m_pic);
    }
}

void CPicture::Frame()
{
    m_pic = new CPic_Frame(m_pic);
}

bool CPicture::UnFrame()
{
    CRefPtr<CPic_Base> p = m_pic->GetUnFrame();
    if(!p.IsNull())
    {
        m_pic = p;
    }

    return !p.IsNull();
}

std::ostream& operator << (std::ostream& os, const CPicture& pic)
{
    pic.m_pic->Print(os);
    return os;
}

下面是我們使用這個類的程式碼：

char* init1[] = {"Paris", "in the", "Spring"};
char* init2[] = {"Hello world", "every", "thing", "is", "OK!"};

int main(int argc, char* argv[])
{
    CPicture p1(init1, 3);
    CPicture p2(init2, 5);

    //
    std::cout << p1;
    cout <<endl << endl; 

    //
    std::cout << p2;
    cout <<endl << endl; 

    //
    p2.Frame();
    cout << p2;
    cout <<endl << endl; 

    //
    p1.Frame();
    p1.Frame();
    cout << p1;
    cout <<endl << endl;

    //
    CPicture pHorCat(p1, p2, false);
    cout << pHorCat;
    cout <<endl << endl; 

    //
    CPicture pVerCat(p1, pHorCat, true);
    cout << pVerCat;
    cout <<endl << endl; 

    //
    pVerCat.Frame();
    cout << pVerCat;
    cout <<endl << endl; 

    //
    pVerCat.Frame();
    cout << pVerCat;
    cout <<endl << endl; 

    //
    pVerCat.UnFrame();
    pVerCat.UnFrame();
    cout << pVerCat;
    cout <<endl << endl; 

    system("pause");

    return 0;
}

可以看到使用起來非常方便和友好，執行截圖：

可以看到使用第二種實現我們只儲存了一份字串影象資料，同時有保留了影象的層次和結構屬性，實現時包含了很多設計模式，比如Template, Decorate, Composite, Facade等，簡單而高效。


最後我們對這2種實現方式作下比較：

方法1的優勢是資料完整，修改一個物件時不會影響其他物件，因為每個物件都是資料的單獨拷貝。劣勢是低效，不能體現物件的結構屬性，我們不知道這個物件是加邊框的物件還是上下合成的物件。


方法2的優勢是高效，資料共享，同時有保留有物件的結構屬性。劣勢是修改一個對像時會影響其他的物件，因為他們可能是共享同一個物件。實際上，對於基於引用計數的共享物件，還有一種叫做Write Copy（寫入時拷貝）的技術，就是如果你要修改一個物件，就自己拷貝一份。同時引用計數技術還有一個風險就是迴圈引用，比如A引用了B，B也引用了A，這2個物件就永遠沒法釋放了，這也是要謹慎的。

 

上面完美的解決了我們UnFrame(去邊框)的問題，我們正對我們使用基於引用計數的技術來完美的構造字串影象類層次而洋洋得意，但是好景不長。


一個星期後，客戶又找到你提了他的新需求，他想讓你的CPicuture類增加一個功能，能返回一個XML格式的字串來告訴他該物件的構造過程。
比如
+-------+
|Paris   |
|in the |
|Spring |
+-------+
返回的XML串是
< CPic_Frame >
<CPic_String> Paris in the Spring </CPic_String>
</ CPic_Frame >

+-------+Paris
|Paris  |in the
|in the |Spring
|Spring |
+-------+

返回的XML串是:

< CPic_HCat >
< CPic_Frame >
<CPic_String> Paris in the Spring </CPic_String>
</ CPic_Frame >
<CPic_String> Paris in the Spring </CPic_String>
</ CPic_HCat >


+-------+Paris
|Paris  |in the
|in the |Spring
|Spring |
+-------+
Paris
in the 
Spring

返回的XML串是:

<CPic_VCat>
< CPic_HCat >
< CPic_Frame >
<CPic_String> Paris in the Spring </CPic_String>
</ CPic_Frame >
<CPic_String> Paris in the Spring </CPic_String>
</ CPic_HCat >
<CPic_String> Paris in the Spring </CPic_String>
</CPic_VCat>

 

你不禁抱怨道，該死的客戶，上次已經因為要支援UnFrame功能而讓我改變了最初的設計，如果沒有客戶的新需求，開發該是一件多麼美好的事情。

但是抱怨歸抱怨，客戶就是上帝，你還是隻能硬這頭皮把事情做完。
那現在讓我們來考慮如果實現這一功能。

一開始想到的當然是在我們的CPic_Base基類中增加一個介面，比如
String GetStructXMLString();

但是面向對像的設計原則告訴我們，介面不該隨便改動，實際上次CPic_Base裡為UnFrame而增加的CRefPtr<CPic_Base> GetUnFrame()介面已經讓你覺得很不爽，感覺這個介面和我們的影象物件沒有直接關係。

那麼我們是否考慮可以重構CPic_Base介面，讓它能以外掛的形式實現各種功能，也就是說我們的類層次這裡是固定的，但是方法卻可以一直增加而不影響原有的程式碼。

這時我們想到了Visitor模式，它基本上是為我們這類需求而量身定做的。
對於Visitor模式的架構，基本上是固定的，定義個IPic_Visitor

class IPic_Visitor
{
public:
    virtual void VisitPicString(CPic_String& pic) {};
    virtual void VisitPicFrame(CPic_Frame& pic) {} ;
    virtual void VisitPicVCat(CPic_VCat& pic) {};
    virtual void VisitPicHCat(CPic_HCat& pic) {};

    virtual ~IPic_Visitor() {}
};

在我們的CPic_Base基類裡增加一個Accept介面virtual void Accept(IPic_Visitor& visitor) = 0;
這樣影象物件就可以讓各種型別的Visitor訪問了，各個影象類的實現也很簡單:

void CPic_String::Accept(IPic_Visitor& visitor)
{
    visitor.VisitPicString(*this);
}
void CPic_Frame::Accept(IPic_Visitor& visitor)
{
    visitor.VisitPicFrame(*this);
}
void CPic_VCat::Accept(IPic_Visitor& visitor)
{
    visitor.VisitPicVCat(*this);
}
void CPic_HCat::Accept(IPic_Visitor& visitor)
{
    visitor.VisitPicHCat(*this);
}

好了，現在我們用一個新Visitor來改寫我們原來的UnFrame功能，

class CUnFrameVisitor: public IPic_Visitor
{
public:
    virtual void VisitPicFrame(CPic_Frame& pic);

public:
    CRefPtr<CPic_Base> GetUnFrameResult();

protected:
    CRefPtr<CPic_Base> m_picRet;
};

因為Visitor方法都是沒有返回值，引數也是固定的，所以一般都是通過在Visitor裡儲存成員變數和返回介面來實現返回值的。
這樣實現就很簡單了：

void CUnFrameVisitor::VisitPicFrame(CPic_Frame& pic)
{
    m_picRet = pic.m_pic;
}

CRefPtr<CPic_Base> CUnFrameVisitor::GetUnFrameResult()
{
    return m_picRet;
}

可以看到只有訪問 CPic_Frame才有非空的返回值；其他都是用預設的空方法，最終返回的也就空物件。

這樣我們在最終暴露的CPicture裡實現UnFrame也就很簡單了：

bool CPicture::UnFrame()
{
    CUnFrameVisitor vistor;
    m_pic->Accept(vistor);

    CRefPtr<CPic_Base> pRet = vistor.GetUnFrameResult();
    if(!pRet.IsNull())
    {
        m_pic = pRet;
    }

    return !pRet.IsNull();
}

接下來我們考慮如何實現客戶的要求返回XML串的需求，實際上我們前面的Visitor模式已經為我們準備好了條件，我們只需要新增加一個Visitor

class CStructXMLVisitor: public IPic_Visitor
{
public:
    virtual void VisitPicString(CPic_String& pic);
    virtual void VisitPicFrame(CPic_Frame& pic);
    virtual void VisitPicVCat(CPic_VCat& pic);
    virtual void VisitPicHCat(CPic_HCat& pic);

public:
    std::string GetStructXMLString() { return m_strStructXML;}

protected:
    std::string m_strStructXML;
};

實現也不復雜：

void CStructXMLVisitor::VisitPicString(CPic_String& pic)
{
    m_strStructXML = "<CPic_String>";
    int nHeight = pic.GetHeight();
    for(int i=0;i<nHeight; ++i)
    {
        m_strStructXML += pic.GetLineData(i);
    }
    m_strStructXML += "</CPic_String>";
}

void CStructXMLVisitor::VisitPicFrame(CPic_Frame& pic)
{
    CStructXMLVisitor v;
    pic.m_pic->Accept(v);
    m_strStructXML = "<CPic_Frame>";
    m_strStructXML += v.GetStructXMLString();
    m_strStructXML += "</CPic_Frame>";
}

void CStructXMLVisitor::VisitPicVCat(CPic_VCat& pic)
{
    m_strStructXML = "<CPic_VCat>";
    CStructXMLVisitor v1;
    pic.m_pic1->Accept(v1);
    m_strStructXML += v1.GetStructXMLString();

    CStructXMLVisitor v2;
    pic.m_pic2->Accept(v2);
    m_strStructXML += v2.GetStructXMLString();

    m_strStructXML += "</CPic_VCat>";
}

void CStructXMLVisitor::VisitPicHCat(CPic_HCat& pic)
{
    m_strStructXML = "<CPic_HCat>";
    CStructXMLVisitor v1;
    pic.m_pic1->Accept(v1);
    m_strStructXML += v1.GetStructXMLString();

    CStructXMLVisitor v2;
    pic.m_pic2->Accept(v2);
    m_strStructXML += v2.GetStructXMLString();

    m_strStructXML += "</CPic_HCat>";
}

然後我們在我們的CPicture介面裡增加一個GetStructXMLString方法，實現也很簡單：

std::string CPicture::GetStructXMLString()
{
    CStructXMLVisitor v;
    m_pic->Accept(v);
    return v.GetStructXMLString();
}

可以看到，改用新的設計之後，以後我們再有什麼新需求，只要直接增加一個Visitor就好了, 所以說設計不是一層不變的，要根據需求不停的重構。

最後貼一下類圖，外部只要和CPicture打交道就可以了:

原始碼下載:  ConsolePicture_1.rar

                ConsolePicture_2.rar
注：(1)該題引自《C++沉思錄》
      (2)C++11裡已經有基於引用計數的智慧指標share_ptr, 所以以後就不用自己寫了，迴圈引用的問題也可以通過weak_ptr解決.

摘要: http://www.cppblog.com/weiym/archive/2012/06/12/178472.html

相關推薦

一道考驗你設計能力的C++程式設計題

看到這道題，我們就開始設計這個影象類了，按照面向物件“依賴倒置”的設計原則，我們站在客戶的立場，來考慮我們這個類該提供哪些介面，很快我們設計瞭如下一個類:  class CSimplePicture { public: CSimplePicture(char* init[], i

C++程式設計題練習程式碼筆記

從文字檔案old.txt讀取字元，將其中的數字字元‘0’、‘1’、‘2’、‘3’、‘4’、‘5’、‘6’、‘7’、‘8’、‘9’ 分別用英文字母字元‘Z’、‘Y’、‘X’、‘W’、‘V’、‘U’、‘T’、‘S’、‘R’、‘Q’替換，其餘字元不變，結果寫入文字檔案new.txt，並分別將兩個

愛奇藝2018秋季校招C++ [程式設計題]奇異數

連結：https://www.nowcoder.com/questionTerminal/7442938f5012486499ddd61ce16f9086 來源：牛客網 如果一個數字滿足以下條件,我們就稱它為奇異數: 1、這個數字至少有兩位 2、這個數的最低兩位是相同的 比如: 1488是

愛奇藝2018秋招C++ [程式設計題]奶牛編號

連結：https://www.nowcoder.com/questionTerminal/b96da2bd7a574699b4ceaaa7819cf65b 來源：牛客網 牛牛養了n只奶牛, 牛牛想給每隻奶牛編號, 這樣就可以輕而易舉地分辨它們了。 每個奶牛對於數字都有自己的喜好, 第i只奶牛想要

愛奇藝2018秋招C++ [程式設計題]紅和綠

連結：https://www.nowcoder.com/questionTerminal/4ea618c551404efc8299c2eaac733329 來源：牛客網 牛牛有一些排成一行的正方形。每個正方形已經被染成紅色或者綠色。牛牛現在可以選擇任意一個正方形然後用這兩種顏色的任意一種進

C/C++程式設計題之計算一個數字的立方根

計算一個數字的立方根方法：使用對數和指數組合的方法表示立方根。loga（b）表示 以a為底，b的對數，a（m）表示a的m次方。我們知道a（loga（b））等於b，並且nloga（b）等於log以a為底b的n次方。結合這兩個性質，我們可以得到任何一個數的任何一個次冪的值，自然

C++程式設計題最常用函式彙總

內容會持續更新，有錯誤的地方歡迎指正，謝謝! 1.型別轉化 string轉int的方式 採用標準庫cstdlib中atoi函式，<cstdlib>是C++裡面的一個常用函式庫， 等價於C中的<stdlib.h>，但不需引入，

C程式設計題2

1.寫一個用矩陣法求定積分的通用函式，求#include<stdio.h> #include<math.h> float integral(float a,float b,int n){ int i; float x,h,s; h=(b-1)/n; x

c/c++程式設計題 之 猴子選大王（陣列、連結串列兩種方法）

一群猴子要選新猴王。新猴王的選擇方法是：讓N只候選猴子圍成一圈，從某位置起順序編號為1-N號。從第1號開始報數，每輪從1報到3，凡報到3的猴子即退出圈子，接著又從緊鄰的下一隻猴子開始同樣的報數。如此不斷迴圈，最後剩下的一隻猴子就選為猴王。請問是原來第幾號猴子當選猴王？

C/C++程式設計題之求兩個數的最大公約數和最小公倍數

求兩個數的最大公約數和最小公倍數 方法：最大公約數使用輾轉相除法求，最小公倍數等於兩個數的乘積/最大公約數 輾轉相除法的原理：用輾轉相除法求幾個數的最大公約數，先求出其中任意兩個數的最大公約數，再

阿里秋招C/C++程式設計題

題目： 伺服器都有上下游依賴關係，輸入第一行表示伺服器的數量，和依賴關係的個數。如下表示有5臺伺服器，4個依賴關係。 接下來的5行是每臺伺服器的啟動延遲（單位ms），最後四行是伺服器之間的依賴關係（5臺伺服器用數字0-4表示）。 不考慮存在環。 輸出要求

C/C++程式設計題之IP地址轉整數

/* 功能：將輸入的string型別的IP資訊轉換為string型別  * 輸入：string型別的IP資訊  * 輸出：DWORD結果，正常返回解析結果值，異常時，dwIP為0  * 返回：返回解析

C程式設計題：求高次方數的尾數

例：編寫程式求出13的13次方的最後三位數。 首先分析題意，我們可以定義兩個變數用於儲存次方底數和指數，再用一個for迴圈對底數進行指數次的自乘，最後擷取最後三位數即可。然而這種方式卻行不通，因為計算

c++程式設計題 求數列的和

最近心好累，行為識別模型明明訓練的好好的，收斂也正常，Avg loss也很小，就是測試效果不好（接近沒效果）！深度學習之路真是道阻且長啊，求求了～～ 偌大的世界，能給我安慰的只有漂亮姐姐了，哈哈哈哈。（還有c++，我愛你。） 題目描述 數列的第一項為n，以後各項為前

c/c++程式設計題 之 驗證哥德巴赫猜想

驗證哥德巴赫猜想 題目描述 哥德巴赫猜想：任何一個大於6的偶數均可表示為兩個素數之和。輸入兩個整數m，n（6小於等於m，m小於等於n，n小於等100），將m，n之間的偶數表示成兩個素數之和   輸入描述 輸入兩個大於6的正整數分別給

C/C++程式設計題開頭字串、資料輸入幾種寫法

1、題設 在IT公司程式設計題中，多數會讓你一併寫上測試資料輸入和結果輸出的Demo，這也是程式設計師基本的功底。想一想如果連自己的測試資料都無法給入，後面的演算法寫的再好，也無法測試它的準確性和效果

C語言/C++程式設計題 之 時鐘（分針追趕時針，分針與時針相遇次數問題）

題目描述 有一個標準的12小時時鐘，它有一個時針，一個分針。現問你，在給定的兩個時刻之間分針與時針相遇幾次？ 輸入 輸入包含多組測試資料。每組輸入包含4個整數，前兩個數字分別表示起始時刻的小時和分，後兩個數字分別表示結束時刻的小時和分。 小時數在[1，12]

c++程式設計題 保留最大的數

終於到家了！開始好好學習演算法及資料結構〜 這是一道兩天前就在寫的題，演算法是想出來了，但是讀入的時候總是出現問題！ 分享下我的解題歷程吧〜 題目如下： 題目描述 給定一個十進位制的正整數數目，選擇從裡面去掉一部分數字，希望保留下來的數字組成的正整數最大。 輸入描

C/C++程式設計題之圓桌遊戲

n個人圍坐在一個圓桌上從1到n編號，順時針從第一個人開始報數，從1開始報到m(m < n)，報到m的那個人出圓桌，再從出桌的人的下一個人從1開始報數，直到圓桌上的人不足m人位置，輸出最終剩下人的編

c++ 程式設計題總結

C++題目總結 型別一：求和 1、求和：S= 1+ 1/(1+2)+1/(1+2+3)+...+1/(1+2+3+...+50) #include <iostream> using nam