For this Question: Newton has shifted to a new house and it came to his notice that there is only one socket in his house !!!
Newton does a lot of experiments using electricity and wants at least B sockets in his house.
Furthermore, he has an ample amount of extension cords and each extension has A sockets and takes one socket. In others words, an extension cord extends one socket into A sockets. You need to tell Newton how many extension cords will be required so that he can have at least B sockets.The first and the only line of the input contains 2 single integers A and B

<b>Constraints:</b>
1) 2 &le; A &le; 200
2) 1 &le; B &le; 200Print the answerSample Input 1:
4 10

Sample Output 1:
3

Sample Input 2:
8 9

Sample Output 2:
2

<b>Explanation 1:</b>
3 power strips, each with 4 sockets, extend the socket into 10 empty sockets.

, I have written this Solution Code: ///#include<bits/stdc++.h>
#include<iostream>
using namespace std;
#include<cmath>
#include<cstdio>
#include<cctype>
#include<vector>
#include<bitset>
#include<map>
#include<set>
#include<algorithm>
#include<cstdio>
#define pi          acos(-1.0)
#define nl       "\n"
/*data type ------------------------------------*/
#define ulli        unsigned long long int
#define lli         long long int
#define ld          long double
/*---------------------------------------------*/

/*container -----------------------------------*/
#define vint        vector<int>
#define vll         vector<long long>
#define vlli        vector<long long int>
#define vchar       vector<char>
/*---------------------------------------------*/
/*container input and output-------------------*/
#define inv(v)      for(auto& i:v) cin>>i
#define outv(v)     for(auto& i:v) cout<<i<<" "
/*---------------------------------------------*/

/*container function --------------------------*/
#define sum(a)      ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)     (*min_element((a).begin(), (a).end()))
#define maxe(a)     (*max_element((a).begin(), (a).end()))
#define mini(a)     ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)     ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x)  ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x)  ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define Sort(a)     ( sort((a).begin(), (a).end()))
#define Sort_d(a)   ( sort(a.begin(), a.end(), greater<int>()))
/*---------------------------------------------*/
#define precision(n) fixed<<setprecision(n)
#define fast ios_base::sync_with_stdio(0);cin.tie(0); cout.tie(0);

/*my function ------------------------------------*/
#define max2(x,y)   ((x>y)?x:y)
#define min2(x,y)   ((x<y)?x:y)
#define lcm(x,y)    ((x*y)/(__gcd(x,y)))
#define mod 1000000007
/*bit manipulation---------------------------------*/
#define twopower(n) (1<<n)
#define MAX         INT_MAX
#define MIN         INT_MIN
#define ishigh(num, position)   ((num&(1<<position))>0? 1:0)
#define ll_count_high(num)         (__builtin_popcountll(num))
#define int_count_high(num)         (__builtin_popcount(num))
#define toupper(char)   (char & '_')
//cout<<(char)toupper('a')<<nl; out:A
#define tolower(char)   (char | ' ')
//cout<<(char)tolower('B')<<nl; out:b
/*-------------------------------------------------*/

/*string convert_int_to_string(int number)
{
    stringstream convert;
    convert<<number;
    string s = convert.str();
    return s;
}*/


//find big factorial using python-3
/*
#User function Template for python3
import math
class Solution:
    def factorial(self, N):
        x = math.factorial(N)
        list = []
        s = str(x)
        for j in s:
            list.append(int(j))
        return list


#{
 # Driver Code Starts
#Initial Template for Python 3

if __name__ == '__main__':
    t=int(input())
    for _ in range(t):
        N = int(input())
        ob = Solution()
        ans = ob.factorial(N);
        for i in ans:
            print(i,end="")
        print()

*/


/*vector<lli>All_perfect_square(lli range)
{
    vector<lli>perfect_square;
    for(lli x = 0; x*x<=range; x++)
    {
        perfect_square.push_back(x*x);
    }
    return perfect_square;
}*/

/*lli find_near_perfect_square(vector<lli>&vect, lli number)
{
    //use binary search
    lli ans = -1;
    lli left = 0, right = vect.size()-1, mid = (left+right)/2;
    while(left<=right)
    {
        if(vect[mid]>=number){ans = vect[mid];right = mid-1; mid = (left+right)/2;}
        else {left = mid+1;mid = (left+right)/2;}
    }
    return ans;
}*/

//sieve algorithm
/*vector<int>all_prime;
long long int index_array[5000] = {0};
void seive(int N)
{
    index_array[0] = 1;
    index_array[1] = 1;
    all_prime.push_back(2);
    for(long long int i = 3; i<=N; i+=2)
    {
        if(index_array[i]==0)
        {
            all_prime.push_back(i);
            for(long long int j = i*i; j<=N; j+=i*2)
            {
                index_array[j] = 1;
            }
        }
    }
}
*/
//find x power y using bit manipulation. complexity O(log N)
/*int bitwise_pow(int a, int n)
{
    int ans = 1;// Stores final answer
    while (n > 0) {
        bool last_bit = (n & 1);
        // Check if current LSB is set
        if (last_bit){ans = ans * a;}
        a = a * a;
        n = n >> 1;// Right shift
    }
    return ans;
}
*/
/*bool isPrime(int n)
{
    if (n <= 1)
        return false;

    // Check from 2 to square root of n
    for (int i = 2; i <= sqrt(n); i++)
        if (n % i == 0)
            return false;

    return true;
}
lli N = 100000;

*/

/*vint ar;
vint ar2;
int p = 1;
int check(int n)
{
    //cout<<n<<endl;
    int sz = ar.size(), sz2 = ar2.size(), no = 0;
    for(int i = p; i<n; i*=n)
    {
        cout<<"i = "<<i<<nl;
        no = 0;
        for(int j = 0; j<sz; j++)
        {
            if(ar[j]%i==0){no = 1;break;}
        }
        if(n%i==0&&no==0)return i;
    }
    return 0;
}

void solve_the_problem()
{
    int n, cnt = 0, ans = 0, x;cin>>n;
    string s;cin>>s;

    for(int i = 1; i<=n; i++)
    {
        if(s[i-1]=='0')
        {
            x = check(i);
            //cout<<x<<nl;
            if(x==0)
            {
                ans+=i;
            }
            else ans+=x;
            cout<<ans<<nl;
        }
        else ar.push_back(i);
    }
    cout<<ans<<nl;
    ar.clear();
    p = 1;


//    cout<<"......"<<endl;
//    outv(ar);
//    cout<<nl;
}
*/


void solve_the_problem(int T)
{
    int a, b, cnt = 0;
    cin>>a>>b;
    int soket = 1;
    while(soket<b)
    {
        soket--;
        soket+=a;
        cnt++;
    }
    cout<<cnt<<nl;
}

int main()
{
        //int t; cin>>t;
        int t = 1;
        for(int i = 1; i<=t; i++) solve_the_problem(t);
}
, In this Programming Language: C++, Now tell me if this Code is compilable or not?