C++ challenge: Sum of numbers

This one is fairly simple but it should help get you thinking about slightly different ways of doing things in C++.

This challenge is C++ only. If you can solve it in C, I will be extremely impressed, though.

Challenge: Write a program which reads integer values from standard input until EOF, then displays their sum on standard output. Do not worry about overflow.

The Goofy Part: Your program must contain EXACTLY ONE SEMICOLON. If you choose to "return 0;" at the end of main(), that semicolon does not count.

You may, and most likely will, use any and all features of standard C++ including STL.

Quote:

---

One of these is obviously for the "return 0;" at the end of main().

---

However, in C++ (and C99), that explicit return 0 is not required. Perhaps just change the requirement to have exactly one semicolon?

Quote:

---

Originally Posted by laserlight

However, in C++ (and C99), that explicit return 0 is not required. Perhaps just change the requirement to have exactly one semicolon?

---

Yeah, I think I'll clarify somewhat.

Just read in number after number and print their sum, and we can only use one semicolon (outside of the return from main())?

Mmkay.

I managed to do it in C as far as I can understand the rules. I can do it without any semicolons, but I think I have undefined behavior in my program. Moving it to only one semicolon, and I believe it to be valid, if not incredibly stupid, C.

Should I send it to you via PM or post it here? Be forewarned, it's pretty ugly. ;)

Ah well, decided to give it a try, and it was simpler than I thought. So yeah, by PM, or post here?

Cool idea.

I've got a solution that works in VC++ 7.1.

Quote:

---

Originally Posted by MacGyver

Just read in number after number and print their sum, and we can only use one semicolon (outside of the return from main())?

Mmkay.

---

It's actually not that weird-looking once you see how it's done.

Quote:

---

I managed to do it in C as far as I can understand the rules. I can do it without any semicolons, but I think I have undefined behavior in my program. Moving it to only one semicolon, and I believe it to be valid, if not incredibly stupid, C.

---

I'd love to see it. How about PM first, and let's give other people a few hours to work on solutions?

Quote:

---

Originally Posted by laserlight

Ah well, decided to give it a try, and it was simpler than I thought. So yeah, by PM, or post here?

---

I figure it's a simple task for people who are already primed for the right kind of problem solving. For others it is going to be a real migraine-causer.

Now, imagine an entire program written in this style. That's how I write C++ :-P

Quote:

---

How about PM first, and let's give other people a few hours to work on solutions?

---

Fair enough, so I have sent you a PM.

PM sent.

Quote:

---

Originally Posted by brewbuck

Now, imagine an entire program written in this style. That's how I write C++ :-P

---

I can almost guarentee my solution is not what you're thinking of if you admit to writing in this style regularly. :p

Laserlight, MacGyver, and Daved -- good stuff so far. I'm glad this isn't as obscure as I feared.

And no MacGyver, I don't refer to THAT when I say I code like that all the time ;)

Quote:

---

Laserlight, MacGyver, and Daved -- good stuff so far.

---

So, can we accuse each other of plagiarism now? I am still amused by the accusation of psychic plagiarism that my prof made against me last semester :)

Quote:

---

Originally Posted by laserlight

So, can we accuse each other of plagiarism now? I am still amused by the accusation of psychic plagiarism that my prof made against me last semester :)

---

Heh. You've got me curious about that now.

But yeah, you and Daved clearly are colluding to win the prize ;)

Psychic plagarism ... please explain!

Okay, okay. Basically, the fellow (I think that's literally his academic designation, Senior Fellow) used some plagiarism detection software that detected that several people submitted similiar programs for an assignment (which was, ironically, about detecting software similiarity).

I was told that my program matched too closely that of a student who I have never met in any way. That student supposedly collaborated with five other students, but strangely my program was not deemed to have been similiar enough to their programs to be matched. My reasoning is that I must have used telepathy or something to communicate, since I clearly never met the student in person, on a forum, by email, phone, etc. As such, we were psychics who cheated with our special abilities.

Anyway, it turned out that the plagiarism detection software had been fooled by the fact that we had adopted a similiar approach to solving the problem, one that involved breaking it down to several small functions in an already small program. So, despite our different naming schemes and styles, the software still decided that we were cheating and then trying to hide it by making minor name alterations.

>> As such, we were psychics who cheated with our special abilities.
Cause that's clearly the only option! Not that his plagiarism software was faulty!
Though I assume that 'accusation' was in jest?

>> But yeah, you and Daved clearly are colluding to win the prize
Darn, I figured changing the indentation style would fool you.


This idea would be interesting to expand. Perhaps a slightly harder computation and a "who can do it with the fewest semicolons?" style contest. I think what we have here is as far as I can go without delving into something that isn't off the top of my head, so it might be fun to try and figure out even more complex solutions.

Quote:

---

Though I assume that 'accusation' was in jest?

---

Actually, no. He actually did not check the results closely and so just had a "guilty until proven innocent" attitude. After all, there were students who had cheated by copying others. Of course, when you have an abnormal amount of students mass cheating, if it is not some psychic broadcast of a model program, then it must be a plagiarism detection software problem :D

Quote:

---

This idea would be interesting to expand. Perhaps a slightly harder computation and a "who can do it with the fewest semicolons?" style contest. I think what we have here is as far as I can go without delving into something that isn't off the top of my head, so it might be fun to try and figure out even more complex solutions.

---

I agree, though it may be good to let things like efficiency be considered as well.

Quote:

---

Originally Posted by Daved

This idea would be interesting to expand. Perhaps a slightly harder computation and a "who can do it with the fewest semicolons?" style contest. I think what we have here is as far as I can go without delving into something that isn't off the top of my head, so it might be fun to try and figure out even more complex solutions.

---

I've got plenty of examples I could submit as challenges. I'll have to think of something a little bit harder, though. Once you get a feel for how to do them they get easier.

Quote:

---

Originally Posted by laserlight

I agree, though it may be good to let things like efficiency be considered as well.

---

I've found that most compilers produce excellent code for these things, so long as it can inline as much stuff as possible. Also, you have to understand what sort of constructs the compiler can completely optimize away. E.g. passing a functor down into several levels of algorithms. As long as you don't blow up the inliner, the functor will often be completely optimized out of existence, as long as its constructor has no side effects.

Quote:

---

I've found that most compilers produce excellent code for these things, so long as it can inline as much stuff as possible. Also, you have to understand what sort of constructs the compiler can completely optimize away. E.g. passing a functor down into several levels of algorithms. As long as you don't blow up the inliner, the functor will often be completely optimized out of existence, as long as its constructor has no side effects.

---

I had more in mind say, an extra semi-colon due to a sort.

Just PM'd a dodgy solution that only works with single digits and is fudged to submission ... :)

So how about: In one hour from the time of this message, the floor is open to people posting their solutions publicly. I've seen some good stuff so far.

When I get home I'll post my solution, which is also the solution given by a few other people. You know who you are -- you used a standard algorithm to compute the answer. Other people (MacGyver, twomer) feel free to post what you've got.

Code:

---

#include <iostream>
#include <iterator>
#include <numeric>

int main()
{
  std::cout << std::accumulate(std::istream_iterator<int>(std::cin),
                                std::istream_iterator<int>(),
                                0);
  return 0;
}

---

That takes out the fun! And why do we have to use a semicolon?

Code:

---

#include <iostream>

void foo(int x, int y) {
  if (std::cin >> x) {
    if (foo(0, x + y), false) { }
  }
  else {
    if (std::cout << y << std::endl) { }
  }
}

int main () {
  if (foo(0, 0), false) { }
}

---

And here's C, while we're at it.

Code:

---

#include <stdio.h>

void foo(int x, int y) {

  if (EOF != scanf("&#37;d",&x)) {
    if (foo(0, x + y), 0) { }
  }
  else {
    if (printf("%d\n", y)) { }
  }
}

int main(void) {
  if (foo(0, 0),0) { }
}

---

No semicolons, but assumption about size of int * and char **, which is probably not a good idea to make:

Code:

---

#include <stdio.h>

int main(int argc, char *argv[])
{
        while(--argc != 0) { }
        while((scanf("%d", (int *)argv) == 1) && (((argc += *(int *)argv) % 1) == 0)) { }
        while((printf("Sum = %d\n", argc) %1) != 0) { }

        return 0;
}

---

Similar, but proper, if but contrived, C code with one semicolon:

Code:

---

#include <stdio.h>

int main(void)
{
        int num=0, total=0;
       
        while((scanf("%d", &num) == 1) && (((total += num) % 1) == 0)) { }
        while((printf("Sum = %d\n", total) % 1) != 0) { }

        return 0;
}

---

Some natural obfuscation given the rules I guess. :)

My solution:

Code:

---

#include <iostream>
#include <algorithm>
#include <iterator>

#define ch_ty(ty)          std::istream_iterator<ty>::char_type
#define tr_ty(ty)          std::istream_iterator<ty>::traits_type

#define cin_iter(ty)        std::istream_iterator<ty, ch_ty(ty), tr_ty(ty)>( std::cin )
#define void_iter(ty)      std::istream_iterator<ty, ch_ty(ty), tr_ty(ty)>()

int main( int argc, char *argv[] ) {
  while ( (cin_iter(size_t)) != void_iter(size_t)
              ? ( std::cin.unget(),
                  argc += *cin_iter(size_t)
              ) : (
                printf( "\nSUM: %d\n", --argc ), system("exit")
              ) );
}

---

Not great but more entertaining than accumulate imo :)
I also did a main-recursion one for kicks.

Two things:
- unget() appears to only unget the last thing that was entered so if I entered 12 my istream iterator would only read 2. Is there a more robust way of ungetting? I thought that by changing the char_type and the traits type that it would accomplish that.
- Is there a better way of exiting the loop than system exiting? I couldn't thing of much else that would work.

My crummy solution:

Code:

---

#include <stdio.h>

#define SEMICOL ;    /* the one semicolon */

int main(void)
{
    int sum = 0, n = 0 SEMICOL
   
    while(scanf("&#37;d", &n) == 1)
        sum += n SEMICOL
   
    printf("Sum was %d\n", sum) SEMICOL
   
    return 0 SEMICOL
}

---

That can't be against the rules, otherwise you'd have to count the semicolons in the headers (stdio.h for example) :)
I dunno, it seems to simple - like it needs to be disqualified -- maybe it's cause I thought of it :)

And for extra points, 1 set of brackets:

Code:

---

#include <stdio.h>

#define SEMICOL ;    /* the one semicolon */
#define B1 (
#define B2 )

int main B1 void B2
{
    int sum = 0, n = 0 SEMICOL
   
    while B1 scanf B1 "%d", &n B2 == 1 B2
        sum += n SEMICOL
   
    printf B1 "Sum was %d\n", sum B2 SEMICOL
   
    return 0 SEMICOL
}

---

That #define SEMICOLON thing was exactly what I was thinking as I was reading the thread, and then in the very last post you beat me to it . . .

Here's another solution:

Code:

---

#include <stdio.h>
#include <stdlib.h>

int main() {
    int num, sum = 0;

    while(scanf("&#37;i", &num) == 1) {
        if(sum += num) {}
    }

    if(printf("%i\n", sum)) {}
}

---

Recursion's no fun, because you need at least one return statement. Or a variable declared that you could pass as a pointer, I suppose. You could probably do a recursive solution with argc like MacGyver with no semicolons.

Code:

---

#include <stdio.h>
#include <stdlib.h>

int sum(int x, int y) {
    if(scanf("%i", &y) == 1 && x += sum(y, 0)) {}

    return x;
}

int main() {
    if(printf("%i\n", sum(0, 0))) {}
}

---

Main-recursion, Mr D. Always fun and good practice and with commandline parameters use argc as your variable.

But then it doesn't compile as C++, Mr. T.

Very well, if you insist, here's one version. I have a sneaking suspicion that it's very similar to a solution that someone's already posted.

Code:

---

#include <stdio.h>

int main(int argc, char *argv[]) {
    while(--argc) {}

    if(scanf("&#37;i", &argc) == 1) {
        if(argc += main(0, 0)) {}
    }

    if(argv && printf("%i\n", argc)) {}

    return argc;
}

---

Since this is a contest, shouldn't there be a winner?

I vote me :)

Quote:

---

Originally Posted by zacs7

Since this is a contest, shouldn't there be a winner?

I vote me :)

---

Sorry guys, I was out of the house for the weekend.

I'm glad my specific wording turned this into a somewhat more interesting affair. I initially considered asking that only a single statement be used, not a single semicolon, but that seemed to give too much freedom. It's easy to chain expressions using comma in a statement-like way and that isn't what I wanted to see.

I thought, if I allow only a single semicolon, that will eliminate at the very least the use of for(;;) and do while(); but it didn't eliminate while-loops or if-statements. On the other hand if I explicitly disallowed all looping constructs I was afraid I would get a homogeneous set of solutions and that would turn the contest into a math exercise (what's 2 + 2? There's only one right answer).

However I did not imagine that someone would "#define SEMICOLON ;" and use it that way. Definitely within the rules, though.

So the award for Best Abuse Of The Rules goes to zacs7.

The award for Doing What I Did goes to Laserlight for being the first one to land it in my Inbox -- but other people were right behind.

Best Abuse Of Pointers goes to MacGyver.

And everybody gets the Politically Correct Self-Esteem-Preserving Consolation And Fuzzy-Wuzzy Prize.

Quote:

---

Originally Posted by brewbuck

Best Abuse Of Pointers goes to MacGyver.

---

I would just like to thank my friends, and the people that encouraged me to write crappy, non-conforming code. It's you people that have a part in this award, and I think you all should be proud of your part.

I would name everyone, but time (space?) does not permit, so I shall just say, "Thanks again". Thanks again.

:D :D :D