The built-in number types in C++ can be divided into integers and floating points.
Integers are whole numbers like `0`

, `691`

, or `-2`

.
Floating point numbers are numbers with a decimal point like `6.02214076`

, `0.1`

, or `-1.616`

.

The following example shows the declaration and initialization of four different variables

```
int m_morales{9241}; // base 10: 0-9
int a_apaec{0x24CD}; // base 16: 0-9 and A-F
int m_gargan{0b10010000011001}; // base 2: 0-1
int b_reilly{022031}; // base 8: 0-7
// Leading with a 0 not the letter o.
```

When you assign a value to an `int`

variable, you can do so directly with a literal.
A literal is a hard-coded number like `9241`

.
There are different integer literals for several bases of the representation.
Decimal integer literals are the most common and use the digits `0`

to `9`

.
By adding a special prefix, like `0x`

, it is possible to use other bases.
The example above shows the number `9421`

in its four representations and prefixes.
All variables are initialized to the same value.

For more details on the different representation systems, take a look at a small tutorial.

You can use an apostrophe to separate digits for easier readability.
`9'241`

is the same as `0b0100'100'0001'1001`

or `92'4'1`

.

The floating-point literals come in two flavors.
In addition to the intuitive `0.0024`

it is possible to use its scientific notation `2.4e-3`

.
The most common floating-point type is `double`

.

C++ supports `+`

, `-`

, `*`

, `/`

, `(`

and `)`

and `%`

to form expressions.
The result from the operation between two integers is also an integer.
`5 / 2`

will return `2`

.
When one of the involved types is a floating-point type, the result will also be of a floating-point.
`5.0 / 2`

and `5 / 2.0`

will return `2.5`

.
`%`

is the remainder operator and will return the remainder of an integer division: `5%3`

is `2`

.

The assignment operator assigns a variable with a literal. Always takes place from right to left, and never the other way around.

```
int length = 5;
int width = 2;
length = width;
```

Here integer value `5`

is assigned to the variable `length`

.
Then integer value `2`

is assigned to variable `width`

.
Finally value of `width`

is copied to the variable `length`

and the earlier value `5`

will be lost.
Consider also that we are only assigning the value of `width`

to `length`

at the moment of the assignment operation.
Therefore, if the value of `width`

changes at a later moment, it will not affect the value taken by `length`

.

Assignment operator can be combined with the other operators(arithmetic & bitwise) known as `compound assignment`

operators `+=`

, `-=`

, `*=`

, `/=`

, `%=`

.
These operators modifies the current value of a variable by performing an operation on it.

```
// we start with 0 people
int people{};
// we need 0 eggs
int eggs{};
// two people joined:
people += 2;
// people is now 2
// let's add 3 eggs per person
eggs += 3 * people;
// eggs is now 6
```

Variables `people`

& `eggs`

are initialized to `0`

.
Then, we add integer value `2`

over the existing value `0`

of the variable `people`

and assign it back to `people`

.
`people`

becomes `2`

now.
Later, we add `3`

eggs for each person, which turns out to be `6`

eggs in total.
Now add this `6`

to existing value `0`

of the variable `eggs`

and assign it back to `eggs`

.
`eggs`

will be `6`

now.
The equivalent expression would be `people = people + 2`

and `eggs = eggs + (3 * people)`

.

In this exercise, you'll be writing code to help a freelancer communicate with a project manager. Your task is to provide a few utilities to quickly calculate daily and monthly rates, optionally with a given discount.

We first establish a few rules between the freelancer and the project manager:

- The daily rate is 8 times the hourly rate.
- A month has 22 billable days.

Sometimes, the freelancer is offering to apply a discount on their daily rate (for example for their most loyal customers or not-for-profit customers).

Discounts are modeled as fractional numbers representing percentages, for example, `25.0`

(25%).

Implement a function called `daily_rate`

to calculate the daily rate given an hourly rate as a parameter.
The contract defines that a day has 8 billable hours.

```
daily_rate(60)
// => 480.0
```

The returned daily rate should be of type `double`

.

Implement a function `apply_discount`

to calculates the price after a discount.
It should accept two parameters: the original price and the discount rate in percent.

```
apply_discount(150, 10)
// => 135.0
```

The returned value should always be of type `double`

, not rounded in any way.

Implement a `monthly_rate`

function to calculate the discounted monthly rate.
It should have two parameters, an hourly rate and the discount in percent.

```
monthly_rate(77, 10.5)
// => 12130
```

The returned monthly rate should be rounded up (take the ceiling) to the nearest integer.

Implement a function `days_in_budget`

that takes a budget, an hourly rate, and a discount, and calculates how many complete days of work that covers.

```
days_in_budget(20'000, 80, 11.0)
// => 35
```

The returned number of days should be rounded down (take the floor) to the next integer.

Sign up to Exercism to learn and master
C++
with
16 concepts,
94 exercises,
and real human mentoring,
**all for free.**