text:
Shortest code to print ':)' random times
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

What's the purpose of subtracting points from popular answers?

@sortfiend These challenges are typically scored in terms of how long your answer is, with shorter being better. Thus you want the lowest score possible. That should be stated in the question, though.

But, further, why is a code golf question scoring based on votes? It's code golf, not a popularity contest

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?

Are quotes ("") allowed in the output? i.e. ":)" versus just :)

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.

-1 for non-code golf scoring when it's tagged code-golf

Why does this have upvotes, people? Even if you fix the spec. The "challenge" is: generate a random number. Wooooooo! That was hard. And so much fun! I mean it's not like they teach that the first day of every programming class ever.

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.

@AndroidRookie should I delete this post ?

@TimSeguine The idea is not just to create a random number, but also to print a string that many times. There are enough ways to go about this (print N times, multiply the string by N, etc) to warrant golfing it, even if the end result is small expressions in every language that fit cleanly into two or three categories of type of solution. If I could upvote the ingenuity that went into the Befunge solution more than once, for example, I would.

@algorithmshark yeah, I understood the challenge, generate a random number and display it in unary. Still not interesting.

@MukulKumar No, you shouldn't delete this post. I think you can't delete it since it has upvoted answers.

@ALL who don't think it's a challenge ! This question is NOT a code-challenge but a code-golf. You don't have to Face challenges but To make the code shortest possible ! If you want challenge then there are other questions! solve those and don't waste your time here debating! If you have any confusion regarding WHAT IS CODE-GOLF then visit here  http://codegolf.stackexchange.com/tags/code-golf/info

Python in 22 on the second page. If you are going to abuse the idea of "random", at least do it right! http://codegolf.stackexchange.com/a/23308/8777

@MukulKumar the word "challenge" has an English meaning independent of the site. Everyone understands that this is a code golf.

Has anyone linked to that xkcd about random number generators yet?

@AakashM Yes.

I don't get why this question has 57 answers, almost 6k views and only 6 upvotes.

@Vereos Well I don't know it either ;[

In [tag:code-golf]'s wiki excerpt: "A competition which scores on a mixture of source length and some other criterion should be tagged [tag:code-challenge] instead.". @sortfiend Presumably it's lowest score wins, which is a common scoring system on this site.

@Vereos The lack of upvotes could be explained by reading the comments.

@Dukeling I did, but, if everyone keeps answering it (and following it), I don't get why they shouldn't upvote it too. My 2 cents.

@Dukeling I edited the question Now is it fine ?

@Vereos Just because you're able to answer, or you're interested in an answer (by the way, no-one favourited this question, not sure what you mean by 'following'), doesn't mean you think it's a good question. And most of the visitors probably got here from the Hot Network Questions, just meaning it might have an attention-drawing title, nothing more.

I would mark it as "Not a duplicate" if I could!

GolfScript, 12 characters
":)"256rand*

Nothing really interesting here.

I don't know about GolfScript but, I think \n is not needed

@Mukul But then the output would be :):):):):)...

No problem with that

It doesn't change the length, but shouldn't that be 256 rather than 255?

@Doorknob Happy 10k!

@DocMax: If we want a uniform distribution from 0 to 255 inclusive, yes. If not, it might as well be 9. :)

@DocMax You're right, fixed!

@Doorknob Even if you wanted to do the newlines between the :), you shouldn't have used \n; you should have used ':) newline '.

Why in the world does this answer have so many upvotes? There are other more interesting answers out there.

It does not even display three outputs of the code.

@Quincunx to point out how uninteresting this problem is. A good code-golf question should not be solvable by boring answers. If it is, it's a bad question.

JavaScript (ES6), 25
":)".repeat(new Date%256)

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

You sir deserve more likes!

that ain't random sir

@rafaelcastrocouto The question does not mention about how good the random generation must be. Using the timestamp seems to be a good compromise between number distribution and randomness.

You can use new Date%256, instead of Date.now()%256. 2 characters shorter.

@rafaelcastrocouto It takes a random seed (The time at which you choose to run it), it's predictable (like any RNG) because you know the seed, still random.

I think using repeat is cheating. It's a proposed part of ES6 and only supported on Firefox.

@Steve most golfing languages are never used in production, at least ES6 will actually be used.

@howderek On this page I see Javascript, Scala, Bash, Ruby, Python, and C. I would say that most are definitely used in production. My complaint was that the method used wasn't even part of the language.

@Steve repeat is supported by Chrome (and v8) with harmony flag. Moreover repeat specification is approved by the ES6 committee.

@rafaelcastrocouto: It's reasonably random. In JavaScript, new Date gives time in milliseconds. Every single value can be received, and I doubt you could run program quickly enough to have the same millisecond.

ok you guys convinced me! by the way ... the repeat method: String.prototype.repeat = function(n){s=this;while(--n)s+=this;return s}

@rafaelcastrocouto You mean String.prototype.repeat = function(n){var s=this;while(--n)s+=this;return s}?

that's less lazy!

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

don't we include files like stdlib.h or so and count their char count ?

It compiles without headers in gcc.  It complains about implicit declaration of built-in function ‘printf’, but works fine.

You could drop 1 character by doing for(x=rand()%256;i++<x;). EDIT: But it would break your ASCII art, yeah.

This can be done with just 60 chars: x;main(){srand(time(0));for(x=rand()%256;--x;)printf(":)");}.

@still_learning - Yeah, I know it can be quite a bit shorter, I structured the loop that way to keep the long strings I could divide distributed right.

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

Add 5 more bytes and you have my vote :)

Did it. Added a chinese smiley: ^^ . Now because your comment has been upvoted once, there should be two more people voting for my answer ^^

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

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

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

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

id(9) is not random and id(9)%255 will never give 255.

@grc: id(9) is random across multiple sessions but not across the same session. To get a random number across Please refer my output :-). And I agree, it should be id(9)%256

It appears to me that the output of id is always divisible by 8, so only 32 unique numbers can be produced from id(x)%256. If you divide by 8 first it should fix this.

@grc: Ahh yes, I forgot about that, yet thought that implementation dependent, yet in cPython which is widely used, its how its implemented

@downvoter: Can you please explain what is wrong with the code and how it can be corrected?

@Abhijit Drop the print. It is not needed in REPL.

@thefourtheye: In that case it may not be a code but a statement. Also, I would want it to run as a script rather than in REPL.

@Abhijit: You can shave off one more character by swapping the multiplication around, since then you can get rid of the parenthesis (but have to add the space after print): print id(9)/8%256*':)' :)

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

The question is a [tag:code-golf], so please include the character count in your answer. Also, try to "golf" your answer by removing unnecessary whitespace for example. And I also think that this answer can be a lot shorter, so for example it is not really necessary to create a class for each part of the smiley. It might be a good programming practice, but this is code-golf, code length is a lot more important than best practices.

Well the previous Java example was critiqued for bad practice and lack of randomosity >:3

Haha I love this. Needs more comments and java doc though.

This made me burst out laughing :D

The real joke is we both program in Perl professionally :)

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.

All Get-<Something> functions in PowerShell are automatically aliased as <Something>, so you can save 4 bytes by getting rid of Get-

I really want to make this shorter, but it's so simple I'm afraid that's not possible. Fair warning about omitting "Get-": It's fine for short scripts like this, but it actually bloats the run time quite significantly. Try Measure-Command {Get-Random}; Measure-Command {Random} to see the difference. On my system, they're 0.1579 ms vs. 30.0963 ms. It's hardly noticeable when you're just running it once, but it can be a big deal when your script uses the command a lot more (say, 30,000 times)!

Thanks for the comment on aliasing. It's always useful to know the potential impact of something like aliasing, even when it is small.

C 50 48 44 (with the suggestion from @urogen and @n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳)
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

I get a segmentation fault about half the time. I suppose it is intentional that you are trying to get a "random" variable by not initializing c?

@skibrianski: Yes, there was some issue with the code. Brackets were misplaced and we need to work with absolute value

Have you tried  (c&0xff) instead of abs(c)%256? This should work due to integer promotion.

c&&main(printf(..),..); would be shorter.

I think you missed urogen's other suggestion, to move the printf to main's arguments.

Even shorter (38): main(a,c){while(c--%256)printf(":)");}

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@"):",,>
@

+1 for noticing that the random distribution need not be uniform.

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.

Which one should I consider...18 char or 12 char solution

The 12 char version doesn't print the string properly whenever the random number is 129 or greater, due to the nature of the J interpreter. Unless the rules change, only the 18 char solution is correct.

You can double the max line length with (9!:37) 0 512 0 222. I'm not sure whether setting global parameters is allowed outside of the character count though.

Assuming the z locale, you can get 17 with echo(+:?128)$':)'

@AlliedEnvy You could get even shorter with echo':)'$~+:?256 (16 char), but it falls prey to the same bug as above, because echo uses 1!:2&2 and not &4, and thus respects the settings in 9!:36.

@grc I don't see why not. I have never used J, but I can imagine increasing the maximal line length without the context of this codegolf challenge.

Another 12 char possibility would be this one: ':)'$~2*?256

Ruby, 18
(with help from manatwork, David Herrmann, and Victor)
$><<':)'*rand(256)

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

Not sure how to show the wrapping in the result part, but they are of different lengths

press enter then add four spaces before text

Shouldn't it be rand(256) to get 0-255?

You can use spare: 1 character by using $><< to output; 2 characters by removing the outer pair of parenthesis. $><<':)'*rand(255)

What about using p? p':)'*rand(255)

Since the number passed to rand(n) is excluded, it should be rand(256)

Now your sample outputs are wrong. p outputs quoted strings.

Ah of course you're correct. Change made to your suggested approach. Thanks.

$><< looks fancy, but is there anything wrong with puts':)'*rand(255)?

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

You can save 2 bytes by: 1 - nuking the space between say and the smiley and 2 - ditching the parens around rand. IOW: 'say":)"x rand 255'

note: rand 255 doesn't include 255

@J.F.Sebastian Oversight, I guess.  I'll change it to 256.  (Between 0 and 255 is ambiguous at best.)

could shave off a byte: say":)"x($$&255) (or if you want to be a smartass, say":)"x($^T&255), where ^T is the literal control character)

What's interesting is that this is almost the same as the shortest Perl6 code. The only difference is that Perl6 requires some whitespace after sub calls ( unless you alter the parsing behaviour with a slang or macro ).

PHP | 30 bytes
 <?=str_repeat(':)',rand()%256)

Add a '#' character before 'PHP' to make it a heading like other answers

Since this question is tagged [tag:code-golf], it is helpful to include the character count in your answer.

You can remove the space and the mt_

A shorter version: <?=str_repeat(":)",rand()%256);

Instead of upvote my answer please upvote @Florent

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

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

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

I am okay with no newline and white spaces

Cool, I edited my answer.

Actually, I was wrong to begin with. print':)'*(whatever) includes newlines. I didn't test it until right now. I learned something new today!

...No, that's a lie. I took out the \n from my answer here and didn't take it out on my local copy. Never mind.

I think you can save up to 7 characters by using os.urandom instead.

What grc means is: import os;print':)'*ord(os.urandom(1))

You don't need the print either, since it doesn't specify the output; the console buffer is sufficient leading to only ':)'*__import__('random').randint(0,255) which is 41 characters in length or only 38 when using the code suggested by @grc: ':)'*ord(__import__('os').urandom(1))

@alexander shorter than that would be: import os;':)'*ord(os.urandom(1)) at 33 chars

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

Examples

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// /:)}
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
$

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.

range is 0-255 not 1-255

Fair enough. If you set ⎕IO to 0 (which is the default in many versions of APL), that will be the effect.

well, you can have numbers from 1-256 then subtract 1 from it

Wrong answer on two counts: It prints lots of forbidden white-space, and the number should be 256.

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

print id(1)%255*":)" would be one byte shorter.

Groovy (37 29 characters, @Michaël Demey's suggestion)
print":)"*(Math.random()*255)

The initial solution was:
print":)"*(new Random().nextInt(256))

I brought it to 29 characters: print":)"*(Math.random()*255)

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

You can probably leave off cat and beat the answer I just posted. ;-)

@Gaffi The output should contain :) only.

Well, I guess that's up to interpretation! Adding a comment to the original question.

@Gaffi The default is sep = " ".

@Gaffi Let me cite the OP: No white-space.

You are correct! I read that (for some bizarre reason) as part of the scoring.

It should be cat(rep(":)",runif(1)*256),sep=""), otherwise you will never get 255 smilies. See length(rep(":)",254.9999)).

Pure ZSH - 32
repeat $[RANDOM%256] echo ":)\c"

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

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

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

fake output? on my machine it always prints the same number of smileys

btw you could save a few char with while(*a--%256)

@izabera try it again !

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

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

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

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

You don't need to convert i to an int immediately. Using a condition like ~~i-- or --i>0 should save 2 chars. You can also save a char with Math.random(t='').

Intead of ~~() save 2 with 0|Math.... And another if you move t='' inside of the random() call

Just as a curiosity, this is the Harmony version, currently working only in Firefox: alert(':)'.repeat(Math.random()*256)).

@manatwork Didn't knew that the repeat method exists (experimental for now, but exists). Anyway, I think that you may post an entirely new answer by yourself for this. I will upvote it.

@Victor It’s new in ES6. Here’s a fully spec-compliant polyfill for it: http://mths.be/repeat

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

Well the random number you choose is 0 all the time therefore I should not consider this as a correct answer ! edit or delete your post

I recommend you edit your post if you want a uniform distribution. As of now, this answer is mathematically perfectly correct.

I asked for a random number! not intentional number or any constants. Intentionally this has 0 all the time! Also random-number is a number which we cannot predict(it may repeat)

Which is still random. I recommend you familiarize yourself with the content of the first link I provided in the post, as well as elementary measure theory and the axiomatic definition of randomness that follows. There is nothing preventing Ω from being a singleton.

Go to this site and read 1st para http://whatis.techtarget.com/definition/random-numbers

Well, you can lead a horse to water, but you can't make him learn measure theory.

Oh, come now. This is a wet blanket answer and you know it. No amount of advanced maths study will enable a troll to change his horns. :) Also, as evidenced by your own "discussion here" link, this gag was already tired in 1994.

I'd argue that there's a difference between finding a loophole in the rules and intentionally syntactically misparsing them, but it's not my job to not submit troll answers when the question is practically begging for them. Downvotes, ahoy!

+1 This is a perfectly reasonable interpretation of the question. The OP didn't specify the distribution. The degenerate distribution is a perfectly valid choice, no more incorrect than a uniform distribution. It may be a tired gag, but I am tied of "underspecified challenges". Make a challenge that is worth solving and nobody will post joke answers.

@JonathanVanMatre This isn't interpreting the challenge too literally. It is not our fault if the OP doesn't know what random means.

@MukulKumar I have a better reference for you: http://math.umn.edu/~isakema/docs/FM5011/Probability%20Spaces.pdf if you want a uniform distribution you have to specify that. Also Here's news for you: I guarantee that about 90% of the answers here won't produce randomness according to a uniform distribution(what is described in your link), because most programmers introduce skew.

"I'd argue"--well it's a good thing you would argue because you're not arguing yet. ;-P Did you consider a more charitable assumption than "OP doesn't know what random means"? Perhaps OP knows that but doesn't know how to rigorously express his/her meaning in English. Every other respondent managed to parse the question and recognize OP's intent. I am confident at least one of them knows as much about measure theory as you two tricksters, but chose to answer the question's spirit instead of its letter.

Finally, if you dislike underspecified challenges, specify a better one. We do need more good content. (And I will in good faith apply the corollary to myself - If you dislike trollish answers, submit a better one.)

@JonathanVanMatre I have posted 3 challenges since joining this site. At the very least that is three more than you have. ;) And no I think you are wrong: I think it is clear from the comments that the OP in fact doesn't know what he wants. The link he provided implies that he wants a uniform distribution, but he hasn't complained, for example, that the Befunge answer doesn't use a uniform distribution. I stand by my statement that good questions don't attract troll answers.

The distribution of a random variable is understood to be uniform, when not otherwise specified.

@Kaz, searching Google for "at random intervals" leads to a bunch of results where people seemingly meant from an exponential-like distribution rather than a uniform one. AFAICT, uniform distributions are only the "natural" choice in combinatorial settings.

@YonatanN I believe that exponential "random intervals" can be obtained by randomly inserting (using a flat distribution) events into a block of time. It's linked to uniformity.

The number of samples before a uniform distribution hits a certain value. The degenerate distribution, on the other hand, is the number of samples before it hits any value. Clearly, they are like the same thing.

@TimSeguine I have yet to post a challenge because I give genuine concern to posting one of quality. I have two in the sandbox and more in the works. If you suggest that is a bad thing, then you are being counterproductive to your own stated wish for higher quality questions. :) Meanwhile, the counterpoint to "good questions don't attract troll answers" is "troll answers do nothing to encourage good questions"

@JonathanVanMatre yeah, I was just messing with you. :)

@TimSeguine All good.  :)

+1 This is a perfectly valid answer. I was about to post a 2 byte answer along the same vein, but your 0 byte one is even better. Again, the OP should have required a specific distribution if he wanted one.

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",":)"));

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

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

“Random times but ranged between 0-255”

But you forgot to update the character count too. :) It's 28 here, you seem to counted the final newline too, which is unnecessary. And take a look at Tips for golfing in Ruby, especially to sepp2k's answer's point 3.

Why not just $><<":)"*rand(256)?

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

use new Date and you win 2 chars

@Sting ES6 didn't exist in 2014, did it?

q - 17 bytes
(2*1?255)[0]#":)"

or a second way:
(2*rand 255)#":)"

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!

repeat is not experimental. It was validated by ES6 committee. Only its implementation is experimental.

Okay, implementationally experimental.. Updated accordingly... But nevertheless, I did it without repeat...

This never outputs 255 smileys.

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

Ah yes, good point... A quick change of one character should fix this... Voila!

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

why not sample(0:255,1) instead of sum(sample(0:1,255,T)))?

@plannapus Good point! Correcting.

Julia, 23
print(":)"^rand(0:255))

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

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

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

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

That's an expression, not a program.

Your line is actually 49 characters, not 50. And I can shave it down to 44 for you: concat.flip replicate":)"<$>randomRIO(0,255) =D

KChaloux, that's awesome! I understand the concat.flip but I did not know <$>, thanks! And Rhymoid, you are right, to make it into a compilable program we'd have to add main= to it's beginning, which costs an extra 5.

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

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(*)

Pyth, 8
*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)

Probably because Pyth appeared after the question was posted.

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

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.

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?

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.

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.

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

Fairly long, but interesting.

Excel Speadsheet Formula (also works in Google docs) - 21
=REPT(":)",RAND()*250)

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

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

Python 3, 38 bytes.
from random import*
':)'*randrange(256)

OUTPUTS
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

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

You could use print(':)'*__import__('random').randrange(256)).

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

This is [tag:code-golf].  You are supposed to remove comments and unnecessary whitespace, and use 1-character variable names.

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.

OK, that is good practice too.

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.

@DocMax - Thanks! I never really relied on int 020h much, but it certainly does work. Updating my answer.

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.

JavaScript
Can't you just do something like this?
var s = ""; for(var a = 0; a<Math.random()*255;a++){s+=":)";} alert(s);

Javascript (on nodejs repl) - 47 chars
Array(Math.floor(Math.random()*255)).join(':)')
output #1
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

output #2
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

output #3
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

You can save char by doing ~~(Math.random()*255) instead of Math.floor(Math.random()*255). Also get rid of your spaces.

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.

Good answers on SO about both. ~~ and bitwise or 0

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)

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.

@orion Good call. The braces were left over from a version where I had two putchars. Those have been combined with the comma operator.

@orion The (int *) stays; without it, we are passing an int to time.

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.

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

Sure, I said int/long/[technically long long], depending on the system, but it's still implicitly convertible. 4-byte 0 is cast implicitly to 8-byte 0, it still means null pointer, which is ignored by time(0). Just do it and compile. It works perfectly, no warnings or errors.

@orion Of course there are no warnings; there is no prototype for time; the <time.h> header has not been included! Since there is no prototype declaration, no conversion (what you're calling "implicit cast") of arguments to the parameter type takes place. If you call time(3.0), then a double is passed, not 3. You could pass a structure: struct foo { char a[23]; } x; time(x);.

Wow, you are using (int*) (insane portability for something that would work anyway on common platforms), and yet you assume ASCII. If you seriously are going to be lolportable, perhaps consider replacing ASCII charcodes with real characters. And not specifying x as function argument (I know, undefined behavior - main takes 0 or 2 arguments, not 1), even if it works on most platforms.

@xfix Your reasoning is flawed. ASCII is much more ubiquitous than ABI-level interchangeability of int and pointers, which have a different size on a whole lot of mass-produced, consumer-grade hardware! Worrying about non-ASCII systems is what is "lolportable".

@xfix The program is hardly obsessed with portability. It depends on the interchangeability of pointers of different types (that int * substitutes for time_t *). It also depends on time_t being an integer (ISO C says "arithmetic type capable of representing time"). I made some practical assumptions which hold quite broadly to keep the program short, without drifting into idiot land.

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

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

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

Output:
:):):):):):):):):):):):):):):):):):):):):)

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

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

Quite bad randomization. http://pastebin.com/va2sgBur . Anyway, I'm afraid that will not compile in Java.

It will compile as tested it :)

Not here: http://pastebin.com/92MqU7zy

I guess default package is not getting loaded for u

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.

@Paŭlo What is the standard way of code-golfing Java: to include or not to include?

thn i have wrtie class, package etc also?

@Ypnypn The standard is to include, unless the challenge asks for a function, in which case, just declare a method

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

PHP - 28
=str_pad('',rand()&255,':)')

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

These are 30 if you include
    <?

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.

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

You can omit -Maximum. At least in PowerShell 2.0.

For 0-255, you need 256 in the Get-Random call. (Like in my own answer).

The Get verb is implied. you can write random 255 instead get-random 255

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

Scala repl short 29
":)"*util.Random.nextInt(256)

First output:
res9: String = :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):)

Second output
res10: String = :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
 :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
 ):):):):):):):):):):):):):):):):):):)

Third output
res11: String =
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):
):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):)

I love scala =)

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

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

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

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

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

Lua, 36
print((':)'):rep(math.random(255)))

Sample output:
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

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

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

Python - 42 chars
import random;random.randrange(0,256)*':)'
could have been reduced to 28 chars if import wasn't counted.
output:
:):):):):):):):):):):):):):):):):):):):)

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

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

Shave off 1 char with from ... import*: from random import*;randrange(0,256)*':)'

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

ah i didnt notice that someone already did the same program!!

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.

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

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.

Wow, thanks for that. Didn't realise that namespaces were optional

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

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

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

Python 3.x 47
import random;print(':)'*random.randint(0,255))

as Doorknob said, boring.

Since this is code-golf you should include a byte count in your title.

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

I had to use a head in my code ;)

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.

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.

Remove the number  16 from your heading and show that code differently

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.

SQL, 79
Because, why not
declare @c int;set @c=rand()*255;while(@c<255) begin print ':)';set @c=@c+1;end

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

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)

AppleScript, 52 bytes
So, uh, yeah.
repeat random number from 0 to 255 times
log":)"
end
I think this is fairly self explanatory.

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

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

Run and see expanded online here

Microscript II, 10 bytes
":)"s256R*

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

authors: n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

authors: Дмитрий Лисин

authors: سید هادی تفرشیان

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Recognize ASCII art numbers
Challenge
Recognize ASCII art numbers. To make things interesting, three random points in the image might be flipped. For example:
 *****
 *  **
    **

   **
  **
 **

Input
A 7x7 ASCII art number generated by the below Python script.
Output
A digit.
Testing script
Here's a Python script (2.6+) to generate the test cases:
import random

digits = '''\
  ***
 ** **
**   **
**   **
**   **
 ** **
  ***

   *
 ***
   *
   *
   *
   *
 *****

  ***
 *  **
     *
    **
   **
  **
 ******

  ***
 *  **
     *
  ***
     *
 *  **
  ***

   **
  ***
 * **
*  **
******
   **
   **

 *****
 **
 ****
     *
     *
 *   *
  ***

  ****
 **
 *****
 *   *
 **  **
 **  *
  ****

 *****
    **
    **
   **
   **
  **
 **

  ****
 **  **
 **  **
  ****
 **  **
 **  **
  ****

  ***
 ** **
**   **
 **  *
  ****
    **
 ****  '''.split('\n\n')

def speckle(image, num_speckles):
    grid = [list(row) for row in image.split('\n')]

    for i in range(num_speckles):
        row = random.choice(grid)
        row[random.randint(0, 6)] = random.choice([' ', '*'])

    return '\n'.join([''.join(row) for row in grid])

digit = random.choice(digits)

print(speckle(digit, 3))

Are you sure the Hamming distance between each two digits is more than 6?

@JanDvorak: I tweaked the font so that this won't be a problem. Do you see one?

APL (87 85)
1-⍨⊃⍒(,↑{7↑'*'=⍞}¨⍳7)∘(+.=)¨{49↑,(16/2)⊤⎕UCS⍵}¨↓10 3⍴'嵝䍝뫂傁ဣ␋䠁䊫낫䢝䊅넂垵僡ᑨ嘙쐅嘹䜝䪀슪퀪岹亝尵䌧뮢'

Explanation:
Each possible ASCII number is encoded in 48 bits. (The 49th bit is always zero anyway). The string 嵝䍝뫂傁ဣ␋䠁䊫낫䢝䊅넂垵僡ᑨ嘙쐅嘹䜝䪀슪퀪岹亝尵䌧뮢 has three characters per ASCII number, each of which encodes 16 bits.

↓10 3⍴: split the data string into 10 3-char groups, each of which encodes a number.
{...}¨: for each of the groups:

(16/2)⊤⎕UCS⍵: get the first 16 bits of each of the three characters
,: concatenate the bit arrays into one array
49↑: take the first 49 elements. There are only 48, so this is equivalent to adding a 0 at the end.

,↑{7↑'*'=⍞}¨⍳7: read 7 lines of 7 characters from the keyboard, make a bit array for each line where 1 means the character was a *, and join them together.
(+.=)¨: for each possible digit, calculate how much bits the input had in common with the digit.
⍒: get the indices for a downwards sort of that list, so that the first item in the result is the index of the largest number in the previous list.
⊃: take the first item, which is the index of the digit
1-⍨: subtract one, because APL indices are 1-based.

wow 87? must be the longest APL program ever.

I always thought APL always looks like Greek.  Now Chinese as well?!?

⎕IO←0, tacit, top-left is always 0; 80: ⊃⍒(,↑{7↑'*'=⍞}¨⍳7)∘(+.=)¨(49⍴(16/2)⊤⎕UCS)¨↓10 3⍴'嵝䍝뫂傁ဣ␋䠁䊫낫䢝䊅넂垵僡ᑨ嘙쐅嘹䜝䪀슪퀪岹亝尵䌧뮢'

Python
I'm sure there will be OCR solutions, but the probability of mine being accurate is much higher.
import difflib as x;r=range;s='2***3**1**1**3****3****3**1**1**3***23*4***6*6*6*6*4*****12***3*2**6*5**4**4**4******2***3*2**6*3***7*2*2**3***23**4***3*1**2*2**2******4**5**21*****2**5****7*6*2*3*3***22****2**5*****2*3*2**2**1**2*3****11*****5**5**4**5**4**4**42****2**2**1**2**2****2**2**1**2**2****12***3**1**1**3**1**2*3****5**2****2'
for c in r(8):s=s.replace(str(c),' '*c)
s=map(''.join,zip(*[iter(s)]*7));a=[raw_input("") for i in r(7)];l=[[x.SequenceMatcher('','|'.join(a),'|'.join(s[i*7:(i+1)*7])).ratio()] for i in r(10)];print l.index(max(l))

Input one line of text at a time.
Not sure of a better way to deal with the asterisks without increasing the character count.

JavaScript (ES6), 89
f=n=>(a=1,[a=(a+a^c.charCodeAt())%35 for(c of n)],[4,25,5,16,0,11,32,13,10,1].indexOf(a))

Usage:
> f("  ***  \n *  ** \n     * \n    ** \n   **  \n  **   \n ******")
2

Un-golfed version:
f = (n) => (
  // Initialize the digit's hash.
  a=1,
  // Hash the digit.
  // 35 is used because the resulting hash is unique for the first ten digits.
  // Moreover, it generates 4 1-digit hashes.
  [a = (a + a ^ c.charCodeAt()) % 35 for(c of n)],
  // Compare the hash to pre-computed digit hash.
  // The matching hash index is the digit.
  [4,25,5,16,0,11,32,13,10,1].indexOf(a)
)

Does this work if the input isn't exactly equal to one of the digits? According to the question, three pixels may be flipped and it should still work.

Bash+ImageMagick+tesseract, 316 chars
Here's a stab at an OCR solution.  Its not very accurate though, even when telling tesseract that we have just one char and it is a digit.  Moderately golfed, but still somewhat readable:
w=0
c()((w=${#2}>w?${#2}:w))
mapfile -c1 -Cc -t l
h=${#l[@]}
{
echo "# ImageMagick pixel enumeration: $w,$h,1,gray"
for y in ${!l[@]};{
for((x=0;x<w;x++));{
[ "${l[$y]:$x:1}" != " " ]
echo "$x,$y: ($?,$?,$?)"
}
}
}|convert txt:- i.png
tesseract i.png o -psm 10 <(echo "tessedit_char_whitelist 0123456789")
cat o.txt

The script takes input from stdin, so we can pipe from the test script.
Note I have put tee >( cat 1>&2 ) in the pipeline just so we can see what the test script actually generated.
Example output (This was a pretty good run with only 1 incorrect char out of 6):

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
  ***
 ** **
*    **
 **  *
  ****
    ***
 ****
Tesseract Open Source OCR Engine v3.02 with Leptonica
9

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
   *
 ***  *
   *
   *
   *
   *
 *****
Tesseract Open Source OCR Engine v3.02 with Leptonica
1

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
  ***
 ** **
**   **
**   **
**   **
  * **
  ***
Tesseract Open Source OCR Engine v3.02 with Leptonica
0

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
 *****
 **
 ****
     *
     *
 **  *
  ***
Tesseract Open Source OCR Engine v3.02 with Leptonica
5

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
  ****
 **
 *****
 *   *
*** ***
 **  **
  ****
Tesseract Open Source OCR Engine v3.02 with Leptonica
5

$ python ./asciitest.py | tee >(cat 1>&2 ) | ./scanascii.sh
  ***
 *  **
     *
    **
   ***
  **
 ******
Tesseract Open Source OCR Engine v3.02 with Leptonica
2

$

LÖVE2D, 560 Bytes
t=...;g=love.graphics g.setNewFont(124)g.setBackgroundColor(255,255,255)A=g.newCanvas()B=g.newCanvas()x=1 y=1 g.setColor(255,255,255)g.setCanvas(B)g.clear(0,0,0)for i=1,#t do x=x+1 if t:sub(i,i)=="\n"then x=1 y=y+1 end if t:sub(i,i)=="*"then g.rectangle("fill",x*16,y*16,16,16)end end u=B:newImageData()g.setCanvas(A)S={}for i=0,9 do g.clear(0,0,0,0)g.print(i,48,0)r=A:newImageData()s={i=i,s=0}for x=0,16*8 do for y=0,16*8 do a=u:getPixel(x,y)b=r:getPixel(x,y)s.s=s.s+math.abs(a-b)end end S[i+1]=s end table.sort(S,function(a,b)return a.s<b.s end)print(S[1].i)

First, draws a blocky representation of the input text, then, for each number 0 - 9, overlays a number, checks how many similar pixels there are, and prints the number which got the closest. Very basic OCR. It matches all the Test Cases, and performs reasonably well with mutations.
Call with:
love.exe "" "INPUT"

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes