You are given 4 items as {value, weightpairs in this format {(20,5), (60, 20), (25, 10}, {X, 25). You can assume that the array is sorted based on the ratio. The capacity of knapsack is 50. The item no. 4 (whose weights 25) is taken fractionally to fill upto the knapsack capacity. That fraction is represented in format. What is the lowest possible value of ?

You are given 4 items as {value, weightpairs in this format {(20,5), (60, 20), (25, 10}, {X, 25). You can assume that the array is sorted based on the ratio. The capacity of knapsack is 50. The item no. 4 (whose weights 25) is taken fractionally to fill upto the knapsack capacity. That fraction is represented in format. What is the lowest possible value of ?

Programming Logic & Design Comprehensive

9th Edition

ISBN:9781337669405

Author:FARRELL

Publisher:FARRELL

Chapter6: Arrays

Section: Chapter Questions

Problem 17RQ

See similar textbooks

Similar questions

Given an array as follows5 4 9 10 2 8 1 3 7 6 Suppose we partition this array using quicksort's partition function and using 5 for the pivot. A) Draw the resulting array after the partition finishes.B) The following is an array which has just been partitioned by the first step of quicksort:3 0 2 4 5 8 7 6 9Give all the elements that could be the pivot? (There may be more than one possibility!) PLEASE HELP WITH PART A AND B AND SHOW WORK!!
Imagine that we want to keep track of friendships between n people. We can do this with an array of size nXn. Each row of the array represents the friends of an individual, with the columns indicating who has that individual as a friend. For example, if person j is a friend of person i, then we place a mark in column j of row i in the array. Likewise, we should also place a mark in column i of row j if we assume that friendship works both ways. What will be the space complexity of this problem
The key observation is as follows. If n/2 < A[n/2], then if such anindex exists, it must be in A[1 . . . n/2−1]. This is because A[n/2+1] > A[n/2]+1 >n/2 + 1, A[n/2 + 2] > A[n/2 + 1] + 1 > n/2 + 2 and so on Could you explain why these are true by using actual number and example of array ?A[n/2+1] > A[n/2]+1 > n/2 + 1, A[n/2 + 2] > A[n/2 + 1] + 1 > n/2 + 2 and so on
Below is the exercise for unsorted arrays. True or False: For each statement below, indicate whether you think it is True or False 3) For the insert function, if the array is empty, there are no comparison operations that need to be performed and you can immediately add the new element 5) Because the update algorithm depends on using linear search, its performance is O(1) in the worst case scenario 6) If you search for and delete an element in an unsorted array and then shift the rest of the elements to fill the hole, the worst case performance is O(n) 7) If you search for and delete an element in an unsorted array and then move the last element to fill the hole, the worst case performance is O(n)
Let A be an array of numbers. In the maximum sub-array problem, your goal is to determine the sub-array A[x . . . y] of consecutive terms for which the sum of the entries is as large as possible. For example, if A = [−2, −3, 4, −1, −2, 1, 5, −3], the maximum sub-array is [4, −1, 2, 1, 5], and the largest possible sum is S = 4 − 1 − 2 + 1 + 5 = 7. Suppose A = [1, 2, −4, 8, 16, −32, 64, 128, −256, 512, 1024, −2048]. Determine S, the largest possible sum of a sub-array of A.
can you solve this please ? Given an array of unsorted integers, you are requested to investigate whether there exist a pair of numbers in this array that has a sum equal to a given key or not. For example, if the arr = [8, 7, 2, 5, 3] and the key = 12, the answer will be "Yes" as the array has a pair (7 and 5) where their sum = 12 = key, otherwise "No" is returned. To solve this problem, the following idea can be used: i. Consider every pair in the given array and check if their sum = key. ii. Sort the array first, keeping two pointers to on the minimum and maximum of the array and then move from both directions toward the center of the array while checking whether the sum = key or not. Answer the following questions: a) Transform each of the above ideas (i) & (ii) into algorithm (pseudocode) and compute their complexities b) Critic these two ideas: [Which is better? Why?] c) Design a better solution with less complexity. [note: your idea should be…
Below is your exercise for Basic Sorts. For submitting your answers, you can either send me an updated Word document with your answers, email your answers directly, or even take a screen shot of your work on paper if you like. In all cases, email me your answers when you feel ready. Use the following array of numbers for each of the sorting tasks below: 6 2 8 1 7 5 3 4 Bubble Sort (not optimized) – show what the array looks like each time the swap operation is performedusing the bubble sort algorithm (not optimized, meaning no use of swapFlag) Selection Sort - show what the array looks like each time the swap operation is performed using the selection sort algorithm Insertion Sort – show what the array looks like at the end of each outer loop iteration of the insertion sort algorithm
Given an array A = [10, 7, 4, 2, 1], and target = 7, return the index of the target if found, else return -1. 1. Can this problem be solved in O(logN)? 2. If so, write the implementation. Mention time and space complexity 3. If this problem cannot be solved using O(logN), what is the solution that you suggest - write the code and also mention time and space complexity.
A) Starting with a dynamic array of length = 32 and numElements = 30, the length after we execute 90 insert at end operations is [answer]Group of answer choices 120 122 128 none of the above B) In each of the following cases, we start with a dynamic array of length = 128 and numElements = 64. After we execute 30 delete last operations, the number of elements isand the length isAfter we execute 32 delete last operations, the number of elements isand the length isAfter we execute 60 delete last operations, the number of elements isand the length is no hand written
t solve this problem using a regular array. The approach we’ll use,which is similar to how we’ll solve the problem using a BitArray, is to initializean array of 100 elements, with each element set to the value 1. Starting withindex 2 (since 2 is the first prime), each subsequent array index is checkedto see first if its value is 1 or 0. If the value is 1, then it is checked to see if itis a multiple of 2. If it is, the value at that index is set to 0. Then we move toindex 3, do the same thing, and so on.To write the code to solve this problem, we’ll use the CArray class developedearlier. The first thing we need to do is create a method that performs the sieve.Write the code in c#:
Take an array of length n where all the numbers are nonnegative and unique. Find the element inthe array possessing the highest value. Split the element into two parts where the first part containsthe next highest value in the array and the second part holds the required additive entity to get thehighest value. Return the array index value. Consider the negative numbers as well.Input: [4, 8, 6, 3, 2]Output: [4, 6, 2, 6, 3, 2]
You are given an array called source, with length n, and a set of m arrays called target, each also with length n. The arrays contain only positive integers. The arrays are unsorted. For any number x, the smallest number in target[x] is guaranteed to be smaller than target[x+1]. All the numbers in target are unique. The following figure illustrates an example of valid source and target arrays for this case, where n=5 and m=6. source = [14, 13, 15, 11, 12]target[0] = [4, 2, 1, 3, 5]target[1] = [6, 8, 7, 10, 9]target[2] = [14, 15, 12, 11, 13]target[3] = [17, 20, 16, 18, 19]target[4] = [22, 21, 24, 23, 25]target[5] = [30, 29, 28, 27, 26] The smallest number in each array in target is styled with bold. You can quickly see that the smallest number in target[0] is smaller than the smallest number in target[1], the smallest number in target[1] is smaller than the smallest number in target[2], and so on. You can also see that there is no duplicate number within the arrays in target. You are…