CareerCup

Could you please clarify on condition 1 & 3.
Condition 1 says that ' If the cost of all the items in an order is more than $1000, split those items into multiple packages, otherwise one package would be enough'

Even if items distributed in a different package with each item having cost more than 1000$ than condition 3 can never be satisfied

typedef struct
{
	int cost;
	int weight;
        int couriercharges; //Indicate courier charges for x weight
}item_t;

typedef struct
{
	item_t *items;//List of items
        int        no_of_items;//no. of items in a package
        int        cost; // Total cost of the package
}package_t;

#define MAX_PACKAGES = 100;
typedef 
{
	package_t *packagelist[MAX_PACKAGES];
	int 	   no_of_package;
}packages_t;


packages_t splits_item_package(item_t item[], length)
{
	int no_of_packages = 0;
	int total_no_of_item_packed = 0;
	packages_t *packages;
	package_t  *package;
	packages = (packages_t*) malloc(sizeof(packages_t));
	packages->no_of_packages = 0;
	if (length == 0) return -1;
        //Sort item in the descending order of Costofcourier/weight ratio
        //and store the same in array sortedItem
        // e.g. weight { 500, 200, 700, 100 }
        // cost {310,310,465,310}
        // cost/Weight {0.62, 1.55, 0.66, 3.1}
	// SortedOrder of Items = {100,200,500,700}
	
        
	for( int i =0 ;i<length ;i++)
	{
		packages->packagelist[i] = (package_t*) malloc(sizeof(package_t));
		package = packages->packagelist[i];         	
		package->items = (item_t*) malloc(sizeof(item_t) * length);
		package->no_of_items = 0;
                package->cost = 0
		j = total_no_of_item_packed;
		for(j ;j< length; j++)
		{
			if(package->cost + sortedItems[j] <= 1000)
			{
				index = package->no_of_items;
				package->item[index].cost = sortedItems[j].cost;
				package->item[index].weight = sortedItems[j].weight;
				package->item[index].courierCharges = 	
				sortedItems[j].courierCharges;
				package->cost += sortedItems[j].cost;
				package->no_of_items++;
				total_no_of_item_packed += package->no_of_items;
				no_of_packages++;
			}
			else
			{
				break;		
			}
								
		}
		if(j  == length)
		break;
	}

	packages->no_of_packages = no_of_packages;
	return packages;			
}

Yes, In the example, i have taken above where
weight { 500, 200, 700, 100 }
Price {150,300,100,800}
Couriercost {310,310,465,310}
In the above example, equal division is not possible, so the result is optimized for courier cost. In the input set which you have taken
weight { 500, 500,1000 }
Price {500,500,1000}
Couriercost {310,310,720}
The equal divison is possible. So, output of the above logic would result in equal divison of weight and optimized courier cost. Please suggest or share some input set.

package com.concurrency.pkg;

public class OrderSplitting {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int itemPrice[] = { 500, 200, 400, 1000, 2500, 3000 };
		int itemWeight[] = { 200, 800, 300, 700, 800, 200 };
		int totalPrice = 0;
		for (int i = 0; i < itemPrice.length; i++) {
			totalPrice = totalPrice + itemPrice[i];
		}
		int reminder = totalPrice % 1000;
		int totalPackage = totalPrice / 1000;
		if (reminder > 0) {
			totalPackage += 1;
		}
		for (int j = 0; j < itemWeight.length; j++)
			System.out.print(itemWeight[j] / totalPackage + " , ");
	}

}