CareerCup

DFS

public boolean canArrange(int[] servers, int[] tasks) {
        boolean[] used = new boolean[tasks.length];
        return canArrangeRecursive(servers, tasks, used);
    }

    public boolean canArrangeRecursive(int[] servers, int[] tasks, boolean[] used) {
        boolean allUsed = true;
        for (boolean b : used) {
            allUsed &=b;
        }
        if (allUsed){
            return true;
        }
        for (int i = 0; i < tasks.length; i++) {
            if (!used[i]) {
                used[i] = true;
                for (int j = 0; j < servers.length; j++) {
                    if (servers[j] >= tasks[i]) {
                        servers[j] = servers[j] - tasks[i];
                        if(canArrangeRecursive(servers, tasks, used)){
                            return true;
                        }
                        servers[j] = servers[j] + tasks[i];
                    }
                }
                used[i] = false;
            }
        }
        return false;

}

Looks like a Max-Flow problem to me.
Let J be the group of jobs and W be the list of work servers.

1. Create a graph so that each job is a node and each worker is a node.
2. Create an Edge between each job node and each server node iff that worker's capacity is less than or equal to the task's requirements, set the value of each edge to be the job requirements.
3. Add a node S, and an edge from S to each task node in T and set the value to infinity (or Integer.MAX_VALUE)..
4. Add a node T, and an edge from each worker in W to T. set the value of each edge to be the capacity of the worker.
5. Run a max flow algorithm (e.g. Ford Fulkerson) and return "True" iff the max flow of the graph equals the sum of all the jobs in J.

#include<stdio.h>
#include<conio.h>

int assign(int serverCapacities[],int tasks[],int no_servers,int tasks_start,int tasks_end)
{
	int i,j,k;
	if( tasks_end < tasks_start)
		return 1;
	
	for( i=0; i<no_servers; i++)
		if( tasks[tasks_start] <= serverCapacities[i] )
		{
			//if current server is capable of handling the cuurent task, then assign it
			//Reduce the capacity of current server
			serverCapacities[i] -= tasks[tasks_start];
			
			
			if(assign(serverCapacities,tasks,no_servers,tasks_start+1,tasks_end))
				return 1;
			//backtracking
			serverCapacities[i] += tasks[tasks_start];
		}
		
	return 0;
	
}
int main()
{
	int serverCapacities[]={8,16,8,32};
	int tasks[]={18,4,8,4,6,6,8,8};
	int no_servers;
	int no_tasks;
	no_servers = sizeof(serverCapacities)/sizeof(int);
	no_tasks = sizeof(tasks)/sizeof(int);
	if ( assign(serverCapacities,tasks,no_servers,0,no_tasks-1) )
	{
		printf("True");
	}
	else
	{
		printf("False");
	}
	getch();
}

class ServerCapacity:
        def __init__(self, list_capacity):
                self.list_capacity = sorted(list_capacity, reverse=True)
                self.list_server = [] * len(list_capacity)
                self.answer = False
        
        def solution(self, list_job):
                self.list_job = sorted(list_job)
                self.recursive_walk(self.list_capacity, self.list_job)
                return self.answer

        def recursive_walk(self, list_capacity, list_job):
                #print 'recursive_walk, cap: ', list_capacity
                #print 'recursive_walk, job: ', list_job

                # if job list is empty, done here
                if not len(list_job):
                        self.answer = True
                        return True

                # pop up the biggest job
                job = list_job.pop()

                # check if any server can take this job
                has_server = False
                for i, capacity in enumerate(list_capacity): 
                        if capacity >= job:
                                list_capacity[i] -= job
                                has_server = True

                                #
                                # if this assign doesn't work, return capacity, check 
                                # next server
                                #
                                if not self.recursive_walk(list_capacity, list_job):
                                        list_capacity[i] += job
                                        has_server = False

                # if no server can handle this job, return False
                if not has_server:
                        return False

if __name__ == "__main__":
        list_cap = [[1,3], [4,1], [8,16,8,32],       [8,6,2]]
        list_job = [[  4], [  4], [18,4,8,4,6,6,8,8],[5,4,4,2,1]]

        for cap, job in zip(list_cap, list_job):
                s = ServerCapacity(cap)
                print 'Solution :', s.solution(job)

first sort the task capacity needs in descending order and try to find best fit for each task capacity needs.
where best fit is min of capacity greater than equal to the task capacity need
eg- capacity limits- 8,16,8,32
after sorting task capacity needs - 18,8,8,8,6,6,4,4
1)best fit for 18 is min no in capacity limit array which is greater than equal to 18, which is 32 after this pass
capacity needs - 8,8,8,6,6,4,4
capacity limits-8,16,8,14

2) best fit for 8 is 8 after this pass
capacity needs -8,8,6,6,4,4
capacity limits-0,16,8,14

3)best fit for 8 is 8
capacity needs -8,6,6,4,4
capacity limits-0,16,0,14

4)best fit for 8 is 14
capacity needs -6,6,4,4
capacity limits-0,16,0,6

5)best fit for 6 is 6
capacity needs -6,4,4
capacity limits-0,16,0,0

6)best fit for 6 is 16
capacity needs -4,4
capacity limits-0,10,0,0

7)best fit for 4 is 10
capacity needs -4
capacity limits-0,6,0,0

8)best fit for 4 is 6
capacity needs -
capacity limits-0,2,0,0

Mode the problem as a giftbox problem, i.e., put several gifts in different sizes into boxes in different sizes. The strategy is try to put the largest gift into the lagest box and repeat the process until all gifts are boxed. If at a certain point the process fails, try the second largest box, then the third largest and so forth.

Implemented in scala is a brute force solution (NP complete, worst case O(n^3), n be the number of gifts), but since it can return early, the algorithm is quite efficient (best case O(n)). Note sorting the boxes can be further optimized with a simple insertion at the right place (linear).

class GiftBox {
	def fit(boxes: Seq[Int], gifts: Seq[Int]) : Boolean = {
		var g = gifts.last
		var b = boxes.last 
		println(s"Checking $boxes for $gifts")
		
		if (gifts.length<=1) return boxes.toList.exists(_>=g)

		for (i<- boxes.size-1 to 0 by -1 if boxes(i)>=g) {
			b = boxes(i)
			val bb = boxes.take(i)++boxes.drop(i+1):+(b-g)
			if (fit(bb.sorted, gifts.init)) return true
		}
		return false
	}
}

object GiftBox extends App {
	val giftBox = new GiftBox
	
	println(giftBox.fit(Seq(8, 16, 8, 32).sorted, Seq(18, 4, 8, 4, 6, 6, 8, 8).sorted))
	println(giftBox.fit(Seq(8,6,2).sorted, Seq(5,4,4,2,1).sorted))
	println(giftBox.fit(Seq(1,3).sorted, Seq(4).sorted))
	
}

The three test cases gives true, true, false

Checking List(8, 8, 16, 32) for List(4, 4, 6, 6, 8, 8, 8, 18)
Checking List(8, 8, 14, 16) for List(4, 4, 6, 6, 8, 8, 8)
Checking List(8, 8, 8, 14) for List(4, 4, 6, 6, 8, 8)
Checking List(6, 8, 8, 8) for List(4, 4, 6, 6, 8)
Checking List(0, 6, 8, 8) for List(4, 4, 6, 6)
Checking List(0, 2, 6, 8) for List(4, 4, 6)
Checking List(0, 2, 2, 6) for List(4, 4)
Checking List(0, 2, 2, 2) for List(4)
Checking List(0, 0, 2, 8) for List(4, 4)
Checking List(0, 0, 2, 4) for List(4)
true
Checking List(2, 6, 8) for List(1, 2, 4, 4, 5)
Checking List(2, 3, 6) for List(1, 2, 4, 4)
Checking List(2, 2, 3) for List(1, 2, 4)
Checking List(1, 2, 8) for List(1, 2, 4, 4)
Checking List(1, 2, 4) for List(1, 2, 4)
Checking List(0, 1, 2) for List(1, 2)
Checking List(0, 0, 1) for List(1)
true
Checking List(1, 3) for List(4)
false

I can think of the following algorithm at high level, correct me if i am wrong

1.Check if we have exact fit available for a task
2.If not find the possible fit for that task
3.Get the best possible fit if we have multiple possible fits available
4.Best possible fit can be defined as the exact fit of 2 or more available tasks combined

Basically, one way is to solve using recursive backtracking with no memoization.
Given a list of jobs L1 with service times S_i, and a list of servers L2 with with capacities C_i, we try each job on all servers one by one until the list L1 is traversed. Its like Depth First Search with backtracking (in case we don't find the solution along the path).
An improvization would/could be memoization instead of backtracking.
Say, we order the list L1 in descending order of service rates.
The state I would memoize is.
S[Sorted List of remaining capacities in L2, i] => The current state of List L2 after processing the 1st i elements of L1
S[Sorted List of remaining capacities in L2, i] = {-1, 0, 1}
-1 means not yet memoized
0 means not possible
1 means possible

------------------------------------------------------------------------------------------------
The important part is that i am storing List L2 after sorting it, because all servers are identical. (so that we don't have to recompute for the same list in different order)

This question is form of bin-packing algorithm. Will post the solution soon.

yes, this is a bin sort problem. First, sort the tasks in the descending order. Then assign the tasks to each bin as long as it can fit it.

here is the solution:
bool bin_packing(int* tasks, int nt, int* workers, int nw) {
quick_sort_kernel(tasks, 0, nt-1);
bool setted_tasks[nt];
for(int i = 0; i < nt; i++) {
int cur_task = tasks[i];
setted_tasks[i] = false;
printf("task:%d ", cur_task);
for(int j = 0; j < nw; j++) printf("%d ", workers[j]);
printf("\n");
for(int j = 0; j < nw; j++) {
if(workers[j]-cur_task >= 0) {
workers[j] = workers[j]-cur_task;
setted_tasks[i] = true;
break;
}
}
}
for(int i = 0; i < nt; i++) {
if(!setted_tasks[i]) return false;
}
return true;
}

bool CanScheduleTasks(std::vector<int> capacities
                          , std::vector<int> tasks)
    {
        bool ret = false;
        
        if (tasks.size() == 0)
        {
            ret = true;
        }
        else if (capacities.size() == 0)
        {
            ret = false;
        }
        else
        {
            for (int i = 0; i < tasks.size(); i++)
            {
                for (int j = 0; j < capacities.size(); j++)
                {
                    if (tasks[i] <= capacities[j])
                    {
                        std::vector<int> tempCapacities(capacities.size());
                        std::copy(capacities.begin(), capacities.end(), tempCapacities.begin());
                        tempCapacities[j] -= tasks[i];

                        std::vector<int> tempTasks(tasks.size());
                        std::copy(tasks.begin(), tasks.end(), tempTasks.begin());
                        tempTasks.erase(tempTasks.begin()+i);
                        
                        ret = ret || CanScheduleTasks(tempCapacities, tempTasks);
                    }
                }
            }
        }
        
        return ret;
    }

isn't this problem the Bin Packing problem, and therefore NP-Hard?

O(m*n) in worst case. Enjoy.

bool canArrange(int* servers, int servers_len, int* tasks, int tasks_len) {
  if (tasks_len == 0)
    return true;
  for (int i = 0; i < servers_len; i++) {
    if (servers[i] >= tasks[tasks_len - 1]) {
      servers[i] -= tasks[task_len - 1];
      if (canArrange(servers, servers_len, tasks, tasks_len - 1))
        return true;
      servers[i] += tasks[task_len - 1];
    }
  }
  return false;
}

1) Let L be an array of tasks in some order.
2) The first server takes as many adjacent tasks as it can from the start of L. From what is left, the second server takes as many adjacent tasks as it can, and so on. If all tasks are taken then we're done and return true.
3) Otherwise, change L to another permutation of tasks and go back to step 2, unless all permutations have been tried, in which case, return false.

Here is C++ code. Notice that can_allocate uses 'std::next_permutation' which generates permutations in lexicographical order. To ensure that all permutations are generated, 'tasks' must be initialized in increasing order.

typedef std::vector<unsigned> array;

bool can_allocate_in_order(array const& tasks, array const& servers) {
  
  auto need = tasks.begin();
  
  for (unsigned limit : servers) {
    
    while (limit >= *need) {
      
      limit -= *need;
      ++need;
      
      if (need == tasks.end())
        return true;
    }
  }
  return false;
}

// Assume tasks is in increasing order.
bool can_allocate(array& tasks, array const& servers) {
  do {
    if (can_allocate_in_order(tasks, servers))
      return true;
  } while (std::next_permutation(tasks.begin(), tasks.end()));
  return false;
}

Let n be the number of tasks and m be the number of servers. We have:

a) 'std::next permutation' has O(n) complexity;
b) 'can_allocate_in_order' is ran at most n! times;
c) 'can_allocate_in_order' has complexity O(n + m).

Since n = 8, 'can_allocate_in_order' can be called up to 8! = 40,320 times. This is arguably a big number however:

a) 'std::next_permutation' takes into consideration repetitions less calls are made. For instance, for tasks = {4, 4, 6, 6, 8, 8, 8, 18}, 4 is repeated 2 times, 6 is repeated 2 times and 8 is repeated 3 times. The number of calls is reduced to, at most, 8! / (2!*2!*3!) = 1,680.

b) Even when this maximum is achieved (e.g., when tasks = {1, 2, 3, 4, 5, 6, 7, 33}) the C++ code above takes a fraction of a second to run in my computer.

c) In contrast, driv3r's algorithm (ported to C++), for tasks = {1, 2, 3, 4, 5, 6, 7, 33} calls 'canArrangeRecursive' 37,369,133 times and takes a few of seconds to run.

The implementation can be easily modified to use Heap's algorithm (which has nothing to do with the homonymous data structure) to generate each permutation in O(1) and it doesn't make any assumption on 'tasks' initial order. The price to pay is that Heap's algorithm doesn't take profit of repetitions.

The algo also saids "If at a certain point the process fails, try the second largest box, then the third largest and so forth". In your example the code will roll back to try gift 5 in box 5.

The algo also saids "If at a certain point the process fails, try the second largest box, then the third largest and so forth". In your example the code will roll back to try gift 5 in box 5.

#include <iostream>
#include <vector>

void printvec(std::vector<int> vec) {
  std::vector<int>::size_type vec_sz = vec.size();
  for (int i=0; i < vec_sz; i++) {
    std::cout << vec[i] << " ";
  } std::cout << std::endl;
}

int main() {
  std::cout << "Server capacity limits: ";
  int user_input;
  std::vector<int> server_cap;

  while (std::cin >> user_input) {
    if (user_input == -1)
      break;
    server_cap.push_back(user_input);
  }

  std::vector<int> task_needs;

  std::cout << "Task capacity needs: ";

  while (std::cin >> user_input) {
    task_needs.push_back(user_input);
  }

  //Sort our server and task vectors
  std::sort(server_cap.begin(), server_cap.end());
  std::sort(task_needs.begin(), task_needs.end());

  typedef std::vector<int>::const_iterator iter;
  typedef std::vector<int>::size_type vec_sz;

  iter task_vec_it = task_needs.begin();
  iter task_vec_it_end = task_needs.end();

  vec_sz task_size = task_needs.size();
  vec_sz server_size = server_cap.size();

  int task_largest;
  int server_largest;

  for (; task_vec_it != task_vec_it_end+1; task_vec_it++) {

    std::cout << "task_needs size: " << task_size << std::endl;
    printvec(server_cap);
    printvec(task_needs);

    if (task_needs.empty()) {
      std::cout << "All tasks handled!" << std::endl;
      return 0;
    }

    //Get the largest value in task_needs & server_cap
    task_largest = *max_element(task_needs.begin(), task_needs.end());
    server_largest = *max_element(server_cap.begin(), server_cap.end());

    if (server_largest < task_largest) {
      std::cout << "No server's can handle your request!" << std::endl;
      return -1;
    }

    //Subtract largest value of tasks from largest value of vectors
    //and store it in server vector
    server_cap[server_size-1] -= task_needs[task_size-1];
    task_needs.pop_back();

    //Re-sort vectors
    std::sort(server_cap.begin(), server_cap.end());
    std::sort(task_needs.begin(), task_needs.end());

    //Get new size of task_needs
    task_size = task_needs.size();
  }

  return 0;
}

{{def isSchedulable(limits,requires):
if len(requires)==0:
return True
if len(limits)==0:
return False
limits.sort()
limits=limits[::-1]
requires.sort()
requires=requires[::-1]
if requires[0]>limits[0]:
return False
else:
limits[0]=limits[0]-requires[0]
while requires[-1]<=limits[0]:
limits[0]=limits[0]-requires[-1]
requires.pop()
if limits[0]==0:
limits.pop(0)
requires.pop(0)
return isSchedulable(limits,requires)}}

No need of DP, greedy algorithm works:

def isSchedulable(limits,requires):
    if len(requires)==0:
        return True
    if len(limits)==0:
        return False
    limits.sort()
    limits=limits[::-1]
    requires.sort()
    requires=requires[::-1]
    if requires[0]>limits[0]:
        return False
    else:
        limits[0]=limits[0]-requires[0]
        while requires[-1]<=limits[0]:
            limits[0]=limits[0]-requires[-1]
            requires.pop()
        if limits[0]==0:
            limits.pop(0)
        requires.pop(0)
        return isSchedulable(limits,requires)

I have got a solution. Correct me if I am wrong conceptually.
Pick the boxes one by one.
For each of the boxes, apply the 0/1 knapsack with the slight modification that if there are multiple ways to fill the box, then choose the way where the weight of the heaviest box is maximum at each step.

import java.util.ArrayList;
import java.util.List;


class Scenario {
	
	int[] remainingValues;
	public Scenario(Scenario scenario) {
		int[] toCopy = scenario.getRemainingValues();
		remainingValues = new int[toCopy.length];
		
		for (int i = 0; i < toCopy.length; i++) {
			this.remainingValues[i] = toCopy[i];
		}
	}

	public Scenario(int[] values) {
		remainingValues = new int[values.length];
		for (int i = 0; i < values.length; i++) {
			this.remainingValues[i] = values[i];
		}
	}

	public int getRemainingValueAt(int server) {
		return remainingValues[server];
	}

	public int[] getRemainingValues() {
		return remainingValues;
	}

	public void decrementRemainingValue(int index, int byValue) {
		this.remainingValues[index] -= byValue;
	}
}
  
class DoesItFit {
	
	public static boolean findIfThingsFit(int[] capacity, int[] proceses) {
		Scenario initialScenario = new Scenario(capacity);
		List<Scenario> scenariosEncountered = new ArrayList<Scenario>();
		scenariosEncountered.add(initialScenario);

		for (int i = 0; i < proceses.length; i++) {
			List<Scenario> newScenarios = new ArrayList<Scenario>();
			for (int j = 0; j < capacity.length; j++) {
				for (Scenario scenario : scenariosEncountered) {
					if (scenario.getRemainingValueAt(j) >= proceses[i]) {
						Scenario newScenario = new Scenario(scenario);
						newScenario.decrementRemainingValue(j, proceses[i]);
						newScenarios.add(newScenario);
					}
				}
				
			}
			scenariosEncountered.clear();
			scenariosEncountered.addAll(newScenarios);
		}
		return scenariosEncountered.size() > 0;
	}
	public static void main (String argv[]){
		System.out.println(findIfThingsFit(new int[]{8, 16, 8, 32}, new int[]{18, 4, 8, 4, 6, 6, 8, 8}));
		System.out.println(findIfThingsFit(new int[]{7,6}, new int[]{5, 3, 3, 2}));
		
	}
}

1. Read the input
2. Put both ServerCapacity and Tasks in separate Integer ArrayList s.
3. Sort both ArraList s in Desc order.
4. For the Biggest task, Try to fit in biggest server.
5. If Task is Bigger Than Capacity then there is no point in moving ahead.

public class ServerCapacity {

    public static void main(String[] args) throws InterruptedException {
        Scanner c = new Scanner(System.in);

        System.out.println("Enter Servers capacity limits: ");
        String serCapLim = "8, 16, 8, 32"; //c.nextLine();
        serCapLim = "1,3";
        System.out.println("Enter Tasks capacity Need: ");
        String taskCapNeed = "18, 4, 8, 4, 6, 6, 8, 8"; //c.nextLine();
        taskCapNeed="4";

        String[] splits = serCapLim.split(",");
        ArrayList<Integer> serCaps = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            serCaps.add(Integer.parseInt(splits[i].trim()));
        }

        splits = taskCapNeed.split(",");
        ArrayList<Integer> taskNeeds = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            taskNeeds.add(Integer.parseInt(splits[i].trim()));
        }

        try {
            boolean flag = checkCapacity(serCaps, taskNeeds);
            System.out.println("flag:" + flag);
        } catch (Exception e) {
        }
    }

    public static boolean checkCapacity(ArrayList<Integer> serCaps, ArrayList<Integer> taskNeeds) throws Exception {
        //check if the capacity is in Limits
        if (serCaps.size() > 8 | taskNeeds.size() > 8) {
            throw new Exception("Either task or servers are not in limit");
        }

        //first sort those lists in desc order
        Collections.sort(taskNeeds, Collections.reverseOrder());
        
        //if the find returns true then 
        return findTaskAssignment(taskNeeds, serCaps);
    }
    
    /**
     * Finds the assignment of task on server and reiterates for remaining.
     * Find the assignment for the biggest Job first on the biggest capacity server.
     * @param taskNeeds
     * @param serCaps
     * @return 
     */
    private static boolean findTaskAssignment(ArrayList<Integer> taskNeeds, ArrayList<Integer> serCaps) {
        if(taskNeeds.size()==0)
            return true;        
        int task = taskNeeds.get(0);
        Collections.sort(serCaps, Collections.reverseOrder());
        System.out.println("task to be assigned:" + task);
        System.out.println("server Caps remaining:" + serCaps);
        
        boolean flag = false;
//        for(int i=0; i<serCaps.size(); i++){
            int i=0;
            int cap=serCaps.get(i);
            //if task is bigger than cap then there is no point
            if (task > cap) {
                return false;
            } //if task is same as cap then assign
            else if (task == cap) {
                serCaps.remove(Integer.valueOf(task));
//                return true;
                taskNeeds.remove(0);
            } //else if the same size is ther
            else if(serCaps.contains(task)){
                //if we just enter task then it considers as index so we have to cast to Integer object
                serCaps.remove(Integer.valueOf(task)); 
//                return true;
                taskNeeds.remove(0);
            }
            //else deduct that task from the cap
            else {
                serCaps.set(i, cap-task);                
//                return true;
                taskNeeds.remove(0);
            }
//        }
        System.out.println("Next iteration");
        return findTaskAssignment(taskNeeds, serCaps);
    }
}

1. Get input Capacity and tasks in separate ArrayList s
2. Sort both ArrayList s in Desc order.
3. For the Highest task check the Highest available Server capacity.
3. If the task is bigger than any server capacity then there is no point in moving ahead.
4. If the same capacity as task is found then remove both task and capacity from respective ArrayList s.
5. If the Task is smalled than the Capacity then deduct from capacity
6. Reiterate till you find servers for all Tasks.

1. Get input Capacity and tasks in separate ArrayList s
2. Sort both ArrayList s in Desc order.
3. For the Highest task check the Highest available Server capacity.
3. If the task is bigger than any server capacity then there is no point in moving ahead.
4. If the same capacity as task is found then remove both task and capacity from respective ArrayList s.
5. If the Task is smalled than the Capacity then deduct from capacity
6. Reiterate till you find servers for all Tasks.

and the code

1. Get input Capacity and tasks in separate ArrayList s
2. Sort both ArrayList s in Desc order.
3. For the Highest task check the Highest available Server capacity.
3. If the task is bigger than any server capacity then there is no point in moving ahead.
4. If the same capacity as task is found then remove both task and capacity from respective ArrayList s.
5. If the Task is smalled than the Capacity then deduct from capacity
6. Reiterate till you find servers for all Tasks.

and the code

1. Get input Capacity and tasks in separate ArrayList s
2. Sort both ArrayList s in Desc order.
3. For the Highest task check the Highest available Server capacity.
3. If the task is bigger than any server capacity then there is no point in moving ahead.
4. If the same capacity as task is found then remove both task and capacity from respective ArrayList s.
5. If the Task is smalled than the Capacity then deduct from capacity
6. Reiterate till you find servers for all Tasks.

import java.io.Console;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class ServerCapacity {

    public static void main(String[] args) throws InterruptedException {
        Scanner c = new Scanner(System.in);

        System.out.println("Enter Servers capacity limits: ");
        String serCapLim = "8, 16, 8, 32"; //c.nextLine();
        serCapLim = "1,3";
        System.out.println("Enter Tasks capacity Need: ");
        String taskCapNeed = "18, 4, 8, 4, 6, 6, 8, 8"; //c.nextLine();
        taskCapNeed="4";

        String[] splits = serCapLim.split(",");
        ArrayList<Integer> serCaps = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            serCaps.add(Integer.parseInt(splits[i].trim()));
        }

        splits = taskCapNeed.split(",");
        ArrayList<Integer> taskNeeds = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            taskNeeds.add(Integer.parseInt(splits[i].trim()));
        }

        try {
            boolean flag = checkCapacity(serCaps, taskNeeds);
            System.out.println("flag:" + flag);
        } catch (Exception e) {
        }
    }

    public static boolean checkCapacity(ArrayList<Integer> serCaps, ArrayList<Integer> taskNeeds) throws Exception {
        //check if the capacity is in Limits
        if (serCaps.size() > 8 | taskNeeds.size() > 8) {
            throw new Exception("Either task or servers are not in limit");
        }

        //first sort those lists in desc order
        Collections.sort(taskNeeds, Collections.reverseOrder());
        
        //if the find returns true then 
        return findTaskAssignment(taskNeeds, serCaps);
    }
    
    /**
     * Finds the assignment of task on server and reiterates for remaining.
     * Find the assignment for the biggest Job first on the biggest capacity server.
     * @param taskNeeds
     * @param serCaps
     * @return 
     */
    private static boolean findTaskAssignment(ArrayList<Integer> taskNeeds, ArrayList<Integer> serCaps) {
        if(taskNeeds.size()==0)
            return true;        
        int task = taskNeeds.get(0);
        Collections.sort(serCaps, Collections.reverseOrder());
        System.out.println("task to be assigned:" + task);
        System.out.println("server Caps remaining:" + serCaps);
        
        boolean flag = false;
//        for(int i=0; i<serCaps.size(); i++){
            int i=0;
            int cap=serCaps.get(i);
            //if task is bigger than cap then there is no point
            if (task > cap) {
                return false;
            } //if task is same as cap then assign
            else if (task == cap) {
                serCaps.remove(Integer.valueOf(task));
//                return true;
                taskNeeds.remove(0);
            } //else if the same size is ther
            else if(serCaps.contains(task)){
                //if we just enter task then it considers as index so we have to cast to Integer object
                serCaps.remove(Integer.valueOf(task)); 
//                return true;
                taskNeeds.remove(0);
            }
            //else deduct that task from the cap
            else {
                serCaps.set(i, cap-task);                
//                return true;
                taskNeeds.remove(0);
            }
//        }
        System.out.println("Next iteration");
        return findTaskAssignment(taskNeeds, serCaps);
    }
}

1. Get input Capacity and tasks in separate ArrayList s
2. Sort both ArrayList s in Desc order.
3. For the Highest task check the Highest available Server capacity.
3. If the task is bigger than any server capacity then there is no point in moving ahead.
4. If the same capacity as task is found then remove both task and capacity from respective ArrayList s.
5. If the Task is smalled than the Capacity then deduct from capacity
6. Reiterate till you find servers for all Tasks.

import java.io.Console;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class ServerCapacity {

    public static void main(String[] args) throws InterruptedException {
        Scanner c = new Scanner(System.in);

        System.out.println("Enter Servers capacity limits: ");
        String serCapLim = "8, 16, 8, 32"; //c.nextLine();
        serCapLim = "1,3";
        System.out.println("Enter Tasks capacity Need: ");
        String taskCapNeed = "18, 4, 8, 4, 6, 6, 8, 8"; //c.nextLine();
        taskCapNeed="4";

        String[] splits = serCapLim.split(",");
        ArrayList<Integer> serCaps = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            serCaps.add(Integer.parseInt(splits[i].trim()));
        }

        splits = taskCapNeed.split(",");
        ArrayList<Integer> taskNeeds = new ArrayList(splits.length);
        for (int i = 0; i < splits.length; i++) {
            taskNeeds.add(Integer.parseInt(splits[i].trim()));
        }

        try {
            boolean flag = checkCapacity(serCaps, taskNeeds);
            System.out.println("flag:" + flag);
        } catch (Exception e) {
        }
    }

    public static boolean checkCapacity(ArrayList<Integer> serCaps, ArrayList<Integer> taskNeeds) throws Exception {
        //check if the capacity is in Limits
        if (serCaps.size() > 8 | taskNeeds.size() > 8) {
            throw new Exception("Either task or servers are not in limit");
        }

        //first sort those lists in desc order
        Collections.sort(taskNeeds, Collections.reverseOrder());
        
        //if the find returns true then 
        return findTaskAssignment(taskNeeds, serCaps);
    }
    
    /**
     * Finds the assignment of task on server and reiterates for remaining.
     * Find the assignment for the biggest Job first on the biggest capacity server.
     * @param taskNeeds
     * @param serCaps
     * @return 
     */
    private static boolean findTaskAssignment(ArrayList<Integer> taskNeeds, ArrayList<Integer> serCaps) {
        if(taskNeeds.size()==0)
            return true;        
        int task = taskNeeds.get(0);
        Collections.sort(serCaps, Collections.reverseOrder());
        System.out.println("task to be assigned:" + task);
        System.out.println("server Caps remaining:" + serCaps);
        
        boolean flag = false;
//        for(int i=0; i<serCaps.size(); i++){
            int i=0;
            int cap=serCaps.get(i);
            //if task is bigger than cap then there is no point
            if (task > cap) {
                return false;
            } //if task is same as cap then assign
            else if (task == cap) {
                serCaps.remove(Integer.valueOf(task));
//                return true;
                taskNeeds.remove(0);
            } //else if the same size is ther
            else if(serCaps.contains(task)){
                //if we just enter task then it considers as index so we have to cast to Integer object
                serCaps.remove(Integer.valueOf(task)); 
//                return true;
                taskNeeds.remove(0);
            }
            //else deduct that task from the cap
            else {
                serCaps.set(i, cap-task);                
//                return true;
                taskNeeds.remove(0);
            }
//        }
        System.out.println("Next iteration");
        return findTaskAssignment(taskNeeds, serCaps);
    }
}

//n^2 greedy approach
#include    <iostream>
using namespace std;

int main()
{
    //int servercap[] = {8, 16, 8, 32};
    //int taskcap[] = {18, 4, 8, 4, 6, 6, 8, 8 };
    int servercap[] = {1,3,1,2,3,4};
    int taskcap[] = {4,3,1,2,3,1};
    int sizea = sizeof(servercap)/sizeof(servercap[0]);
    int sizeb = sizeof(taskcap)/sizeof(taskcap[0]);
    int i = 0;
    for(;i<sizeb;i++)
    {
        int minWasteIdx = -1;
        int wastage  = -1;
        int minwastage = 999;
        for(int j=0;j<sizea;j++)
        {
            if(taskcap[i] <= servercap[j])
            {
                wastage = servercap[j] - taskcap[i];
                if(wastage >= 0 && wastage < minwastage) {
                    minwastage = wastage;
                    minWasteIdx = j;
                }
            }
        }
        if(minWasteIdx == -1)
            break;
        servercap[minWasteIdx] -=taskcap[i];
    }
    if( i != sizeb)
        cout<<"No Sol Possible"<<endl;
    else {
        cout<<"Solution Possible"<<endl;
        for(int i=0;i<sizea;i++)
            cout<<servercap[i]<<"\t";
    }
    cout<<endl;
    return 0;
}

public static boolean ReturnSeverCanDo(int task[],int capacity[])
		{
		Arrays.sort(task);
		Arrays.sort(capacity);
		String s=Arrays.toString(task);
		int sum_task=0;
		int sum_capacity=0;
		for(int i=0;i<task.length;i++)
		{
			sum_task+=task[i];
		}
		for(int i=0;i<capacity.length;i++)
		{
			sum_capacity+=capacity[i];
		}
	if((task[task.length-1]<capacity[capacity.length-1])&&(sum_task<=sum_capacity))
	{
		return true;
	}
	
	return false;
}

public static boolean ReturnSeverCanDo(int task[],int capacity[])
		{
		Arrays.sort(task);
		Arrays.sort(capacity);
		String s=Arrays.toString(task);
		int sum_task=0;
		int sum_capacity=0;
		for(int i=0;i<task.length;i++)
		{
			sum_task+=task[i];
		}
		for(int i=0;i<capacity.length;i++)
		{
			sum_capacity+=capacity[i];
		}
	if((task[task.length-1]<capacity[capacity.length-1])&&(sum_task<=sum_capacity))
	{
		return true;
	}
	
	return false;
}

#include<iostream>
#include<algorithm>
#define SIZE 10
#define TASKSIZE 3

using namespace std;

int main(){
    int server[SIZE] = {2,5,10,4,13,19,23,11,8,17};
    
    int task[TASKSIZE] = {30, 2, 1};
    sort(task, task+TASKSIZE);
    int *tempServer = new int[SIZE];
    
    sort(server,server + SIZE);
    sort(task, task+TASKSIZE);
    
    for(int i = 0; i<SIZE; i++)
        tempServer[i] = server[i];
    
    
    for(int i=TASKSIZE-1; i>=0; i--){
        for(int j=SIZE-1; j>=0;j--){
            if(task[i] < tempServer[j]){
                tempServer[j] = tempServer[j] - task[i];
                task[i] = 0;
                break;
            }
        }
    }
    
    int k=0;
    for(k=0; k<TASKSIZE; k++)
        if(task[k] != 0) break;
    if(k==TASKSIZE)
        cout<<"Request Served"<<endl;
    else
        cout<<"Request Cannot be Served"<<endl;
    
    
}

#include<iostream>
#include<algorithm>
#define SIZE 10
#define TASKSIZE 3

using namespace std;

int main(){
    int server[SIZE] = {2,5,10,4,13,19,23,11,8,17};
    int task[TASKSIZE] = {30, 2, 1};
    int *tempServer = new int[SIZE];
    
    sort(server,server + SIZE);
    sort(task, task+TASKSIZE);
    
    for(int i = 0; i<SIZE; i++)
        tempServer[i] = server[i];
    
    
    for(int i=TASKSIZE-1; i>=0; i--){
        for(int j=SIZE-1; j>=0;j--){
            if(task[i] < tempServer[j]){
                tempServer[j] = tempServer[j] - task[i];
                task[i] = 0;
                break;
            }
        }
    }
    
    int k=0;
    for(k=0; k<TASKSIZE; k++)
        if(task[k] != 0) break;
    if(k==TASKSIZE)
        cout<<"Request Served"<<endl;
    else
        cout<<"Request Cannot be Served"<<endl;
    
    
}

For each task, check if it can fit into any server.
DFS as long as tasks fit

public class ServerCapacity {

	// Server capacity
	public static boolean fits(int[] tasks, int[] servers, int n) {

		if (n == tasks.length)
			return true;

		for (int i = n; i < tasks.length; i++) {
			boolean serverFound = false;
			
			for (int j = 0; j < servers.length; j++) {
				if (servers[j] >= tasks[i]) {
					serverFound = true;
					servers[j] -= tasks[i];

					if (fits(tasks, servers, i + 1))
						return true;
					
					serverFound = false;
					servers[j] += tasks[i];
				}
			}
			
			// The task cannot fit into any servers
			if (!serverFound)
				return false;
		}

		return false;
	}

	public static void main(String[] args) {
		int[] servers = new int[] { 8, 16, 8, 30 };
		int[] tasks = new int[] {18, 4, 8, 4, 6, 6, 8, 8};

		System.out.println(fits(tasks, servers, 0));
	}
}

bool SchedulingSolutionDP(std::vector<int>& serverCenter,
                           const std::vector<int>& tasks, const size_t taskIndex)
{
    if (tasks.empty()) {
        return true;
    }

    if (taskIndex >= (tasks.size() - 1)) {
        // the last corner case
        for (size_t index = 0; index < serverCenter.size(); ++index) {
            if (tasks[taskIndex] <= serverCenter[index]) {
                return true;
            }
        }
        return false;
    }

    for (size_t index = 0; index < serverCenter.size(); ++index) {
        if (tasks[taskIndex] <= serverCenter[index]) {
            // create sub-problem and call recursively
            serverCenter[index] -= tasks[taskIndex];
            if (SchedulingSolutionDP(serverCenter, tasks, taskIndex + 1)){
                // recover to the original problem
                serverCenter[index] += tasks[taskIndex];
                return true;
            }
            // recover to the original problem
            serverCenter[index] += tasks[taskIndex];
        }
    }

    return false;
}

Find more about the sub-problem description and test here: cpluspluslearning-petert.blogspot.co.uk/2014/11/dynamic-programming-task-schedulling.html

This is a discrete bin packing problem - a variant of a classical bin packing ( en.wikipedia.org/wiki/Bin_packing_problem ), where bins are computers and items are tasks. Please note, that heuristic algorithms proposed in the discussion are incorrect solutions for this task (unless approximations are acceptable).
Generally, bin packing problem is NP-hard, however we can take advantage that weights and capacities are discrete (integers) and solve this with pseudo-polynomial dynamic programming algorithm with O(P) space and O(P) time where P is a product of capacities of all bins multiplied by a number of items. The storage is a multi-dimensional bit array which caches the partial solutions. dpCache[i][b0][b2]...[bk] is a bit which stores possibility of bin packing of first i items inside bins with capacity b0...bk.

Here's code:

class DiscreteBinPacking 
{
public:
	DiscreteBinPacking(const vector<int>& bins, const vector<int>& items)
		: bins(bins), remainingCapacity(bins), items(items)
	{
		// computing size of bit-vector to store multidimentional matrix
		// for caching partial solutions
		int size = items.size();
		for (int i = 0; i < bins.size(); i++) {
			size *= bins[i] + 1;
		}
		dpCache.resize(size);
		dpCacheMask.resize(size);
	}

	bool CanBePacked()
	{
		return CanBePacked(items.size());
	}

private:
	const vector<int> bins;
	const vector<int> items;

	vector<int> remainingCapacity;
	// two bit-vectors - they both represent multidimentional bit arrays to cache partial solutions
	vector<bool> dpCache;
	vector<bool> dpCacheMask;

	// returns true if bin packing is solvable for first i items
	bool CanBePacked(int i)
	{
		if (i == 0) return true;
		int cacheIndex = i - 1;
		for (int b = 0; b < bins.size(); b++) {
			cacheIndex *= bins[b] + 1;
			cacheIndex += remainingCapacity[b];
		}
		if (dpCacheMask[cacheIndex]) return dpCache[cacheIndex];

		bool result = false;
		int itemSize = items[i - 1];
		for (int b = 0; b < remainingCapacity.size() && !result; b++) {
			if (remainingCapacity[b] >= itemSize) {
				remainingCapacity[b] -= itemSize;
				result = CanBePacked(i - 1);
				remainingCapacity[b] += itemSize;
			}
		}
		dpCacheMask[cacheIndex] = true;
		dpCache[cacheIndex] = result;
		return result;
	}
};

package com.company;

import java.util.Arrays;
import java.util.Collections;

public class Main {

public static void main(String[] args) {

int[] serverCapacity = {1, 3};
int[] taskCapacity = {4};
Arrays.sort(serverCapacity);
Arrays.sort(taskCapacity);
Data data = null;
for(int i = taskCapacity.length-1; i>-1; i--){
data = findCapacityInServer(serverCapacity, taskCapacity[i]);
serverCapacity = data.serverCapacity;
if(!data.foundCapacity){

System.out.println("Capacity Problem!");
break;
}
}
if(data.foundCapacity)
System.out.println("Looks Good!");

}

public static class Data{
public int serverCapacity[];
public boolean foundCapacity;
public Data(int servCapacity[], boolean foundCap){
serverCapacity = servCapacity;
foundCapacity = foundCap;
}
}

private static Data findCapacityInServer(int serverCapacity[], int taskCapacity){
for(int i = serverCapacity.length-1; i>-1; i--){
if(taskCapacity <= serverCapacity[i]){
serverCapacity[i] -= taskCapacity;
return new Data(serverCapacity, true);
}
}
return new Data(serverCapacity, false);
}
}

package com.company;

import java.util.Arrays;
import java.util.Collections;

public class Main {

    public static void main(String[] args) {

        int[] serverCapacity = {1, 3};
        int[] taskCapacity = {4};
        Arrays.sort(serverCapacity);
        Arrays.sort(taskCapacity);
        Data data = null;
        for(int i = taskCapacity.length-1; i>-1; i--){
            data = findCapacityInServer(serverCapacity, taskCapacity[i]);
            serverCapacity = data.serverCapacity;
            if(!data.foundCapacity){

                System.out.println("Capacity Problem!");
                break;
            }
        }
        if(data.foundCapacity)
            System.out.println("Looks Good!");

    }

    public static class Data{
        public int serverCapacity[];
        public boolean foundCapacity;
        public Data(int servCapacity[], boolean foundCap){
            serverCapacity = servCapacity;
            foundCapacity = foundCap;
        }
    }

    private static Data findCapacityInServer(int serverCapacity[], int taskCapacity){
        for(int i = serverCapacity.length-1; i>-1; i--){
            if(taskCapacity <= serverCapacity[i]){
                serverCapacity[i] -= taskCapacity;
                return new Data(serverCapacity, true);
            }
        }
        return new Data(serverCapacity, false);
    }
}

I think its a best fit algorithm problem in which a number of processes are given and some memory blocks are given and we have to find the best fit memory block for a problem.

There might a more efficient way to slove this problem but i would like to solve this problem with the help of linked list and a array.

Lets suppose we have a linked list whose each node representing the memory space of each data center. Take your first example .
Servers capacity limits: 8, 16, 8, 32
Tasks capacity needs: 18, 4, 8, 4, 6, 6, 8, 8

Linked list : 32->16->8->8
array : 18,4,8,4,6,6,8,8
Now i will search best fit memory space (which is wasting minimum memory space after acqureing required space)of each process .

18 :
14->16->8->8
16->14->8->8

4:
16->14->4->8
16->14->8->4

8:
16->14->4

4:
16->14

6:
16->8

6:
16->2

8:
8->2

8:
2

I may be mistaken, but isn't this problem as simple as determining whether the highest server capacity is higher than the highest task capacity?

If so, all you have to do is make one pass through the server capacities, find the max. Make another pass through the task capacities, find the max. The comparison between the two determines if they can be scheduled.

Is there a hidden constraint in the problem that says we can't use sorting, because if we can use sorting then this problem can be solved easily, the following are the steps to do that -:

1) sort the servers by their capacity/memory limits, so for instance in the example shown above we will have our servers in the following order after sorting - 8,8,16,32

2) Perform the same step as above for the tasks that you want to allocate on these servers, so the sequence of jobs now becomes the following - 4,4,6,6,8,8,8,18

3) now for each job scan through the list of server's sorted by their memory limits and if a task can fit in the server decrease the capacity of the server by the size of the job in each step, so the final list becomes the following - 0,2,2,6 and hence you can return true when you have exhausted finding a best fit for all the jobs, else if you failed finding a best fit for a specific task you can return false immediately

Sorry, my previous version has a bug. Here is working one.

class ServerCapacity:
    def __init__(self, list_capacity):
        self.list_capacity = sorted(list_capacity, reverse=True)
        self.answer = False

    def solution(self, list_job):
        self.list_job = sorted(list_job)
        self.recursive_walk(self.list_capacity, self.list_job)
        return self.answer

    def recursive_walk(self, list_capacity, list_job):
        # if job list is empty, done here
        if not len(list_job):
            self.answer = True
            return True

        # pop up the biggest job
        job = list_job.pop()

        # check if any server can take this job
        has_server = False
        for i, capacity in enumerate(list_capacity):
            if capacity >= job:
                list_capacity[i] -= job
                has_server = True

                #
                # if this assign doesn't work, return capacity, check
                # next server
                #
                if not self.recursive_walk(list_capacity, list_job):
                    list_capacity[i] += job
                    list_job.append(job)
                    has_server = False

        # if no server can handle this job, return False
        if not has_server:
            return False

if __name__ == "__main__":
    list_cap = [[1,3], [4,1], [8,16,8,32],       [8,6,2]]
    list_job = [[  4], [  4], [18,4,8,4,6,6,8,8],[5,4,3,3,1]]

    for cap, job in zip(list_cap, list_job):
        s = ServerCapacity(cap)
        print 'Solution :', s.solution(job)

Not sure we need dynamic programming for this,

if n servers are there and m number of tasks are there, first make max heap out of n servers, a second max heap of m taks,
pseudo code:
while(second max heap of m tasks is empty)
{
if(first server heap is empty)
return false;

mmax = get max task element out of second task heap
smax = get max server element of first server heap;

if(smax < mmax)
return false;

if(smax-mmax > 0)
insertintofirstserverheapandheapify(smax-mmax)
}

return true;

timecomplexity (mtaskitems log(servers) + mtaskitems log(mtaskitems ))

def canhandleload(sv, ld):
    sv = sorted(sv);
    ld = sorted(ld);    
    d = False;
    for x in reversed(ld) :
        d = False;
        for y in range(len(sv)):
            if(x <= sv[y]) :
                sv[y] =  sv[y]-x ;
                sv = sorted(sv);
                d  = True;
                break;
        if(d == False):
            return False;    
    return d;

s = [ 8, 16, 8, 32 ]
l = [18, 4, 8, 4, 6, 6, 8, 8 ]

print canhandleload(s,l);

Here's my 2 cents, correct me if I'm wrong.

1) Sort the server and task according to capacity/memory from large to small; return false if the some tasks are larger than the largest server;
2) Starting from large server, try to pack tasks in sequence into server, if some task can't fit in current server, go to smaller server and do the same thing;
3) Repeat until all task are filled. return false if there's left-over tasks

What if you push back on a question like this since by the time any algorithm solves it, it would have been faster to just "randomly" assign the tasks to the servers and let them finish. There is no fast optimal solution to this. See "The Maximum Resource Bin Packing Problem", Boyar et al

I would just take the shortest job dump it on the server with the least capacity for which it fits and move forward. This greedy algorithm isn't optimal, but is a hell of a lot faster than getting the absolute correct answer and since the load balancer (ie your solution to this problem) is what is getting pounded the hardest in this system, it has to be fast to dish out the tasks. It's google, if they can't handle the load on their work servers perfectly, screw it, they'll buy another million machines ;-)

Can we just simply get sums of two arrays? Then, sum of server capacity is greater than sum of tasks, it will be true. Am I missing anything?

Here is one more solution:

import std.stdio;
import std.algorithm;

void print(string name, const int[] array)
{
	write(name, ": [ ");
	foreach(int el; array) write(el, " ");
	writeln("]");
}

unittest
{
	int[] a = [2,5,1,2];
	sort!("a > b")(a);
	assert(a == [ 5, 2, 2, 1 ]);
	assert(isSorted!("a > b")(a));
}

bool TryToSchedulle(ref int[][] schedulled, int[]servers, int[]tasks)
{	
	if (tasks.length == 0) return true; // nothing process - success
	if (servers.length == 0) return false; // no servers left, but tasks exist - fail
	if (!isSorted!("a > b")(servers)) sort!("a > b")(servers); // if not reverse sorted - make reversed sort
	if (!isSorted!("a > b")(tasks)) sort!("a > b")(tasks);     // the same
	
	int[] skipped; // tasks
	int[] current; // list of tasks for the current server
	int capacity = servers[0]; // capacity of the current server
	foreach(task; tasks)
	{		
		if (capacity >= task)
		{						
			current ~= task; // run task in current server
			capacity -= task;	
		}
		else
		{
			skipped ~= task;
		}	
	}
	schedulled ~= current;	// add list of the task into solution
	return TryToSchedulle(schedulled, servers[1..$], skipped);	// make same with rest of the servers and skipped tasks
}

unittest
{
	{
		int[][] shedulled;
		assert(TryToSchedulle(shedulled, [],[]));
		assert(TryToSchedulle(shedulled, [1],[]));
		assert(TryToSchedulle(shedulled, [8, 16, 8, 32], [18, 4, 8, 4, 6, 6, 8, 8]));
		foreach(int[] tasks; shedulled) print (">", tasks);
	}

	{
		int[][] shedulled;
		assert(!TryToSchedulle(shedulled, [1,3], [4]));
	}

	{
		int[][] shedulled;
		assert(TryToSchedulle(shedulled, [8,6,2], [5,4,3,2,1]));
		foreach(int[] tasks; shedulled) print (">", tasks);
	}
}


int main(string[] argv)
{
    return 0;
}

Output:

>: [ 18 8 6 ]
>: [ 8 8 ]
>: [ 6 ]
>: [ 4 4 ]
>: [ 5 3 ]
>: [ 4 2 ]
>: [ 1 ]

class Program
{
static void Main(string[] args)
{
List<int> servers = new List<int>() { 8, 6, 2 };
List<int> tasks = new List<int>() { 6,5,3,2,1 };

bool result = BinFilling(servers, tasks);
}

//Servers: 8, 16, 8, 32
//Tasks: 18, 4, 8,4,6,6,8,8
//Servers: 8,6,2
//Tasks: 5,4,3,2,1

public static bool BinFilling(List<int> servers, List<int> tasks)
{
if (tasks.Count == 0)
return true;


for (int i = 0; i < servers.Count; i++)
{
for(int j=0; j< tasks.Count; j++)
{
if (tasks[j] != 0 && tasks[j] <= servers[i])
{
List<int> cloneServers = new List<int>(servers);
List<int> cloneTasks = new List<int>(tasks);
cloneServers[i] -= cloneTasks[j];
cloneTasks.RemoveAt(j);
if (BinFilling(cloneServers, cloneTasks))
{
return true;
}
}
}
}
return false;
}
}

What if sort the server and task first and assign the largest task to largest server, then add the smaller task to that server. The following code is the implementation of the algorithm above

public boolean arrange(int[] servers, int[] tasks){
    	Arrays.sort(servers);
    	Arrays.sort(tasks);
    	
    	for(int i = servers.length - 1; i >= 0; i--){
    		for(int j = tasks.length - 1; j >= 0; j--){
    			if(tasks[j] <= servers[i]){
    				servers[i] -= tasks[j];
    				tasks[j] = 0;
    			}
    		}
    	}
    	
    	for(int j = 0; j < tasks.length; j++){
    		if(tasks[j] > 0)
    			return false;
    	}
    	
    	return true;
    }