0

in Delphi :

program simplecount;

var
   i: Integer;
 
begin
   for i := 1 to 10 do
      WriteLn(IntToStr(i));
end.

and in perl (because everyone loves perl) :

#!/usr/bin/perl

for($i  = 0; $i < 10; ++$i)
    {
        print $i . "\n"
    }

I use Ruby mostly these days. From previous posts you can tell why; so so elegant

1

HTML

<html>
<head><title>It's an instructional language</title></head>
<body>
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
</body>
</html>

If we apply some simple definitions to terms, HTML is a valid language to use for this. (i.e. Program: Series of instructions to be executed. HTML thusly instructs the interpreter to write the code.)

Ada

with Ada.Integer_Text_IO;

procedure print10 is
  begin
     for i in integer range 1..10 loop
       Ada.Integer_Text_IO.put(i);
     end loop;
  end print10;

Yet another C++ version:

#include <iostream>

using namespace std;

int main()
  {
  int i=1;
  cout << i;    // 1
  cout << ++i;  // 2
  cout << ++i;  // 3
  cout << ++i;  // 4
  cout << ++i;  // 5
  cout << ++i;  // 6
  cout << ++i;  // 7
  cout << ++i;  // 8
  cout << ++i;  // 9
  cout << ++i;  // 20
  }
0

8080 Assembler

code    segment                     ; Start of the code
        assume  cs:code             ; Load code segment register
                org     100h        ; and set program up as a .COM file
start:  
        assume  cs:code

        mov     ax,     1           ; Start at 1
loop:
        call    outdec              ; Output the AX register
        inc     ax                  ; next value
        cmp     ax,     10          ; Above 10 yet?
          jle     loop

        mov     al,     0
        mov     ah,     4Ch
        int     21h                 ; Exit 

; ******************************** ;

outdec:
        push    ax                  ; save AX
        mov     bx,     10          ; divisor
        mov     cx,      3          ; # characters
convloopd:
            mov     dx,      0      ; zero high word for div
            div     bx              ; divide by 10
            add     dl,     30h     ; convert remainder to char
            push    dx              ; Save character
            loop    convloopd       ; do it til cx = 0
        
        mov     cx,     3           ; start another loop
outloopd:
        pop     dx                  ; get the character
        mov     ah,     02h         ; output character fcn
        int     21h                 ; output it
        loop    outloopd

        mov     ah,     02h
        mov     dl,     ' ' 
        int     21h                 ; output 2 spaces
        int     21h

        pop     ax                  ; restore original number
        ret
code ends
end start
0

Haskell, with the integer datatype implemented from scratch:

First, let's implement a datatype for storing integers.

> data IntType = Zero
>              | Succ IntType
>              | Pred IntType
>                deriving Eq

Then we'll want to implement comparison for integers.

> instance Ord IntType where
>     compare (Pred xt) (Pred yt) = compare xt yt
>     compare (Pred _)  _         = LT
>     compare _         (Pred _)  = GT
>     compare Zero      Zero      = EQ
>     compare (Succ xt) (Succ yt) = compare xt yt
>     compare (Succ _)  _         = GT
>     compare _         (Succ _)  = LT

Integers should be enumerable too...

> instance Enum IntType where
>     toEnum 0 = Zero
>     toEnum n = accume n Zero
>         where accume 0 k = k
>               accume n k
>                   | n < 0 = accume (n+1) (Pred k)
>                   | n > 0 = accume (n-1) (Succ k)
>     fromEnum k = adder 0 k
>         where adder n Zero = n
>               adder n (Pred kt) = adder (n-1) kt
>               adder n (Succ kt) = adder (n+1) kt
>     succ (Pred kt) = kt
>     succ k         = Succ k
>     pred (Succ kt) = kt
>     pred k         = Pred k
>     enumFrom x = iterate succ x
>     enumFromTo x y
>         | x == y    = [x]
>         | otherwise = x : enumFromTo (succ x) y

And we need to perform arithmetic.

> instance Num IntType where
>     x         + Zero = x
>     Zero      + y    = y
>     (Pred xt) + y    = xt + pred y
>     (Succ xt) + y    = xt + succ y
>     x - Zero      = x
>     x - (Pred yt) = succ x - yt
>     x - (Succ yt) = pred x - yt
>     Zero      * y = Zero
>     (Pred xt) * y = xt * y - y
>     (Succ xt) * y = xt * y + y
>     abs x@(Pred _) = Zero - x
>     abs x          = x
>     signum (Pred _) = Pred Zero
>     signum (Succ _) = Succ Zero
>     signum Zero     = Zero
>     fromInteger n = accume n Zero
>         where accume 0 k = k
>               accume n k
>                   | n < 0 = accume (n+1) (Pred k)
>                   | n > 0 = accume (n-1) (Succ k)

They must be an instance of Real in order to be an instance of
Integral.

> instance Real IntType where
>     toRational = toRational . toInteger

Our integers are indeed integral :-)

> instance Integral IntType where
>     quotRem Zero _ = (Zero, Zero)
>     quotRem n d = appsig (signum n * signum d) (foo n d)
>         where appsig k (q,r) = (k*q, k*r)
>               foo n d = countup (abs n) (abs d) Zero
>               countup n@(Pred _) d c
>                   = (pred c, n + d)
>               countup n d c
>                   = countup (n - d) d (succ c)
>     toInteger k = acc 0 k
>         where acc n Zero      = n
>               acc n (Pred kt) = acc (n-1) kt
>               acc n (Succ kt) = acc (n+1) kt

Finally, implement an instance of the Show class, for converting
integers to strings.

> instance Show IntType where
>     show n | n == Zero = "0"
>            | n < Zero = '-' : show (negate n)
>            | n > Zero = onshow n ""
>         where ten = Succ $ Succ $ Succ $ Succ $ Succ five
>               five = Succ $ Succ $ Succ $ Succ $ Succ Zero
>               onshow Zero s = s
>               onshow k s = let (q,r) = quotRem k ten
>                            in onshow q (charate r : s)
>               charate Zero = '0'
>               charate (Succ kt) = succ (charate kt)

Might as well show off that it works...

> greaterroot :: IntType -> IntType
> greaterroot n = head [k | k <- [Zero ..], k * k >= n]

Finally, our main function!  Make a list of perfect squares from Zero
to (Succ (Succ (Succ ... (one hundred times) ... (Succ Zero) ... ))),
then find their square roots, and output them!

> main :: IO ()
> main = 
>   mapM_ (putStrLn . show) $ map greaterroot squares
>     where squares = map (\x -> x*x) [one .. ten]
>           one = Succ Zero
>           two = one + one
>           five = two + two + one
>           ten = two * five
1

I just started teaching myself O'Caml :)

let rec range s f =
    if s > f then []
    else s :: range (s + 1) f ;;

let count s f = 
    List.iter (fun i -> Printf.printf "%d " i) (range s f)  ;;

count 1 10 ;;
0

XML/XSLT

I guess XML isn't a language, and XSLT doesn't have to be, but this is certainly programmatic. It requires an input XML file and produces an HTML output file with the numbers one to ten separated by line breaks. The elements in the XML input file are irrelevant, as long as the root element is called "lots", and every "lots" element contains one more "lots" element than its parent. Until you get to ten of course.

Here's the input file (lots.xml)

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="countem.xsl"?>
<lots>
  <lots><lots><lots>
  <lots><lots><lots>
  <lots><lots><lots>
  <right /><what /><we /><are /><going /><to />
  <do /><here /><is  /><create /></lots><of />
  <elements /><infact /><they /><are /><xml />
  <elements /><and /></lots><of /><them /><are />
  <in /><this /><file /><yes /></lots><of /><em />
  <doesnt /><matter /><whats /><in /></lots><of />
  <them /><because /><most /><infact /></lots><of />
  <them /><are /><just /></lots><and /><thats />
  <got /></lots><of /><importance /></lots><and />
  </lots>
</lots>

And heres the XSLT stylesheet:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="[URL]http://www.w3.org/1999/XSL/Transform[/URL]" version="1.0">
 
    <xsl:template match="/">
        <html>
            <head><title>Count to ten!</title></head>
            <body>
                <xsl:apply-templates select="lots"/>
            </body>
        </html>
    </xsl:template>
 
    <xsl:template match="lots">
        <xsl:value-of select="count(*)"/>
        <br />
        <xsl:apply-templates select="lots"/>
    </xsl:template>
</xsl:stylesheet>

Matt

0

By programming myBrain (in real-time) to use the "handwriting" library : system requirements included "pencil" and "paper" : tested in the "my kitchen" environment only.

Yep that's right, I wrote down the numbers 1 to 10 on a piece of paper. It had a very short implementation time, and I even drew a squiggly line around the numbers when I'd finished.

I unfortunately can't provide any evidence to support this feat - you'll just have to trust me.

Matt

0

MIPS assembler. Using SPIM simulator

.data
str1: .asciiz "1 2 3 4 5 6 7 8 9 10"
.globl main                            
.text                                  
                                       
main:
   la $a0, str1                   # load string address into $a0 and I/O code into $v0     
   li $v0, 4            
   syscall                          # execute the syscall to perform input/output 
                                      # via the console
                                    
   li $v0, 10                      # syscall code 10 for terminating the program
   syscall
0

Just been playing about with C++ Templates, and thought of this thread :)
(By the way, only 44 posts?! we can do better than that...! )

#include <iostream>

template<int i> void count()
{
    std::cout << i << std::endl;
    count<i+1>();
}

template<> void count<10>()
{
    std::cout << 10 << std::endl;
}

int main()
{
    count<1>();
}
0

(By the way, only 44 posts?! we can do better than that...! )

That we can. On the forum where I stole this idea, we got to 500. :)

#include <iostream>

template <int n>
class Counter {
    public:
        Counter() {
            Counter<n - 1> count;
            std::cout << n << std::endl;
        }
};

template <>
class Counter<0> {
    public:
        Counter() {}
};

int main() {
    Counter<10> count;
}

EDIT: I'm in shock! I'm sorry that my code is so similar to yours. It was a complete coincidence. :eek:

0

EDIT: I'm in shock! I'm sorry that my code is so similar to yours. It was a complete coincidence. :eek:

heh, I think you can claim that yours is a more OO version :)

1

#include<stdio.h>
void main(){
static int i =0;
while(++i<=10){
printf("%d\n",i);
main();
}

Votes + Comments
but the idea is nice (andor)
0

#include<stdio.h>
void main(){
static int i =0;
while(++i<=10){
printf("%d\n",i);
main();
}

Don't use void main() instead use int main() . Never call main recursivly. Ok i can be static but why it's not just auto variable. For last you need one more } . After all forums are to improve our skills.
Bye

0
#include <stdio.h>

int main()
{
   char  c[] = {4, 16, 2, 0, 68, 65, 77, 83, 21, 84, 89, 0, 71, 82, 81, 78, 77, 0, 106, 1, '\n'};
   char * p = c;
   char * tmp = "500 ways to print [1..10]!";
   
   while(*p != '\n')
      putchar(*p++^*tmp++);
   return 0;
}
0

Another C#:

public class Count{
     
       public static void main(){
                 
                 int [] a = {1,2,3,4,5,6,7,8,9,10};
 
                 foreach(int i in a)
                       System.Console.Write(i + " ");
       }
}
0

what is the shortest way of printing 1..10 in any language?

i can't see any being much shorter than this :

1.upto(10) { |i| puts i }
0

what is the shortest way of printing 1..10 in any language?

i can't see any being much shorter than this :

1.upto(10) { |i| puts i }

In perl:

print 1..10;

or even shorter:

die 1..10;

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.