Shortest code to print ':)' random times

Question

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

Answer 1

GolfScript, 12 characters

":)"256rand*

Nothing really interesting here.

Answer 2

JavaScript (ES6), 25

":)".repeat(new Date%256)

Outputs (REPL):

> ":)".repeat(new Date%256)
":):):):):)"
> ":)".repeat(new Date%256)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"
> ":)".repeat(new Date%256)
":):):):):):):):):):):):):):):):):):):):):):):):):):):)"

Answer 3

C - 116 (including artistic whitespace)

  x,i;           main
  (){           srand
         (time
         (0));
for                   (x=
 rand()            %256;
   i<x;           i++)
      printf(":)");}

I never get to do ASCII art code, and the 65 needed characters in the code are already running long as is... This was actually harder than I thought it would be because of the small number of characters to work with and the density of the code. Gets the point across at least.

Boring version:

x,i;main(){srand(time(0));for(x=rand()%256;i<x;i++)printf(":)");}

Note - Auto code counts are going to be off because I had to replace 8 tabs with spaces to get it to look the same in the code window. You can verify my count here if you want.

Edit: Oops, forgot to post output (newlines added for legibility).

comintern@fidel ~ $ ./a.out 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):)
comintern@fidel ~ $ ./a.out 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
comintern@fidel ~ $ ./a.out 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):)

Answer 4

Scala REPL 1337

Scala makes everyone happy. Need 266 votes to lower the score.

("""
:^)  :^(  :^[  :^]  :^D  :^P  :^b  :^&  
:o)  :o(  :o[  :o]  :oD  :oP  :ob  :o&  
:O)  :O(  :O[  :O]  :OD  :OP  :Ob  :O&  
:)  :(  :[  :]  :D  :P  :b  :&  
;^)  ;^(  ;^[  ;^]  ;^D  ;^P  ;^b  ;^&  
;o)  ;o(  ;o[  ;o]  ;oD  ;oP  ;ob  ;o&  
;O)  ;O(  ;O[  ;O]  ;OD  ;OP  ;Ob  ;O&  
;)  ;(  ;[  ;]  ;D  ;P  ;b  ;&  
=^)  =^(  =^[  =^]  =^D  =^P  =^b  =^&  
=o)  =o(  =o[  =o]  =oD  =oP  =ob  =o&  
=O)  =O(  =O[  =O]  =OD  =OP  =Ob  =O&  
=)  =(  =[  =]  =D  =P  =b  =&  
8^)  8^(  8^[  8^]  8^D  8^P  8^b  8^&  
8o)  8o(  8o[  8o]  8oD  8oP  8ob  8o&  
8O)  8O(  8O[  8O]  8OD  8OP  8Ob  8O&  
8)  8(  8[  8]  8D  8P  8b  8&  
B^)  B^(  B^[  B^]  B^D  B^P  B^b  B^&  
Bo)  Bo(  Bo[  Bo]  BoD  BoP  Bob  Bo&  
BO)  BO(  BO[  BO]  BOD  BOP  BOb  BO&  
B)  B(  B[  B]  BD  BP  Bb  B&  
%^)  %^(  %^[  %^]  %^D  %^P  %^b  %^&  
%o)  %o(  %o[  %o]  %oD  %oP  %ob  %o&  
%O)  %O(  %O[  %O]  %OD  %OP  %Ob  %O&  
%)  %(  %[  %]  %D  %P  %b  %&  
@^)  @^(  @^[  @^]  @^D  @^P  @^b  @^&  
@o)  @o(  @o[  @o]  @oD  @oP  @ob  @o&  
@O)  @O(  @O[  @O]  @OD  @OP  @Ob  @O&  
@)  @(  @[  @]  @D  @P  @b  @&  
X^)  X^(  X^[  X^]  X^D  X^P  X^b  X^&  
Xo)  Xo(  Xo[  Xo]  XoD  XoP  Xob  Xo&  
XO)  XO(  XO[  XO]  XOD  XOP  XOb  XO&  
X)  X(  X[  X]  XD  XP  Xb X&
^__^
""".replaceAll("\n","").replaceAll("x|X",":)")
.replaceAll("(:|=|8|B|;|%|@)+",":")
.replaceAll("[^:]+","\\)")
.substring(0,new scala.util.Random().nextInt(256)*2))

Output 1

res32: String = :)

Output 2

res33: String = 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):)

Output 3

res34: String = 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

FYI, the code to generate all smileys is the following:

for(i <- ":;=8B%@X"; j <- "^oO".toIterator.map(_.toString) ++ List(""); k <- ")([]DPb&") yield (i.toString+j.toString+k.toString)
//         eyes          nose or nothing                                      mouth

Answer 5

Python 23

print':)'*(id(9)/8%256)

Demo

D:\temp>smiley.py
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):)

D:\temp>smiley.py
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):)

D:\temp>smiley.py
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):)

Answer 6

Java 72 lines 1,832 bytes and ~50 seconds runtime

Me and my buddy pair programmed (Agile Methods ftw) this golfed Java Enterprise solution.

import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.List;

public class EnterpriseJavaSolution {

    public static class BodyPart {

        private char[] part = new char[2];

        public BodyPart (String part) {
            this.part = part.toCharArray();
        }

        public String toString() {
            return new String(part);
        }

    }

    public static class Eyes extends BodyPart {

        public Eyes () {
            super(":");
        }

    }

    public static class Mouth extends BodyPart {

        public Mouth () {
            super(")");
        }

    }

    public static class Face extends BodyPart {

        /**
         * So generic, much parts
         */
        public Face (List<BodyPart> parts) {
            super(parts.toString());
        }

    }

    public static void main (String[] args) {

        SecureRandom seed = new SecureRandom();
        //Very random, dont use all RAM though!!
        SecureRandom reallyRandom = new SecureRandom(seed.generateSeed((int) (Runtime.getRuntime().maxMemory() / 2.0)));
        byte[] randomNumber = new byte[1];
        reallyRandom.nextBytes(randomNumber);
        ArrayList<Face> smilees = new ArrayList<Face>();

        //Why are Java bytes signed! Such inconvenience
        for (int numSmilee = 0; numSmilee <= Math.abs(randomNumber[0] * 2.0); numSmilee++) {
            ArrayList<BodyPart> bits = new ArrayList<BodyPart>(new Integer((int)2.0)); //Optimal
            bits.add(new Eyes());
            bits.add(new Mouth());
            smilees.add(new Face(bits));
        }

        //TODO: make N-tier solution for printing
        System.out.println(smilees.toString().replaceAll("[^:)]",""));

    }

}

I've timed the runtime and given some example output below. I'm satisfied at the production readiness of this code.

$ time java EnterpriseJavaSolution
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

real    0m53.678s
user    0m4.380s
 sys    0m48.568s

$ time java EnterpriseJavaSolution
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

real    0m51.928s
user    0m4.218s
 sys    0m46.704s

$ time java EnterpriseJavaSolution
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

real    0m55.480s
user    0m4.074s
 sys    0m50.621s

Answer 7

PowerShell 21, 17

":)"*(Random 256)

PS C:\Users\DocMax> ":)"*(Random 256) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

PS C:\Users\DocMax> ":)"*(Random 256) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

PS C:\Users\DocMax> ":)"*(Random 256) :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Edit: Removed Get- following Rynant's awesome news-to-me input. It's not often that PowerShell is competitive at code golf.

Answer 8

C 50 48 44 (with the suggestion from @urogen and @n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳)

Note I liked what @Comintern, so tried to do something similar with my answer

/*
Uninitialized c will always randomized to an address range (assuming system 
supports ASLR. 
Recursion instead of loop to reduce code length 
As whitespace is not counted, organized the code to represent a smiley character
*/
main(a
        ,
          c)
  {c       &&  
 main        (    
printf        (
 ":)"        )
  ,(       c&
         255
       )
-1);}

Demo

D:\temp>Smiley.exe
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):)
D:\temp>Smiley.exe
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):)
D:\temp>Smiley.exe
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):)

IDEONE

http://ideone.com/ZWPjqS

Answer 9

Befunge 98 - 20 bytes (with unicode)

?1+:'ÿ`!j@"):",,>
@

? sends the IP in a random direction, either left, right, up, or down. After doing so, I increment a counter and compare it to 255: 1+:'ÿ`!. j@ will exit if this is the 256th time. "):" is the frowny face that I'm supposed to print, and ,, prints it (output: :)). The > is to ensure that if the IP goes left, it will change directions and go right.

On each iteration, there is a 2/3 probability that the loop will exit. This means that the probability that comparing to 255 is needed (assuming perfect random) is

(1/3)255 = 1/46336150792381577588313262263220434371406283602843045997201608143345357543255478647000589718036536507270555180182966478507

Is that close enough to zero to justify not comparing to 255 (it would save me 10 bytes, bringing me down to 10 bytes)? For comparison, this number is about 2.158 × 10-122. The number of atoms in the universe is about 1080. The Planck length, the smallest measurable length (as in the universe does not allow for smaller), is 1.616199(97) × 10-35 m. This means that if this number were the size of the Planck length, the Planck length would be about

8.5×1059 × diameter of the observable universe (93 billion light-years)

First output:

:)

Second output:

:):)

Third output:

:):):):):)

---

Alternatively, if I am allowed to print null characters, then this works, for 19 bytes:

?,,":)"_@#-ÿ':+1
@

---

Exploit (you say random times in the range 0-255, so I'll choose random in the range 0-126, saving 1 more byte):

?1+:'~`!j@"):",,>
@

Answer 10

J - 18 char

Surprisingly, there is a subtle behaviour in the J interpreter that prevents a quick 12 character solution: the interpreter's REPL output is truncated after 256 characters, so you have to print directly to stdout to "do it right".

1!:2&4^:(?256)':)'

Explained:

• 1!:2&4 - Print to stdout (file handle 4)...
• ^:(?256) - ... a random number of times less than 256...
• ':)' - ... the string :).

Examples:

   1!:2&4^:(?256)':)'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
   1!:2&4^:(?256)':)'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
   1!:2&4^:(?256)':)'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

And, for posterity, here's the 12 char solution which generates the string but is unable to display it right.

':)'$~2*?256

We take the random int, multiply it by 2, and then create a string that long, cyclically pulling characters from :). Yes, this is shorter than copying the string.

Answer 11

Ruby, 18

(with help from manatwork, David Herrmann, and Victor)

$><<':)'*rand(256)

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

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

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

Answer 12

perl 20, 17 characters

Thanks to skibrianski for shaving 3 characters.

say":)"x rand 256

Sample execution:

$ perl -M5.10.0 -e 'say":)"x rand 256'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):)

$ perl -M5.10.0 -e 'say":)"x rand 256'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):)

$ perl -M5.10.0 -e 'say":)"x rand 256'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):)

$ perl -M5.10.0 -e 'say":)"x rand 256'                                                 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Answer 13

PHP | 30 bytes

 <?=str_repeat(':)',rand()%256)

Answer 14

Python 2.7 - 45 bytes

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

(Originally this printed :)\n, the newline was removed upon OP's clarification)

The (slightly) more idiomatic way to do this is

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

which is... also 45 bytes, but I figured "why not make it a one-liner?"

Three sample outputs:

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

 

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

 

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

Answer 15

Mathematica 35

Row@Table[":)", {RandomInteger@255}]

---

Examples

Answer 16

Pure Bash, 41

printf -va %$[RANDOM>>7]s;echo ${a// /:)}

Sample outputs:

$ printf -va %$[RANDOM>>7]s;echo ${a// /:)}
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
$ printf -va %$[RANDOM>>7]s;echo ${a// /:)}
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
$ printf -va %$[RANDOM>>7]s;echo ${a// /:)}
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
$ 

Answer 17

APL: 12 characters

(?255)⍴⊂':)'

In this code, ?255 generates a random number between 1 and 255. The ⍴ function repeats the argument to the right this number of times. The expression ⊂':)' encpsulates the string :) into a single object, since otherwise the expression 3⍴':)' would yield :): as opposed to :) :) :).

Edit: The behaviour of this function depends on the value of ⎕IO. If it's set to 0 (the default in many versions of APL) then ?255 will return a value in the range 0-254. If it is 1, the return value with be in the range 1-255.

Answer 18

Python - 21

The randomness is stretching the rules a fair bit, but each run will probably be different.

print':)'*(id(1)%255)

And some example runs:

> python -c "print ':)'*(id(1)%255)"
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
> python -c "print ':)'*(id(1)%255)"
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
> python -c "print ':)'*(id(1)%255)"
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Answer 19

Javascript - 51 characters

Thanks to @grc and @DocMax for shaving 3 characters.

for(i=0|Math.random(t='')*256;i--;)t+=':)';alert(t)

4 Outputs:

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

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

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

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

Answer 20

Groovy (37 29 characters, @Michaël Demey's suggestion)

print":)"*(Math.random()*255)

The initial solution was:

print":)"*(new Random().nextInt(256))

Answer 21

R, 34

cat(rep(":)",runif(1)*256),sep="")

Answer 22

Pure ZSH - 32

repeat $[RANDOM%256] echo ":)\c"

Output 1:

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

Output 2:

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

Answer 23

C++ 104 84 107

#include<iostream>
int main(){int *a=new int;a+=2;*a%=256;std::cout<<*a;while(*a-->0)std::cout<<":)";}  

:( I think I'll never beat other languages in golfing !
Anyway...OUTPUT

#1

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

#2

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

#3

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

Answer 24

(PHP/Python/Perl/Javascript/others)-Polyglot - 0 bytes

---

---

Output 1:

Output 2:

Output 3:

You never specified a distribution for the random variable denoting the number of times, so this outputs from the degenerate one with the entire mass on zero. This is fine under the definition of range where it is equal to the codomain of a function, rather than its image.

Alright, it's a huge cheat, but since the id(9) code was successful despite not being guaranteed uniform, I figured this isn't entirely unclever.

Also compiles in C under some compilers. See discussion here.

Answer 25

Java - 59 bytes

int n=255;while(n--*Math.random()>0)System.out.print(":)");

Note that you asked for "shortest code", not shortest complete program. On each run of the loop, there is a 1/7036874417766 probability that the loop exits (see How many double numbers are there between 0.0 and 1.0?). To make this a more even distribution, simply do

int n=0;n+=Math.random()*256;while(n-->0)System.out.println(":)");

Sample run: http://ideone.com/ZLppjR

Output #1:

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

Output #2:

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

Output #3:

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

_{yes the outputs are identical. I'm not going to run the program until I get an output that is not identical; it would take too long.}

---

Complete program (104 chars):

class c{public static void main(String[]a){int n=255;while(n--*Math.random()>0)System.out.print(":)");}}

---

Original method (92 chars):

String s="";for(int i=255;Math.random()*i-->0;)s+="x";System.out.print(s.replace("x",":)"));

Answer 26

Ruby (25 Chars)

rand(256).times{$><<":)"}

Wanted to try my hands at ruby. What better way than a codegolf ;)

Answer 27

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(':)'))

Answer 28

q - 17 bytes

(2*1?255)[0]#":)"

or a second way:

(2*rand 255)#":)"

Answer 29

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!

Answer 30

R 37

To mirror @Sven Hohenstein's more correct solution, added cat(<>,sep=""):

cat(rep(':)',sum(sample(0:1,255,T))),sep="")

Including @Plannapus' suggestion (I'm an R user, not an R expert!):

cat(rep(':)',sample(0:255,1)),sep="")

Tested on R-Fiddle.

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

Answer 31

Julia, 23

print(":)"^rand(0:255))

Usage:

julia> print(":)"^rand(0:255))
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

julia> print(":)"^rand(0:255))
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

julia> print(":)"^rand(0:255))
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Answer 32

Haskell (50)

fmap(\a->concat$replicate a":)")$randomRIO(0,255)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"

fmap(\a->concat$replicate a":)")$randomRIO(0,255)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):)"

fmap(\a->concat$replicate a":)")$randomRIO(0,255)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"

Answer 33

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'
:):):):):):):):):):):):)

Answer 34

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

Answer 35

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.

Answer 36

Java - 84

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

Fairly long, but interesting.

Answer 37

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

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

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

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

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

Answer 38

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

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

Answer 39

Python 3, 38 bytes.

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

OUTPUTS

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

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

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

Answer 40

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

Answer 41

JavaScript

Can't you just do something like this?

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

Answer 42

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)

Answer 43

Javascript (on nodejs repl) - 47 chars

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

output #1

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

output #2

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

output #3

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

Answer 44

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)

Answer 45

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

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

Answer 46

JAVA 61

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

Output:

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

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

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

Answer 47

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)
':):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)'

Answer 48

PHP - 28

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

or

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

These are 30 if you include <?

Answer 49

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)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

Answer 50

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...

Answer 51

Lua, 36

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

Sample output:

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

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

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

Answer 52

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 ]||:|\)& };:

Answer 53

Python - 42 chars

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

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

output:

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

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

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

Answer 54

Scala repl short 29

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

First output:

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

Second output

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

Third output

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

I love scala =)

Answer 55

PHP 28

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

Output 1

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

Output 2

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

Output 3

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

Answer 56

Clojure

  (doseq [t (take (rand-int 256) (repeat ":)"))]
    (print t))

Answer 57

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

Answer 58

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 . . .

Answer 59

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:

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

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

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

Answer 60

Python 3.x 47

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

as Doorknob said, boring.

Answer 61

BASH 34 characters

yes ":)" | head -$(($RANDOM%255))

I had to use a head in my code ;)

Answer 62

Simplex v.0.5, 17 bytes

(":)")257{ppj1X}g
(    )257            ~~ repeat inner expression 257 times
 ":)"                ~~ set the current bytes to :, the next byte to ), and increment pointer by two
         {     }     ~~ repeat inner expression until current byte is zero
          pp         ~~ remove two cells, moving pointer backwards twice
            j        ~~ insert a new cell
             1       ~~ the cell is zero, and thus is initialized to 1
              X      ~~ sets the cell to an integer N, 0 <= N <= 1
                g    ~~ clears the strip and outputs characters as ASCII characters.

Technically, this compiles to the following Simplex code:

":)"":)"...(257 times total)...":)"{ppj1X}g

Now, this abuses the fact that the exit chance need not to be equally distributed. Here are some example outputs using my interpreter on my hard drive (working on releasing it sometime on the GitHub):

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

FYI, the chance of getting one :) is:

So, yeah, it's still possible, yet unlikely.

Answer 63

Python, 16 characters

print ":)"*id(1)

Warning!!!! "Random" on my system is typically between 100-10 million or so this can take a while:

$ python dumb.py | wc -c
75397329
$ python dumb.py | wc -c
43243729

Add four bytes and mod it by 256. Woo.

Answer 64

Extended BrainFuck: 13

,(->|":)"(-))

This is bending the rules a little since BrainFuck (runtime of EBF) doesn't have a random function so it has to get random bytes as input.

Compilation:

sylwester@pussycat ~> bf ebf.bf < ransmiley.ebf > ransmiley.bf

3 runs:

sylwester@pussycat ~> bf ransmiley.bf </dev/random
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)⏎
sylwester@pussycat ~> bf ransmiley.bf </dev/random
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)⏎
sylwester@pussycat ~> bf ransmiley.bf </dev/random
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)⏎
sylwester@pussycat ~> 

The examples here are shown with bf which is a BrainFuck interpreter implementation available in all debian based linux distros with:

sudo apt-get install bf

Also it can be compiled from source

BrainFuck: 51

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

This is just the compiled EBF code. It seems pretty compact.

Answer 65

SQL, 79

Because, why not

declare @c int;set @c=rand()*255;while(@c<255) begin print ':)';set @c=@c+1;end

Answer 66

Javascript: 24 23 (-1 if you not count 's')

This code needs as input 255 ":)" characters in s.

s.substr(new Date%257*2)

Second approach:

s.slice(new Date%257*2)

Outputs

input: ":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)".substr(new Date%256*2)
output: ":):):):):):):):):):):):):):):):):):):):):):):):):)"
input: same
output: ":):):):):)"
input: same
output: ":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"

Answer 67

Cobra - 60

class P
    def main
        for i in Random().next(256),print ":)"

Batch - 60

@set /aa=%random%%%256
@for /l %%i in (0,1,%a%) do @echo :)

Answer 68

Ruby - 15 bytes

This was a fun, simple little code golf. Here's the code:

p":)"*rand(255)

which prints something like

":):):):):):):):):):):):):):):):):):):):)"

To print without the quotes you would have to add 3 bytes and say:

puts":)"*rand(255)

Answer 69

AppleScript, 52 bytes

So, uh, yeah.

repeat random number from 0 to 255 times
log":)"
end

I think this is fairly self explanatory.

Answer 70

CJam, 12 11 10 chars

Y8#mr":)"*

I'm very new to golfing (this is my first post), so I'm not quite sure what to say here. :-P

Answer 71

Hassium, 47 Bytes

func main()print(":)"*new Random().next(0,255))

Run and see expanded online here

Answer 72

Microscript II, 10 bytes

":)"s256R*

Answer 73

Hoon, 34 bytes

(runt (~(rad og eny) 256)^':)' "")

++runt prepends b a times. Giving it just an empty tape, pulling a random number from ++rad:og with the entropy variable eny.

Really, the only interesting thing in this is the syntax a^b - it's sugar for [a b] which saves two bytes, since runt really needs to be called like (runt [a b] c)

> (runt (~(rad og eny) 256)^':)' "")
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"
> (runt (~(rad og eny) 256)^':)' "")
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"
> (runt (~(rad og eny) 256)^':)' "")
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"