Problem Set 0: Reflection

findPath() has a simple return type (Array<number>) but a complicated postcondition, without much static checking. For each of these alternative return types, would it be safer from bugs (because more of the postcondition is now enforced by static checking) or less safe from bugs (because of less static checking)?

string
// e.g., "turn(0),forward(50),turn(180),forward(50),turn(180)"

 

Array<number|string>
// where angles are strings and distances are numbers: e.g., ["0", 50, "180", 50, "180"]

 

Array<{ turn: number, forward: number }>
// e.g., [ {turn: 0, forward: 50}, {turn: 180, forward: 50}, { turn: 180, forward: 0 } ]

 

How much time in hours did you spend working on the alpha? Please enter a number (which may be a decimal fraction).

How much time in hours did you spend working on code review? Please enter a number (which may be a decimal fraction).

How much time in hours did you spend working on the beta? Please enter a number (which may be a decimal fraction).

Which of the following things did you do while working on Problem Set 0?

I helped somebody, or was helped, while both of our solutions were visible on our screens.

For every piece of code that I found on the web and used in my solution, I included a comment citing the source of the code.

I worked on my solution while somebody else’s solution was visible to me (e.g. on Caesar, or in some other window on my screen, or on somebody else’s screen, or on paper).

I worked closely with somebody on part of the problem set, discussing or sharing step-by-step, algorithmic instructions.

I was helped by somebody who is neither a current 6.102 staff member, nor a current 6.102 student, nor an HKN tutor assigned to me.

I obtained part or all of somebody else’s solution electronically, or provided part or all of my own solution to somebody else.

I publicly posted part of my solution online as part of a portfolio of code to show to recruiters.