Problem:
Score : 100 points

Problem Statement

There is an N-car train.

You are given an integer i. Find the value of j such that the following statement is true: "the i-th car from the front of the train is the j-th car from the back."

Constraints

1 \leq N \leq 100

1 \leq i \leq N

Input

Input is given from Standard Input in the following format:

N i

Output

Print the answer.

Sample Input 1

4 2

Sample Output 1

3

The second car from the front of a 4-car train is the third car from the back.

Sample Input 2

1 1

Sample Output 2

1

Sample Input 3

15 11

Sample Output 3

5

Solution in Rust (1.15.1) (judge verdict: Accepted)

pub trait FromFragment: Sized {
    fn from_fragment(s: &str) -> Result<Self, String>;
}
impl FromFragment for String {
    fn from_fragment(s: &str) -> Result<String, String> {
        Ok(s.to_owned())
    }
}
#[allow(unused_macros)]
macro_rules ! impl_from_fragment { ( $ ( $ t : ty ) * ) => { $ ( impl FromFragment for $ t { fn from_fragment ( s : & str ) -> Result <$ t , String > { use std :: str :: FromStr ; <$ t >:: from_str ( s ) . map_err ( | _ | { format ! ( "cannot parse \"{}\" as {}" , s , stringify ! ( $ t ) ) } ) } } ) * } ; }
impl_from_fragment ! ( isize usize i8 u8 i16 u16 i32 u32 i64 u64 f64 ) ;
pub trait FromLine: Sized {
    fn from_line(line: &str) -> Result<Self, String>;
}
impl<T: FromFragment> FromLine for T {
    fn from_line(line: &str) -> Result<T, String> {
        T::from_fragment(line.trim_right_matches('\n'))
    }
}
#[doc = " Reads arbitrary number of `T`s."]
impl<T: FromFragment> FromLine for Vec<T> {
    fn from_line(line: &str) -> Result<Vec<T>, String> {
        let mut result = Vec::new();
        for fragment in line.trim_right_matches('\n').split_whitespace() {
            match T::from_fragment(fragment) {
                Ok(v) => result.push(v),
                Err(msg) => {
                    return Err(format!(
                        "fragment {} of line \"{}\": {}",
                        result.len() + 1,
                        line,
                        msg
                    ))
                }
            }
        }
        Ok(result)
    }
}
#[allow(unused_macros)]
macro_rules ! impl_from_line_for_tuples { ( $ t : ident $ var : ident $ count : expr ) => ( ) ; ( $ t : ident $ var : ident $ count : expr ; $ ( $ inner_t : ident $ inner_var : ident $ inner_count : expr ) ;* ) => { impl_from_line_for_tuples ! ( $ ( $ inner_t $ inner_var $ inner_count ) ;* ) ; impl <$ t : FromFragment , $ ( $ inner_t : FromFragment ) ,*> FromLine for ( $ t , $ ( $ inner_t ) ,* ) { # [ allow ( unused_assignments ) ] fn from_line ( line : & str ) -> Result < ( $ t , $ ( $ inner_t ) ,* ) , String > { let fragments : Vec <& str > = line . trim_right_matches ( '\n' ) . split_whitespace ( ) . collect ( ) ; if fragments . len ( ) != $ count { return Err ( format ! ( "line \"{}\" has {} fragments, expected {}" , line , fragments . len ( ) , $ count ) ) ; } let mut iter = fragments . iter ( ) ; let mut n = 1 ; let $ var = <$ t >:: from_fragment ( iter . next ( ) . unwrap ( ) ) . map_err ( | msg | { format ! ( "fragment {} of line \"{}\": {}" , n , line , msg ) } ) ?; n += 1 ; $ ( let $ inner_var = <$ inner_t >:: from_fragment ( iter . next ( ) . unwrap ( ) ) . map_err ( | msg | { format ! ( "fragment {} of line \"{}\": {}" , n , line , msg ) } ) ?; n += 1 ; ) * Ok ( ( $ var , $ ( $ inner_var ) ,* ) ) } } } }
impl_from_line_for_tuples ! ( T4 x4 4 ; T3 x3 3 ; T2 x2 2 ; T1 x1 1 ) ;
#[macro_export]
#[allow(unused_macros)]
macro_rules ! read { ( ) => { let mut line = String :: new ( ) ; std :: io :: stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; } ; ( $ pat : pat = $ t : ty ) => { let mut line = String :: new ( ) ; std :: io :: stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; let $ pat = <$ t >:: from_line ( & line ) . unwrap ( ) ; } ; ( $ ( $ pat : pat = $ t : ty ) ,+ ) => { read ! ( ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) ) ; } ; }
#[macro_export]
#[allow(unused_macros)]
macro_rules ! readls { ( $ ( $ pat : pat = $ t : ty ) ,+ ) => { $ ( read ! ( $ pat = $ t ) ; ) * } }
#[allow(unused_macros)]
macro_rules ! read_loop { ( $ pat : pat = $ t : ty ; $ block : block ) => { use std :: io :: BufRead ; let stdin = std :: io :: stdin ( ) ; for line in stdin . lock ( ) . lines ( ) { let line = line . expect ( "read from stdin failed" ) ; let $ pat = <$ t >:: from_line ( & line ) . unwrap ( ) ; $ block } } ; ( $ ( $ pat : pat = $ t : ty ) ,* ; $ block : block ) => { read_loop ! ( ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) ; $ block ) ; } }
#[allow(unused_macros)]
macro_rules ! readn_loop { ( $ n : expr ; $ pat : pat = $ t : ty ; $ block : block ) => { use std :: io :: BufRead ; let stdin = std :: io :: stdin ( ) ; { let lock = stdin . lock ( ) ; for _ in 0 ..$ n { let line = String :: new ( ) ; lock . read_line ( & mut line ) . expect ( "read from stdin failed" ) ; let $ pat = <$ t >:: from_line ( & line ) . unwrap ( ) ; $ block } } } ; ( $ n : expr ; $ ( $ pat : pat = $ t : ty ) ,* ; $ block : block ) => { read_times_loop ! ( $ n ; ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) ; $ block ) ; } }

fn main() {
    read!(n = u8, i = u8);
    println!("{}", n-i+1);
}