< PREVIOUS KATA
NEXT KATA >

## 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        ,        y        );
                    ^                 ^         
                    |                 |         
             Term upto which   Number of times  
              Basic Pattern     Basic Pattern   
                should be         should be     
                 created          repeated      
                                 vertically    
    
* Note: `Basic Pattern` means what we created in Complete The Pattern #12 i.e. a `simple X`.

## Rules/Note:

* The pattern should be created using only unit digits.
* If `n < 1` then it should return "" i.e. empty string.
* 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 ∈ (-∞,50]`
  + `y ∈ (-∞,25]`
* If only one argument is passed then the function `pattern` should run as if `y <= 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
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
         2   2 
          3 3  
           4   
          3 3  
         2   2 
        1     1
       
##### pattern(10,2):

        1                 1
         2               2 
          3             3  
           4           4   
            5         5    
             6       6     
              7     7      
               8   8       
                9 9        
                 0         
                9 9        
               8   8       
              7     7      
             6       6     
            5         5    
           4           4   
          3             3  
         2               2 
        1                 1
         2               2 
          3             3  
           4           4   
            5         5    
             6       6     
              7     7      
               8   8       
                9 9        
                 0         
                9 9        
               8   8       
              7     7      
             6       6     
            5         5    
           4           4   
          3             3  
         2               2 
        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<<<

Source: codewars | Difficulty: EASY
Tags: String algorithms

Fundamentals

Data structures

Starter code: def pattern(n, y=1, *_):
	

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


def pattern(n, y=1, *a):
	if n < 1:
		return ''
	(l, y) = (2 * n - 1, max(1, y))
	sngl = ['{}{}{}'.format(x % 10, ' ' * (l - 2 * x), x % 10 if x != n else '').center(l) for x in range(1, n + 1)]
	cross = sngl + sngl[:-1][::-1]
	return '\n'.join(cross + cross[1:] * (y - 1))


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


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


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


def pattern(n, y=1, *_):
	if n < 1:
		return ''
	(ans, p, y) = ([], [], max(y, 1))
	for i in range(1, n + 1):
		t = [' '] * (n * 2 - 1)
		t[i - 1] = t[n * 2 - 1 - 1 - i + 1] = str(i % 10)
		p.append(''.join(t))
	p += p[:-1][::-1]
	for _ in range(y):
		ans += p[1:] if ans else p
	return '\n'.join(ans)


def pattern(n, m=1, *args):
	if n < 1:
		return ''
	m = max(m, 1)
	r = ['{0}{1}{2}{1}{0}'.format(' ' * (i - 1), i % 10, ' ' * ((n - i) * 2 - 1)) for i in range(1, n)]
	r = r + ['{0}{1}{0}'.format(' ' * (n - 1), n % 10)] + r[::-1]
	return '\n'.join(r + r[1:] * (m - 1))


def pattern(*args):
	n = args[0]
	y = args[1] if len(args) >= 2 else 0
	res = ''
	for count in range(max(1, y)):
		for i in range(n):
			if count >= 1 and i + 1 == 1:
				continue
			elif i + 1 != n:
				res += ' ' * i + str((i + 1) % 10) + ' ' * ((n - 1 - i) * 2 - 1) + str((i + 1) % 10) + ' ' * i + '\n'
			else:
				res += ' ' * i + str((i + 1) % 10) + ' ' * i + '\n'
		for i in range(n - 2, -1, -1):
			if i + 1 != n:
				res += ' ' * i + str((i + 1) % 10) + ' ' * ((n - 1 - i) * 2 - 1) + str((i + 1) % 10) + ' ' * i + '\n'
	return res[:-1]