-1
\$\begingroup\$

I challenge you to generate the following sequence till 100 terms through any programming language in shortest characters possible.
The sequence is like this :-

1 2 3 4 5 10 20 30 40 50 100 200 300 400 500 ........  

The output needs to be like this (above) only, nothing extra.

Remember, You can use + and - only and for mathematical calculations only (++ and -- are also allowed) and no other mathematical function like tan(), log(), pow(), ......etc.

Also, You cannot use any character variables in your code.

\$\endgroup\$
15
  • \$\begingroup\$ "You can use + and - only for mathematical calculations" So is this a [restricted-source] challenge? \$\endgroup\$ Apr 16, 2014 at 2:35
  • \$\begingroup\$ Eh, seems easier to just treat them as strings and concat '0' each loop. \$\endgroup\$
    – Geobits
    Apr 16, 2014 at 2:36
  • \$\begingroup\$ @algorithmshark can there be [restricted-source] + [code-golf]? \$\endgroup\$ Apr 16, 2014 at 2:37
  • 1
    \$\begingroup\$ Wait a minute, if we can't use characters or strings, how do we output the numbers separated with spaces? Can they be newline separated instead? \$\endgroup\$
    – Doorknob
    Apr 16, 2014 at 2:44
  • 1
    \$\begingroup\$ “You can use + and - only for mathematical calculations” – Does this mean that I must not use + and - for something other than mathematical calculations or does this mean that I must not use any other mathematical operators than + and -? \$\endgroup\$
    – Wrzlprmft
    Apr 16, 2014 at 14:48

9 Answers 9

6
\$\begingroup\$

GolfScript (21 chars)

If

You can use + and - only for mathematical calculations

means what it says then:

[6,1>~{4$10*}95*]' '*

If it is intended to say

The only mathematical operators you can use are + and -

then the multiplications can be replaced with string manipulation at the same character count:

[6,1>~{4$0`+}95*]' '*

Dissection:

[         # Start gathering values into an array
  6,1>~   # Dump the numbers 1 to 5 onto the stack
  {       # Beginning of loop body
    4$    # Copy the 5th item on the stack

Here the variants differ

    10*   # Multiply it by 10

or

    0`+   # Postpend '0'

And then merge again

  }95*    # Loop 95 times, so we end up with 100 items on the stack
]         # Gather those 100 items into an array
' '*      # Space-separate them
\$\endgroup\$
2
  • \$\begingroup\$ I don't know GolfScript but 4$10* # Copy the 5th number on the stack and multiply by 10 -- Only addition subtraction and (in|de)crements are allowed \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:04
  • \$\begingroup\$ @user80551, that's not clear to me, but it's easily worked around at the same character count. \$\endgroup\$ Apr 16, 2014 at 14:34
4
\$\begingroup\$

Perl, 38 bytes

Disclaimer: The restrictions of the changed question are not too clear to me.

for$i(0..19){print$_.0 x$i.$"for 1..5}

The code uses variables with integer values except for $" which is used for the separation space. It can be easily replaced by ' ' (+1 byte).

Mathematical operations are not used, the code only contains string concatenations and the repetition operator.

The result are 100 numbers:

1 2 3 4 5 10 20 30 40 50 100 200 300 400 500 1000 2000 3000 4000 5000 10000 20000 30000 40000 50000 100000 200000 300000 400000 500000 1000000 2000000 3000000 4000000 5000000 10000000 20000000 30000000 40000000 50000000 100000000 200000000 300000000 400000000 500000000 1000000000 2000000000 3000000000 4000000000 5000000000 10000000000 20000000000 30000000000 40000000000 50000000000 100000000000 200000000000 300000000000 400000000000 500000000000 1000000000000 2000000000000 3000000000000 4000000000000 5000000000000 10000000000000 20000000000000 30000000000000 40000000000000 50000000000000 100000000000000 200000000000000 300000000000000 400000000000000 500000000000000 1000000000000000 2000000000000000 3000000000000000 4000000000000000 5000000000000000 10000000000000000 20000000000000000 30000000000000000 40000000000000000 50000000000000000 100000000000000000 200000000000000000 300000000000000000 400000000000000000 500000000000000000 1000000000000000000 2000000000000000000 3000000000000000000 4000000000000000000 5000000000000000000 10000000000000000000 20000000000000000000 30000000000000000000 40000000000000000000 50000000000000000000

Ungolfed:

for $i (0..19) { # 20 * 5 = 100 numbers
    for $_ (1..5) {
        print $_     # first digit
            . 0 x $i # zeros
            . $"     # separator (space)
    }
}    
\$\endgroup\$
1
  • \$\begingroup\$ Not a bad solution. The shortest I could manage was 34: print 1..5,!($,="0$,"||$")for a..t \$\endgroup\$
    – primo
    Apr 17, 2014 at 7:25
4
\$\begingroup\$

Python 60

r=range
for i in r(20):
 for j in r(1,6):print str(j)+'0'*i,

Thanks to @ace for pointing out that this was way too long.

Python 113

from itertools import*
i=j=0
for x in cycle(range(1,6)):
 i+=1;print str(x)+'0'*j,
 if i%5==0:j+=1
 if i>99:break

\$\endgroup\$
6
  • 2
    \$\begingroup\$ It should be shorter if you use two loops instead of itertools \$\endgroup\$
    – user12205
    Apr 16, 2014 at 9:16
  • \$\begingroup\$ for j in'12345' lets you omit the str() command, which brings you down to 51 characters, if you remove the first line and spell out range \$\endgroup\$
    – MrLemon
    Apr 16, 2014 at 14:39
  • \$\begingroup\$ @MrLemon j will then become a character variable which is not allowed. \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:58
  • \$\begingroup\$ @user80551 I totally overlooked that part, you are correct. \$\endgroup\$
    – MrLemon
    Apr 16, 2014 at 15:12
  • \$\begingroup\$ Use list comprehension and this will reduce to 47 characters [i*10**j for j in range(21)for i in range(1,6)] \$\endgroup\$
    – Abhijit
    Apr 16, 2014 at 15:47
3
\$\begingroup\$

GolfScript, 30 25 characters (26 23 newline separated)

;6,1>{.{10*}%}20*][]*' '*

Commented:

;         # pop the input string (empty)
6,1>      # generate [1 2 3 4 5]
{.{10*}%} # duplicate the array and multiply everything by 10
20*       # do this 20 times (5 * 20 = 100)
]         # wrap the whole stack in an array
[]*       # flatten
' '*      # join by space

I really don't like the repetition at the end, but GS doesn't provide a flat_map or flatten of any sort. Thanks @PeterTaylor for providing a way to flatten!

If we can separate by newlines instead of spaces, then 23 characters:

;6,1>{.{10*}%}20*][]*n*
\$\endgroup\$
5
  • \$\begingroup\$ You should create a programming language called DoorknobScript. \$\endgroup\$
    – Justin
    Apr 16, 2014 at 5:50
  • 1
    \$\begingroup\$ To get an array of 1 to 5 it's better to do either 6,(; or 6,1>. GS does provide a couple of ways to do one-level flatten: []* or {~}%. But to use either you'll need to remove the initial '' from the stack (which is currently giving you output with a leading space) or avoid including it by using an explicit [. \$\endgroup\$ Apr 16, 2014 at 7:34
  • \$\begingroup\$ {.{10*}%} # duplicate the array and multiply everything by 10 Multiplying isn't allowed. \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:08
  • \$\begingroup\$ @user Where does it say that? Most of the other answers use multiplication too. \$\endgroup\$
    – Doorknob
    Apr 16, 2014 at 15:04
  • \$\begingroup\$ It says "Remember, You can use + and - only and for mathematical calculations only (++ and -- are also allowed)". Doesn't "only" means ..... "only"? \$\endgroup\$
    – microbian
    Apr 16, 2014 at 17:02
3
\$\begingroup\$

APL (17 24)

,⍉10⊥¨(⍳5)∘.{⍺,1↓⍵/0}⍳20
\$\endgroup\$
2
  • \$\begingroup\$ Multiply and power are not allowed. \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:05
  • \$\begingroup\$ @user80551: ok I changed it \$\endgroup\$
    – marinus
    Apr 16, 2014 at 14:16
2
\$\begingroup\$

Java,185

class g {public static void main(String[] args){for(int x=0;x<20;x++){for(int i=1;i<6;i++){System.out.print(""+i); for(int j=0;j<x;j++){System.out.print("0");}System.out.print(" ");}}}}
\$\endgroup\$
5
  • 1
    \$\begingroup\$ You forgot a space between int and j so your code didn't compile. I edited your answer to fix that. \$\endgroup\$
    – ProgramFOX
    Apr 16, 2014 at 13:31
  • 1
    \$\begingroup\$ It's also an infinite loop rather than printing 100 terms. \$\endgroup\$
    – Geobits
    Apr 16, 2014 at 13:36
  • \$\begingroup\$ Oh ok, sorry I'll edit it. \$\endgroup\$ Apr 16, 2014 at 13:38
  • 1
    \$\begingroup\$ You can get it down to 169 by 1) renaming args 2) restructuring the loops and 3) declaring your ints up front : class G{public static void main(String[]a){int x=0,i,j;for(;x<20;x++)for(i=0;i++<5;System.out.print(" ")){System.out.print(""+i);for(j=0;j++<x;System.out.print("0"));}}} \$\endgroup\$
    – Geobits
    Apr 16, 2014 at 13:51
  • \$\begingroup\$ Can't you remove the space just before the third for \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:19
2
\$\begingroup\$

Julia - 38

[print(i,"0"^j," ") for i=1:5,j=0:19];

Output:

1 2 3 4 5 10 20 30 40 50 100 200 300 400 500 1000 2000 3000 4000 5000 10000 20000 30000 40000 50000 100000 ...
\$\endgroup\$
3
  • 1
    \$\begingroup\$ -1 , multiplication and power are not allowed. \$\endgroup\$
    – user80551
    Apr 16, 2014 at 14:06
  • \$\begingroup\$ Now they are strings, so i think it doesnt break the rules \$\endgroup\$
    – CCP
    Apr 16, 2014 at 14:30
  • 1
    \$\begingroup\$ I just wrote the exact same solution before seeing yours. \$\endgroup\$
    – gggg
    Apr 16, 2014 at 17:43
2
\$\begingroup\$

C, 93

i;main(j,k){for(;++i;)for(j=0;++j<6;){for(putchar(48+j),k=0;++k<i;putchar(48));putchar(32);}}

// it draws nice patterns on the terminal...

\$\endgroup\$
1
2
\$\begingroup\$

PHP - 61

for($i=0;$i++<21;)for($j=0;$j++<5;)echo str_pad($j,$i,0).' ';
\$\endgroup\$

Not the answer you're looking for? Browse other questions tagged or ask your own question.