//    .------------------------------------------------------------.
//    |                     K U S A Y A R O U                      |
//    |                                                            |
//    |        ---|---|---      ___   ____       _\_   ___         |
//    |          _______       |_|_|     /      |___| |  /         |
//    |         |_______|      |_|_|    \       |___| | /          |
//    |         |_______|        |   _____      |     |  \         |
//    |        _____|_____     __|__   | /      |  \  | __\        |
//    |             |            |     |        | / \ |            |
//    |             |          __|__  \|        |/    |            |
//    |                                                            |
//    |------------------------------------------------------------|
//    |                      .------------.                        |
//    |                      | KerakTelor |                        |
//    |                      |------------|                        |
//    |                      | 2020-07-21 |                        |
//    |                      '------------'                        |
//    '------------------------------------------------------------'

#include <bits/stdc++.h>
#define DEBUG(...)

// #pragma GCC optimize("O2,unroll-loops")
// #pragma GCC target("tune=native")

#define fi first
#define se second

using namespace std;

using ll = long long;
using ld = long double;

template<class T>
using vec = vector<T>;
template<class T>
using v2d = vector<vector<T>>;
template<class T>
using prq = priority_queue<T>;
template<class T>
using rpq = priority_queue<T, vector<T>, greater<T>>;

int n;
v2d<ld> dp;

ld solve(int on)
{
    if(on == n)
    {
        return 0;
    }
    int off = n - on;
    return (ld) n / off * ((ld) off / n * solve(on + 1) + 1);
}

int main()
{
    scanf("%d", &n);
    printf("%.12Lf\n", solve(1));
}


#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
#define U 998244353
#define N 1000005
#define int long long
#define sz(c) (int)c.size()
#define fr first
#define ll long long 
#define sc second
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define rep(i,a,n) for(int i=a ; i<n ; i++)
#define r0 return 0;
#define endl '\n'
#define INF (int)1e15

/* Debug Begins */ 
# define trace(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); \
  stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
string to_string(char c) { return "'" + string(1, c) + "'";}
string to_string(string s) { return '"' + s + '"';}
string to_string(bool f) { if(f) return "True"; else return "False";}
string to_string(const char* s) { return to_string((string) s);}
template<typename A> string to_string(A);
template<typename A, typename B> string to_string(pair<A, B> p){
  return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";}
template<typename A> string to_string(A v) {bool f = false; string r = "{"; 
  for (auto x: v) {if (f) r += ", "; r += to_string(x); f = true;} return r += "}";}
template<typename A> string to_string(vector<vector<A>> v) {string r; 
  for (auto x: v) r += "\n" + to_string(x); return r;}
int Nerr;
template<typename A> string to_string(A *p) {return to_string(vector<A>(p, p + Nerr));}
void err(istream_iterator<string>) { cerr << endl; }
template<typename T,typename... Args> void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << to_string(a) << "; "; err(++it, args...); }
template<typename T> void kek(T ans) {cout << ans << endl; exit(0);}
#define Lu(...) [&] (auto &&u) { return __VA_ARGS__; }
#define Luv(...) [&] (auto &&u, auto &&v) { return __VA_ARGS__; }
/***************************************************************/

bool sortbysec(const pair<int,int> &a, 
              const pair<int,int> &b) 
{ 
    return (a.second < b.second); 
}

signed main()
{
    ios_base::sync_with_stdio(0);
    int TESTS=1;
    // cin>>TESTS;
    while(TESTS--)
    {   
        double ans = 0;
        int n;
        cin >> n;
        rep(i,1,n) ans += n*1.0/i;
        cout << fixed << setprecision(10) << ans << endl;
    }
}