5
\$\begingroup\$

This question already has an answer here:

You have to create a code which prints

:)  

a random number of times from 1 to 255 inclusive. Your output may not contain any whitespace.

Your score :
The count in bytes

EDIT : Also show 3 outputs of your code

\$\endgroup\$

marked as duplicate by Mego, DJMcMayhem, Rɪᴋᴇʀ, NoOneIsHere, ericw31415 May 16 '16 at 6:41

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

  • 22
    \$\begingroup\$ What's the purpose of subtracting points from popular answers? \$\endgroup\$ – sortfiend Mar 6 '14 at 4:41
  • 24
    \$\begingroup\$ But, further, why is a code golf question scoring based on votes? It's code golf, not a popularity contest \$\endgroup\$ – doppelgreener Mar 6 '14 at 8:38
  • 8
    \$\begingroup\$ Can you define "random"? Do you mean a uniform distribution between 0 and 255 number of occurrences, any probability distribution where each number of occurences between 0 and 255 has a non-zero probability, or just an unpredictable amount of smileys? \$\endgroup\$ – Bakuriu Mar 6 '14 at 10:27
  • 16
    \$\begingroup\$ My php solution is 0 bytes. It is an empty php file. Since you didn't specify what "random" means: For my custom made random number generator, I chose the distribution which gives zero with probability 1 and all other numbers with 0 probability (the degenerate distribution). I am sure you will find it obeys all of your rules. \$\endgroup\$ – Tim Seguine Mar 6 '14 at 14:10
  • 7
    \$\begingroup\$ I agree with @TimSeguine, if I could I would downvote. This is super easy, basically no option to be creative in any way, strange score system (mix of code-golf and popularity), the challenge itself isn't very innovativ. \$\endgroup\$ – print x div 0 Mar 6 '14 at 15:09

73 Answers 73

3
\$\begingroup\$

Perl 6 (20 18 bytes (I'm going to ignore scoring system, it's silly))

say ":)"x 256.rand

256.rand gives random number that is equal or higher than 0 or lower than 256. x multiplies the string given number of times, and floors the integer.

Sample:

glitchmr@feather ~> perl6 -e 'say ":)"x 256.rand'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
glitchmr@feather ~> perl6 -e 'say ":)"x 256.rand'
:):):):):):):):):):):):)
\$\endgroup\$
  • \$\begingroup\$ I kind of like say ':)' x (^256).pick better, but there is no way to make it shorter than using rand. Although it does come in handy if you want to output all of the possible outputs in random order .say for ":)" Xx (^256).pick(*) \$\endgroup\$ – Brad Gilbert b2gills Nov 27 '14 at 15:15
3
\$\begingroup\$

JavaScript (pre-ES6) 45

This is how we do it without using implementationally experimental repeat commands...

console.log(Array(Date.now()%257).join(":)"))

Output 1:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
Output 2:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
Output 3:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

One thing I have found that both a random throw of 0 or 1 will yield no characters, so the 0-255 smileys will still hold!

\$\endgroup\$
  • 1
    \$\begingroup\$ repeat is not experimental. It was validated by ES6 committee. Only its implementation is experimental. \$\endgroup\$ – Florent Mar 6 '14 at 11:36
  • \$\begingroup\$ Okay, implementationally experimental.. Updated accordingly... But nevertheless, I did it without repeat... \$\endgroup\$ – WallyWest Mar 6 '14 at 11:44
  • 1
    \$\begingroup\$ This never outputs 255 smileys. \$\endgroup\$ – Neil Mar 7 '14 at 0:28
  • 1
    \$\begingroup\$ @WallyWest: You need one more elements than repeats for Array.join trick. If you type [1, 2, 3].join("-") you will get "1-2-3". Note two instances of dash, not three. \$\endgroup\$ – Konrad Borowski Mar 7 '14 at 16:37
  • \$\begingroup\$ Ah yes, good point... A quick change of one character should fix this... Voila! \$\endgroup\$ – WallyWest Mar 9 '14 at 5:53
3
\$\begingroup\$

JavaScript, 44 bytes

alert(Array(0|Math.random()*257).join(':)'))

Note: zero-length string twice as common as other lengths (2-510).

Edit: 5 fewer characters using Date.now()%257 instead:

alert(Array(Date.now()%257).join(':)'))
\$\endgroup\$
  • \$\begingroup\$ use new Date and you win 2 chars \$\endgroup\$ – Fabricio May 12 '14 at 21:42
  • \$\begingroup\$ @Sting ES6 didn't exist in 2014, did it? \$\endgroup\$ – Neil May 28 '16 at 14:35
2
\$\begingroup\$

PHP - 32

<?=str_pad('',rand(0,255),':)');

Or if we do not need to include php open tag, then it is 30:

=str_pad('',rand(0,255),':)');

Whichever suits you best

\$\endgroup\$
  • \$\begingroup\$ The equals sign is part of the php open tag in this case. You also can't leave it off in this case, otherwise the program won't print anything. \$\endgroup\$ – Tim Seguine Mar 6 '14 at 14:46
  • \$\begingroup\$ It will not print anything either way, with or without equals sign. Well, to be more precise it will print the source code if you omit the php tag. What is the difference between a line beginning with ` echo` (space in front) and a line beginning with = (no space in front). If you add php opening tag <? before any of them, they will both work? \$\endgroup\$ – Damir Kasipovic Mar 6 '14 at 14:54
  • 1
    \$\begingroup\$ The difference: a line beginning with = is not valid syntax. <?echo 1; is valid syntax, btw(there need not be a space before echo). You see the point I am making but want to language lawyer anyway. \$\endgroup\$ – Tim Seguine Mar 6 '14 at 15:01
  • \$\begingroup\$ Yeah, you are right about that, but I was just pointing out, as far as execution goes, neither of them works without <? if you put them in php interpreter. But I see your point, that's what I thought too, that's why I wrote 32 as length. \$\endgroup\$ – Damir Kasipovic Mar 6 '14 at 17:16
2
\$\begingroup\$

C: 44 (39 if sloppy)

Extracting randomness from the pointer provided. Granted, it is aligned (multiples of 8) but it's a start:

main(a,b){while(b--&255)printf(":)");}

Fixed at expense of 5 chars:

main(a,b){b/=8;while(b--&255)printf(":)");}

Edit: noticed that newlines are not allowed. A solution is to replace puts with printf adding two chars. I now noticed that Abhijit's solution has the same idea. Sorry.

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

Excel Speadsheet Formula (also works in Google docs) - 21

=REPT(":)",RAND()*250)

Output 1:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Output 2:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Output 3:
:):):):):):):):):):):):):):):):):):)

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

Java - 84

System.out.println(new String(new char[(int)(Math.random()*255)]).replace("\0",":)"));

Fairly long, but interesting.

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

Brainfuck (shell support) - 49/62

This bf program (49 bytes) reads a byte from stdin (0-255) and prints that many smileys:

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

Compile this to a file a and execute

./a</dev/random

Alternatively, assuming your PATH is set up properly (13 bytes):

a</dev/random

62 bytes in total, guaranteed randomness.

1st output

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

2nd output

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

3rd output

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
2
\$\begingroup\$

x86 DOS Assembly - 27 25

Not the greatest attempt in the world (complete with crappy LCG PRNG), but I had to do something. This is a COM file. The raw source is (in hex):

B42CCD210FAFCA32EDBA1601B409E304CD21E2FCCD203A2924

In more readable ASM:

    ; Get system time (for random amount)
    mov ah, 02Ch
    int 021h

    ; Make cl pseudo-random
    imul cx, dx
    xor ch, ch

    ; Prepare for our print
    mov dx, Smile
    mov ah, 9

    ; Loop a random number of times
    jcxz Done
MainLoop:
    int 021h
    loop MainLoop
Done:

    ; End
    int 020h

    ; Our smile
Smile:
    db ':)$'

Sample output:

C:\TEMP>smiley1
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
C:\TEMP>smiley1
:):):):):):)
C:\TEMP>smiley1
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):)

EDIT Changed to int 020h per DocMax

\$\endgroup\$
  • \$\begingroup\$ This is code-golf. You are supposed to remove comments and unnecessary whitespace, and use 1-character variable names. \$\endgroup\$ – Hosch250 Mar 8 '14 at 22:09
  • \$\begingroup\$ The resulting code is binary hex values. I can remove the spacing from that. I added the readable translated version so people can see what it is. \$\endgroup\$ – Mark Ormston Mar 8 '14 at 22:10
  • \$\begingroup\$ OK, that is good practice too. \$\endgroup\$ – Hosch250 Mar 8 '14 at 22:10
  • \$\begingroup\$ It may not be as universally supported, but if you limit the versions of DOS that your answer runs on you can use int 20 instead of xor ah,ah/int 21 to save 2 more bytes. \$\endgroup\$ – DocMax Mar 8 '14 at 23:01
  • \$\begingroup\$ @DocMax - Thanks! I never really relied on int 020h much, but it certainly does work. Updating my answer. \$\endgroup\$ – Mark Ormston Mar 8 '14 at 23:08
2
\$\begingroup\$

JavaScript

Can't you just do something like this?

var s = ""; for(var a = 0; a<Math.random()*255;a++){s+=":)";} alert(s);
\$\endgroup\$
2
\$\begingroup\$

Python 3, 38 bytes.

from random import*
':)'*randrange(256)

OUTPUTS

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
  • \$\begingroup\$ You could use print(':)'*__import__('random').randrange(256)). \$\endgroup\$ – Toothbrush Mar 8 '14 at 20:42
2
\$\begingroup\$

Pyth, 8 (non-competing)

Note: This answer is non-competing since Pyth was invented after the challenge was posted.

*O256":)

I'm surprised Pyth hasn't been used yet.

Output

Output 1
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
Output 2
:):)
Output 3
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Explanation:

*             Multiply...
 O256         Random from range(255)
     ":)      ...By ":)". End quote is inferred.
              (Printing is implicit)
\$\endgroup\$
  • \$\begingroup\$ Probably because Pyth appeared after the question was posted. \$\endgroup\$ – manatwork Oct 15 '15 at 19:04
1
\$\begingroup\$

JAVA 61

for(int i=0;i<Math.random()*255;i++){System.out.print(":)");}

Output:

:):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):)
\$\endgroup\$
  • 1
    \$\begingroup\$ Quite bad randomization. pastebin.com/va2sgBur . Anyway, I'm afraid that will not compile in Java. \$\endgroup\$ – manatwork Mar 6 '14 at 11:24
  • \$\begingroup\$ It will compile as tested it :) \$\endgroup\$ – NULL Mar 6 '14 at 12:26
  • \$\begingroup\$ Not here: pastebin.com/92MqU7zy \$\endgroup\$ – manatwork Mar 6 '14 at 12:54
  • \$\begingroup\$ I guess default package is not getting loaded for u \$\endgroup\$ – NULL Mar 6 '14 at 13:23
  • \$\begingroup\$ What manatwork means (I suppose) is that you should add something like class C{public static void main(String[]a){...}} to your code for it to be compilable. \$\endgroup\$ – Paŭlo Ebermann Mar 6 '14 at 22:27
1
\$\begingroup\$

Python - 40

import random;':)'*random.randint(0,255)

output:

>>> import random;':)'*random.randint(0,255)
':):):)'

>>> import random;':)'*random.randint(0,255)
':):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)'

>>> import random;':)'*random.randint(0,255)
':):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)'
\$\endgroup\$
1
\$\begingroup\$

PHP - 28

=str_pad('',rand()&255,':)')

or

=str_repeat(':)',rand()&255)

These are 30 if you include <?

\$\endgroup\$
  • \$\begingroup\$ PHP programs have to end with ; (unless you have {} block, or something like this), and = is not a token by itself (-r that allows you not to specify <? considers program that begins with = to be a syntax error). Change your program to have <? at beginning, and ; at end. \$\endgroup\$ – Konrad Borowski Mar 7 '14 at 16:40
1
\$\begingroup\$

Windows Powershell - 30 21

Thanks to manatwork for telling me I don't need "-maximum" to specify upper limit

":)"*(get-random 255)
:):):):):):):):):):):):):):):):):)

":)"*(get-random 255)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

":)"*(get-random 255)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
  • \$\begingroup\$ You can omit -Maximum. At least in PowerShell 2.0. \$\endgroup\$ – manatwork Mar 6 '14 at 15:27
  • \$\begingroup\$ For 0-255, you need 256 in the Get-Random call. (Like in my own answer). \$\endgroup\$ – DocMax Mar 8 '14 at 22:59
  • \$\begingroup\$ The Get verb is implied. you can write random 255 instead get-random 255 \$\endgroup\$ – mazzy Dec 11 '18 at 13:14
1
\$\begingroup\$

Python 116

a=list(string.printable*255)
random.shuffle(a)
print ''.join([ x+y for x,y in zip(*[iter(a)]*2) if x==":" and y==")"])

Relying on that popularity aspect to bring score down...

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

C: 62

(61 characters plus newline)

main(){int x=time((int*)0)&510;while(x--)putchar(x&1?58:41);}
  • Avoids the undefined behavior of calling variadic functions without a prototype in scope.
  • Slight abuse in passing a null pointer possibly of the wrong type to time; however, pointers are all represented the same way on many platforms: the function call time((long*)0) won't generate code that is any different from time((int*)0).
  • ASCII dependency in putchar call: the IBM mainframe salesman was out playing golf.
  • Not very random, but at least the output changes. Seeding a PRNG adds length.

This version elicits a "data definition has no type or storage class" diagnostic from GCC:

x;main(){x=time((int*)0)&510;while(x--)putchar(x&1?58:41);}

According to ISO C syntax, a declaration must have specifiers, and according to the Constraints, it "shall declare at least a declarator (other than the parameters of a function or the members of a structure or union), a tag, or the members of an enumeration." (ISO 9899:1999 6.7)

\$\endgroup\$
  • \$\begingroup\$ This is wasteful. Remove braces around putchar. Remove (int*) from time (I don't even do that in real code, let alone golfing). You may also remove int, depending on the standard. \$\endgroup\$ – orion Mar 6 '14 at 16:43
  • \$\begingroup\$ @orion Good call. The braces were left over from a version where I had two putchars. Those have been combined with the comma operator. \$\endgroup\$ – Kaz Mar 6 '14 at 19:07
  • \$\begingroup\$ @orion The (int *) stays; without it, we are passing an int to time. \$\endgroup\$ – Kaz Mar 6 '14 at 19:09
  • \$\begingroup\$ It's fine, pointers are integers and zero is just zero, when compiled, there's no distinction between pointers and int/long types. Zero means to ignore it anyway. There are puritans that swear by having exact types but that's not even strictly required in c++, let alone c. Try it. \$\endgroup\$ – orion Mar 6 '14 at 21:43
  • \$\begingroup\$ @orion Yes, there is a distinction between integers and pointers. For example, on my 64 bit Debian box, an int is 4 bytes wide, and a pointer is 8 bytes wide. That's just one kind of difference. On some machines, integers and pointers may be passed or returned in different registers even if they are the same size. E.g. Motorola 68000: pointers in regs A0-A7, data values in D0-D7. \$\endgroup\$ – Kaz Mar 7 '14 at 4:40
1
\$\begingroup\$

Lua, 36

print((':)'):rep(math.random(255)))

Sample output:

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
1
\$\begingroup\$

Bash, 14-45 bytes

(the last time I tried to post this, the question had been suddenly closed)

This fork bomb is sad because it can never explode.

:(){ :|\)& };:

bash: ): command not found
bash: ): command not found
bash: ): command not found

If you execute this, you will probably want to pkill -1 bash, since each process survives for only moments.

To make it stop automatically, it can be changed to:

r=$[RANDOM>>7];:(){ [ $[r--] = 0 ]||:|\)& };:
\$\endgroup\$
1
\$\begingroup\$

Javascript (on nodejs repl) - 47 chars

Array(Math.floor(Math.random()*255)).join(':)')

output #1

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

output #2

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

output #3

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
  • \$\begingroup\$ You can save char by doing ~~(Math.random()*255) instead of Math.floor(Math.random()*255). Also get rid of your spaces. \$\endgroup\$ – Danny Mar 6 '14 at 14:57
  • \$\begingroup\$ I didn't actually know how that works but it does. Someone also suggested (0|Math.random()*255) which produces the same result. I think it's time for me to study bitwise, I usually skip those chapters on most books I've read. \$\endgroup\$ – Mark Dee Mar 7 '14 at 2:29
  • \$\begingroup\$ Good answers on SO about both. ~~ and bitwise or 0 \$\endgroup\$ – Danny Mar 8 '14 at 1:57
1
\$\begingroup\$

Python - 42 chars

import random;random.randrange(0,256)*':)'

could have been reduced to 28 chars if import wasn't counted.

output:

:):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
  • \$\begingroup\$ Shave off 1 char with from ... import*: from random import*;randrange(0,256)*':)' \$\endgroup\$ – Justin May 19 '14 at 21:14
1
\$\begingroup\$

Coreutils and Bash 36

yes :\)|head -$[RANDOM>>7]|tr -d \\n

I borrowed the creative use of RANDOM from @DigitalTrauma.

Testing:

$ yes :\)|head -$[RANDOM>>7]|tr -d \\n

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

$ yes :\)|head -$[RANDOM>>7]|tr -d \\n

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

$ yes :\)|head -$[RANDOM>>7]|tr -d \\n

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

Scala repl short 29

":)"*util.Random.nextInt(256)

First output:

res9: String = :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):): 
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):)

Second output

res10: String = :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
 :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
 ):):):):):):):):):):):):):):):):):):)

Third output

res11: String = 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):)

I love scala =)

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

PHP 28

str_repeat(':)',rand(0,255))

Output 1

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Output 2

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Output 3

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
1
\$\begingroup\$

Clojure

  (doseq [t (take (rand-int 256) (repeat ":)"))]
    (print t))
\$\endgroup\$
1
\$\begingroup\$
import random
x=random.randint(0,255)
print(':)'*x)
\$\endgroup\$
  • \$\begingroup\$ ah i didnt notice that someone already did the same program!! \$\endgroup\$ – Pruthvi Raj Mar 9 '14 at 7:49
  • \$\begingroup\$ You have to write :) between 0 and 255 times. This program cannot print :) 42 times, for example. Also, it could be shortened, by removing whitespace around = operator. If you use Python 2, you can remove parenthesis around print. You should also specify your language. \$\endgroup\$ – Konrad Borowski Mar 9 '14 at 8:22
1
\$\begingroup\$

C# - 162

using System;using System.Linq;namespace G{class Program{static void Main(){Console.WriteLine(string.Join("",Enumerable.Repeat(":)",new Random().Next(255))));}}}

Pretty Print:

using System;
using System.Linq;

namespace G
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine(string.Join("",Enumerable.Repeat(":)", new Random().Next(255))));
        }
    }
}

Output:

1

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):) Press any key to continue . . .

2

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):) Press any key to continue . . .

3

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):) Press any key to continue . . .

\$\endgroup\$
  • \$\begingroup\$ Without going into heavy golfing, a shorter version - 118 - using System;class P{static void Main(){Console.WriteLine(new string('.',new Random().Next(256)).Replace(".",":)"));}}. Yours can be shortened down to 142 by removing the namespace and renaming Program to P. \$\endgroup\$ – JimmiTh May 12 '14 at 19:54
  • \$\begingroup\$ Wow, thanks for that. Didn't realise that namespaces were optional \$\endgroup\$ – Matthew Steeples May 13 '14 at 11:10
1
\$\begingroup\$

C++ - 76 72

(counting the newline as one character)

#include <iostream>
main(){for(int k;++k<(((long)&k)%255);)std::cout<<":)";}

Actually, using a while and some C-style output I managed to shave off a few more:

#include <cstdio>
main(){int k;while(++k<(((long)&k)%255))printf(":)");}

Output examples:

:):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
\$\endgroup\$
1
\$\begingroup\$

Python 3.x 47

import random;print(':)'*random.randint(0,255))

as Doorknob said, boring.

\$\endgroup\$
  • \$\begingroup\$ Since this is code-golf you should include a byte count in your title. \$\endgroup\$ – ace_HongKongIndependence May 12 '14 at 22:50

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