## 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")

Difficulty: introductory

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))))

m,r=lambda s:s+s[-2::-1],lambda s,n:s+s[1:]*n
def pattern(*a):
    n, h = (a+(1,))[:2]
    return '\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))

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(''.join(p) for p in pict)