Can you count to ten?

Little fun game. Write a program segment that prints the
numbers from 1 to 10, You can use any language you wish, and
any legal syntax of that chosen language to do so. Let's see how many
ways there are to do so in as many languages as possible.

I'll Start :D

Language Ada:

Code:

---

with Ada.Text_IO;
use Ada.Text_IO;

for I in 1 .. 10 loop
  Put_Line (I);
end loop;

---

Bash

Code:

---

$ for ((i=1;i<=10;i++)); do echo $i ; done

---

Awk

Code:

---

$ awk 'BEGIN { for ( i = 1 ; i <= 10 ; i++ ) { print i } }'

---

Perl

Code:

---

$ perl -e 'print join("\n",(1..10)) . "\n";'

---

C#:

Code:

---

        var ten = "1,2,3,4,5,6,7,8,9,10".Replace(",", "\n");
        Console.WriteLine(ten);

---

Python:

Code:

---


for i in range(1,11):
  print i

---

Fortran, of course

Code:

---

print *, (/ (i, i = 1, 10) /)

---

Quote:

---

Originally Posted by gemera

Python:

Code:

---


for i in range(1,11):
  print i

---

---

Or even more succinctly:

Code:

---

print range(1, 11)

---

There was no stated requirement that each number be on its own line.

C:

Code:

---

int j = 0;
while (true) {
    for (int i = 5; i < 35; i += 3) {
        char* s = malloc(i);
        sprintf(s, "%d", ((i - 5) / 3) + 1);
        printf("%s\n", s);
        j = (i / 2) * 6;
    }
    if (j > 10) break;
}

---

@Elkvis If list notation is acceptable it would even be possible to go raw with:

Code:

---


range(1,11)

---

Now, that's snappy code.

LOL @ Yarin :D

Rust:

Code:

---

for i in 0..11 {
    print!("{} ", i);
}

---

BASIC


FOR..NEXT loop

Code:

Code:

---

FOR I = 1 TO 10

PRINT I

NEXT I
END

---

REPEAT..UNTIL loop

Code:

---

I=0
REPEAT

PRINT I
I=I+1

UNTIL I>=11
END

---

Java:

Code:

---

public class Program {
    public static void main(string[] args) {
        for (int i =  1; i <= 10; ++i)
            System.out.print(" " + i);
    }
}

---

C - absolutely horrible way to do it:

Code:

---

int a = 1, b = 2, c = 3, d = 4,  e = 5, f = 6, g = 7,  h = 8, i = 9, j = 10;
int *ptr1 = &a;
int *ptr2 = &b;
int *ptr3 = &c;
int *ptr4 = &d;
int *ptr5 = &e;
int *ptr6 = &f;
int *ptr7 = &g;
int *ptr8 = &h;
int *ptr9 = &i;
int *ptr10 = &j;

printf(" %d", *ptr1);
printf(" %d", *ptr2);
printf(" %d", *ptr3);
printf(" %d", *ptr4);
printf(" %d", *ptr5);
printf(" %d", *ptr6);
printf(" %d", *ptr7);
printf(" %d", *ptr8);
printf(" %d", *ptr9);
printf(" %d\n", *ptr10);

---

Code:

---

    char cs[] = "TWENTYFOUR";
    char *ptr = cs;
    while (*ptr++) {
        printf("%d\n", (int) (ptr - cs));
    }

---

You know, I thought I'd be clever and try to do this in Haskell. Then I got frustrated and just quit lol XD

Quote:

---

Originally Posted by MutantJohn

You know, I thought I'd be clever and try to do this in Haskell. Then I got frustrated and just quit lol XD

---

Haskell:

Code:

---

main = print([1..10])

---

Quote:

---

Originally Posted by gemera

@elkvis if list notation is acceptable it would even be possible to go raw with:

Code:

---


range(1,11)

---

now, that's snappy code.

---

matlab:

Code:

---

1:10

---

Quote:

---

Originally Posted by Yarin

Haskell:

Code:

---

main = print([1..10])

---

---

Ha! That's so easy lol.

Okay, I just suck at Haskell T_T

Quote:

---

Originally Posted by MutantJohn

Okay, I just suck at Haskell T_T

---

I'd imagine that's probably true for most of us.

Lua :

Code:

---

for i=1,10
do

print(i)

end

---

In a language that may not be named:

Code:

---

++++++++[>++++++>++++++<<-]><+++++++++[>+.<-]>>+.-.

---

Here is a version with newline

Code:

---

++++++++[>++++++>++++++>+<<<-]>>>++<<<+++++++++[>+.>>.<<<-]>>+.-.

---

I had to "cheat" for "10" in both versions but oh well..

Overdone recursion in C++:

Code:

---

#include <iostream>

template<int N>
class Count
{
public:
    Count()
    {
        Count<N-1>();
        std::cout << N << std::endl;
    }
};

template<>
class Count<1>
{
public:
    Count()
    {
        std::cout << 1 << std::endl;
    }
};

int main()
{
    Count<10>();
}

---

Quote:

---

Originally Posted by Elkvis

I'd imagine that's probably true for most of us.

---

Lol seriously though. I sat down and really, really tried to learn it. I'm now convinced the people that love it are actually just experiencing Stockholm syndrome. I worked through the stuff of how functions and lists can operate as an applicatives and then I was like, "I'm over-complicating what's basically a nested for-loop in C"

Quote:

---

Originally Posted by MutantJohn

Lol seriously though. I sat down and really, really tried to learn it. I'm now convinced the people that love it are actually just experiencing Stockholm syndrome. I worked through the stuff of how functions and lists can operate as an applicatives and then I was like, "I'm over-complicating what's basically a nested for-loop in C"

---

I don't really believe Haskell or other crap similar to that (like OCaml, these niche langauges...) is practical or useful. I mean that in the sense of "why would you choose this over something else more recognized and readable that can do it just as fast".

In general, kind of resent the idea of using languages like that just for the sake of being different, as opposed to it actually being useful.

Quote:

---

Originally Posted by Epy

I don't really believe Haskell or other crap similar to that (like OCaml, these niche langauges...) is practical or useful. I mean that in the sense of "why would you choose this over something else more recognized and readable that can do it just as fast".

In general, kind of resent the idea of using languages like that just for the sake of being different, as opposed to it actually being useful.

---

The problem is, someone realized that you can apply category theory as a means of expressing programs. The biggest issue with this is that, well, math sucks. No one wants to reason about their code as categories and then how they relate to each other through the use of functors, here "functor" is the formal definition of mapping of values and their morphisms in a category to a separate category.

The terms "monoid in the category of endofunctors" only really make sense to people who are really, really into math. I don't think it's a useful programming construct at all. It's almost abhorrent, the amount of extra cognitive overhead that's applied to relatively simple code.

FP did bring some useful things to the table though, namely higher-order functions.

I do like FP, I started off with Lisp after all. Just some programming languages look more like a puzzle than elegant / readable IMO. Unnecessary unless just messing with it as a hobby IMO.

Okay, I've come back to say that I've done it!
I can do it on my own now:

Code:

---

main = foldr((>>) . putStrLn . show)(return ())([1 .. 10]);

---

Took me 4 weeks to learn how to print 1 through 10 in Haskell lol but I've done it and I understand it! I understand how you form monads out of endofunctors and the two natural transformations and how they form monoids over categories themselves. Bloody Hell...

This is also ridiculously inefficient compared to imperative languages as well. Category theory is fun to learn but gosh darn, some things it's apparent that the "dumb" way is clearly the "better" way.

Sorry to interrupt the serious conversation, but I realised this video from a Japanese game show has not been posted.

Lucas would have done it like this, probably:

Code:

---

#include <stdio.h>
int main()
{
    for(int tmp, a = 0, b = 1; b <= 10; tmp = 2 * b - a, a = b, b = tmp)
        printf("%d\n", b);
}

---

Code:

---

'(1 2 3 4 5 6 7 8 9 10)

---

Which is almost a quine, if not for the ' (unquote) character.

BTW, that is Scheme code which will evaluate to the list of integers from 1 to 10. In Scheme, code is data and vice-versa (mostly).

Actually, most Scheme code can evaluate to itself which makes writing quines in Scheme mostly trivial if you can account for the unquote operator.

Code:

---

main = foldr((>>) . putStrLn . show)(return ())([1 .. 10]);

---

Thats the most ugly code I've ever seen. If I didn't know it prints 1 to 10 then I'd be lost in days of analysis trying to figure it out. Sucks. Whats wrong with just

Code:

---

[1 .. 10]

---

Also WTF is the return() HAH who ever writes this crap?

BBC Basic

Code:

---

REM 1-10 printing
REM written by Ada Skyla-Rose
REM ===================
FOR i = 1 TO 10
PRINT i
NEXT i
ENDPROC
END

---

Quote:

---

Originally Posted by MacNilly

Code:

---

main = foldr((>>) . putStrLn . show)(return ())([1 .. 10]);

---

Thats the most ugly code I've ever seen. If I didn't know it prints 1 to 10 then I'd be lost in days of analysis trying to figure it out. Sucks. Whats wrong with just

Code:

---

[1 .. 10]

---

Also WTF is the return() HAH who ever writes this crap?

---

4. Weeks.

This took me 4 weeks to figure out lol XD

It is very ugly but let me explain, the foldr signature is :

Code:

---

foldr :: (a -> b -> b) -> b -> [a] -> b

---

I'm using `[a]` instead of traversable `t a` for simplicity.

foldr is somewhat intuitive in that it folds from right to left. Using this and the above type signature, we can infer that first part of our fold is

Code:

---

(>>) . putStrLn . show $ 10

---

which gives us a partially applied monadic sequence operation. Using the `b` part of our signature, this is then applied to `return ()` which just gives us an empty monad instance.

So basically, what we wind up with is this:

Code:

---

... (8 >> (9 >> (10 >> IO())))

---

Remember that

Code:

---

m >> k = m >>= \_ -> k

---

for monads.

So you wind up with (let's pretend we don't need the show crap and we're only going 1 through 5):

Code:

---

putStrLn("1") >> (putStrLn("2") >> (putStrLn("3") >> (putStrLn("4") >> ((putStrLn("5") >> return ())))))

---

Long-story short, this is why Haskell is stupid and isn't used in the industry and no amount of hipster nonsense (credit to Yarin for the hipster term ;P) can ever hope to make it a practical and viable programming language.

However, learning category theory has done nothing but make me a better programmer.

Edit:

Some of the stuff is just there because Haskell has a decent type system. If we have a number, we need to Show it first and then when we putStrLn, we simply get a monad back out. Because we want to sort of chain these guys together, it's easiest to fold using a sequence which does our >>= stuff for us. Basically, we want to map over the list creating an IO instance of each element and then we want to chain them together. This is most easily expressed as a fold with a monadic sequencing.

Something something functors something something applicative, no one understands my code, god, Mom!

You would make a good Java programmer, John

What makes you say that?

Your Haskell is enterprise quality :D

Lol I literally just started reading about how in categorical terms an applicative is actually a monoidal functor. I think everything in Haskell is enterprise-quality by nature of the beast XD

Seriously, the most useless thing ever but I can't pull myself away from it!

Well, in procedural terms an applicative can be thought of as a function. So, you could say C++ is enterprise-quality.
The good thing about comparison theorems is that you can always think of an ant as type of elephant.

Heh heh. Not as much fun as the category theory version though :P

It's really fun to think about while I'm at work because Lord knows I can't focus on actual work that long.

Quote:

---

Originally Posted by MutantJohn

However, learning category theory has done nothing but make me a better programmer.

---

Well there you go then. You found a use for Haskell after all ;)

Well, I can see you "learned you some Haskell for some good". Bravo! :cool:

I mean, I like a lot of the concepts of Haskell, but when I hit monads I gave up. I understand that they adopted the monad concept in order to encapsulate side-effects in order to make Haskell "pure", but to me it just seems to be to be excessively difficult to apply and a basically useless abstraction. I mean, think about it: some side effect must have occurred, if any I/O is actually done. Then, the whole point of the monad type is to limit the amount of "damage" that these side effects have on the rest of the program. However, this could be done in other ways that are conceptually simpler. What about a language that had an "iterative" and "functional" subsets... and differentiated between "pure" functions and "side-effecting" functions, and these could only be used in certain contexts? I think it would achieve the same separation between pure/impure that is the whole point of the monad, without introducing the difficulties.

For example, you could have "functions" (pure) and "procedures" (impure), denoted by different keywords. While the majority of the program would be pure (disallowing "impure" procedure calls) you could have a "do" block that enters a iterative context, where you can freely mix assignment and procedure call. Actually, I am working on a language like this at the moment...

D actually supports a "pure" keyword. I wish C++ did too... :P

But yeah, the IO monad is basically a way of guaranteeing the same function execution, even if the input is different. Fundamentally, FP is about categories over types and how those types are transformed from one to the other. The type system does help keep things in line but that's more or less because it represents a functor and how functors transform categories.

Quote:

---

Originally Posted by MutantJohn

D actually supports a "pure" keyword. I wish C++ did too... :P

---

It's not as useful as it seems. Purity is trivial to statically prove. And it doesn't help with CTFE, since if you want to guarantee it, the expression in question should be decorated as such, which C++ does have, in the form of constexpr.

Apl:

Code:

---

⍳10

---

Quote:

---

Originally Posted by swgh

BBC Basic

Code:

---

REM 1-10 printing
REM written by Ada Skyla-Rose
REM ===================
FOR i = 1 TO 10
PRINT i
NEXT i
ENDPROC
END

---

---

This won't run in BBC BASIC since you haven't defined the procedure. Remove the ENDPROC and it will work - or define the procedure. This will work in BBC BASIC for Windows:

Code:

---

      PROC_loop
      PRINT
      PRINT "THE END."
      END
   
      DEF PROC_loop
      FOR I=1 TO 10
        PRINT I;
      NEXT I
      ENDPROC

---

...as will the REPEAT...UNTIL loop in BBC BASIC that I posted earlier on in this thread.

May as well add the WHILE...ENDWHILE loop way of doing this in BBC BASIC

Code:

---

     
      REM WHILE...ENDWHILE loop BBC BASIC (BBC BASIC for Windows & BBC BASIC V)
      a%=0
      WHILE a%<10
        a%+=1
        PRINT a%
      ENDWHILE
      END

---

However let it be said that the only correct way to program BBC BASIC today is to program it wrong.

Quote:

---

Originally Posted by Mario F.

However let it be said that the only correct way to program BBC BASIC today is to program it wrong.

---

BBC BASIC dates back to 1981 but it has continued to be developed over the years. Perhaps you would explain the paradox that you see.

I confess wasn't expecting that. What paradox? The only dysfunctional thing happening here is the idea that there's any sort of reason for a legacy system to remain in in the domain of BBC BASIC and not have been ported already. Is that what you are trying to say? The language wasn't even able to sustain very large systems due to the combination of syntax and semantics that made large programming tasks overly complex and impractical. Today it remains only an historical figure and a source of curiosity, nothing more. If you know of anyone or anything maintaining some BASIC system on a need-for basis, they are idiots.

Quote:

---

Originally Posted by Mario F.

I confess wasn't expecting that. What paradox? The only dysfunctional thing happening here is the idea that there's any sort of reason for a legacy system to remain in in the domain of BBC BASIC and not have been ported already. Is that what you are trying to say? The language wasn't even able to sustain very large systems due to the combination of syntax and semantics that made large programming tasks overly complex and impractical. Today it remains only an historical figure and a source of curiosity, nothing more. If you know of anyone or anything maintaining some BASIC system on a need-for basis, they are idiots.

---

I must confess that I wasn't expecting your overreaction to my request that you explain what you meant when you said that the only way to correctly program BBC BASIC was to do it wrong - a paradox. A quick bit of research on your part will show that in fact BBC BASIC was originally designed to teach programming but did have commercial uses. At least one modern implementation of the dialect is being used commercially today (I don't think I could describe such users as 'idiots' though), although as you rightly point out, it is small scale especially when compared to languages like C. See "Happy Birthday BBC BASIC" on this link, which will provide more information.

www.rtrussell.co.uk

For me, BBC BASIC is nothing more than an enjoyable hobby, along with pottering around with 8 bit micros like the BBC Micro and ZX Spectrum - a hobby that I understand we share :)

BBC Basic was fun back in the day, but I only used it generally to access the built-in assembler. Much of the code I wrote was for use on Econet or games. It was certainly easier to access the full power of the machine on a BBC than on a Sinclair, as you needed an assembler which itself took 20 minutes to load from a tape deck. Brings back memories :)

Quote:

---

Originally Posted by Hobbit

It was certainly easier to access the full power of the machine on a BBC than on a Sinclair

---

Couldn't recall the details, so I fired my emulator just now and the BASIC interpreter uses up roughly 20k of a 48k total available memory. A hog. The BBC implementation uses less space, but its still 16k and it has no access to graphics or sound. The BBC implementation does have a neat feature that allows you to embed assembly language into the BASIC code (which you mention) and helps bypass its limitations and actually permits BASIC code to do extravagant things not possible with just either shape of BASIC. But other than because one is pressured for time, the Z8x instruction set is so easy that it pays to just go full assembly and forget BASIC entirely.

I still do Z80 programming as an occasional hobby as part of my love for the ZXSpectrum machine, which is where I started programming. Precisely on BASIC. But I think not even a couple of years later I first started back in the early 80s, I had already moved entirely to Z80 assembly.

EDIT: I remember returning to BASIC back in the early days of DOS, namely the DOS BASIC. But that too was short-lived because soon enough first DBase and then Clipper, completely robbed the space for any interest in BASIC. I can understand the appeal as an hobby and a curiosity, that much I said before. Who doesn't have fond memory of POKEing their way through games or learning to program by copying code from the Crash or MySinclair magazines. But anecdotal evidence of the existence of modern and semi-modern implementations of BASIC code doesn't remove the fact it is a dead language. My statement a couple of posts above was evidently a joke making a stab at that fact.

EDIT 2: And one is still an idiot if they use BASIC to monitor seismic activity on the Roman Colosseum. The risks of maintaining such a system are evident for no other reason than the tremendous difficulty that it must be to guarantee the availability of programmers in case something goes wrong.

I started with the ZX80. Learnt BASIC very quickly but it wasn't enough. Soon picked up the z80 programmers handbook and taught myself assembly language. Trouble was the choice was a 20+ min load of an assembler from a tape or to write on paper, look up each op code and type in the numbers bit by bit, in actual fact one or two games for Sinclair machines were actually written exactly like that as computer time for some was scarce. I had a zx80 then a Spectrum 48k. School built a brand new computer labs complete with BBC 'B's, and a few Master 128k all linked with Econet. A mate also had a Beeb so I had time to learn 6502 asm before the labs were finished. The Speccy had greater capabilities for sure, but writing for the Beeb was easier. The Beeb was for sure the better built machine, they were solid, Speccys often went boom from overheating or failing components. Some games companies back then really pushed the Speccy to the limit. I always thought the best Speccy games came from Ultimate Play the Game. On the Beeb we were all playing Elite if I recall correctly, Ian Bell's and David Braben's masterpiece.

You should love this place. And its forums.
We are still a very active development community.

Along the same lines, I have seen the full source code for the !Run application of Lemmings on the old Acorn Computer - and the entire file is BBC Basic. I do not know if Psygnosis coded that entire version of the game in BBC Basic due to the speed the code ran on Acorns and the limited memory space would not have made C (which most modern versions of the game were coded in) a viable language for that platform.

Pygnosis did however, do a brilliant job with the code - and getting such a (back then) graphically enhanced version of the game to run flawless on limited hardware is full credit to them. Yes, they also created Shadow of the Beast and Agony, but neither of those games had an Acorn port (I don't think they did) due to the scale of them compared to simplicity of Lemmings.

Who doesn't remember Manic Miner or for Beeb afficionados Elite. That version of Elite is written in C reverse engineered painfully by hand from the original 6502 asm source codes. Colour has been added as the original was black and white and wireframe.
Yes Mario I am already aware of that community. It's been a long time since I used z80 or 6502 asm.

Quote:

---

Originally Posted by Mario F.

You should love this place. And its forums.
We are still a very active development community.

---

Yes I am a member of this community and it has a thriving BASIC scene - original Sinclair BASIC and extended implementations. Here are links to some of the latter:

ZXBasic - BorielWiki

pauldunn

You may also be interested in this community too:

Sinclair ZX80 / ZX81 Forums - Index page

BASIC is making a bit of a comeback as a teaching language:

Welcome - Every Child Can CodeEvery Child Can Code

and BBC Micros are being used by some schools to teach coding because you have to use more mental muscle to get results within the available memory:

http://www.tnmoc.org/explore/computing-education

I don't think people are idiots for using BBC BASIC commercially. There may be popular and more capable languages for many commercial tasks but BASIC has less overhead than many languages and its simplicity and stability are its strengths. In other words, if the language is up to the job then why not?

I'm sure that commercial users would have business continuity plans is place and it should be no problem for professional programmers to pick up and maintain well structured and documented BBC BASIC, even if they haven't cut their teeth on BASIC.

As late as 2004, a BBC Micro was still being used to steer the 42ft telescope at Jodrell Bank, which emphasises its reliability, stability and suitability for critical tasks like monitoring seismic activity on the Roman Colosseum even if there are more obvious languages out there for doing so.

This is starting to sound like Haskell programmers justifying the viability of their language as well...

Okay, I tease. I don't know any BASIC. I just thought it was a funny opportunity for a joke :P

Forgive me.

Quote:

---

Originally Posted by MutantJohn

This is starting to sound like Haskell programmers justifying the viability of their language as well...

Okay, I tease. I don't know any BASIC. I just thought it was a funny opportunity for a joke :P

Forgive me.

---

:o Yep, you're right it does look like that - plus its pretty much off topic. Sorry swgh, I got carried away blabbing on about my hobby!

I'm actually here because I'm learning C and I end up talking about BASIC! :tongue:

Still, the links might be interesting to some... :)

Quote:

---

Originally Posted by Richey

I'm learning C and I end up talking about BASIC!

---

Good thing it's the "General Discussion" part of the forum.

Tcl:

Code:

---

for {set i 1} {$i <= 10} {incr i} {puts $i}

---

C:
heheh

Code:

---

#include <stdio.h>
int main()
{
    short fun=1;
    if(fun == 1)
        printf("%hi",fun);
        fun++;
        if(fun == 2)
            printf("%hi",fun);
            fun++;
            if(fun == 3)
                printf("%hi",fun);
                fun++;
                if(fun == 4)
                    printf("%hi",fun);
                    fun++;
                    if(fun == 5)
                        printf("%hi",fun);
                        fun++;
                        if(fun == 6)
                            printf("%hi",fun);
                            fun++;
                            if(fun == 7)
                                printf("%hi",fun);
                                fun++;
                                if(fun == 8)
                                    printf("%hi",fun);
                                    fun++;
                                    if(fun == 9)
                                        printf("%hi",fun);
                                        fun++;
                                        if(fun == 10)
                                            printf("%hi",fun);
puts("");
return 0;       
}

---

First post [X]

Lua:

Code:

---

for i=1,10 do print(i) end

---

Brainfunk: :p

Code:

---

++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++
+.<.>+.<.>+.<.>+.<.>+.<.>+.<.>+.<.>+.<.>+.<.>--------.-.<.>

---