Problem:
Score : 1000 points

Problem Statement

For an n \times n grid, let (r, c) denote the square at the (r+1)-th row from the top and the (c+1)-th column from the left.
A good coloring of this grid using K colors is a coloring that satisfies the following:

Each square is painted in one of the K colors.

Each of the K colors is used for some squares.

Let us number the K colors 1, 2, ..., K. For any colors i and j (1 \leq i \leq K, 1 \leq j \leq K), every square in Color i has the same number of adjacent squares in Color j. Here, the squares adjacent to square (r, c) are ((r-1)\; mod\; n, c), ((r+1)\; mod\; n, c), (r, (c-1)\; mod\; n) and (r, (c+1)\; mod\; n) (if the same square appears multiple times among these four, the square is counted that number of times).

Given K, choose n between 1 and 500 (inclusive) freely and construct a good coloring of an n \times n grid using K colors.
It can be proved that this is always possible under the constraints of this problem,

Constraints

1 \leq K \leq 1000

Input

Input is given from Standard Input in the following format:

K

Output

Output should be in the following format:

n
c_{0,0} c_{0,1} ... c_{0,n-1}
c_{1,0} c_{1,1} ... c_{1,n-1}
:
c_{n-1,0} c_{n-1,1} ... c_{n-1,n-1}

n should represent the size of the grid, and 1 \leq n \leq 500 must hold.
c_{r,c} should be an integer such that 1 \leq c_{r,c} \leq K and represent the color for the square (r, c).

Sample Input 1

2

Sample Output 1

3
1 1 1
1 1 1
2 2 2

Every square in Color 1 has three adjacent squares in Color 1 and one adjacent square in Color 2.

Every square in Color 2 has two adjacent squares in Color 1 and two adjacent squares in Color 2.

Output such as the following will be judged incorrect:

2
1 2
2 2

3
1 1 1
1 1 1
1 1 1

Sample Input 2

9

Sample Output 2

3
1 2 3
4 5 6
7 8 9

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

#![allow(unused_imports)]
use std::io::*;
use std::fmt::*;
use std::str::*;
use std::cmp::*;
use std::collections::*;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn print_answer(table: Vec<Vec<usize>>) {
  let n = table.len();
  let mut num_map = vec![-1; 4*n+10];
  let mut num_index = 1;

  println!("{}", n);
  for i in 0..n {
      for j in 0..n {
          if j >= 1 {
              print!(" ");
          }
          if num_map[table[i][j]] == -1 {
            num_map[table[i][j]] = num_index;
            num_index += 1;
          }
          print!("{}", num_map[table[i][j]]);
      }
      println!("");
  }
}

fn main() {
  input! {
    w: usize
  };

  if w <= 8 {
    let mut ans = vec![vec![0; w]; w];
    for i in 0..w {
      for j in 0..w {
        ans[i][j] = j;
      }
    }
    print_answer(ans);
    return
  }

  let n = (w+1) / 2;
  let n = if n % 2 == 1 { n + 1 } else { n };
  let mut ans = vec![vec![0; n]; n];
  for i in 0..n {
    for j in 0..n {
      let offset = (i/2)*2;
      ans[i][j] = (i%2)*n+(offset+j)%n;
      if w < 2*n && ans[i][j] == n*2-1 {
        ans[i][j] = ans[i-1][(j+1)%n]; 
      }
      if w < 2*n-1 && ans[i][j] == n*2-3 {
        ans[i][j] = ans[i-1][(j+1)%n];
      }
      if w < 2*n-2 && ans[i][j] == n*2-5 {
        ans[i][j] = ans[i-1][(j+1)%n];
      }
    }
  }

  print_answer(ans);
}