fork download
copy 
  1. #include <iostream>
  2. #include <algorithm>
  3. #include <cstring>
  4. using namespace std;
  5.  
  6. class CIntArray {
  7. private:
  8. 	int *m_Array;
  9. 	int m_Length;
  10.  
  11. public:
  12. 	CIntArray();
  13.     CIntArray(const CIntArray& temp);
  14.     CIntArray(int len);
  15.  
  16.     ~CIntArray();
  17.  
  18.     void InputArray();
  19.     void OutputArray();
  20.  
  21.     CIntArray Remove();
  22.     CIntArray Remove(int k);
  23.     CIntArray Remove(int n, int k);
  24.     CIntArray Replace(int oldVal, int newVal);
  25.  
  26.     CIntArray AddHead(int val);
  27.     CIntArray AddTail(int val);
  28.     CIntArray Insert(int val, int k);
  29.  
  30.     int Max();
  31.     int Min();
  32.  
  33.     CIntArray Ascending();
  34.     CIntArray Descending();
  35.     bool IsSymmetry();
  36.  
  37.     CIntArray MoveForward();
  38.     CIntArray MoveForward(int n);
  39.     CIntArray MoveBehind();
  40.     CIntArray MoveBehind(int n);
  41.  
  42.     CIntArray Invert();
  43.     int Appearance(int val);
  44. };
  45.  
  46. CIntArray::CIntArray() : m_Array(nullptr), m_Length(0) {}
  47.  
  48. CIntArray::CIntArray(int len) : m_Length(len) {
  49.     if(len < 0) {
  50.     	CIntArray();
  51.     	return;
  52.     }
  53.  
  54.     m_Array = new int[len];
  55.     for (int i = 0; i < m_Length; ++i) 
  56.         m_Array[i] = 0;
  57. }
  58.  
  59. CIntArray::CIntArray(const CIntArray& temp) : m_Length(temp.m_Length) {
  60. 	if(m_Length <= 0) {
  61. 		CIntArray();
  62. 		return;
  63. 	}
  64.  
  65.     m_Array = new int[m_Length];
  66.     for (int i = 0; i < m_Length; ++i) 
  67.         m_Array[i] = temp.m_Array[i];
  68. }
  69.  
  70. CIntArray::~CIntArray() {
  71.     delete[] m_Array;
  72.     m_Array = nullptr;
  73.     m_Length = 0;
  74. }
  75.  
  76. void CIntArray::InputArray() {
  77.     cin >> m_Length;
  78.     if (m_Length < 0) {
  79.     	m_Length = 0;
  80.     	delete[] m_Array;
  81.         m_Array = nullptr;
  82.         return;
  83.     }
  84.  
  85.     delete[] m_Array;
  86.     m_Array = new int[m_Length];
  87.     for (int i = 0; i < m_Length; ++i) {
  88.         cin >> m_Array[i];
  89.     }
  90. }
  91.  
  92. void CIntArray::OutputArray() {
  93.     if (m_Length == 0) {
  94.         cout << "Mang rong." << '\n';
  95.         return;
  96.     }
  97.  
  98.     for (int i = 0; i < m_Length; ++i) {
  99.         cout << m_Array[i] << " ";
  100.     }
  101.     cout << '\n';
  102. }
  103.  
  104. CIntArray CIntArray::Remove() {
  105.     if (m_Length == 0) {
  106.         return *this;
  107.     }
  108.  
  109.     int cnt = 0;
  110.     for(int i = 0; i < m_Length; ++i) {
  111.     	bool isUnique = true;
  112.     	for(int j = 0; j < i; ++j)
  113.     		if(m_Array[i] == m_Array[j]) {
  114.     			isUnique = false;
  115.     			break;
  116.     		}
  117.     	cnt += isUnique;
  118.     }
  119.  
  120.     CIntArray result(cnt);
  121.     cnt = 0;
  122.  
  123.     for(int i = 0; i < m_Length; ++i) {
  124.     	bool isUnique = true;
  125.     	for(int j = 0; j < i; ++j)
  126.     		if(m_Array[i] == m_Array[j]) {
  127.     			isUnique = false;
  128.     			break;
  129.     		}
  130.  
  131.     	if(isUnique) {
  132.     		result.m_Array[cnt++] = m_Array[i];
  133.     	}
  134.     }
  135.  
  136.     return result;
  137. }
  138.  
  139. CIntArray CIntArray::Remove(int k) {
  140. 	if(k < 0 || k >= m_Length || m_Length == 0)
  141. 		return *this;
  142.  
  143. 	CIntArray result(m_Length - 1);
  144.     for (int i = 0, j = 0; i < m_Length; ++i) {
  145.         if (i != k) {
  146.             result.m_Array[j++] = m_Array[i];
  147.         }
  148.     }
  149.     return result;
  150. }
  151.  
  152. CIntArray CIntArray::Remove(int n, int k) {
  153. 	if(k < 0 || k >= m_Length || m_Length == 0)
  154. 		return *this;
  155.  
  156. 	if(k + n > m_Length) {
  157. 		n = m_Length - k;
  158. 	}
  159.  
  160. 	CIntArray result(m_Length - n);
  161.     for (int i = 0, j = 0; i < m_Length; ++i) {
  162.         if (i < k || i >= k + n) {
  163.             result.m_Array[j++] = m_Array[i];
  164.         }
  165.     }
  166.     return result;
  167. }
  168.  
  169. CIntArray CIntArray::Replace(int oldVal, int newVal) {
  170. 	CIntArray result(*this);
  171.     for (int i = 0; i < result.m_Length; ++i) {
  172.         if (result.m_Array[i] == oldVal) {
  173.             result.m_Array[i] = newVal;
  174.         }
  175.     }
  176.     return result;
  177. }
  178.  
  179. CIntArray CIntArray::AddHead(int val) {
  180. 	CIntArray result(m_Length + 1);
  181.     result.m_Array[0] = val;
  182.     for (int i = 0; i < m_Length; ++i) {
  183.         result.m_Array[i + 1] = m_Array[i];
  184.     }
  185.     return result;
  186. }
  187.  
  188. CIntArray CIntArray::AddTail(int val) {
  189. 	CIntArray result(m_Length + 1);
  190. 	for (int i = 0; i < m_Length; ++i) {
  191.         result.m_Array[i] = m_Array[i];
  192.     }
  193.     result.m_Array[m_Length] = val;
  194.     return result;
  195. }
  196.  
  197. CIntArray CIntArray::Insert(int val, int k) {
  198. 	if (k < 0) {
  199. 		return AddHead(val);
  200. 	}
  201.  
  202. 	if (k >= m_Length) {
  203.         return AddTail(val);
  204.     }
  205.  
  206.     CIntArray result(m_Length + 1);
  207.     for (int i = 0, j = 0; i <= m_Length; ++i) {
  208.         if (i == k) {
  209.             result.m_Array[i] = val;
  210.         } else {
  211.             result.m_Array[i] = m_Array[j++];
  212.         }
  213.     }
  214.     return result;
  215. }
  216.  
  217. int CIntArray::Max() {
  218. 	int res = m_Array[0];
  219. 	for(int i = 1; i < m_Length; ++i)
  220. 		res = max(res, m_Array[i]);
  221. 	return res;
  222. }
  223.  
  224. int CIntArray::Min() {
  225. 	int res = m_Array[0];
  226. 	for(int i = 1; i < m_Length; ++i)
  227. 		res = min(res, m_Array[i]);
  228. 	return res;
  229. }
  230.  
  231. CIntArray CIntArray::Ascending() {
  232. 	CIntArray result(*this);
  233.     sort(result.m_Array, result.m_Array + result.m_Length);
  234.     return result;
  235. }
  236.  
  237. CIntArray CIntArray::Descending() {
  238. 	CIntArray result(*this);
  239.     sort(result.m_Array, result.m_Array + result.m_Length, greater<int>());
  240.     return result;
  241. }
  242.  
  243. bool CIntArray::IsSymmetry() {
  244. 	for(int i = 0; i < m_Length / 2; ++i)
  245. 		if(m_Array[i] != m_Array[m_Length - 1 - i])
  246. 			return false;
  247. 	return true;
  248. }
  249.  
  250. CIntArray CIntArray::MoveForward() {
  251. 	if(m_Length <= 0) 
  252. 		return *this;
  253.  
  254. 	CIntArray result(m_Length - 1);
  255.     for (int i = 0; i < result.m_Length; ++i) {
  256.         result.m_Array[i] = m_Array[i + 1];
  257.     }
  258.  
  259.     if(result.m_Length == 0) {
  260.     	m_Array = nullptr;
  261.     }
  262.  
  263.     return result;
  264. }
  265.  
  266. CIntArray CIntArray::MoveForward(int n) {
  267. 	if(n >= m_Length) {
  268. 		return CIntArray(0);
  269. 	}
  270.  
  271. 	CIntArray result(m_Length - n);
  272. 	for(int i = n, j = 0; i < m_Length; ++i) {
  273. 		result.m_Array[j++] = m_Array[i];
  274. 	}
  275.     return result;
  276. }
  277.  
  278. CIntArray CIntArray::MoveBehind() {
  279. 	CIntArray result(m_Length + 1);
  280.     for (int i = 0; i < m_Length; ++i) {
  281.         result.m_Array[i + 1] = m_Array[i];
  282.     }
  283.     return result;
  284. }
  285.  
  286. CIntArray CIntArray::MoveBehind(int n) {
  287. 	CIntArray result(m_Length + n);
  288. 	for(int i = n; i < result.m_Length; ++i) {
  289. 		result.m_Array[i] = m_Array[i - n];
  290. 	}
  291.     return result;
  292. }
  293.  
  294. CIntArray CIntArray::Invert() {
  295. 	CIntArray result(*this);
  296.     reverse(result.m_Array, result.m_Array + result.m_Length);
  297.     return result;
  298. }
  299.  
  300. int CIntArray::Appearance(int val) {
  301. 	int cnt = 0;
  302.     for (int i = 0; i < m_Length; ++i) {
  303.         if (m_Array[i] == val) {
  304.             cnt++;
  305.         }
  306.     }
  307.     return cnt;
  308. }
  309.  
  310. int32_t main() {
  311.  
  312. 	return 0;
  313. }
Success #stdin #stdout 0.01s 5288KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/MgoNIW
language:
C++14 (gcc 8.3)
created:
10 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!