Gain insights into competitive programming, explore C++ skills with theory, code samples, practice problems, and master faster implementation for contests like ACM ICPC, Google CodeJam, and HackerCup.

Competitive programming can be a great way to build out your programming skills, get on any major company’s radar, and earn a little extra cash along the way.

In this course, you will learn to prepare for competitive programming contests like ACM ICPC, Google CodeJam, Facebook HackerCup, and many more.

Each topic is broken down with a healthy mix of theory, code samples, step-by-step solved sample problems, illustrations, useful practice problems, and tips and tricks for faster implementation.

You will need some solid C++ foundations coming into this course, but by the end it, you will be confident enough in your C++ skills to take home the win.

Competitive Programming in C++: The Keys to Success

# Problem statement
Given a string, $S$, of length $$ consisting of lowercase characters, in one action, you have to change any character to any other character.

Find the minimum number of actions required so that the resulting string is a palindrome.

**Input format**

The single line of input contains the string $S$ of length $N(1 \leq N \leq 10^6)$.

**Output format**

Print a single integer, the minimum number of actions required.

---

# Sample

**Input**
```
madam
```
**Output**
```
0
```

**Input**
```
radecar
```

**Output**
```
1
```
---

# Explanation

Sample $1$: is already a palindrome, so $0$ action is needed.

Sample $2$: We can change `d` to `c` to get `racecar` using 1 action.

---

# Solution
For a palindrome, the first character is the same as the last character. Similarly, the second character is the same as the second to last character.

We can iterate using two pointers.
1. Starting at the first character moving to the right
2. Starting at the last character moving to the left
At each step
1. If the characters match, nothing needs to be done.
2. If the characters don’t match, we can make the characters the same using one action.


Since we are iterating over the string once, the time complexity is $O(N)$.

In this lesson, we'll discuss a problem to better understand palindromes.


Introduction

Complexity Analysis

Number Theory

Arrays and Vectors

Sieve of Eratosthenes

Strings

Sorting

Linked List

Stack

Queue

Binary Tree

2 Pointers

Heap

Binary Search Tree

Balanced Binary Search Tree

Course Conclusion

Solved Problem - Make String Palindrome

Problem statement