$python
>>>>import stuff
>>>>stuff.doStuff(argument)
>>>> ^some errors, you fail
]I don't use the interactive interpreter, no. The method I described is exactly how I wrote my only real python project: guardonce (a tool to switch back and forth between include guards and pragma once in C/C++ headers).
I've tried a few, but I just ended up using the standard unittest framework. It's simple and available with just 'import unittest'.
You can just add new cases to the same script.
Alternatively, one can replace step 3 with: "python -i thing.py"
On that topic, here's a nice progress bar for python command line I saw recently.
"If I had more time, I could have written a shorter letter." ~ (attributed to) Pascal
The most important thing when deciding whether to transfer is figuring out how many credits will transfer.
{
"pagination": {},
"data": [
{...},
{...},
]
}public List<Payment> GetPayments(int limit, DateTime before, DateTime after)
{
string requestUri = "this is the API url with parameters";
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(requestUri);
request.BeginGetResponse(GetPaymentsCallback, request);
return new List<Payment>();
}
void GetPaymentsCallback(IAsyncResult result)
{
HttpWebRequest request = result.AsyncState as HttpWebRequest;
if (request != null)
{
try
{
WebResponse response = request.EndGetResponse(result);
// now what?
}
catch (WebException e)
{
// error stuff here
return;
}
}
}Is this the full problem description? I have a hard time coming up with a solution that doesn't involve keeping track of visited or fringe nodes, unless something more is known about the maze - e.g. that it's a regular grid where every room has four doors, or that it has no loops.
Same compiler as before? Same compiler arguments as before? Same environment variables set?
You need to deserialize the json to an object. I strongly recommend using the excellent library json.net which is what everybody uses. You can get it via nuget package management, or from the website.
public class FooResponse
{
public object pagination { get; set; }
public List<Payment> data { get; set; }
}
public class Payment
{
public int Value { get; set; }
}string jsonResponse = GetResponseSomehow();
FooResponse responseObject = JsonConvert.DeserializeObject<FooResponse>(responseString);
List<Payment> payments = responseObject.data;public class Room {
public Room getN() {
//Gets north room
}
public Room getS() {
//Gets north room
}
public Room getE() {
//Gets north room
}
public Room getW() {
//Gets north room
}
public boolean isExit() {
//returns whether the room is the exit or not
}
}If you do a breath-first search you'll hit the end on one branch even if the others never terminate.
BFS uses a queue to keep track of the fringe nodes, it's not simpler by any means.
_/¯BFS uses a queue to keep track of the fringe nodes, it's not simpler by any means.
A solution occurred to me that does not involve explicitly keeping track of visited nodes, and will work with any maze, but it's almost too retarded to post. I seriously hope the interviewer wasn't looking for this - if she was, Hylian7 dodged a bullet when failing the interview.
Iterative deepening brute force recursion ¯\_(ツ
BFS uses a queue to keep track of the fringe nodes, it's not simpler by any means.
A solution occurred to me that does not involve explicitly keeping track of visited nodes, and will work with any maze, but it's almost too retarded to post. I seriously hope the interviewer wasn't looking for this - if she was, Hylian7 dodged a bullet when failing the interview.
Iterative deepening brute force recursion ¯\_(ツ
2 major exams tomorrow, going to do horrible on both (well not great on one, horrible on the other). This semester sucks.
That seems to just be 'breath-first, recalculating intermediate results when needed, rather than storing them'. Though, 'iterative deepening depth first' has a better ring to it than my description, for sure.Iterative deepening brute force recursion ¯_(ツ
I've never taken graph theory, so I'm not sure what 'simply connected' means, but can't that algorithm get you stuck in a loop if you start with one on your left?
No, BFS has very different behavior. My suggestion is essentially iterative deepening depth first search but without backtracking prevention. Or sanity. Recursion is just an implementation detail; equivalent pseudocode is
loop L = 1.. infinity
generate all possible NSEW movement combinations of length L
attempt to walk each one; bail when walking over exit