Can anybody give me a hint how to find efficient solution for the problem below?
Alex brought a roll to the kitchen, which he wants to share with his colleagues. To do this, he wants to cut the roll into N equal parts. Of course, the roll can only be cut across. Accordingly, Alex will make N − 1 cut with a knife at regular intervals.
Upon returning from the coffee break, Alex wondered - could it be possible to do with fewer movements, if Vanya's knife was infinitely long (in other words, if he could make as many cuts as he wanted at a time, if these cuts lie on one straight line)? It is believed that the places for the cuts are planned in advance, and all cuts are made with pinpoint precision.
It turns out that you can. For example, if Alex would like to divide the roll into 4 parts, he could do with two cuts - first he would divide the roll into two halves, and then combine the two halves and cut both in half at the same time. So I need to find the minimum of cuts.
Given N - people
6
Result
3
Given N - people
5
Result
3
I can do it with a small number of people, but what if there 100 or 1000 people?
My code below:
public class Cake{
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int number = Integer.parseInt(reader.readLine());
int all = 0;
if (N % 2 == 0) {
all = number/ 2;
}
else {
all = number / 2 + 1;
}
System.out.println(all);
}
}
It is indeed a math problem. You will need log(N,2) cuts for the first power of 2 people and one more for the extra people.
from math import log
def cutCount(N): return 0 if N<2 else int(log(N-1,2))+1
output:
for N in range(1,10): print(N,"people, cuts: ",cutCount(N))
1 people, cuts: 0
2 people, cuts: 1
3 people, cuts: 2
4 people, cuts: 2
5 people, cuts: 3
6 people, cuts: 3
7 people, cuts: 3
8 people, cuts: 3
9 people, cuts: 4
To verify for larger numbers, you can simulate the cuts mentally:
cutCount(50) # 6
1st cut --> 2 pieces
2nd cut --> 4 pieces
3rd cut --> 8 pieces
4th cut --> 16 pieces
5th cut --> 32 pieces
6th cut --> only cut 18 of the 32 pieces --> 50 pieces
Assuming you placed the pieces strategically every time, the last 18 pieces you need to cut are exactly 2/50th of the total length and the 14 others are 1/50th
there are several ways to do the "strategic" cuts. Here's an example:
Number x Lengths (in 1/50th of the total length):
cut #1 : [-----1x32-----][------------1x18---------------] total 2 pieces
cut #2 : [-----2x16-----][------------2x9----------------] total 4 pieces
cut #3 : [------4x8-----][---2x4--][--------2x5----------] total 8 pieces
cut #4 : [------8x4-----][---4x2--][--2x2--][----2x3-----] total 16 pieces
cut #5 : [-----16x2-----](------12x1-------)(-2x1-)[-2x2-] total 32 pieces
(----------14x1--------)[--------18x2-----------]
cut #6 : (----------14x1--------)(--------32x1-----------) total 50 pieces
(---------------------50x1----------------------)
Brackets are not to scale. Pieces that are 1/50th are not cut any further
If you want a recursive version of this calculation, you can count 1 for every time you are able to divide the number of people by 2 and then add 1 if there was at least one odd result in these divisions:
def cutCount(N,odd=0):
return odd if N<2 else 1+cutCount(N//2,odd|N%2)
Using Recursive algorithm
Note: Alain T answer is exact formula
Code
def cuts(n):
'''
Recursively decide number of required cuts '
Algorithm:
Base case: n = 0 or 1:
no cuts, so answer is 0
n is even: divide roll into two rolls of n//2 (1 cut).
These two rolls can be cut in parallel in the future
so cuts will be 1 + cuts(n//2).
Since n is even, n//2 == (n+1)//2,
so this can also be written as 1 + cuts((n+1)//2).
So answer is: 1 + cuts((n+1)//2)
Odd n: divide roll into two rolls of lengths n//2 and (n+1)//2 (1 cut)
One of these is even, the other odd.
These two rolls can be cut in parallel successively
until the longer 1 is reduced to length 1.
Thus cuts is 1 + cuts(max((n//2), (n+1)//2))
For all n: (n+1)//2 >= (n//2), so
max((n//2), (n+1)//2) = (n+1)//2
So answer is 1 + cuts((n+1)//2)
So we have:
if n = 0 or 1: return 0
otherwise: return 1 + cuts((n+1)//2)
'''
return 0 if n < 2 else 1 + cuts((n+1)//2)
for n in list(range(9)) + [20, 50, 100, 1000, 10000]:
print(f'{n} people, cuts: {cuts(n)}')
Output
0 people, cuts: 0
1 people, cuts: 0
2 people, cuts: 1
3 people, cuts: 2
4 people, cuts: 2
5 people, cuts: 3
6 people, cuts: 3
7 people, cuts: 3
8 people, cuts: 3
20 people, cuts: 5
50 people, cuts: 6
100 people, cuts: 7
1000 people, cuts: 10
10000 people, cuts: 14
For example, with input like:
4 6 7
1 2 6 2
......//more routes statement same format as second line
1 4
It means there are 4 places in total, and 6 routes in total, with 7cm convex hull of the ship(From the first line). The next 6 lines states where does the route connect, time needed and how many cm of the hull were worn down in the process. (In the second line, the route connects 1 and , takes 6 minutes, and wore down the hull by 2. The last line states where the starting point and destination are (1 and 4 in this case). The goal for this program is to get the minimum time used with the hull not completely worn down. I had tried using a
map(starting point of a route, end point);
but I can't really assign time used or the number of hull worn down this way, since multiple route can have the same starting point, meaning the two locations can't be used as a key like
map(starting point, time);
Also
Matrix[boolean][boolean]
doesn't seem to be an effective way to do this question. What technique should I use for this program and how do I do it?
Complete example with input:
10 4 7
1 2 4 4
1 3 7 2
3 1 8 1
3 2 2 2
4 2 1 6
3 4 1 1
1 4 6 12
1 4
output:
7
The routes can be used in two directions.
This question deals with building a correct Criteria in Hibernate for the following case.
Suppose I start with a table like this:
id ts metric value carrier
1 1 distance 4 alice
2 1 count 2 alice
3 2 distance 3 alice
4 2 count 1 alice
5 1 distance 3 becky
6 1 count 2 becky
7 2 distance 4 becky
8 2 count 1 becky
9 1 distance 10 other
10 1 count 10 other
11 2 distance 10 other
12 2 distance 10 other
What this is is a time-bucketed set of metrics recording how far alice, becky and a general other carried some count of items some distance.
I'd like to roll it up in the following fashion: metrics with 'other' or the 'winner' as decided by distance for each time bucket are kept. Thus, the above table would yield the following result set:
id ts metric value carrier
1 1 distance 4 alice
2 1 count 2 alice
7 2 distance 4 becky
8 2 count 1 becky
9 1 distance 10 other
10 1 count 10 other
11 2 distance 10 other
12 2 distance 10 other
Ultimately this is translated to this:
ts carrier distance count
1 alice 4 2
1 other 10 10
2 becky 4 1
2 other 10 10
But this translation I already understand how to do. What I'm unclear on is how to build the criteria to keep the 'top n' metrics. Which brings us to the wrinkle: while this example is simplified, there would be a large number of 'carriers', and what I'm interested in is the top n such carriers, discarding the rest. Thus in the example above n = 1, but it's likely to be greater than 1 in most cases.
I know that I can use addOrder(Order.desc("value"), but that poses both a problem in that other is intermixed and distances and counts will be incorrectly intermingled. I'm looking for something that sorts 'blocks' of rows which are decided, in order by ts, then carrier, then using the metric = "distance" for the sort order.
I'm trying to create guitar chord application but the chord chart for a single chord is too many. Listing all would take time and not efficient. For example, C major chord has variation such as the chart below
x 3 2 0 1 0
x 3 2 0 1 3
x 3 5 5 5 0
8 10 10 9 8 8
Is there any way that the chart can be generated by with/without knowing the keys to create the chord? ie, CEG for chord C major.
Contrary to the comments I think this is possible. If you got all of the open chord shapes such as..
0 2 2 1 0 0 (open E)
0 0 2 2 2 0 (open A)
0 3 2 0 1 0 (open C)
X 0 0 2 3 2 (open D)
Then you can shift them up using bar chords and you should be able to write code to calculate all the permutations for a particular chord. For example if you wanted all the C major triads (as in your question) you know one is
0 3 2 0 1 0 (open C)
But you also know one of them is the open A shape above but shifted UP 3 frets...
3 3 5 5 5 3 (open A shifted up as a bar chord)
This is your third chord in your question. You can also calculate where to shift the open E shape, which would be...
8 10 10 7 8 8
Again, this is one of the chords in your question. This way you can calculate all the positions for any chord using code - providing you have a sufficient set of open chords that can be comfortably shifted up like this.
So your set of C chords using these initial open shapes would be...
C Chords...
8 10 10 7 8 8
3 3 5 5 5 3
0 3 2 0 1 0
X 10 10 12 14 12
Now if you wanted to know the set of D chords you can actually calculate these by adding 2 to all the numbers above (two of them wrap around an octave but you can work this into a calculation)
D Chords...
10 12 12 11 10 10
5 5 7 7 7 5
10 13 12 10 11 10
X 0 0 2 3 2
Have you ever seen the book called "Fret Logic"? It shows the mathematical logic of the guitar fretboard.
There are also shortcut versions of most chords, such as the nice 3 string version used a lot in cross picking:
x
x
x
x
5
5
3
This is a shortened version the C chord in the A position, but it is used a lot.
Given a dataset
0 0 1
3 4 1
5 9 1
12 1 1
8 7 1
9 8 -1
6 12 -1
10 8 -1
8 5 -1
14 8 -1
When applied SVM on these train data,
3 4 1,8 7 1 and 6 12 -1 are missclassified.
What does it mean--
whether the datapoint 3 4 doesnot fall in class label 1 and but falls in -1.
Is it like that?
Yes, it means that the model you have calibrated yields :
3 4 => -1
8 7 => -1
6 12=> +1
You have an error rate of 30%.
Using linear discriminant analysis approach, you can have a 20% error rate.
But keep in mind that you do not have much elements in your population (only 10). This is relatively low for 2 descriptors.
Indeed, if you estimate the error rate with a bootstrap method, we find out :
A 60% error rate for discriminant analysis approach
A 55% error rate for SVM approach : SVM is often more robust to overfitting.
Cheers