Stack Overflow: Printing 1 to 1000 in C

http://stackoverflow.com/questions/4568645/printing-1-to-1000-without-loop-or-conditionals/4583502#4583502

by numeromancer • 15 years ago

284 90 15 years ago

stackoverflow.com

jrockway• 15 years ago

Too bad the site is currently too slow for me to close as "not a real question".

jedsmith• 15 years ago

It was tried when it was new[1].

To me, abuse of vote to close is up there with deletionism on Wikipedia as making no sense, particularly in this case.

[1] http://stackoverflow.com/posts/4568645/revisions

gnaritas3• 15 years ago

Deletion-ism makes perfect sense, it maintains a high signal to noise ratio.

RiderOfGiraffes2• 15 years ago

... without conditionals.

Cute puzzle, nice to see some inventive torturing of C, and various dialects that people believe are C.

chops• 15 years ago

and various dialects that people believe are C.

To be fair, the SO question specifies "using C or C++", not just C.

RiderOfGiraffes2• 15 years ago

True. At a glance I'm suspicious that some might truly be in neither, but I'm not really bothered to check.

Any Language Lawyers around?

ctdonath• 15 years ago

"nice to see some inventive torturing of C"

What ever happened to the IOCCC? (International Obfuscated C Coding Contest, ioccc.org)

afhof• 15 years ago

Obvious, but passing arguments to this will cause it to break.

One other mod: (j/1000) could be replaced with (j>999) which is still non conditional, but faster.

dchest• 15 years ago

Well, just move the logic into its own function.

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

        void pr(int j) {
                printf("%d\n", j);
                (pr + (exit - pr)*(j/1000))(j+1);
        }

        int main(int argc, char** argv) {
                pr(1);
                return 0;
        }

acqq5• 15 years ago

I like it this way, it compiles on the compilers where the parent's doesn't (see http://news.ycombinator.com/item?id=2323964), I believe it fits to all standards, doesn't depend on any undefined behavior, it doesn't assume any convenient type size, it doesn't call exit, it doesn't crash and also it doesn't use any relational operators. It even uses only two arithmetic operators, and only on integers.

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

    int pk( int i )
    {
        static int (*v[])( int ) = { pk, abs };
        printf( "%d\n", i );
        return v[ i/1000 ]( i+1 );
    }

    int main( void )
    {
        pk( 1 );
        return 0;
    }

artmageddon• 15 years ago

My favorite response:

The real answer is "don't work there".

HelloBeautiful• 15 years ago

>> The real answer is "don't work there

, if you have to ask this question ;-)"

silentbicycle3• 15 years ago

A comment on the question says: "Why do interview questions always want you to write code that you shouldn't realistically write in application?"

To prepare you for the code they shouldn't realistically have in production. Oh.

efnx• 15 years ago

I just learned a little more about C thanks to this. Compiling does cause a warning, though:

gcc printy.c printy.c: In function ‘main’: printy.c:4: warning: return type of ‘main’ is not ‘int’

oakenshield• 15 years ago

It's an abuse of the standard (c90 and c99). main is supposed to return int and take either no arg or two args, but I think a lot of legacy code violates this, so most compilers let you off with a warning. That said, "-Wall -Werror" are two useful things to always add to your gcc invokation.

ahlatimer• 15 years ago

Previously posted and discussed: http://news.ycombinator.com/item?id=2062058

kunjaan• 15 years ago

printf "numbers from 1 to 1000 without using any loop or conditional statements. Don't just write the printf() or cout statement 1000 times.\n How would you do that using C or C++?"

ajays2• 15 years ago

How would you do the same in other languages? It would be interesting to see the same question answered in Python, Perl, Java, etc. etc. Just as a fun thought exercise, and not to get into language flamewars.

3pt141593• 15 years ago

1.upto 1000 {|n| puts n} # ruby ftw

ajays2• 15 years ago

Isn't "upto" a loop? The idea, IIRC, is to print the numbers without loops and conditionals.

silentbicycle3• 15 years ago

1+!1000

No stinking loops!

iskander• 15 years ago

1 + til 1000 No stinking distinction between monadic/dyadic usage of array operators!

BobKabob3• 15 years ago

Here's a solution in Python, using pretty much the same logic as the top vote-getter on Stack Overflow:

    def f(a):
        print a
        print a+1
        {999: int}.get(a,f)(a+2)

    f(1)

Note, I had to count by twos, because when I counted by ones, I got a "maximum recursion limit exceeded" error.

Basically, the concept is to call f recursively, until you get to 999 (and had printed 999 and 1000), at which time you call some non-recursive function (I call "int").

At 999, the inner-called f function terminates, leading to the unwinding of the stack (each previous f function terminating), and then the program ends.

This statement is the hard one to understand:

        {999: int}.get(a,f)(a+2)

Basically, it's saying "Look up 'a' in this hard-coded dictionary that only has one value in it - for 999. If 'a' isn't found (as it won't be most of the time), set the look-up value to the function called 'f'. Otherwise, set the look-up value to the function called 'int'. In either case, call that looked-up value, passing the parameter of a+2."

rararational2• 15 years ago

Does this fit the criteria for python:

    print str(range(1,1001)).strip('[]').replace(', ','\n')

Edit: added missing [ as pointed out below

kroo• 15 years ago

no! For one thing, it still prints out an opening '[' before 1. Second of all, relying on the structure of the string representation of an array is just silly. Perhaps:

    print "\n".join(map(str, range(1,1001)))

    print "\n".join(str(i) for i in range(1,1001))

xentronium• 15 years ago

Will this count for solution? :)

    MAX = 1000

    def execute_if_not_equals(value, other, &block)
      noop = lambda {}
      [block, noop][value / other].call
    end

    def print(i)
      execute_if_not_equals(i, MAX) do
        puts(i + 1)
        print(i + 1)
      end
    end

    print(0)

[edit]: updated to not use != operator which is probably a cheat.

gurraman• 15 years ago

An Erlang solution:

    f() -> f(1).
    f(1001) -> ok;
    f(N) -> io:fwrite("~p~n", [N]), f(N + 1).

BobKabob3• 15 years ago

How about this Python solution:

    z="0123456789"
    print map(lambda x:int("".join(x))+1,zip(sorted(zip(*z)[0]*100),
              sorted(zip(*z)[0]*10)*10,
              zip(*z)[0]*100))

Only downside is that it prints as a list (so it has the format of [1,2,3..])

patrickyeon• 15 years ago

  ('\n').join(map(str, [1,2,3]))

BobKabob3• 15 years ago

Even better Python variation: Prints 1 to 1000 and quits:

    from __future__ import print_function 
    z="0123456789"
    map(print,map(lambda x: int("".join(x))+1,zip(sorted(z*100),
                      sorted(z*10)*10, z*100)))

The way it works is to create 3 strings, one for each digit-place. The first digit, when counting from 000 to 999, is 100 zeros, followed by 100 ones, followed by 100 twos, etc. That is represented by

    sorted(z*100)

The middle digit is 10 zeros, 10 ones, etc... and repeat this 10 times. So this is

    sorted(z*10)*10.

The least significant digit is represented by a string that just counts and starts over. it's 1000 characters long: "0123456789012345..." and represented by

    z*100.

I define an unnamed function (using lambda), that does the following: Join the three digits, make it an int, and add 1. So the result of this is a list of numbers from 1 to 1000. In other words,

    map(lambda x:  int("".join(x))+1,zip(sorted(z*100),
                              sorted(z*10)*10, z*100)))

is about the same as if I just used range(1,1001)

Then I map it to the new print function that is available in Python 3.0, or with the import statement.

A simpler version would use range, but that seems a little too simple:

    from __future__ import print_function 
    map(print,range(1,1000))

Now that I think about it, this last one is the right answer!

die_sekte• 15 years ago

Haskell:

    mapM_ (putStrLn . show) [1..1000]

kamechan• 15 years ago

actually, can be done more simply as:

mapM_ print [1..1000]

but yeah, ...haskell +1 for that :D

jsmcgd• 15 years ago

Clojure: (map println (range 1 1001))

scrabbles• 15 years ago

Is there a better way than this for scheme (racket)?

  (map (lambda (n)
       (displayln n))
     (cdr (build-list 1001 values)))

jodrellblank• 15 years ago

http://pleac.sourceforge.net/ - Perl cookbook examples translated to other languages, and links to similar translation challenges.

acqq5• 15 years ago

For this specific task, I think the shortest Perl, as I've mentioned in http://news.ycombinator.com/item?id=2326372 is just

   $,="\n"; print 1..1000

Tomek_• 15 years ago

Javascript, validity depends on how exactly do you define conditions and loops:

  var items = [];
  var rec = function(item) {
      var func = [];
      func[true] = function(item) { items.push(item); [item-1].map(rec); };
      func[false] = function(item) {};
      return func[Boolean(item)](item);
  };
  var item = [1000];
  item.map(rec);
  console.log(items.reverse().join(','));

Won't do in browsers due to recurssion limit but change [1000] to [10] and you'll see it works.

imechura• 15 years ago

printf("1 To 1000");

lysium• 15 years ago

The original question is unclear. What is a 'loop' and what is a 'conditional'?

Tail-recursive calls (like the linked solution uses, though C compilers usually do not implement 'proper' tail calls) or short-cut conditionals might not look like but are still loops or conditionals.

So, why the answer is funny it does not answer the original question.

seiji• 15 years ago

though C compilers usually do not implement 'proper' tail calls

With optimizations turned on, gcc turns a tail recursive function into the equivalent of a for loop.

danvet• 15 years ago

.. which I've lately found out the hard way: Code of mine randomly crashed and valgrind told me it's due to use of unintiliazed memory. An awful lot of time later (i.e. one valgrind --track-origins=yes run) I know that it's from function foo's stack space. Which contains one local variable which is clearly assigned at the beginning. _Much_ later I find out that the problem is in bar, tail-called by foo.

At least now I know that latest gcc can do tail-call optimizations.

RodgerTheGreat• 15 years ago

how about a simple implementation in Forth?

  : o         dup . cr 1+               ;
  : t         o o o o o  o o o o o      ;
  : h         t t t t t  t t t t t      ;
  : thousand  h h h h h  h h h h h drop ;

  1 thousand

zem• 15 years ago

one of the c solutions took that approach [http://stackoverflow.com/questions/4568645/printing-1-to-100...]

kragen2• 15 years ago

Unsurprisingly, its author worked at Forth, Inc., long ago.

nova• 15 years ago

Nice. Linear interpolation of C functions.

orblivion• 15 years ago

I'd say:

#include<stdio.h>

void output(x) { int y; printf("%i\n", x); y = 1 / (1000 - x); output(x + 1); }

int main() { output(1); }

With gcc on Linux it has the added bonus of "Floating Point Exception", don't know if that disqualifies it.

EDIT: Nevermind, I got it:

#include<stdio.h>

int output(x) { printf("%i\n", x); (x >= 1000 ) || output(x + 1); return 1; }

int main() { output(1); }

silvajoao• 15 years ago

  #include <stdio.h>
  #define print printf("%d\n", n++);
  #define times2(x) x x
  #define times5(x) x x x x x
  #define pow3(x,f) x(x(x(f)))
  
  int main() {
    int n = 1;
  
    pow3(times2, pow3(times5, print));
    
    return 0;
  }

blazer2• 15 years ago

This might be from some clever and lazy programmer.. lol

291 printf("numbers from 1 to 1000");jondavidjohn Dec 31 '10 at 7:07

blazer2• 15 years ago

Well, what do you think about

int main(void) { printf(" 1 2 3 4 5 6 7 8"); return 0; }

I bet that 1000 was in binary and he was obviously checking the guy's CQ ( compSci Quotient)

amitraman1• 15 years ago

My favorite is: system("/usr/bin/seq 1000");

Only thing is, the interviewer would ask, "How would this work in Windows?"

pbhjpbhj• 15 years ago

>the interviewer would ask, "How would this work in Windows?"

Cygwin?

xenophanes• 15 years ago

too lazy to write it, but you could easily write a ruby script which writes a C program to a file. The ruby script loops to 1000. the C program is around 1000 lines long, prints one number per line. the ruby script compiles and runs the c script. problem solved?

vilya• 15 years ago

Just because I haven't seen it mentioned yet, here's a solution using gcc's computed goto feature:

  #include <cstdio>
  int main(int argc, char** argv) {
    void* labels[2] = { &&doing, &&done };
    int i = 1;
  doing:
    printf("%d\n", i++);
    goto *labels[i / 1001];
  done:
    return 0;
  }

Still consider goto harmful? (Well yeah, so do I generally. But hey...)

mhb• 15 years ago

printf("1 10 11 100 101 110 111 1000");

swah• 15 years ago

Bad HN title.

spirit23• 15 years ago

//https://gist.github.com/870150

(function(max){ new Array(max + 1).join(' ').replace(/\s/g, function(c, i){ console.log(i + 1); }) })(1000)

Almaviva• 15 years ago

Writing "a + condition * (b - a)" is just a math cheat to make a ternary operator. So isn't this a conditional itself?

wbhart• 15 years ago

Wow, HN must have a pretty large readership. Note that before this got posted on HN today my SO score from the solution was pretty static, for weeks. All of a sudden it's sprung up 300 points.

If I learned one thing from the experience it is that often the popularity of something is not a measure of how "correct" it is. It's often a measure of the compromises you are prepared to make, and also how "appealing" it is.

FWIW, thanks HN. I actually read about the question right here in the first place!

By the way, the "correct" version was added by someone else. Posts to whoever added it.

KeithMajhor• 15 years ago

Using the preprocessor

http://pastebin.com/Gxia1aBV

singular• 15 years ago

It's things like this which convince me that I am never going to pass an interview at a decent tech place. When I attempt to write solutions to things like this I make a million mistakes and can never quite get there.

My idea was to create a buffer of 1000 bytes and recursively call a function while each byte is dereferenced until it finally hits a byte which causes a segfault... but I just can't get it working.

The function pointer solution is genius...

Stack Overflow: Printing 1 to 1000 in C

Related Stories