## Task:

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

* Note:`Returning` the pattern is not the same as `Printing` the pattern.

### Parameters:
    
    pattern(        n        ,        x        );
                    ^                 ^         
                    |                 |         
             Term upto which   Number of times  
              Basic Pattern     Basic Pattern   
                should be         should be     
                 created          repeated      
                                horizontally    
    
* Note: `Basic Pattern` means what we created in [Complete the pattern #12]("http://www.codewars.com/kata/558ac25e552b51dbc60000c3")
### 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.
* `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 ∈ (-∞,50]`
  + `x ∈ (-∞,25]`
* If only one argument is passed then the function `pattern` should run as if `x <= 1`.
* The function `pattern` should work when extra arguments are passed, by ignoring the extra arguments.
   
   
###Examples:

* Having Two Arguments-

 + pattern(4,3):

        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
       
  + 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
        
        
[List of all my katas]("http://www.codewars.com/users/curious_db97/authored")

Source: codewars | Difficulty: EASY
Tags: String algorithms

Fundamentals

Data structures

Starter code: def pattern(n, x=1, *args):
	

Solutions:
def pattern(n, *x):
	if n < 1:
		return ''
	x = x[0] if x and x[0] > 0 else 1
	result = []
	for i in range(1, n + 1):
		line = ' ' * (i - 1) + str(i % 10) + ' ' * (n - i)
		result.append(line + line[::-1][1:] + (line[1:] + line[::-1][1:]) * (x - 1))
	return '\n'.join(result + result[::-1][1:])


def pattern(n, x=1, *args):
	x = x if x > 1 else 1
	top = ['1' + ''.join((' ' * (2 * n - 3) + '1' for k in range(x)))] if n > 1 else []
	wing = [' ' + ''.join((' ' * (i - 2) + str(i % 10) + ' ' * (2 * (n - i) - 1) + str(i % 10) + ' ' * (i - 1) for k in range(x))) for i in range(2, n)]
	middle = [(str(n % 10) + ''.join([' ' * (2 * n - 3) + str(n % 10) for k in range(x - 1)])).center(2 * (n - 1) * x + 1)] if n > 1 else '1'
	return '\n'.join(top + wing + middle + wing[::-1] + top) if n > 0 else ''


pattern = lambda n, a=1, *ignored: '\n'.join([s + s[1:] * (a - 1) for s in (lambda u: u(list((u(' ' * (i - 1) + str(i % 10) + ' ' * (n - i)) for i in range(1, n + 1)))))(lambda x: x + x[-2::-1])])


pattern = lambda n, x=1, w=1, e=1, r=1, y=1, u=1: '\n'.join([(lambda r: ''.join(r) + ''.join([''.join(r[1:]) for j in range(1, x)]))([' '] * (i - 1) + [str(i % 10)] + [' '] * (2 * (n - i) - 1) + [str(i % 10)] + [' '] * (i - 1)) for i in range(1, n)] + [(lambda r: r + ''.join([r[1:] for j in range(1, x)]))(' ' * (n - 1) + str(n % 10) + ' ' * (n - 1))] + [(lambda r: ''.join(r) + ''.join([''.join(r[1:]) for j in range(1, x)]))([' '] * (i - 1) + [str(i % 10)] + [' '] * (2 * (n - i) - 1) + [str(i % 10)] + [' '] * (i - 1)) for i in range(n - 1, 0, -1)]) if n > 0 else ''


def pattern(n, x=1, *_):
	x = x if x > 1 else 1
	s1 = ''.join(('1' + ' ' * (2 * n - 3) for i in range(x))) + str(1) + '\n'
	s = '\n'.join(((' ' * i + str(i + 1)[-1] + ' ' * (2 * n - 2 * i - 3) + str(i + 1)[-1] + ' ' * (i - 1)) * x + ' ' for i in range(1, n - 1)))
	s1 = s1 if s == '' else s1 + s + '\n'
	s = s1 + (' ' * (n - 1) + str(n)[-1] + ' ' * (n - 2)) * x + ' '
	return '' if n < 1 else s + s1[::-1]


def pattern(n, x=1, *args):
	pat = [''.join([' ' * (i - 1), str(i % 10), ' ' * (n - i)]) for i in range(1, n + 1)]
	pat = [''.join([i, i[-2::-1]]) for i in pat]
	pat = [''.join([i, i[1:] * (x - 1)]) for i in pat]
	return '\n'.join(pat + pat[-2::-1])


(m, r) = (lambda s: s + s[-2::-1], lambda s, n: s + s[1:] * n)
pattern = lambda n, h=1, *a: '\n'.join(m(list((r(m(' ' * (i - 1) + str(i % 10) + ' ' * (n - i)), h - 1) for i in range(1, n + 1)))))


def pattern(n, *args):
	if n < 1:
		return ''
	x = 1 if len(args) == 0 else max(args[0], 1)
	(width, height) = (1 + 2 * (n - 1) * x, 2 * n - 1)
	pict = [[' '] * width for _ in range(height)]
	x_positions = set()
	for x in range(0, width, 2 * (n - 1)):
		x_positions.add(('r', x))
		x_positions.add(('l', x))
	for (y, n) in enumerate(list(range(1, n + 1)) + list(range(n - 1, 0, -1))):
		new_x_positions = set()
		for (d, x) in x_positions:
			pict[y][x] = str(n)[-1]
			if d == 'r' and x + 1 < width:
				new_x_positions.add((d, x + 1))
			elif d == 'l' and 0 <= x - 1:
				new_x_positions.add((d, x - 1))
		x_positions = new_x_positions
	return '\n'.join(map(''.join, pict))