알고리즘 의 미소스 코드 발표 (6)
부록 중의 고전 필기시험, 면접 문제 참고 답안 은 다음 과 같 습 니 다.
http://blog.csdn.net/baimafujinji/article/details/50484683
In genel, 나 는 책 한 권 (기술 서) 을 펼 치 는 것 을 그다지 좋아 하지 않 는 다. 그 안에 빽빽 한 것 은 모두 코드 이다.그래서 나 도 내 책 에 원리 와 사고방식 을 토론 할 수 있 는 공간 을 더 많이 남 겼 으 면 좋 겠 다.물론 코드 도 중요 하 다. 모든 원 리 는 결국 코드 에 실 현 돼 야 한다.이 때문에 나 는 그들 을 모두 책 에 나열 해서 편폭 을 차지 하 는 것 이 아니 라 블 로그 에 코드 를 올 리 는 것 에 익숙 하 다.마지막 으로 저 는 알고리즘 과 데이터 구 조 를 잘 배 우려 는 학생 들 에 게 책 에서 언급 된 알고리즘 원 리 를 철저히 격파 하고 그 이 유 를 더 잘 알 도록 하 겠 습 니 다. 그래 야 당신 이 진정 으로 배 운 것 이 라 고 할 수 있 습 니 다. 그래 야 새로운 프로 그래 밍 문 제 를 만 났 을 때 속수무책 이 되 지 않 습 니 다.
만약 당신 이 이 책의 독자 라면 알고리즘 학습 군 (495573865) 에 가입 하 는 것 을 강력 히 건의 합 니 다. 그 안에 더 많은 자원 이 당신 을 기다 리 고 있 습 니 다. 그리고 당신 이 책 을 읽 으 면서 만난 의문 도 제 첫 번 째 시간의 해답 을 얻 을 수 있 습 니 다.본 블 로그 에 더 많은 관심 을 가지 고 있 습 니 다. 저 는 이 책의 모든 소스 코드 를 본 블 로그 에 계속 발표 할 것 입 니 다.
P187 트 리 의 추상 적 데이터 구조
template<class T> class Tree;
template<class T>
class TreeNode
{
friend class Tree<T>;
private:
T m_value;
TreeNode<T> * leftChild; // ,
TreeNode<T> * rightSibling; //
public:
TreeNode(const T&); //
~TreeNode(); //
bool isLeaf(); //
T getValue();
TreeNode<T>* getLeftChild();
TreeNode<T>* getRightSibling();
void setValue(T & value); //
//
void setLeftChild(TreeNode<T>* pLeftChild);
//
void setRightSibling(TreeNode<T>* pRightSibling);
};
template<class T>class Tree
{
TreeNode<T>* root, * parent;
int getParent(TreeNode<T>* root,TreeNode<T>* current);
public:
Tree();
Tree(TreeNode<T>* rt); // ，
~Tree(); //
TreeNode<T> * getRoot(); // ， ， Null
// current ， n ， Null
TreeNode<T> * Parent(TreeNode<T> * current);
// t ， Null
TreeNode<T> * getFirstChild(TreeNode<T> * t);
// t ， Null
TreeNode<T> * getNextSibling(TreeNode<T> * t);
// t n
void insertChild(TreeNode<T> * t, TreeNode<T> * n);
void deleteSubTree(TreeNode<T> * t); // t
bool isEmpty(); //
};
P193 이 진 트 리 류 의 실현
BinaryTreeNode.h
#ifndef BINARYTREENODE_H
#define BINARYTREENODE_H
#include "iostream"
using namespace std;
template <class Type>
class BinaryTreeNode
{
Type m_data; //
BinaryTreeNode<Type> *m_leftChild; //
BinaryTreeNode<Type> *m_rightChild;//
public:
BinaryTreeNode(){m_leftChild = m_rightChild = NULL;};
BinaryTreeNode(const Type &data,
BinaryTreeNode *leftChild = NULL,
BinaryTreeNode *rightChild = NULL)
{
m_data = data;
m_leftChild = leftChild;
m_rightChild = rightChild;
};
Type & GetData(){return m_data;}; //
//
BinaryTreeNode<Type>* GetLeftChild(){return m_leftChild;};
//
BinaryTreeNode<Type>* GetRightChild(){return m_rightChild;};
//
void SetData(const Type & data){m_data = data;};
//
void SetLeftChild(BinaryTreeNode<Type> *leftChild){m_leftChild = leftChild;};
//
void SetRightChild(BinaryTreeNode<Type> *rightChild){m_rightChild = rightChild;};
};
#endif
BinaryTree.h
#include"BinaryTreeNode.h"
#include<queue>
using namespace std;
template<class T>
class BinaryTree
{
BinaryTreeNode<T> *m_root;
public:
BinaryTree(){m_root = NULL;};
BinaryTree(T data){m_root = new BinaryTreeNode<T>(data);};
virtual ~BinaryTree();
bool IsEmpty() const{return m_root == NULL ? true:false;};//
//
bool IsLeftChild(BinaryTreeNode<T> *p)
{return p == GetParent(p)->GetLeftChild() ? true:false;};
//
bool IsRightChild(BinaryTreeNode<T> *p)
{return p == GetParent(p)->GetRightChild() ? true:false;};
//
BinaryTreeNode<T>* GetRoot(){return m_root;};
//
BinaryTreeNode<T>* GetParent(BinaryTreeNode<T> *p){return Parent(m_root, p);};
//
BinaryTreeNode<T>* LeftChild(BinaryTreeNode<T> *root) const
{return root == NULL ? NULL:root->GetLeftChild();};
//
BinaryTreeNode<T>* RightChild(BinaryTreeNode<T> *root) const
{return root == NULL ? NULL:root->GetRightChild();};
//
BinaryTreeNode<T>* LeftSibling(BinaryTreeNode<T> *leftChild);
//
BinaryTreeNode<T>* RightSibling(BinaryTreeNode<T> *rightChild);
//
T Retrieve(BinaryTreeNode<T> *p) const {return p->GetData();};
//
void Assign(BinaryTreeNode<T> *p, const T &d) const {p->SetData(d);};
//
void InsertRightChild(BinaryTreeNode<T> *p, const T &d) const;
//
void InsertLeftChild(BinaryTreeNode<T> *p, const T &d) const;
//
void DeleteRightChild(BinaryTreeNode<T> *p){Destroy(p->GetRightChild());};
//
void DeleteLeftChild(BinaryTreeNode<T> *p){Destroy(p->GetLeftChild());};
virtual void PreOrderTraverse(BinaryTreeNode<T> *root) const;//
virtual void InOrderTraverse(BinaryTreeNode<T> *root) const;//
virtual void PostOrderTraverse(BinaryTreeNode<T> *root) const; //
virtual void LevelOrderTraverse(BinaryTreeNode<T> *root) const;//
protected:
BinaryTreeNode<T>* Parent(BinaryTreeNode<T> *root, BinaryTreeNode<T> *p);
void Destroy(BinaryTreeNode<T> *p);
};
template<class T>
BinaryTree<T>::~BinaryTree(void)
{
Destroy(m_root);
m_root = NULL;
}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::RightSibling(BinaryTreeNode<T> *p)
{
BinaryTreeNode<T> *q;
q = Parent(m_root, p);
if ((NULL == q) || (p == q->GetRightChild()))
return NULL;
else
return q->GetRightChild();
}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::LeftSibling(BinaryTreeNode<T> *p)
{
BinaryTreeNode<T> *q;
q = Parent(m_root, p);
if ((NULL == q) || (p == q->GetLeftChild()))
return NULL;
else
return q->GetLeftChild();
}
template<class T>
void BinaryTree<T>::InsertLeftChild(BinaryTreeNode<T> *p, const T &d) const
{
BinaryTreeNode<T> *q = new BinaryTreeNode<T>(d);
q->SetLeftChild(p->GetLeftChild());
p->SetLeftChild(q);
}
template<class T>
void BinaryTree<T>::InsertRightChild(BinaryTreeNode<T> *p, const T &d) const
{
BinaryTreeNode<T> *q = new BinaryTreeNode<T>(d);
q->SetRightChild(p->GetRightChild());
p->SetRightChild(q);
}
template<class T>
void BinaryTree<T>::Destroy(BinaryTreeNode<T> *p)
{
if (NULL != p)
{
Destroy(p->GetLeftChild());
Destroy(p->GetRightChild());
delete p;
}
}
template<class T> BinaryTreeNode<T>*
BinaryTree<T>::Parent(BinaryTreeNode<T> *root, BinaryTreeNode<T> *p)
{
BinaryTreeNode<T> *q;
if (NULL == root)
return NULL;
if ((p == root->GetLeftChild()) || (p == root->GetRightChild()))
return root;
if (NULL != (q = Parent(root->GetLeftChild(), p)))
return q;
else
return Parent(root->GetRightChild(), p);
}
template<class T>
void BinaryTree<T>::LevelOrderTraverse(BinaryTreeNode<T> *root) const
{
queue<BinaryTreeNode<T> *> q;
if (NULL != root)
q.push(root);
while (!q.empty())
{
root = q.front(), q.pop();
cout << root->GetData();
if (root->GetLeftChild())
q.push(root->GetLeftChild());
if (root->GetRightChild())
q.push(root->GetRightChild());
}
}
P195 이 진 트 리 의 테스트 코드
main.cpp
#include"BinaryTreeNode.h"
#include"BinaryTree.h"
#include"iostream"
using namespace std;
int main()
{
BinaryTree<char> myBinTree('a');
myBinTree.InsertLeftChild(myBinTree.GetRoot(), 'D');
myBinTree.InsertRightChild(myBinTree.GetRoot(), 'G');
myBinTree.InsertLeftChild(myBinTree.GetRoot(), 'B');
myBinTree.InsertRightChild(myBinTree.GetRoot()->GetLeftChild(), 'E');
myBinTree.InsertRightChild(myBinTree.GetRoot(), 'C');
myBinTree.InsertLeftChild(myBinTree.GetRoot()->GetRightChild(), 'F');
cout << " ? : " << myBinTree.IsEmpty() << endl;
cout << " : "
<< myBinTree.Retrieve(myBinTree.GetRoot());
cout << endl << " A!";
myBinTree.Assign(myBinTree.GetRoot(), 'A');
cout << " : "
<< myBinTree.Retrieve(myBinTree.GetRoot()) << endl;
cout << " : " << endl;
myBinTree.LevelOrderTraverse(myBinTree.GetRoot());
cout << endl;
return 0;
}
P198-1 재 귀적 으로 실 현 된 PreOrder Traverse () 함수
template<class T>
void BinaryTree<T>::PreOrderTraverse(BinaryTreeNode<T> *root) const
{
if (NULL != root)
{
cout << root->GetData();
PreOrderTraverse(root->GetLeftChild());
PreOrderTraverse(root->GetRightChild());
}
}P198-2 스 택 (비 재 귀적) 기반 PreOrderTraverse () 함수
template<class T>
void BinaryTree<T>::PreOrderTraverse(BinaryTreeNode<T> *root) const
{
stack<BinaryTreeNode<T>*> s;
BinaryTreeNode<T> *p=root;
while(!s.empty()||p!=NULL)
{
while(p)
{
s.push(p);
cout<<p->GetData();
p=p->GetLeftChild();
}
p=s.top();
s.pop();
p=p->GetRightChild();
}
}
P199-1 재 귀적 으로 실 현 된 InOrderTraverse () 함수
template<class T>
void BinaryTree<T>::InOrderTraverse(BinaryTreeNode<T> *root) const
{
if (NULL != root)
{
InOrderTraverse(root->GetLeftChild());
cout << root->GetData();
InOrderTraverse(root->GetRightChild());
}
}P199 - 2 스 택 (비 재 귀적) 기반 InOrderTraverse () 함수
template<class T>
void BinaryTree<T>::InOrderTraverse(BinaryTreeNode<T> *root) const
{
stack<BinaryTreeNode<T>*> s;
BinaryTreeNode<T> *p=root;
while(!s.empty()||p!=NULL)
{
while(p)
{
s.push(p);
p=p->GetLeftChild();
}
p=s.top();
s.pop();
cout<<p->GetData();
p=p->GetRightChild();
}
}
P200 재 귀적 으로 실 현 된 PostOrder Traverse () 함수
template<class T>
void BinaryTree<T>::PostOrderTraverse(BinaryTreeNode<T> *root) const
{
if (NULL != root)
{
PostOrderTraverse(root->GetLeftChild());
PostOrderTraverse(root->GetRightChild());
cout << root->GetData();
}
}
P206 나무의 노드 클래스 중 일부 주요 구성원 함수 의 실현
template<class T>
TreeNode<T>::TreeNode(const T& value)
{
m_value=value;
leftChild=rightSibling=NULL;
}
template<class T>
bool TreeNode<T>::isLeaf()
{
if(NULL==leftChild)
return true;
else return false;
}
template<class T>
T TreeNode<T>::getValue()
{
return m_value;
}
template<class T>
void TreeNode<T>::setValue(T & value)
{
m_value = value;
}
template<class T>
TreeNode<T>* TreeNode<T>::getLeftChild()
{
return leftChild;
}
template<class T>
TreeNode<T>* TreeNode<T>::getRightSibling()
{
return rightSibling;
}
template<class T>
void TreeNode<T>::setLeftChild(TreeNode<T>* pLeftChild)
{
leftChild = pLeftChild;
}
template<class T>
void TreeNode<T>::setRightSibling(TreeNode<T>* pRightSibling)
{
rightSibling = pRightSibling;
}
P207 트 리 중 일부 주요 구성원 함수 의 실현
template<class T>
Tree<T>::Tree()
{
root = NULL;
parent = NULL;
}
template<class T>
Tree<T>::Tree(TreeNode<T>* rt)
{
root = rt;
parent = NULL;
}
template<class T>
TreeNode<T> * Tree<T>::getRoot()
{
return root;
}
template<class T>
bool Tree<T>::isEmpty()
{
if(root == NULL)
return true;
else
return false;
}
template<class T>
int Tree<T>::getParent(TreeNode<T>* t,TreeNode<T>* p)
{
TreeNode<T>* q = t->getLeftChild();
while(q!=NULL && q!=p)
{
if( getParent(q, p) != 0 )
return 2;
q = q->getRightSibling();
}
if(q!=NULL && q==p)
{
parent = t;
return 1;
}
else return 0;
}
template<class T>
TreeNode<T> * Tree<T>::Parent(TreeNode<T>* current)
{
TreeNode<T>* pointer=current, *t;
if(current==NULL||current==root)
{
current = NULL;
return 0;
}
t = root;
getParent(t, pointer);
return parent;
}
template<class T>
TreeNode<T> * Tree<T>::getFirstChild(TreeNode<T> * t)
{
return t->getLeftChild();
}
template<class T>
TreeNode<T> * Tree<T>::getNextSibling(TreeNode<T> * t)
{
return t->getRightSibling();
}
template<class T>
void Tree<T>::insertChild(TreeNode<T> * t, TreeNode<T> * n)
{
if(t->getLeftChild()==NULL)
t->setLeftChild(n);
else
{
TreeNode<T> * p=t->getLeftChild();
while(p->getRightSibling()!=NULL)
p=p->getRightSibling();
p->setRightSibling(n);
}
}
P218 하프 만 코드
#include "stdafx.h"
#include <iostream>
#include <string>
#include <queue>
#include <map>
#include <iterator>
#include <algorithm>
using namespace std;
typedef vector<bool> HuffCode;
typedef map<char, HuffCode> HuffCodeMap;
class INode
{
public:
const int f;
virtual ~INode() {}
protected:
INode(int f) : f(f) {}
};
class InternalNode : public INode
{
public:
INode *const left;
INode *const right;
InternalNode(INode* c0, INode* c1) : INode(c0->f + c1->f), left(c0),
right(c1) {}
~InternalNode()
{
delete left;
delete right;
}
};
class LeafNode : public INode
{
public:
const char c;
LeafNode(int f, char c) : INode(f), c(c) {}
};
struct NodeCmp
{
bool operator()(const INode* lhs, const INode* rhs) const { return
lhs->f > rhs->f; }
};
INode* BuildTree(map<char, int> frequs)
{
priority_queue<INode*, vector<INode*>, NodeCmp> trees;
map<char, int>::iterator it = frequs.begin();
for ( ; it != frequs.end(); it++)
{
trees.push(new LeafNode(it->second, it->first));
}
while (trees.size() > 1)
{
INode* childR = trees.top();
trees.pop();
INode* childL = trees.top();
trees.pop();
INode* parent = new InternalNode(childR, childL);
trees.push(parent);
}
return trees.top();
}
void GenerateCodes(const INode* node, const HuffCode& prefix, HuffCodeMap&
outCodes)
{
if (const LeafNode* lf = dynamic_cast<const LeafNode*>(node))
{
outCodes[lf->c] = prefix;
}
else if (const InternalNode* in = dynamic_cast<const InternalNode*>
(node))
{
HuffCode leftPrefix = prefix;
leftPrefix.push_back(false);
GenerateCodes(in->left, leftPrefix, outCodes);
HuffCode rightPrefix = prefix;
rightPrefix.push_back(true);
GenerateCodes(in->right, rightPrefix, outCodes);
}
}
int _tmain(int argc, _TCHAR* argv[])
{
//
map<char, int> frequs;
cout<<" :"<<endl;
string str;
getline(cin, str);
const char* ptr = str.c_str();
while (*ptr != '\0')
{
if(frequs.find(*ptr)!=frequs.end())
frequs[*ptr]=frequs[*ptr]+1;
else
frequs[*ptr]=1;
*ptr++;
}
INode* root = BuildTree(frequs);
HuffCodeMap codes;
GenerateCodes(root, HuffCode(), codes);
delete root;
for (HuffCodeMap::const_iterator it = codes.begin(); it != codes.end(); ++it)
{
cout << it->first << " ";
copy(it->second.begin(), it->second.end(),ostream_iterator<bool>(cout));
cout << endl;
}
system("PAUSE");
return 0;
}P224 STL 의 vector 사용 예시
#include <string>
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v1(10);
vector<double> v2;
vector<string> v3(10, "OK!");
vector<string> v4(v3);
v1[1] = 2;
v1.at(2) = 45;
for(int i = 0; i < 9; i++)
{
v2.push_back(1.0+i);
}
v2.pop_back();
cout<<v2.back()<<endl;
cout<<v2.front()<<endl;
cout<<v2.at(5)<<endl;
cout<<v1[2]<<endl;
for(i = 0; i < 10; i++)
cout<<v3[i]<<" ";
cout<<endl;
for(i = 0; i < 10; i++)
cout<<v4[i]<<" ";
cout<<endl;
return 0;
}
P226 vector 기반 트 리 구조
#include<vector>
#include<iostream>
using namespace std;
class TreeNode
{
int num;
vector<TreeNode*> * Sub;
public:
TreeNode::TreeNode(int n)
{
num = n; Sub = NULL;
}
int getNum(){return num;}
vector<TreeNode*> * getSub(){return Sub;}
void setNum(int n)
{
this->num = n;
}
void setSub(vector<TreeNode*> * newSub)
{
this->Sub = newSub;
}
//
};
class Tree
{
TreeNode* root;
public:
Tree(TreeNode* rt){root = rt;}
void DisplayTree(TreeNode * r)
{
cout<<r->getNum()<<endl;
if(r->getSub()==NULL)
{
cout<<" !"<<endl;
return;
}
cout<<" :";
for(int i = 0; i < (r->getSub())->size(); i++)
{
cout<<(r->getSub())->at(i)->getNum()<<" ";
}
cout<<endl;
for(i = 0; i < (r->getSub())->size(); i++)
{
DisplayTree((r->getSub())->at(i));
}
}
//
};
int main()
{
TreeNode treenode0(0);
TreeNode treenode1(1);
TreeNode treenode2(2);
TreeNode treenode3(3);
TreeNode treenode4(4);
TreeNode treenode5(5);
TreeNode treenode6(6);
vector<TreeNode*> subOfTreeNode0, subOfTreeNode1, subOfTreeNode2;
subOfTreeNode0.push_back(&treenode1);
subOfTreeNode0.push_back(&treenode2);
subOfTreeNode1.push_back(&treenode3);
subOfTreeNode2.push_back(&treenode4);
subOfTreeNode2.push_back(&treenode5);
subOfTreeNode2.push_back(&treenode6);
treenode0.setSub(&subOfTreeNode0);
treenode1.setSub(&subOfTreeNode1);
treenode2.setSub(&subOfTreeNode2);
Tree tree(&treenode0);
tree.DisplayTree(&treenode0);
return 0;
}
P228 STL 의 map 사용 예시
#include<map>
#include<string>
#include<iostream>
using namespace std;
int main()
{
map<string, string> writer;
writer["Shakespeare"] = "English writer,
his works include 'Hamlet', 'Othello', and 'King Lear', etc.";
writer["Tagore"] = "India writer,
his works include 'Gitanjali', etc.";
writer["Tolstoy"] = "Russian writer,
his works include 'War and Peace', and 'Anna Karenina', etc.";
writer["Andersen"] = "Danish writer,
his works include 'The Ugly Duckling', etc.";
writer["Dumas"] = "French writer,
his works include 'The Count of Monte Cristo', and 'The Three Musketeers', etc.";
cout<<writer.size()<<endl<<endl;
int i = 1;
map<string, string>::iterator it = writer.begin();
for ( ; it != writer.end(); it++)
{
cout << i << " : " <<endl;
cout << it->first << ": " << it->second << endl;
i++;
}
cout<<endl;
cout<<(writer.find("Tagore"))->second<<endl<<endl;
writer.erase(writer.find("Tagore"));
cout<<writer.size()<<endl<<endl;
writer.clear();
cout<<writer.size()<<endl;
return 0;
}
내용 소개: 비밀 알고리즘 세 계 를 탐색 하고 데이터 구조의 길 을 모색 한다.전형 적 인 문 제 를 모 아 프로 그래 밍 기법 의 취 미 를 즐 깁 니 다.구직 핫 이 슈 를 지적 하여 개업 계 의 유명 기업 의 문 을 두드리다.이 책 은 알고리즘 과 데이터 구조 라 는 화 제 를 중심 으로 현대 컴퓨터 기술 에서 자주 사용 하 는 40 여 개의 전형 적 인 알고리즘 과 역 추적 법, 분 치 법, 탐욕 법 과 동적 계획 등 알고리즘 디자인 사상 을 점차적으로 소개 했다.이 과정 에서 이 책 은 링크 (단 방향 링크, 단 방향 순환 링크 와 양 방향 순환 링크 포함), 스 택, 대기 열 (일반 대기 열 과 우선 순위 대기 열 포함), 트 리 (이 진 트 리, 하프 만 트 리, 더미, 레 드 블랙 트 리, AVL 트 리 와 사전 트 리 포함), 그림, 집합 (교차 하지 않 음 포함) 과 사전 등 상용 데이터 구 조 를 체계적으로 설명 했다.이 동시에 22 개의 전형 적 인 문제 (조세 프 링 문제, 한 노 타 문제, 8 황후 문제 와 기사 여행 문제 등 포함) 에 대한 설명 을 통 해 데이터 구조 뒤에 숨겨 진 알고리즘 원 리 를 점차적으로 밝 히 고 독자 들 이 지식 비축 을 다 지 는 데 도움 을 주 며 사고 기술 을 활성화 시 키 고 최종 적 으로 프로 그래 밍 능력 의 향상 을 방해 하 는 복잡 한 울 타 리 를 돌파 하려 고 한다.완전한 C + + 소스 코드 를 추가 하고 STL 의 각종 용 기 를 삽입 하여 소개 합 니 다.
인터넷 서점:
중국 - pub 중국 상호작용 출판 망:http://product.china-pub.com/4911922
당당 망:http://product.dangdang.com/23851244.html
아마 존:http://www.amazon.cn/%E7%AE%97%E6%B3%95%E4%B9%8B%E7%BE%8E-%E9%9A%90%E5%8C%BF%E5%9C%A8%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E8%83%8C%E5%90%8E%E7%9A%84%E5%8E%9F%E7%90%86-%E5%B7%A6%E9%A3%9E/dp/B01AGNUIE8/ref=sr_1_8?ie=UTF8&qid=1453527399&sr=8-8&keywords=%E5%B7%A6%E9%A3%9E
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
정수 반전Udemy 에서 공부 한 것을 중얼거린다 Chapter3【Integer Reversal】 (예) 문자열로 숫자를 반전 (toString, split, reverse, join) 인수의 수치 (n)가 0보다 위 또는 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
