text: """
  Bill Gates is on one of his philanthropic journeys to a village in Utopia. He has N packets of candies and would like to
   distribute one packet to each of the K children in the village (each packet may contain different number of candies).
   To avoid any fighting among the children, he would like to pick K out of N packets, such that unfairness is minimized.
  
  Suppose the K packets have (x1, x2, x3,....xk) candies in them, where xi denotes the number of candies in the ith
  , then we define unfairness as
  
  max(x1,x2,...xk) - min(x1,x2,...xk)
  
  where max denotes the highest value amongst the elements, and min denotes the least value amongst the elements. Can you
  figure out the minimum unfairness and print it?
  
  Input Format
  The first line contains an integer N.
  The second line contains an integer K. N lines follow. Each line contains an integer that denotes the candy in the ith
  packet.
  """
  __author__ = 'Danyang'
  
  
  class Solution(object):
      def solve_TLE(self, cipher):
          """
          Naive approach - simulate combination.
  
          Sort and group as K
          :param cipher: the cipher
          """
          N, K, lst = cipher
          lst.sort()
          global_min = 1 << 32 - 1
          for i in xrange(N - K):
              seq = lst[i: i + K]
              global_min = min(global_min, max(seq) - min(seq))
  
          return global_min
  
      def solve_TLE2(self, cipher):
          """
          Sliding window
  
          :param cipher: the cipher
          """
          N, K, lst = cipher
          lst.sort()
  
          seq = lst[0: K]
          mini = min(seq)
          maxa = max(seq)
          global_min = maxa - mini
          for i in xrange(K, N):
              popped = seq.pop(0)
              cur = lst[i]
              seq.append(cur)
              if popped != mini:
                  mini = min(mini, cur)
              else:
                  mini = min(seq)
              if popped != maxa:
                  maxa = max(maxa, cur)
              else:
                  maxa = max(seq)
  
              global_min = min(global_min, maxa - mini)
  
          return global_min
  
  
      def solve(self, cipher):
          """
          Sliding window
          O(n lgn)
  
          :param cipher: the cipher
          """
          N, K, lst = cipher
          lst.sort()
  
          mini = lst[0]
          maxa = lst[K - 1]
          global_min = maxa - mini
          for i in xrange(1, N - K):
              mini = lst[i]
              maxa = lst[i + K - 1]
              global_min = min(global_min, maxa - mini)
  
          return global_min
  
  
  if __name__ == "__main__":
      import sys
  
      f = open("1.in", "r")
      # f = sys.stdin
      N = int(f.readline().strip())
      K = int(f.readline().strip())
      lst = []
      for t in xrange(N):
          # construct cipher
          lst.append(int(f.readline().strip()))
  
      cipher = (N, K, lst)
      # solve
      s = "%s\n" % (Solution().solve(cipher))
      print s,
  