Hey, sweet idea, wtd Hopefully this'll turn into a long-standing tradition at compsci.ca

Can anyone chip in with their own questions, or only the thread owner?

PS: You're very close to 1337 posts I wanna take a screenshot when that happens!

with what language? haskell only?

I write the following program and compile it with a modern C++ compiler (GCC 3.3):

code:

#include <iostream.h> main() {    cout << "Hello world!" << endl; }

It compiles and runs, but I've made four mistakes. Name them. 5 bits for each mistake.

Write a program which prompts for the user's name and accepts it on a single line, then greets the user in all caps. A sample run might look like:

code:

You are? Simon HELLO SIMON!  SORRY FOR YELLING!!!

Reference material:

http://www.haskell.org
http://www.familygeek.com/haskell/tutorial.html

so technically.. there are only two rite? 8)

well.. i noe its unconventional, but if u put void infront of main, and add the .h to the iostream, then it would be fine

since when did u conform to the norm wtd?

For 30 bits, just to shake things up.

I have the following class in Ruby:

code:

class Foo    def initialize(bar, baz)       @bar, @baz = bar, baz    end end

Now, @bar and @baz are private, as all instance variables are in Ruby, but I can write methods which let me access those variables.

With only two additional lines of code add the ability to read and write to @bar, and read @baz.

If you use more than two lines, there will be no bits.

martin:i dont think so. i compiled it.. and apparently contstuctors cannot initialise const values.

For 30 bits, what's wrong with the following "hello world" program that causes it not to compile?

ada:

with Ada.Text_IO; use Ada.Text_IO; procedure Hello_World is begin    Put_Line("Hello world!"); end hello_world;

I dont know if this is still valid, but I thought I might as well try...

Is the problem that first letters in the hello_world where you say "end hello_world" not the same case as the procedure "procedure Hello_World"?

btw, I don't know ada

Do you understand the difference between:

code:

int c = 0;

and

code:

int c(0);

or

code:

c++;

and

code:

++c;

Do you know the difference between a struct and a class?

I think that since that post seems to have scared people off, and nobody seems to be able to answer them all, we should start picking it apart piece by piece. So, I will start with my minor knowledge of c++.


Well, for the first two, the first one uses assignment, and the second one uses initialization. I'm not sure of the differences of what they do, but they are two different operations, and they are used in different contexts usually.

For the second two, the first is a postfix increment, and the second is a prefix increment. They both increment the value by one, but the postfix is not as good since it still outputs the previous value, not the newly incremented one.

For the last question, a struct makes all member functions/variables public, while classes allow you to declare what is private/public/or protected. This prevents bugs because you can control when and where the member of the class is manipulated.

a struct (class with all public members)

Ok, I don't get it, you said it yourself:

Is that not what I said?

I think

code:

int c;

declares an integer c

code:

int c[0];

declares an array

code:

c++

increments the value of c by 1

code:

int b = ++c;

makes the value b = (c+1) but the value of c stays same

A constructor can 'allocate' memory, or for example open a file, and a destructor is needed to automatically close that file, and deallocate the resources without creating a new function.

I think it's about time for a Turing question.

Well, it may be "interesting" by some definition of that word, but these tests are meant to test details, and things that are often overlooked.

I either don't know Turing well enough to myself test others on such things, or haven't seen an opportunity to ask such questions.

With that said, the next question:

Ok, Pythonistas, this one's for you again.

Given the class Foo:

Python:

class Foo(object):    def __init__(self):       self.bar = 42

We can easily add attributes to an instance of Foo at run-time.

Python:

baz = Foo() baz.ninja = 27.3 print baz.ninja

That's not a problem.

Create a subclass Wooble of Foo which makes all added attributes strings. Make sure it doesn't change the type of "bar".

Do this in one function in the Wooble class.

A Haskell question:

Let's have a simple factorial program.

code:

import IO main =   do     putStr "Enter a number: "     hFlush stdout     inputLine <- hGetLine stdin     let inputNumber = read input     let factorial = product [1..number]     let strFactorial = show factorial     putStrLn strFactorial

Now... rewrite main as a single line of code with no explicit passing of state (such as: "let inputNumber = read input" and "let factorial = product [1..number]").

A C++ question.

Given that we have a file "input_file" open and pointing to a plain text file, and a std::vector of characters "chars_of_input_file", write a single line of code which will slurp all of the chars in the file into the vector.

You may not use "for" or "while", or multiple semi-colons (you're allowed one to terminate the entire line).

and for the Obj-C one..

obj-c:

#import <objc/Object.h> #include <stdio.h> @protocol SaysHello     - (void) sayHello; @end @interface Foo : Object <SaysHello> - (void) sayHello; @end @interface Bar : Object <SaysHello> - (void) sayHello; @end void sayHello(id); int main() {    Foo *f = [[Foo alloc] init];    Bar *b = [[Bar alloc] init];    sayHello(f);    sayHello(b); } void sayHello(id<SaysHello> greetingObject) {    [greetingObject sayHello]; } @implementation Foo - (void) sayHello {    puts("Hello"); } @end @implementation Bar - (void) sayHello {    puts("Yo"); } @end

Turing's not interesting enough to do anything tricky.

hmm i just added 3 lines of code and modifed another 3 lines..
wht's the shorter alternative?

A Haskell question:

Let's have a simple factorial program.

code:

import IO main =   do     putStr "Enter a number: "     hFlush stdout     inputLine <- hGetLine stdin     let inputNumber = read input     let factorial = product [1..number]     let strFactorial = show factorial     putStrLn strFactorial

Now... rewrite main as a single line of code with no explicit passing of state (such as: "let inputNumber = read input" and "let factorial = product [1..number]").

Here's a python question.

Python:

class Student(object):    def __init__(self, name, *grades):       self.name = name       self.grades = grades    def __str__(self):       return "%s has an average of %.2f" % (self.name, self.average_grade)

Add a single line of code which makes the above class work correctly. It must not only work, but also accurately report the student's average grade.

Write a Perl one-liner to print out the 8-12th lines of a file. (this means i should be able to execute the code with perl -e)

The solution...

Perl:

8 .. 12 and print while (<>)

Write a Perl one-liner, but avoid using any {} blocks.

The one-liner should parse a file extracting all Java-like comments where nesting /* */ comments is not allowed. (i.e you can safely assume there are no nested /* */ comments)

s7ank: i want to be one of those guys that types
"s/j&jd//.^$ueu*///djsls/sm."
and it's a perl script that turns dog crap into gold.

Nope, but thanks for playing our game. The code I posted should compile without alteration.

Oooh. I misread the question. You want the actual command used to compile it. In that case,

code:

javac -nowarn OldArrayListTest.java

There No more warning.

Not quite there yet. Turning off warnings is cheating.

Drat But it technically does do what you asked

How about this?

code:

javac -source 1.4 OldArrayListTest.java

O'Caml TYS:

Given a function "find" which takes a "'a list" and a "'a" and returns None if the list doesn't contain the specified element, and Some int indicating the position in the list if it does...

Take this code:

code:

match find some_list some_value with    | None -> print_endline "Not found"    | Some pos -> print_endline ("Found it at: " ^ string_of_int pos)

And modify it such that "Found it at: " becomes "Found it at even: " if the position is an even number. If it's odd, the message should remain the same as in the above code.

You may not use "if" or "else".

In conjunction with number 2, I need to return zero to indicate the program finished successfully.