Test your skills (2005)

[rizzix]

ah but that's more work.. i needed to delete 2 extra lines

[wtd]

A C++ question.

What part ofthe following prevents it from compiling in Visual C++ 6.0?

c++:

template <typename T> class Foo {    private:       T m_value;        public:       Foo();       Foo(T);       T value() const;       template <typename _T>       void add(_T); }; template <typename T> Foo<T>::Foo() : m_value(T()) { } template <typename T> Foo<T>::Foo(T initValue) : m_value(initValue) { } template <typename T> T Foo<T>::value() const {    return m_value; } template <typename T> template <typename _T> void Foo<T>::add(_T other) {    m_value += other; }

Will this successfully compile with GCC or a newer version of Microsoft's C++ compiler?

Modify the above so that it will compile in Visual C++ 6.0.

[wtd]

I have the following simple Ada generic package:

ada:

generic     Size : Positive;     type Item_Type is private;   package Generic_Stack is     procedure Push(E : in  Item_Type);     procedure Pop (E : out Item_Type);     Overflow, Underflow : exception;   end Generic_Stack;

With body:

ada:

package body Generic_Stack is     type Table is array (Positive range <>) of Item_Type;     Space : Table(1 .. Size);     Index : Natural := 0;     procedure Push(E : in Item_Type) is     begin       if Index >= Size then         raise Overflow;       end if;       Index := Index + 1;       Space(Index) := E;     end Push;     procedure Pop(E : out Item_Type) is     begin       if Index = 0 then         raise Underflow;       end if;       E := Space(Index);       Index := Index - 1;     end Pop;   end Generic_Stack;

That can be used like so:

ada:

procedure Test_Proc is   package Stack_Int is new Generic_Stack(Size => 200, Item => Integer);   A : Integer; begin   Stack_Int.Push(42);   Stack_Int.Pop(A); end Test_Proc;

Modify the package declaration for Generic_Stack such that the type used for Item_Type must work with the equality (=) operator.

If you add more than one line, you're doing it wrong.

[wtd]

I have the following Python class:

Python:

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

Where self.__bar is (essentially) a private variable.

Add a single line of code to ths class which provides a read-only accessor named "bar" for that private variable.

[Hikaru79]

Python:

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

? Or does that not count because you have to call "myObject.bar()" instead of "myObject.bar" ?

[wtd]

Hikaru79 wrote:

Python:

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

? Or does that not count because you have to call "myObject.bar()" instead of "myObject.bar" ?

Exactly.

[wtd]

Ruby challenge!

Write a class Foo whereby you can run this code:

code:

>> Foo.new.collect { |x| x * 2} => ["foofoo", "barbar", "bazbaz"]

Without cheating by having a method all on one line or using semicolons, do this in six lines. Blank lines won't be included in the count.

One line blocks are permitted.

When you're finished, do the equivalent in Python to make the following possible:

code:

>>> map(lambda x: x + x, Foo()) ['foofoo', 'barbar', 'bazbaz']

[wtd]

Write the shortest possible piece of code that makes it possible to create a very simple object with:

Python:

x()

[wtd]

wtd wrote:

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]").

code:

putStr "Enter a number: " >> hFlush stdout >> hGetLine stdin >>= print . product . enumFromTo 1 . read

[wtd]

code:

putStr "Enter a number: " >> hFlush stdout >> hGetLine stdin >>= print . product . enumFromTo 1 . read

Rewrite this without using the >> operator. You're still permitted to use the >>= operator.

[Martin]

I just edited the title of the topic to reflect, well, present times.

[wtd]

Thanks.

Now answer some questions.

[rizzix]

code:

main = sequence[putStr "Enter a number: ", hFlush stdout, hGetLine stdin >>= print . product . enumFromTo 1 . read]

???

[wtd]

While that works, I was thinking of:

code:

putStr "Enter a number: " >>= \_ -> hFlush stdout >>= \_ -> hGetLine stdin >>= print . product . enumFromTo 1 . read

[wtd]

A new C++ Test Your Skills.

I start with the following source:

c++:

#include <iostream> using namespace std; int main() {    int a = 4, b = 5;    cout << a << b << endl;    cout << a << b << endl;    return 0; }

This prints:

code:

45 45

Add two lines of code to this which will make it print:

code:

45 54

You may not compact code to meet the two line limit, nor may you introduce new variables, nor may you use macros. You also may not alter any of the code in the original source.