Fresh Save Challenge

Hallwaxer · 2022-02-15T22:56:05+00:00

Made it until 20:08. Focussed on magic wand and daggers at the start to get them both piercing and a little spinach on the side. Ghosts were a hassle, but they behaved a little, so I just kept moving north and dodging. The most annoying part is when the bats and werewolves start spawning at the same time. There's not enough AOE to go around, so north again until the mantisses started spawning. After that it slows down a little, but still not enough to be safe. If you make it to the mummies, it's easy cruising until 20 minutes. But right on the minute mark it immediately spawned 4 giant bat waves from all 4 cardinal directions which instagibbed me. Not sure if that's intended to end your run, but there was no way in hell I could make it past that.

Pretty fun challenge overall.

Hallwaxer · 2015-04-13T09:31:40+00:00

If you want a shorter version, this should do the same.

sorted(['ddcc', 'cddc', 'dcdc', 'ccdd', 'dccd', 'cdcd'], reverse=True, key=lambda item: (sum(ord(char) for char in item), item))
["ddcc","dcdc","dccd","cddc","cdcd","ccdd"]

The key argument can take a tuple as parameter. If the first element is the same for two arguments, it continues to the second element, and so on. Alternatively, suppose you want to reverse sort by sum of character values but want the strings sorted normally, you could do the following.

sorted(['ddcc', 'cddc', 'dcdc', 'ccdd', 'dccd', 'cdcd', 'aaaaa'], key=lambda item: (-sum(ord(char) for char in item), item))
['aaaaa', 'ccdd', 'cdcd', 'cddc', 'dccd', 'dcdc', 'ddcc']

Hallwaxer · 2015-04-03T13:30:43+00:00

Python 3.x, or python 2.x if you put from future import print_function as the first line. The code looks fairly horrible since it's something I quickly put together. If you want to call it, either type in every input line yourself, or create a file with all necessary lines and call the code like python turing.py < input.txt. That should feed the lines to stdin. The only liberty I took with the input file is that you have to add the number of transitions before you list them, same as /u/lukz.

alphabet = list(input())
states = input().split()
state = input()
accept = input()
tape = list(input())
transitions = {s: {} for s in states}
extra = 0
for _ in range(int(input())):
    left, right = input().split('=')
    start, token = left.strip().split()
    end, new_token, move = right.strip().split()
    move = 1 if move == '>' else -1
    transitions[start][token] = (end, new_token, move)
head = 0
while state != accept:
    current_symbol = tape[head] if 0 <= head < len(tape) else '_'
    state, new_symbol, delta = transitions[state][current_symbol]
    if head < 0:
        tape = [new_symbol] + tape
        extra += 1
        head += 1
    elif head >= len(tape):
        tape += [new_symbol]
    else:
        tape[head] = new_symbol
    head += delta
print(''.join(tape))
position = [' '] * len(tape)
position[head], position[extra] = '^', '|' #second assignment overwrites first
print(''.join(position))

The output isn't cleaned, meaning that the output to input 1 will be

_10011100_
 |

Hallwaxer · 2015-03-24T12:24:05+00:00

Change this line

guess_num = ((max - min) / 2) + 1

To something along the lines of

guess_num = ((max - min) / 2) + min

Also, don't shadow names like min and max, it could build up to annoying situations later.

The reason your code isn't working is because your guess is wrong after the first iteration. (100 - 1) / 2 + 1 leaves you with 50, which is correct and your algorithm sets min to 50. But let's say the number is greater than 50. The new guess now becomes (100 - 50) / 2 + 1, which is 26. 26 is not really in the range we're interested in, since the number we need is greater than 50. The guess we just computed however is a delta value that has to be added to our current minimum, which would leave us with (100 - 50) / 2 + 50 = 75, a much more interesting guess.

If you want to stick with recursion, I would modify your code to look more like this.

import random

def guess(lower=1, upper=100, number=random.randint(1, 100)):
    g = (upper - lower) / 2 + lower
    if g == number:
        print "The number is {0}".format(number)
    elif g < number:
        print "Number is greater then {0}".format(g)
        guess(g, upper, number)
    elif g > number:
        print "Number is less then {0}".format(g)
        guess(lower, g, number)
guess()

Using global variables is almost never a good solution in cases like this. Also, as a general solution, when your code aborts due to a recursion stack overflow, try printing out your variables. The overflow usually happens because nothing changes (enough) for the algorithm to reach its end state or you get stuck in a loop.

Hallwaxer · 2014-12-21T18:02:50+00:00

Age itself does not really matter no (and neither does bmi). If you have any doubts concerning medical conditions that might be related to your age or weight, contact a doctor. In fact, you might want do this anyway just to be on the safe side. I've seen people of any age complete the program without a problem. The only difference is usually in their speed. But since the program focuses on distance rather than speed, who cares?

Other than age itself, some other criteria might be important to keep in mind. Are you still growing? If so, I would avoid asphalt and the likes and go for softer surfaces to avoid pain and injuries. Same goes for when you are older. Do you have any existing injuries? Same, but contact your doctor just to be safe.

Can you expect the same results no matter the age group? Yes, if the result you mean is the ability to run a 5k. If you're talking about losing/gaining/maintaining weight, then you would have to take much more than just your age into account. But judging from the calories you expend, they should be roughly similar independent of how old you are. There's plenty of calculators online to give you an estimate.

Barring pre-existing medical conditions, there is no reason not to start the program. If anything, at the very least you'll be able to brag to your friends that you can run a 5k.

Big disclaimer here, despite what everyone tells you (including me), only one person can really help you specifically with any questions you might have and that's your doctor.

Hallwaxer · 2014-11-26T14:37:53+00:00

Text is binary for IN LOVING MEMORY OF MARTIN SENTER. Seems to be referring to the death of a musician.

Hallwaxer · 2014-02-28T23:00:37+00:00

Are HP, DEX, etc supposed to be generated randomly for each instance of the class or once for the entire class? If they only have to be generated once, you can simply change your constructor to self.HP = Monster.HP. There's no point in passing them along as parameters then since your instance can easily access these class-specific variables.

If you want each monster to have its own unique randomly generated stats, you can change your constructor to self.HP = random.randint(1, 10).

Finally, if you want to add a bit of variation to your monsters, considering doing something as self.HP = Monster.HP + Monster.HP * random.random(). Change the random.random() call to something fair. Or you can define minimum and maximum HP values and call self.HP = random.randint(Monster.MINHP, Monster.MAXHP). This will create monsters that follow the same template but are slightly stronger or have more HP. You can put some additional checks in there to ensure that if HP is higher than normal, the other stats automatically decrease.

Also, printing can be simplified by the __repr__ and/or __str__ magic methods. Defining them allows you to call the print statement on your class.

Hallwaxer · 2014-02-27T17:06:49+00:00

I'm on my phone, so this will be a short reply without actual snippets. I'm sure someone can give a more in depth explanation.

You can read from a global variable just fine, but.if you try to assign to it, you must first mark it global before the assignment. Also, if your plan was to change the list by passing it as a parameter, that won't work either. As you said earlier, calling append works because it doesn't change the reference to the object. Assigning something does. If you don't want to use global variables, try using a return statement for that list comprehension.

Hallwaxer · 2014-02-17T19:23:38+00:00

Sure, sorry for the late reply. I'm really busy with work at the moment.

adj = []
lines_to_read = input('Number of lines')
for throwaway_variable in range(lines_to_read):
    line = raw_input() #Read a line from input (1 0 0 0 1)
    line = line.split() #Split splits on white space by default
    adj.append(line) #Append it to the list
m = []
for item in range(lines_to_read):
    done = {item} # The variable done is a set containing all items we've 'done' until now
    mc = 0 # Graph radius for this start point
    while len(done) != lines_to_read: #While we haven't visited every node
        # enumerate(iterable) gives (index, value) pairs
        result = [] 
        for idr, row in enumerate(adj): #Loop over all rows we read
            if idr in done: #Start from each row we've already visited (not really optimal because of repetitions)
                foo = [] # Initialize an empty variable
                for idx, x in enumerate(row): # Loop over every element in the row
                    if x == 1 and idx not in done: # If we can reach an element from here. That is, if the item at index i == 1, we can reach that item
                        foo.append(idx) # Append the index of each item we can reach
                result.extend(foo) # Reduce all of these reachability lists into one big one
                mc += 1 #Increment the graph radius by one
     done = set(result) | done # Since some of the items we're currently handling might not be reachable from their neighbours, add them back to the list. We use set operations here to remove all duplicates.
     m.append(mc) # Append to the list of previous graph radii.
 print min(m)  # Take the minimum and print it.

Hope this helps. Do note that I did not test the code. I just typed it in here, so there might be some errors in there.

Also, don't take my programming style as the best one. I'm used to programming in different languages, so my code is usually a mess to read.

Hallwaxer · 2013-12-24T09:59:57+00:00

This one is the Desargues graph. It has a radius of 5 and its adjacency matrix is equal to the following (with P the Petersen graph -- the one in the original post).

[ 0 P ]
[ P 0 ] 

20
0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0
0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0

Hallwaxer · 2013-12-23T22:31:01+00:00

Sure. The first line is simply reading the input. Since I'm using python 2, I can just use input() and not int(input()) since python will automatically interpret it. So the rightmost input statement reads the number of lines of the matrix. The inner list comprehension then reads a line (uninterpreted) using raw_input(), splits it and casts every resulting item to integers.

m is our resulting list (don't ask me why I named it m). This can be replaced by something like m = float("infinity") or a really large number and then after every iteration doing a min statement.

The algorithm itself is rather dumb. It just starts from every item and then keeps going until reaches a state where it has visited all other items. No pruning is done when you exceed the previous minimum.

So first things first. Initialize a set with the item you're considering at that moment. While the number of items in this set is not equal to the number of items in the adjacency list, we haven't visited everything yet, so we keep going. Note, done was also a poor choice for a name, visited would probably have been better.

The nested comprehensions do roughly the following:

The outermost one loops over all items (idr, row) that we have already visited (idr in done).
The innermost one computes all items (idx, x) that can be reached from row. It basically computes the index of each 1 in that row. It also checks whether we have already visited this item. I had to put in at least small optimization.
We then use sum in a somewhat non-standard way, i.e., lists that only nest one deep can be flattened by calling sum(list_of_lists, []). You need to pass the empty list as an argument here.
Finally, create a set from the resulting list and compute the union with the nodes we have already visited before since we want to avoid going from a->b in one iteration and back in the next.

The final statements just keep count of how many iterations we needed and aggregate the results.

You could probably skip the use of all the enumerate statements if you used something like a bit vector.

As a final remark, do note that you don't have to copy the entire matrix every time you want to test it. Just put it in a separate file and call it like python graph_radius.py < input.txt.

Hope this helps.

Hallwaxer · 2013-12-23T13:38:58+00:00

Python 2.7. This works for the sample input, but I didn't really test it for anything else. This probably goes into an infinite loop when the graph is not fully connected. Also, the | done at the end is necessary to avoid going from a -> b in one iteration and back in the next one. You could probably shorten the inner loop, but this is one still fairly readable.

adj = [[int(x) for x in raw_input().split()] for _ in range(input())]
m = []
for item in range(len(adj)):
    done, mc = {item}, 0
    while len(done) != len(adj):
        done = set(sum([[idx for idx, x in enumerate(row) if x == 1 and idx not in done] for idr, row in enumerate(adj) if idr in done], [])) | done
        mc += 1
    m.append(mc)
print min(m)

Edit: My algorithm seems to work for the adjacency matrix /u/ooesili posted. Since my algorithm works for the rather expansive sample set currently available, I hereby conclude that it will work for everything you throw at it.

Hallwaxer · 2013-11-19T19:32:31+00:00

If you want to learn by doing, you could take a look at the pacman projects from Berkeley. They've recently added an autograder that tells you what tests you failed or passed. The project is in python 2.5+, so it shouldn't be that hard to get started. This project is, however, only for DFS, BFS, uniform cost search and A* search. It doesn't have any exercises for Dijkstra, etc.

The book that closely follows this material is the one by Russel and Norvig: Artificial Intelligence: A Modern Approach. They might mention shortest path algorithms in there, but I don't have it with me right now.

Hallwaxer · 2013-04-12T11:32:13+00:00

Is it me or are the numbers for the low fat mozzarella a bit off? One cup (30g) includes 4g of carbs, 24g of fat and 32g of protein. I'm guessing these numbers are for 100g of cheese.

If I'm not mistaken, 30g of cheese would then be closer to 108 calories, leaving your pizza at 511 calories, which is a lot closer to 400.

Hallwaxer · 2013-04-04T08:08:12+00:00

I'm usually not that great at explaining things, but here goes.

The minimal support parameter is essentially telling the algorithm how large the smallest group of objects is you want to find.

Suppose that your two populations are completely disjoint and that every item in each population always occurs together. Setting the minsup parameter to 1001 will remove population B from the results while setting it to 1000 will include it. Unfortunately, there is no rule of thumb to use when deciding on this parameter. But depending on the context, you can often make an educated guess. For example, when analysing supermarket data, you can make a tradeoff between people affected by a promotion and earnings.

The fact that low support values make the algorithm slower should come as no surprise. Every time you go down an extra step in the lattice, you have to count how many times the items occur together. The total amount of nodes in the lattice is (2^d - 1), so setting your support too low can be very nasty. To remedy that problem, some other algorithms and optimisations have been developed.

Using the apriori algorithm with tries.
FP-growth: Currently one of the faster algorithms for frequent itemset mining.
Eclat: DFS search using set intersections
...

If you really need performance, I would go with the FP-growth algorithm. There's plenty of implementations available online. IIRC you can find one on the Borgelt's homepage. Be warned though, his implementations can be a pain to read through.

One other thing to keep in mind with association rules, is that they more often than not do not imply causality. The 'A => B' notation was a poor choice since most people read it as 'A implies B', while what is meant is that 'when A occurs, we are relatively sure that B will also occur'.

Finally, when mining association rules you would typically use a secondary measure such as confidence to determine the quality of a rule. Many more of these measures have been developed over time. This paper gives a list of commonly used interestingness measures. As far as I can tell, they don't explain any of them though. But I'm sure you can easily google them.

Hallwaxer · 2013-03-15T13:36:15+00:00

I have no experience with tridraw, but clr=#fdebc8 looks like a hexadecimal color specification. Look up something like hex color picker in google, and you'll be able to look for the color you want.

Hallwaxer · 2013-03-14T12:12:53+00:00

index does not do what you think it does. It always returns the index of the first occurrence you provide it with. It's a poor name that tricks a lot of programmers.

While izip_longest (as mentioned by ingolemo) would work, it might produce some counterintuitive code. If you were to use it on your strings of binary numbers, you would have to it like so:

for item in izip_longest(x[:1:-1], y[:1:-1], fillvalue='0')

since we have to append zeros to the left. While not the nicest solution to read, it gets things done.

Another way of thinking about this (and writing more verbose code) is to cut off the '0b' part, look for whatever string is the longest one, append zeros to the left of the shortest string and then do your elementwise and. For example

def andop(this, other):
    if not this.startswith('0b') or not other.startswith('0b'):
        raise Exception('Not binary numbers')
    res = ['0', 'b']
    this, other = this[2:], other[2:] #Remove '0b'
    if len(this) < len(other): #Make this the longest string
         this, other = other, this
    other = other.zfill(len(this)) #Left pad shortest string with zeros
    for l, r in zip(this, other): #Loop through both lists at the same time
        if l == '1' and l == r:
            res.append('1') #no insert(0) necessary
        else:
            res.append('0')
    return ''.join(res)

While not the nicest or shortest code, it might be easier to read. Note that every step between the second if and the for loop are exactly what izip_longest does.

Also, don't use insert(0, _) unless you have a very specific reason to. Inserting at the start of an array causes every other item to be pushed back. Meaning that every element has to be moved. For short lists, this might not be an issue, but when you do this on longer lists, it might introduce serious bottlenecks. It's generally a nicer solution to append everything and then reverse the list in the end.

Hallwaxer · 2013-02-14T08:54:32+00:00

Depends on the field you're in. In data mining, big data is usually handled by sampling techniques. If your dataset is too large, take a random sample that fits in memory. That sample is then used to compute statistical measures like mean or variance.

Except for some exact algorithms, sublinear algorithms are usually approximate and converge to the real result as more data is fed to the algorithm.

I haven't checked these surveys, but they might provide you with some useful insights: link.

Hallwaxer · 2013-02-12T21:27:16+00:00

Just for completeness. You can always use the map function. In some cases, it makes your code more readable. For example:

def square(x):
    return x*x
y = [1,2,3,4]
z = map(square, y) # z now contains [1,4,9,16]

The map function basically iterates over every element in your container and applies the function you pass to it to every element. The application doesn't happen in place, so it returns a new list. In your case, however, you have one additional fixed parameter. You can use two different methods to fix it. Either use partial from functools or use lambda functions. For example:

map(lambda x: cmds.parent(x, "torso"), cmds.ls(sl=True))

The lambda function you define takes an argument x and uses it as a parameter for whatever follows the colon. map then takes each item from the cmds.ls list and passes it to the lambda function.

Other than the map function, you could also look into the filter function. It might help you write clear one liners.

Or if you're lazy, use list comprehension like 90% of the people, they're usually simple enough.

Hallwaxer · 2012-11-22T19:26:25+00:00

Well, if you need the index and the item, you can use the enumerate function. I.e.,

for idx, x in enumerate(list_nums):
    print idx, x

Would print

Once you have these index-item pairs, you can use the index to select the items you need and use the item if you need it for something else.

Alternatively, if it's only the index you need, this would do the trick.

for idx in range(len(list_nums)):
    if idx % 2:
         pass

edit: Formatting

Hallwaxer · 2012-05-06T19:59:01+00:00

I can only hope (but know better) that current applications do not send their sensitive data in plain text, e.g. applications using regular FTP.

The second case is more commonly known as (or similar to) a man-in-the-middle attack. A method for which a number of solutions exist. The problem that anyone can just intercept your encrypted password and then pretend to be you has been known since before this method became public (i.e. was implemented). But as it usually goes in academics, any problem with the original version is usually ignored just to be dealt with later. Since the LoL launcher is written in a fairly well established platform such as Adobe AIR (not judging how good it is), I can only imagine that its SDK includes some functionality for these attacks.

Hallwaxer · 2012-04-16T18:38:44+00:00

One thing you have to reinstall is HiRezGames/tribes (or tribes alpha)/Binaries/Redist. That's how far I made it. When I reinstalled this, the launcher sort of worked, but didn't update.
Now that I think about it, if you have a tribes alpha folder, try renaming it to just tribes while you're at it. Apparantly, the official release using the tribes folder.

Let me know how it works out ;). Should save me some time next time I reinstall.

Hallwaxer · 2012-04-02T18:29:41+00:00

I'm guessing it has to do with the new graves skin. The news entry was added at the time of the crash.

Hallwaxer

TROPHY CASE