C++11 quiz

[botg]

What does below code do? Try to solve it without compiling and executing it. And before you ask, yes, it is valid code.

Code: Select all

#include <iostream>

using namespace

   std;int
    main(){for(struct
       l{int i,k;??>
       j=[:>()

    <%decltype
        (l::i)i,j;cin>>i>>j;
        return l{
            i,j};
        }
        ();
        j.k!=0;
        j={j.k,j.i%*&j.k},j.k?
cout:
        cout<<j.i<<endl)
        {??(](){
    %>

    ();}

    return 0;
}

[MoonUnitZappa]

What does below code do? Try to solve it without compiling and executing it. And before you ask, yes, it is valid code.

main() { for(struct

I am no expert but there is no corresponding } to the main {
I can not compile it with code:blocks & mingw GCC

As this has been here for some months now and no replies .. how about you tell us what it does ..
or at least what you believe it does ..

[botg]

I am no expert but there is no corresponding } to the main {

Oh, but there is. There are different ways to spell }

I can not compile it with code:blocks & mingw GCC

Try solving this without a compiler, compiling it ruins the fun.

Anyhow, your compiler isn't C++11 capable or you're compiling with C++11 support disabled. Get a newer version of your compiler or enable C++11 support.

With GCC, pass this: -std=c++11

[MoonUnitZappa]

Try solving this without a compiler, compiling it ruins the fun.

With GCC, pass this: -std=c++11

Well ... as I have no idea what "the fun" aspect of the solution is I won't spoil "the fun" for any one else.

I have managed to compile it by passing the "-std=c++11" as a GCC (v471) compiler option but
I am not sure if the result i get is the one you intended ... PM me if you are interested to see my result.

anyway - i learned something new today thanks to this quiz so at least that is good

edit: does "bo" stand for "bastard operator" by any chance

[botg]

edit: does "bo" stand for "bastard operator" by any chance

Maybe. Maybe not

[Betrayal]

Uuuuuh i can't read digraphs and trigraphs. So with help of wikipedia i replaced all di/trigraphs into usual symbols.

1. put the struct right before the loop
2. deleted the useless lambda in loop-body [](){}();
3. changed decltype(l::i) to int
4. renamed l to structType
5. renamed j to obj
6. removed *& in obj.i%*&obj.k

so, this is much more readable now:

Code: Select all

#include <iostream>
using namespace std;

int main()
{
    struct structType
    {
        int i,k;
    };

    for(
            structType obj=[]()
            {
                int i,j;
                cin>>i>>j;
                return structType {i,j};
            }();

            obj.k != 0;

            obj= {obj.k, obj.i%obj.k}, obj.k
                ? cout
                : cout<<obj.i<<endl
        )
    {

    }

    return 0;
}

next a little more restructuring.
7. renamed i and k into first and second
8. defined obj before the loop without lampda-crap

Code: Select all

#include <iostream>
using namespace std;

int main()
{
    struct structType
    {
        int first,second;
    };

    structType obj;
    cin>>obj.first>>obj.second;

    for(
           ;
            obj.second != 0
           ;
            obj = {obj.second, obj.first%obj.second},
            obj.second ? cout : cout<<obj.first<<endl
        )
    {}

    return 0;
}

so and now trying to understand.
the loop-update part sets first = second and second = first%second.
when second==0 then first will be printed and the loop ends.

so due to this algorithm i think this programm calculates the greatest common divisor for first and second with euclid's algorithm

[Betrayal]

waiting for prize

[botg]

100 points.

[MoonUnitZappa]

You guys can See The Matrix .. right ???

Well done though !

[boco]

*Sniff sniff* Thread necro, anyone?

[botg]

You guys can See The Matrix .. right ???

I programmed a non-existing spoon once.


Let's revive the quiz.

New challenge:

Code: Select all

template<int ...>
struct a {};

template<int d, int ...c>
struct b : b<d - 1, d - 1, c...> {};

template<int ...c>
struct b<0, c...> {
	typedef a<c...> type;
};

template<typename e, typename g, typename h, int... i>
auto l(e&& k, g&& f, h&& t, a<i...> const&) -> decltype((std::forward<e>(k)->*std::forward<g>(f))(std::get<i>(std::forward<h>(t))...)) {
	return (std::forward<e>(k)->*std::forward<g>(f))(std::get<i>(std::forward<h>(t))...);
}

template<typename e, typename g, typename h, typename c = typename b<std::tuple_size<typename std::remove_reference<h>::type>::value>::type>
auto m(e&& k, g && f, h&& j) -> decltype(l(std::forward<e>(k), std::forward<g>(f), std::forward<h>(j), c())) {
	return l(std::forward<e>(k), std::forward<g>(f), std::forward<h>(j), c());
}

This is from the FZ repository, with the variable names obfuscated. Can you guess what this does and what it is being used for? No peeking please