C++ Exercises: Concatenate three copies of each string in a given list of strings
C++ Basic Algorithm: Exercise-127 with Solution
Write a C++ program to create a new list from a given list of strings where each element is replaced by 3 copies of the string concatenated together.
Test Data:
Sample Input:
{ "1", "2", "3" , "4" }
Expected Output :
111 222 333 444
Sample Solution:
C++ Code :
#include <bits/stdc++.h>
#include <list>
using namespace std;
list<string> test(list<string> nums) {
list<string> new_list;
list<string>::iterator it;
for (it = nums.begin(); it != nums.end(); ++it)
{
new_list.push_back(*it + *it + *it);
}
return new_list;
}
display_list(list<string> g)
{
list<string>::iterator it;
for (it = g.begin(); it != g.end(); ++it)
cout << *it << ' ';
cout << '\n';
}
int main() {
list<string> text = { "1", "2", "3" , "4", "5", "6" };
cout << "Original list of elements:\n";
display_list(text);
list<string> result_list;
result_list = test(text);
cout << "\nNew list from the said list where each element is replaced\nby 3 copies of the string concatenated together:\n";
display_list(result_list);
return 0;
}
Sample Output:
Original list of elements: 1 2 3 4 5 6 New list from the said list where each element is replaced by 3 copies of the string concatenated together: 111 222 333 444 555 666
Flowchart:

C++ Code Editor:
Contribute your code and comments through Disqus.
Previous: From a list of strings, create a new list with "$" at the beginning and end.
Next: Create a list of integers, add each value to 3 and multiply the result by 4.
What is the difficulty level of this exercise?
C++ Programming: Tips of the Day
What is the usefulness of `enable_shared_from_this?
It enables you to get a valid shared_ptr instance to this, when all you have is this. Without it, you would have no way of getting a shared_ptr to this, unless you already had one as a member.
class Y: public enable_shared_from_this{ public: shared_ptr f() { return shared_from_this(); } } int main() { shared_ptr p(new Y); shared_ptr q = p->f(); assert(p == q); assert(!(p < q || q < p)); // p and q must share ownership }
The method f() returns a valid shared_ptr, even though it had no member instance. Note that you cannot simply do this:
class Y: public enable_shared_from_this{ public: shared_ptr f() { return shared_ptr (this); } }
The shared pointer that this returned will have a different reference count from the "proper" one, and one of them will end up losing and holding a dangling reference when the object is deleted.
Ref : https://bit.ly/3pwVzzz
- Weekly Trends
- Java Basic Programming Exercises
- SQL Subqueries
- Adventureworks Database Exercises
- C# Sharp Basic Exercises
- SQL COUNT() with distinct
- JavaScript String Exercises
- JavaScript HTML Form Validation
- Java Collection Exercises
- SQL COUNT() function
- SQL Inner Join
- JavaScript functions Exercises
- Python Tutorial
- Python Array Exercises
- SQL Cross Join
- C# Sharp Array Exercises