Mock all of the DB calls to return either valid responses or errors. Then make calls to the rest service for various scenarios. For instance, send a valid JSON but have the mock DB call return a connection error. If your rest endpoint is supposed to send a 500 error with some kind of payload then assert that it actually happens. Do the same for any other scenario you can think of. If the JSON is transformed and validated in other business classes then writing unit tests for that should be easy. If not then you will likely need more tests that send different types of payloads to your rest endpoint and asserts responses for valid and invalid inputs are correct. I would also ensure that a misformatted JSON payload returns a proper response.
Do the text files all look the same in terms of dimensions, just that the numbers vary?
If you just want the numbers in the second line, go through it character by character, identify each number individually and parse it using eg. the atoi or stoi function. But C++ has like fifty other ways to do this with depending on how safe, concise or legible you want to be. How are you storing your data? As raw memory or eg. in a vector container?
Complexity of the conjecture functions is O(n^4) and you're surprised it's quickly slow? If you want to multiply the upper limit by 2, you multiply the time needed by 8.
)), so it will be bazing fast to compute all primesAre those integers or real numbers?
to me, since checking a value whose primality has been precomputed is O(1)Well, I agree that the number of operation is
). k/log(k) is far too close to k, and log(k) grows infinitely slower than sqrt. which dominates n log(k)Don't you have it backwards? Since pi(x) grows with log(x), pi(x)/x tends to 0 as x tends to infinity. So the number of primes you are looking through is actually very small once x is big enough. Thus it's less than O(n^k) for any k > 1?Well, I agree that the number of operation is
sum( pi(k/2) ) for even k over 1..n
where pi(k) is the prime counting function, and py(k) = Theta(k / log(k))
Problem is, I don't know what sum(pi(k)) gives. It''s obviously O(n^2), so I used that. I would like to know a more precise estimation.
But I really doubt it's O(n log
In another way :
sum(k / log(k)) dominates sum(k / sqrt(k)) which is equivalent to n sqrt
So, yes, it's less than O(n^2), but sufficiently close to it, I'd say, so that you'll never see a proper difference.
I suspect it's Omega(n^x) for basically any x<2... and it's not even O(n^1.9999999)
But I may be wrong, I'm bad at this kind of summing those special functions (and a couple of my own students are probably even better at it than me :/ )
Well you can sum a large quantity of very small things and still get huge results...
I think you are correct
.I'm fine with O(n^2/logSorry, i meant n^2 / log
), indeed. here matters much*... you'll deal with 4 million numbers instead of 1 million in 1h on an average computer, which is welcome, but won't turn tables.), or O and O(n log) are usually nearly the same...
Thanks a lot for this indepth feedback but I made this from what we've learned so far in the class. I appreciate it though. Ill refer to this in the future.Complexity of the conjecture functions is O(n^4) and you're surprised it's quickly slow? If you want to multiply the upper limit by 2, you multiply the time needed by 8.
Multiply it by 10 and the time needed is multiplied by 10000
That's normal... You have to write it completely differently, even a supercomputer will struggle quite fast (the limit depend on the power, but it will never be high)
The correct way to do this:
- compute ONCE all primes up to N using Eratosthene sieve
- keep BOTH a table containing primes and the table containing TRUE/FALSE values needed in the sieve
- to check whether x is the sum of two primes, take all primes p before x/2 (by using the first table) and check whether x-p is prime (by checking the TRUE/FALSE value in the second time at position x-p)
Eratosthene is O(n log(log
Testing all values will still be slow, at O(n^2), but nowhere as slow... (for an upper bound of 1000, for example, the speed will be x1000000)
Edit: at the very least, you should be looking for divisors in isprime when i*i <= number and not i <= (number / 2), but that's a menial gain compared to other things...
Are those integers or real numbers?
As said, there's a bunch of different solution, depending on how well you want to be able to identify bad formatted files.
But if the file is properly formated, you can simply read digits, commas and ignore everything else...
guest = ['Jake', 'Fred', 'Joey']
guest_number = len(guest)
print(guest_number)print("How many guest is it? Oh it's " + guest_number + ".")TypeError: must be str, not intprint("How many guest is it? Oh it's " + str(guest_number) + ".")emailRegex = re.compile(r'''
# some.+_thing@something.com
# [a-zA-Z0-9_.+]+ --> custom char class
[a-zA-Z0-9_.+]+ ##name part - custom char class, search for one or more
@ #@
[a-zA-Z0-9_.+]+ #domain name part --> search for one or more
''', re.VERBOSE)
Output:
[u'Uricks@astate.eduU', u'Utmohajir@astate.eduU', u'Ughogue@astate.eduU', u'Urhannah@astate.eduU']I'm late, and there was a perfect answer, but just a comment... + require strings on both sides, so str is a solution, but slightly better: don't use +, use commas
print("How many guest is it? Oh it's ", guest_number, ".", sep="")Pretty sure it comes from the pdf, something related with underlining the mails... I'd say the regex is fine, it's an issue in the regex/data relation or the way you read the content/the pdf reader.
Sorry, I'll explain in depth a bit later... It's fine with what you now, I do it with students that have less than 4h of experience in coding, it's easy...
It's the sensible way to do things if you want to take the quick road (though I wouldn't suggest leaning coding with Java) but my heart would say learn C# and hope Android developpers come to their senses and get rid of Java
I don't doubt that... It's just... it's hard to guess what's the background of people, and I'm really sorry when I misjudge it.
If that's the case, it's perfectly normal it's slow, and there's little you can do about it, except some tweaks.
#include<stdio.h>
int main(int argc, char* argv[]) {
bool* isPrime = new bool[1000000]; // can't allocate large arrays the other way
int* primes = new int[1000000];
int nbPrimes = 0;
// Initialize isPrime:
// isPrime[i] will be true if i is prime
// at the end of the sieve
//
// At the beginning:
// - even numbers aren't -> false
// - odd numbers *can* be primes -> true
// - exceptions: 1 is not prime, 2 is prime
for(int i=0; i<1000000; ++i) {
isPrime[i] = (i%2 != 0);
}
isPrime[1] = false;
isPrime[2] = true;
// Compute primes with Erat. sieve
for(int i=0; i<1000000; ++i) {
// Take all numbers in order
// if there's true in isPrime[i],
// i is prime
if (isPrime[i]) {
primes[nbPrimes] = i; // Remember i
nbPrimes++; // One more prime
// Multiples of i are not primes
// Only odd multiples above i**2
// actually need to be removed,
// so only if i<sqrt(n)
if (i<1000) // 1000 is sqrt(1000000)
for(int m=i*i; m<1000000; m+=2*i)
isPrime[m] = false;
}
}
// Check conjecture
for(int i=4; i<1000000; i+=2) {
bool OK = false;
int k=0;
// Test all primes p <= i/2
// and check whether (i-p) is a prime
while (!OK) {
if (isPrime[i-primes[k]]) // We found a solution
OK = true;
else if (2*primes[k] >= i) { // We reached i/2
printf("The conjecture is false for %d\n", i);
OK = true;
}
k = k+1;
}
}
return 0;
}
private static void RestartSecondServer()
{
Console.WriteLine("Computer details retrieved using Windows Management Instrumentation (WMI)");
//Connect to the remote computer
ConnectionOptions co = new ConnectionOptions();
co.Username = @"***********";
co.Password = "*********";
ManagementScope ms = new ManagementScope("\\\\******\\root\\cimv2", co);
//Query remote computer across the connection
ObjectQuery oq = new System.Management.ObjectQuery("SELECT * FROM Win32_OperatingSystem");
ManagementObjectSearcher query1 = new ManagementObjectSearcher(ms, oq);
ManagementObjectCollection queryCollection1 = query1.Get();
foreach (ManagementObject mo in queryCollection1)
{
string[] ss = {""};
mo.InvokeMethod("Reboot", ss);
Console.WriteLine(mo.ToString());
Console.WriteLine("Reboot complete");
//Process.Start("shutdown", "/r /t 0");
}
}