Related to my previous question, just wonder how to solve a system of linear equations with non-negative integral solutions, for example:
c11*x+c12*y+c13*z=d1
c21*x+c22*y+c23*z=d2
Thanks a lot!
Edit
I meant efficiently. For example, I could have used FrobeniusSolve to get two solution lists and try to find the intersection. But sometimes, the individual solution list is probably hugely large. Or try to verify each individual solution returned by one FrobeniusSolve to see whether they satisfy all the remaining equations, but that suffers from the same drawback.
Reduce is able to solve these types of problems.
To answer the specific case in your comment above:
In[1]:= solns = Reduce[x1 + 2 x2 + 5 x3 + 7 x4 == 40 &&
x1 + x2 + 2 x3 + x4 == 20 &&
x1 > 0 && x2 > 0 && x3 > 0 && x4 > 0,
{x1, x2, x3, x4}, Integers]
Out[1]= (x1 == 6 && x2 == 11 && x3 == 1 && x4 == 1) ||
(x1 == 7 && x2 == 8 && x3 == 2 && x4 == 1) ||
(x1 == 8 && x2 == 5 && x3 == 3 && x4 == 1) ||
(x1 == 9 && x2 == 2 && x3 == 4 && x4 == 1) ||
(x1 == 11 && x2 == 5 && x3 == 1 && x4 == 2) ||
(x1 == 12 && x2 == 2 && x3 == 2 && x4 == 2)
Edit:
You can check that this is the same solution you get by solving the two equations separately and taking the intersection of their solutions:
In[2]:= a = Reduce[x1 + 2 x2 + 5 x3 + 7 x4 == 40 &&
x1 > 0 && x2 > 0 && x3 > 0 && x4 > 0,
{x1, x2, x3, x4}, Integers];
b = Reduce[x1 + x2 + 2 x3 + x4 == 20 &&
x1 > 0 && x2 > 0 && x3 > 0 && x4 > 0,
{x1, x2, x3, x4}, Integers];
In[4]:= solns == Intersection[a, b]
Out[4]= True
And you can extract the solutions by, e.g.,
turning the solutions into a list of replacement rules
and applying to the variables:
In[5]:= {x1, x2, x3, x4} /. {ToRules[solns]}
Out[5]= {{6, 11, 1, 1}, {7, 8, 2, 1}, {8, 5, 3, 1},
{9, 2, 4, 1}, {11, 5, 1, 2}, {12, 2, 2, 2}}
Related
This is an ICPC online round question. I checked sample input and my own imaginary inputs.
This is link to question
Here is my code. This code is in Python.
for _ in range(int(input())):
x1,y1,x2,y2=map(int,input().split())
if (x2-x1==y2-y1)or((x2-x1!=0)and(y2-y1!=0)):
print('sad')
elif (x2-x1==0 and y2-y1>0):
print('up')
elif (x2-x1==0 and y2-y1<0):
print('down')
elif (y2 - y1 == 0 and x2 - x1 > 0):
print('right')
elif (y2 - y1 == 0 and x2 - x1 < 0):
print('left')
Can anyone suggest inputs for that code will not work?? If code is correct for all inputs , any modification will be welcomed?.
Your code already does not parse the input correctly. Have a look:
python /tmp/test.py
1
0 0 0 1
Traceback (most recent call last):
File "/tmp/test.py", line 3, in <module>
x1, y1, x2, y2 = map(int, input().split())
File "<string>", line 1
0 0 0 1
^
Besides from that, it seems to be logical correct.
However, your coding style is improvable. Have a look at my version:
for _ in range(int(input())):
x1, y1, x2, y2 = map(int, input().split())
if x1 != x2 and y1 != y2:
print('sad')
elif x1 == x2 and y1 < y2:
print('up')
elif x1 == x2 and y1 > y2:
print('down')
elif y1 == y2 and x1 < x2:
print('right')
elif y1 == y2 and x1 > x2:
print('left')
The only thing I changed was to improve the conditions. Furthermore, I removed the redundant condition at the bottom.
As a former participant of NWERC and ACM-ICPC I can only suggest to have an eye on readable code. It is not as important as in production code bases, but it helps a lot when you have to debug printed code, as happens at real competitions.
I just had to write a function that seemed simple to write, but when I actually did it, it turned out way gorier than I had expected. It's really bugging me, I feel like there's a better solution, but my brain is going crazy trying to think of it, so therefore I'm turning to you fine folks.
Basically, I have 2 triangles, and I want to know if they share a common edge. The triangles are indexed by their vertices (i.e. their vertices is just an index to an array containing the actual coordinates), so it comes down to finding if two sets of three numbers have two numbers in common. I.e. triangles (1,2,3) and (3,1,5) do share an edge, the (1,3) edge. However, triangles (1,2,3) and (1,5,6) does not share an edge (only a vertex) and neither does (1,2,3) and (4,5,6).
How would you write this "two numbers in common function"? You can assume all values inside each set are distinct (i.e. (1, 1, 2) is not going to be an input) and you can also assume that two sets don't equal each other (i.e. I'm not going to compare (1,2,3) and (1,3,2), because those two are the same triangle). However, no assumptions can be made regarding order, they are not sorted or anything like that.
This is basically what I came up with (assuming the sets are (x0, x1, x2) and (y0, y1, y2)):
// If the x0 is equal to any of (y0, y1, y2), make sure at least one of (x1, x2)
// is equal to one of the y numbers
if (x0 == y0) {
return x1 == y1 || x1 == y2 || x2 == y1 || x2 == y2;
} else if (x0 == y1) {
return x1 == y0 || x1 == y2 || x2 == y0 || x2 == y2;
} else if (x0 == y2) {
return x1 == y0 || x1 == y1 || x2 == y0 || x2 == y1;
} else {
// if x0 is not equal to any of (y0, y1, y2), then x1 and x2 both have
// to be equal to two of the y numbers.
return (x1 == y0 && x2 == y1)
|| (x1 == y0 && x2 == y2)
|| (x1 == y1 && x2 == y0)
|| (x1 == y1 && x2 == y2)
|| (x1 == y2 && x2 == y0)
|| (x1 == y2 && x2 == y1);
}
but it feels so gory to me! So many branches and such long boolean statements! I feel like i'm missing an obvious easy solution, and it's driving me insane.
In addition, this happens in an inner loop in a very performance sensitive application, so performance (branching, arithmetic, whatever) matters.
BTW, the code I'm writing is C#, but the question is the same in more or less any imperative language.
EDIT:
I put together a quick benchmark (here's the code) with the suggestions so far. Here are the results (running it at a million random pairs of triangles):
Original method result: 7035, time elapsed in ms: 8.6252
qwertyman method result: 7035, time elapsed in ms: 8.2537
midjji method result: 7035, time elapsed in ms: 8.7984
Single HashSet method result: 7035, time elapsed in ms: 184.4984
Many HashSets method result: 7035, time elapsed in ms: 190.5785
The numbers remain fairly consistent run to run, with #qwertyman's method always being a bit faster than my original version or #midjii's. It also has the advantage of being the cleanest and nicest of them all, so I'm going to go with that one.
I was actually a bit surprised that the "Many HashSets" was so close to "Single HashSet", I would have thought constructing a million HashSets would have a bigger overhead than around 16 milliseconds (though this obviously doesn't count the increased pressure on the garbage collector), though they're both obviously far behind the other methods.
Thanks for the help!
You can do something like this:
int n = 0;
// check if x0 is among the values in the second set
if (x0 == y0 || x0 == y1 || x0 == y2) {
n++;
}
// check if x1 is among the values in the second set
if (x1 == y0 || x1 == y1 || x1 == y2) {
n++;
}
// check if x2 is among the values in the second set
if (x2 == y0 || x2 == y1 || x2 == y2) {
n++;
}
return n >= 2;
This relies on the fact that (as you mentioned) the numbers in each set are distinct, resulting in a simpler logic.
If you are using C, you could write it shorter:
int n = 0;
n += x0 == y0 || x0 == y1 || x0 == y2;
n += x1 == y0 || x1 == y1 || x1 == y2;
n += x2 == y0 || x2 == y1 || x2 == y2;
return n >= 2;
I would use:
...
{
//ti= xi in y
bool t0= (x0==y0) ||(x0==y1)|| (x0==y2);
bool t1= (x1==y0) ||(x1==y1)|| (x1==y2);
bool t2= (x2==y0) ||(x2==y1)|| (x2==y2);
return (t0 && t1) || (t0 && t2) || (t1 && t2);
}
Mostly because I think its easier to read.
Performance-wise it is rather likely that with the right settings it should be as fast. Compilers are fantastic at optimizing self enclosed, no side effect, logical statements and use lazy evaluation for bool(assuming nothing silly has been done to ==).
Basically I am generating numbers and they can't be equal to any other numbers I've generated. Is there a quicker way to do this because it looks slightly ridiculous.
Thanks
#possible generated values
x1 = 0
x2 = 1
x3 = 2
#generate co-ordinates
x4 = rand(7)
until x4 != x1 && x4 != x1+1 && x4 != x1+2 && x4 != x2 && x4 != x2+1 && x4 != x2+2 && x4 != x3 && x4 != x3+1 && x4 != x3+2 do
x4 = rand(7)
end
#possible generated values
y1 = 0
y2 = 1
y3 = 2
y4 = rand(7)
until y4 != y1 && y4 != y1+1 && y4 != y1+2 && y4 != y2 && y4 != y2+1 && y4 != y2+2 && y4 != y3 && y4 != y3+1 && y4 != y3+2 do
y4 = rand(7)
end
For Ruby 1.9+
(0..6).to_a.sample(x)
or for older versions
(0..6).to_a.shuffle.take(x)
where x is the number of integers you want to take. Since rand(7) does not include the number 7, you need your range to be one less than the number you'd pass to rand.
And obviously you can't take more numbers than are in the range.
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 10 years ago.
Improve this question
Suppose, I have an differential equation like this one:
mu1 u1[x] - u1''[x] - 10 u1[x] == 0
where mu1 is the eigenvalue and u1 is the eigenfuntion. Now, How can i calculate the eigenvalue mu1 numerically??? Can anyone help me out with this problem??
I'm assuming you want to solve something like
u1''[x] + 10 u1[x] == mu1 u1[x]
with boundary conditions
u1[x0] == 0; u1[x1] == 0; u1'[x0] =!= 0
for some x0 < x1. One way to do that is to first solve the differential equation plus the boundary conditions at x0, e.g.
sol = DSolve[{mu1 u1[x] - u1''[x] - 10 u1[x] == 0, u1[x0] == 0, u1'[x0] == 1}, u1, x][[1]]
which gives as output
{u1 -> Function[{x}, -((E^(-Sqrt[-10 + mu1] x - Sqrt[-10 + mu1] x0)
(-E^(2 Sqrt[-10 + mu1] x) + E^(2 Sqrt[-10 + mu1] x0)))/(2 Sqrt[-10 + mu1]))]}
We can then use this solution to find mu1 such that the boundary condition at x1 is satisfied:
sol1 = Solve[{u1[x1] == 0 /. sol[[1]], x1 > x0}, mu1, MaxExtraConditions -> All]
From which we find
{{mu1 -> ConditionalExpression[(10 x0^2 - 20 x0 x1 + 10 x1^2 - 4 \[Pi]^2 C[1]^2)/(
x0^2 - 2 x0 x1 + x1^2),
x0 \[Element] Reals && C[1] \[Element] Integers && C[1] >= 1 && x1 > x0]},
{mu1 -> ConditionalExpression[(-\[Pi]^2 + 10 x0^2 - 20 x0 x1 + 10 x1^2 -
4 \[Pi]^2 C[1] - 4 \[Pi]^2 C[1]^2)/(x0^2 - 2 x0 x1 + x1^2),
x0 \[Element] Reals && C[1] \[Element] Integers && C[1] >= 0 && x1 > x0]}}
I have a set of inequalities, for example,
2 x1 >=3 x2 && 0<=x1<=1 && 0<=x2<=1
which can be solved with Reduce. Then I want to do an integration for the function f(x1,x2)=1/x1 in the area defined by the inequalities above. In this case, Reduce gives a result
(x1 == 0 && x2 == 0) || (0 < x1 <= 1 && 0 <= x2 <= (2 x1)/3)
Then I can do integration by using
Integrate[Integrate[1/x1, {x2, 0, 2 x1/3}], {x1, 0, 1}]
But these all need my manual intervention. How do I do this in a streamline fashion? Many thanks!
Integrate[1/x1 Boole[2 x1 >= 3 x2 && 0 <= x1 <= 1 &&0 <= x2 <= 1], {x1, -\[Infinity], \[Infinity]}, {x2, -\[Infinity], \[Infinity]}]