input: Write a function to divide a given list of numbers into two parts such that the difference between the sum of the two parts is minimized. If the list cannot be split into two equal parts due to an odd number of elements, the function should still attempt to minimize the difference in sums.
  
  ### Function Header:
  def divide_in_two_parts_min_diff(lst):
  
  ### Assert Test Cases:
  assert divide_in_two_parts_min_diff([2, 3, 4, 5, 6, 7]) == ([2, 3, 7], [4, 5, 6])
  assert divide_in_two_parts_min_diff([1, 2, 3, 4, 5]) == ([1, 5], [2, 3, 4])
  assert divide_in_two_parts_min_diff([10, 20, 30, 40]) == ([10, 40], [20, 30])
  assert divide_in_two_parts_min_diff([1, 1, 1, 1]) == ([1, 1], [1, 1])
  assert divide_in_two_parts_min_diff([]) == ([], [])
output: def divide_in_two_parts_min_diff(lst):
      total_sum = sum(lst)
      n = len(lst)
      half_sum = total_sum // 2
      dp = [[False] * (half_sum + 1) for _ in range(n + 1)]
      dp[0][0] = True
  
      for i in range(1, n + 1):
          for j in range(half_sum + 1):
              if j >= lst[i - 1]:
                  dp[i][j] = dp[i - 1][j] or dp[i - 1][j - lst[i - 1]]
              else:
                  dp[i][j] = dp[i - 1][j]
  
      for j in range(half_sum, -1, -1):
          if dp[n][j]:
              part1_sum = j
              break
  
      part1 = []
      part2 = lst[:]
      for i in range(n, 0, -1):
          if part1_sum >= lst[i - 1] and dp[i - 1][part1_sum - lst[i - 1]]:
              part1.append(lst[i - 1])
              part2.remove(lst[i - 1])
              part1_sum -= lst[i - 1]
  
      return part1, part2