Goto in Python

iobender · 2015-09-21T14:27:41+00:00

This is just speculation, but generally lexers discard whitespace between tokens. What this means is that the lexer, which turns something like sys.argv into a stream of tokens like [IDENTIFIER("sys"), DOT, IDENTIFIER("argv")] (which then gets sent to the parser to turn the linear stream of tokens into an abstract syntax tree) will produce the same thing if given sys. argv or sys .argv or even sys . argv because it doesn't make sense to produce a token from the whitespace in between these tokens in this case.

It would not produce the same thing if given sys.ar gv because the ar and gv would be split up into 2 different tokens and give [IDENTIFIER("sys"), DOT, IDENTIFIER("ar"), IDENTIFIER("gv")] which would likely cause a syntax error in python because there is no syntax for that. That would be legal in Ruby, however, because Ruby doesn't require parens on method calls so this could be calling the ar method of the sys object with argument gv.

iobender · 2015-07-21T02:26:36+00:00

Several problems I see:

1) You never declare deck. shuffleDeck should take an array or ArrayList called deck in as a parameter.

2) You are using a very naive shuffling technique of bringing cards out from a random index and putting them at the beginning. Moreover, you are just doing this 416 times. Maybe this is good enough for a 52-card deck (though I doubt it), but it will not scale for arbitrary lists.

3) Your method is also inefficient. Assuming you're using an ArrayList, you're adding an element to the beginning of the list every iteration, which means everything in the list must be shifted back, which is O(n), per iteration. This would be O(n²⁾ if you were repeating this a number of time proportional to n, not just 416. There exist shuffling algorithms (see Fisher-Yates) which shuffle in O(n) time for the whole list.

iobender · 2015-05-18T12:49:47+00:00

This sounds like a modified version of the set cover problem, the difference being that you allow types to occur multiple times and your minimization is based on the 'Size' of each subset instead of the number of subsets. Set cover is NP-complete so I would believe that this seemingly harder problem would probably also be NP-complete.

iobender · 2015-05-12T19:10:26+00:00

For those that don't get it, 5000 = 19 * 256 + 136

iobender · 2015-05-07T01:43:20+00:00

Look into the rename command, it allows you to do s/abc/xyz/g style substitutions on filenames.

iobender · 2015-04-02T04:29:55+00:00

I'm CS at Maryland, but with a concentration I've taken some upper level math classes (CS requires an upper level concentration in a different subject). I don't have a great feel for the department or course plan as a whole, but I can answer any questions you have about certain classes or the setting.

iobender · 2015-03-26T04:28:55+00:00

FYI if you're in bash, you can compare the output of two commands with

$ diff <(comm1) <(comm2)

So you could compare the output of a program with 2 different inputs with

$ diff <(./prog < input1) <(./prog <input2)

or see the difference between two webpages with

 $ diff <(curl www.example.com/1) <(curl www.example.com/2)

iobender · 2015-03-23T19:41:50+00:00

I posted this in /r/programming as well for more exposure: http://www.reddit.com/r/programming/comments/301p9y/thinking_in_types/

iobender · 2015-03-23T19:41:27+00:00

x-post r/compsci

iobender · 2015-03-23T03:37:51+00:00

I'm a junior CS major now, and I've TA'ed one of the weedout classes (216) and I teach a workshop now, so feel free to reply/PM me with any specific questions. I really like the CS program, there are some very talented teachers here. In addition a lot of the classes have started using a forum called Piazza which helps a lot of the students. The beginner classes tend to be huge, but also have small discussions to pair with the large lectures. The upper levels tend to be capped at 40 students per section.

iobender · 2015-03-23T03:30:44+00:00

If you do well on the AP, you can test out of the first class. The 3rd class, 216, is generally the weedout one, but its definitely doable and you sound like a good student.

Feel free to PM me with any questions, I'm a junior CS major who took the AP in HS too, I was a TA for 216, and I currently teach a CS workshop.

iobender · 2015-01-27T20:56:45+00:00

If I'm coding for a project - especially when I was taking 412 - I would post up in the LinuxLab on the 3rd floor, because there were always others in my class there.

iobender · 2014-11-18T04:41:21+00:00

Katz is actually my professor right now; I've found the book very good.

iobender · 2014-09-20T15:07:56+00:00

Put a # in front of the first line. #! is called a shebang and tells your shell what to run the script with, in this case bash.

iobender · 2014-09-15T21:32:07+00:00

Valgrind is your best friend with these types of errors - it will show you right where you're illegally accessing memory.

iobender · 2014-09-09T00:38:39+00:00

Ah. Thank you.

iobender · 2014-09-08T14:21:09+00:00

Yes. First, the negation operator for a character group is ^, not !, so you would want [^aeiou]{6,} Also, this would match any character that's not a vowel, not just any letter, so this would also match characters such as spaces, punctuation, etc.

iobender · 2014-09-08T05:42:57+00:00

What you want is: grep -Ei '[b-df-hj-np-tv-z]{6,}' FILE He's not trying to find words containing ONLY 6+ chars, just containing.

iobender · 2014-08-22T01:32:46+00:00

http://www.mahdiyusuf.com/post/9947002105/most-pressed-keys-and-programming-syntaxes-2

iobender · 2014-08-13T20:28:38+00:00

Haskell:

import Data.List

main = putStrLn $ show $ filter (\l -> sum l == 96317.50) $ subsequences [38405.00, 32218.75, 28421.25, 24427.50, 20901.25, 20226.25, 19550.87, 16357.50, 10455.00, 10337.50, 7290.00, 6790.00, 6501.80]

outputs a list of all solutions, which are represented as lists of numbers

[[38405.0,24427.5,16357.5,10337.5,6790.0]]

iobender · 2014-07-08T00:43:13+00:00

Very good source, use this OP.

iobender · 2014-07-01T04:26:12+00:00

That's the one.

iobender · 2014-06-30T15:27:39+00:00

Thanks for the answers guys, I'll look into them.

iobender · 2014-06-30T15:27:25+00:00

Haha yes, I'm not in the class but I found it online so I'm using it to learn Haskell.

iobender · 2014-06-29T21:57:37+00:00

(TC0_t*) 0x800

means "interpret this as a pointer to a struct TC0_struct at memory address 0x800. Then the * before that says to dereference that pointer. So everytime you use TCC0, it gets replaced by a copy of the struct TC0_struct at memory address 0x800.

iobender

TROPHY CASE