=begin

Task:

You have to write a function pattern which returns the following Patter
(See Examples) upto desired number of rows.

Note:Returning the pattern is not the same as Printing the pattern.
Parameters:

pattern(        n        ,        x        ,        y        );
                ^                 ^                 ^
                |                 |                 |
         Term upto which   Number of times   Number of times
          Basic Pattern     Basic Pattern     Basic Pattern
            should be         should be         should be
             created          repeated           repeated
                            horizontally        vertically
Note: Basic Pattern means what we created in Complete The Pattern #12
Rules/Note:

The pattern should be created using only unit digits.
If n < 1 then it should return "" i.e. empty string.
If x <= 1 then the basic pattern should not be repeated horizontally.
If y <= 1 then the basic pattern should not be repeated vertically.
The length of each line is same, and is equal to the length of longest line in
the pattern.
Range of Parameters (for the sake of CW Compiler) :
n ∈ (-∞,25]
x ∈ (-∞,10]
y ∈ (-∞,10]
If only two arguments are passed then the function pattern should run as
if y <= 1.
If only one argument is passed then the function pattern should run as
if x <= 1 & y <= 1.
The function pattern should work when extra arguments are passed, by ignoring
the extra arguments.
Examples:

Having Three Arguments-

pattern(4,3,2):

1     1     1     1
 2   2 2   2 2   2
  3 3   3 3   3 3
   4     4     4
  3 3   3 3   3 3
 2   2 2   2 2   2
1     1     1     1
 2   2 2   2 2   2
  3 3   3 3   3 3
   4     4     4
  3 3   3 3   3 3
 2   2 2   2 2   2
1     1     1     1
Having Two Arguments-

pattern(10,2):

1                 1                 1
 2               2 2               2
  3             3   3             3
   4           4     4           4
    5         5       5         5
     6       6         6       6
      7     7           7     7
       8   8             8   8
        9 9               9 9
         0                 0
        9 9               9 9
       8   8             8   8
      7     7           7     7
     6       6         6       6
    5         5       5         5
   4           4     4           4
  3             3   3             3
 2               2 2               2
1                 1                 1
Having Only One Argument-

pattern(25):

1                                               1
 2                                             2
  3                                           3
   4                                         4
    5                                       5
     6                                     6
      7                                   7
       8                                 8
        9                               9
         0                             0
          1                           1
           2                         2
            3                       3
             4                     4
              5                   5
               6                 6
                7               7
                 8             8
                  9           9
                   0         0
                    1       1
                     2     2
                      3   3
                       4 4
                        5
                       4 4
                      3   3
                     2     2
                    1       1
                   0         0
                  9           9
                 8             8
                7               7
               6                 6
              5                   5
             4                     4
            3                       3
           2                         2
          1                           1
         0                             0
        9                               9
       8                                 8
      7                                   7
     6                                     6
    5                                       5
   4                                         4
  3                                           3
 2                                             2
1                                               1


=end

# My Solution
def pattern(n,x2=0,y=1,*arr)
  return "" if n < 1
  y = 1 if y < 1
  x2 = 1 if x2 < 1
  result = []
  1.upto(y) do |go|
    go == 1 ? start = 1 : start = 2
    num = start
    (start).upto(n-1) do |x|
      result << (" " * (x-1)) + "#{num}" + (" " * ((n-x)*2-1)) + "#{num}" + (" " * (x-1))
      0.upto(x2-2) do |h|
        if x == 1
          result << (" " * ((n-x)*2-1)) + "#{num}"
        else
          result << (" " * (x-2)) + "#{num}" + (" " * ((n-x)*2-1)) + "#{num}" +  (" " * (x-1))
        end
      end
      result << "\n"
      num += 1
      num = 0 if num > 9
    end
    0.upto(x2-1) do |h|
      result << (" " * (n - 1)) + "#{num}" + (" " * ((n - 1)-1))
    end
    result << " \n"
    num -= 1
    num = 9 if num < 0
    mid = 1
    (n-1).downto(1) do |x|
      result << (" " * (x-1)) + "#{num}" + (" " * ((n-x)*2-1)) + "#{num}" + (" " * (x-1))
      0.upto(x2-2) do |h|
        if x == 1
          result << (" " * ((n-x)*2-1)) + "#{num}"
        else
          result << (" " * ((x-1)-1)) + "#{num}" + (" " * ((n-x)*2-1)) +  "#{num}" + (" " * (x-1))
        end
      end
      result << "\n"
      num -= 1
      num = 9 if num < 0
    end
  end
  result.join[0..-2]
end


# Better Solution
def pattern(n,x=1,y=1, *args)
    return "" if n < 1
    x = 1 if x < 1
    y = 1 if y < 1
    ary = (1..n).to_a + (1..(n-1)).to_a.reverse
    pat = ary.map { |i| ([ary[0]] + ary[1..-1]*x).map { |j| i == j ? i % 10 : ' ' }.join }
    ([pat[0]] + pat[1..-1]*y).join("\n")
end
