Take the 2-minute tour ×
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

You have to create a code which prints

:)  

No white-space and newline character included
Random times but ranged between 0-255

Your score :
The count in bytes

EDIT : Also show 3 outputs of your code

share|improve this question
22  
What's the purpose of subtracting points from popular answers? –  sortfiend Mar 6 at 4:41
24  
But, further, why is a code golf question scoring based on votes? It's code golf, not a popularity contest –  doppelgreener Mar 6 at 8:38
8  
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? –  Bakuriu Mar 6 at 10:27
14  
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. –  Tim Seguine Mar 6 at 14:10
7  
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 Mar 6 at 15:09

68 Answers 68

up vote 26 down vote accepted

GolfScript, 12 characters

":)"256rand*

Nothing really interesting here.

share|improve this answer
1  
It doesn't change the length, but shouldn't that be 256 rather than 255? –  DocMax Mar 6 at 5:05
10  
@Doorknob Happy 10k! –  DigitalTrauma Mar 6 at 5:09
1  
@DocMax: If we want a uniform distribution from 0 to 255 inclusive, yes. If not, it might as well be 9. :) –  Ilmari Karonen Mar 6 at 9:05
6  
Why in the world does this answer have so many upvotes? There are other more interesting answers out there. –  Quincunx Mar 6 at 21:05
4  
@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. –  Lohoris Mar 9 at 0:32

JavaScript (ES6), 25

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

Outputs (REPL):

> ":)".repeat(new Date%256)
":):):):):)"
> ":)".repeat(new Date%256)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"
> ":)".repeat(new Date%256)
":):):):):):):):):):):):):):):):):):):):):):):):):):):)"
share|improve this answer
2  
You sir deserve more likes! –  Silviu Burcea Mar 6 at 10:48
5  
@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. –  Florent Mar 6 at 17:44
3  
You can use new Date%256, instead of Date.now()%256. 2 characters shorter. –  toothbrush Mar 6 at 19:11
4  
@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. –  George Reith Mar 7 at 0:01
1  
@Steve most golfing languages are never used in production, at least ES6 will actually be used. –  howderek Mar 7 at 20:08

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 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):)
share|improve this answer
    
don't we include files like stdlib.h or so and count their char count ? –  Mukul Kumar Mar 6 at 5:55
    
It compiles without headers in gcc. It complains about implicit declaration of built-in function ‘printf’, but works fine. –  Comintern Mar 6 at 6:01
    
You could drop 1 character by doing for(x=rand()%256;i++<x;). EDIT: But it would break your ASCII art, yeah. –  Maxime Lorant Mar 8 at 10:00
    
This can be done with just 60 chars: x;main(){srand(time(0));for(x=rand()%256;--x;)printf(":)");}. –  still_learning Mar 8 at 11:15
    
@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. –  Comintern Mar 9 at 1:24

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
share|improve this answer
2  
+1 for the most entertaining solution! –  Jonathan Van Matre Mar 6 at 15:19
2  
Add 5 more bytes and you have my vote :) –  Quincunx Mar 6 at 18:54
1  
Did it. Added a chinese smiley: ^__^ . Now because your comment has been upvoted once, there should be two more people voting for my answer ^__^ –  Mikaël Mayer Mar 7 at 15:11
5  
+1 for the "1337" score. –  Comintern Mar 7 at 18:23

Python 23

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

Demo

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

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

D:\temp>smiley.py
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):)
share|improve this answer
    
id(9) is not random and id(9)%255 will never give 255. –  grc Mar 6 at 5:00
2  
@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 –  Abhijit Mar 6 at 5:44
    
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 Mar 6 at 6:00
    
@grc: Ahh yes, I forgot about that, yet thought that implementation dependent, yet in cPython which is widely used, its how its implemented –  Abhijit Mar 6 at 6:08
    
@downvoter: Can you please explain what is wrong with the code and how it can be corrected? –  Abhijit Mar 6 at 6:09

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
share|improve this answer
    
The question is a 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. –  ProgramFOX Mar 7 at 18:42
2  
Well the previous Java example was critiqued for bad practice and lack of randomosity >:3 –  MattOates Mar 7 at 20:25
    
Haha I love this. Needs more comments and java doc though. –  krs013 May 20 at 5:17

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.

share|improve this answer
1  
All Get-<Something> functions in PowerShell are automatically aliased as <Something>, so you can save 4 bytes by getting rid of Get- –  Rynant May 12 at 18:36
1  
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)! –  Iszi May 27 at 15:26
    
Thanks for the comment on aliasing. It's always useful to know the potential impact of something like aliasing, even when it is small. –  DocMax May 27 at 16:45

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

share|improve this answer
    
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 Mar 6 at 4:47
    
@skibrianski: Yes, there was some issue with the code. Brackets were misplaced and we need to work with absolute value –  Abhijit Mar 6 at 5:53
    
Have you tried (c&0xff) instead of abs(c)%256? This should work due to integer promotion. –  n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Mar 6 at 6:48
    
c&&main(printf(..),..); would be shorter. –  ugoren Mar 6 at 6:51
    
I think you missed urogen's other suggestion, to move the printf to main's arguments. –  hvd Mar 6 at 13:24

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@"):",,>
@
share|improve this answer
2  
+1 for noticing that the random distribution need not be uniform. –  imallett Mar 6 at 7:14

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.

share|improve this answer
    
Which one should I consider...18 char or 12 char solution –  Mukul Kumar Mar 6 at 3:38
1  
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. –  algorithmshark Mar 6 at 3:57
1  
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. –  grc Mar 6 at 5:09
    
Assuming the z locale, you can get 17 with echo(+:?128)$':)' –  AlliedEnvy Mar 7 at 1:04
    
@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. –  algorithmshark Mar 7 at 1:33

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// /:)}
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
$ 
share|improve this answer

Ruby, 18

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

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

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

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

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

share|improve this answer
    
Not sure how to show the wrapping in the result part, but they are of different lengths –  Greg Jennings Mar 6 at 3:38
1  
press enter then add four spaces before text –  Mukul Kumar Mar 6 at 3:53
    
thanks for the tip. :) –  Greg Jennings Mar 6 at 4:06
    
Shouldn't it be rand(256) to get 0-255? –  Victor Mar 6 at 6:15
3  
$><< looks fancy, but is there anything wrong with puts':)'*rand(255)? –  minitech Mar 6 at 19:53

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'                                                 
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer
    
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' –  skibrianski Mar 6 at 4:47
    
@skibrianski Indeed. Thanks! –  devnull Mar 6 at 4:55
    
note: rand 255 doesn't include 255 –  J.F. Sebastian Mar 8 at 8:39
    
@J.F.Sebastian Oversight, I guess. I'll change it to 256. (Between 0 and 255 is ambiguous at best.) –  devnull Mar 8 at 8:42
    
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) –  Eevee Mar 9 at 19:36

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.

share|improve this answer
    
range is 0-255 not 1-255 –  Mukul Kumar Mar 6 at 5:27
    
Fair enough. If you set ⎕IO to 0 (which is the default in many versions of APL), that will be the effect. –  Elias Mårtenson Mar 6 at 5:28
    
well, you can have numbers from 1-256 then subtract 1 from it –  Mukul Kumar Mar 6 at 5:29

Mathematica 35

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

Examples

outputs

share|improve this answer

PHP | 30 bytes

 <?=str_repeat(':)',rand()%256)
share|improve this answer
    
Add a '#' character before 'PHP' to make it a heading like other answers –  Mukul Kumar Mar 6 at 4:57
    
@MukulKumar Thanks –  gvgvgvijayan Mar 6 at 5:08
1  
Since this question is tagged code-golf, it is helpful to include the character count in your answer. –  grc Mar 6 at 6:52
    
You can remove the space and the mt_ –  TimWolla Mar 6 at 11:20
4  
A shorter version: <?=str_repeat(":)",rand()%256); –  Florent Mar 6 at 13:01

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:

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

 

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

 

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer
    
I am okay with no newline and white spaces –  Mukul Kumar Mar 6 at 2:51
1  
Actually, I was wrong to begin with. print':)'*(whatever) includes newlines. I didn't test it until right now. I learned something new today! –  undergroundmonorail Mar 6 at 3:00
3  
I think you can save up to 7 characters by using os.urandom instead. –  grc Mar 6 at 4:51
1  
What grc means is: import os;print':)'*ord(os.urandom(1)) –  Quincunx Mar 6 at 7:04
1  
@alexander shorter than that would be: import os;':)'*ord(os.urandom(1)) at 33 chars –  Quincunx Mar 6 at 21:04

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:

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer
1  
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=''). –  grc Mar 6 at 4:39
1  
Intead of ~~() save 2 with 0|Math.... And another if you move t='' inside of the random() call –  DocMax Mar 6 at 4:45
    
Just as a curiosity, this is the Harmony version, currently working only in Firefox: alert(':)'.repeat(Math.random()*256)). –  manatwork Mar 6 at 7:49
    
@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 Mar 6 at 8:09
    
@Victor It’s new in ES6. Here’s a fully spec-compliant polyfill for it: mths.be/repeat –  Mathias Bynens Mar 6 at 14:54

Python - 22

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)"
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer

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

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

The initial solution was:

print":)"*(new Random().nextInt(256))
share|improve this answer
1  
I brought it to 29 characters: print":)"*(Math.random()*255) –  Michaël Demey Mar 7 at 11:59

R, 34

cat(rep(":)",runif(1)*256),sep="")
share|improve this answer
    
You can probably leave off cat and beat the answer I just posted. ;-) –  Gaffi Mar 6 at 12:12
    
@Gaffi The output should contain :) only. –  Sven Hohenstein Mar 6 at 12:13
1  
@Gaffi Let me cite the OP: No white-space. –  Sven Hohenstein Mar 6 at 12:25
1  
It should be cat(rep(":)",runif(1)*256),sep=""), otherwise you will never get 255 smilies. See length(rep(":)",254.9999)). –  djhurio Mar 8 at 12:16
1  
@djhurio Thanks, good point! –  Sven Hohenstein Mar 8 at 12:52

Ruby (25 Chars)

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

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

share|improve this answer
    
“Random times but ranged between 0-255” –  manatwork Mar 6 at 9:00
    
Updated. Thanks –  Clyde Lobo Mar 6 at 9:08
    
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. –  manatwork Mar 6 at 9:16
    
Why not just $><<":)"*rand(256)? –  Doorknob Mar 6 at 23:50

q - 17 bytes

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

or a second way:

(2*rand 255)#":)"
share|improve this answer

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.

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer
    
why not sample(0:255,1) instead of sum(sample(0:1,255,T)))? –  plannapus Mar 6 at 13:05
    
@plannapus Good point! Correcting. –  Gaffi Mar 6 at 13:10

Julia, 23

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

Usage:

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

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

julia> print(":)"^rand(0:255))
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer

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)
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"
share|improve this answer
    
That's an expression, not a program. –  Rhymoid Mar 8 at 23:15
    
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 Mar 10 at 12:57
    
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. –  linse Mar 10 at 21:59

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

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer
    
+1 for gratuitous memory leak. –  imallett Mar 6 at 7:17
    
fake output? on my machine it always prints the same number of smileys –  izabera Mar 6 at 9:07
    
btw you could save a few char with while(*a--%256) –  izabera Mar 6 at 9:07
    
@izabera try it again ! –  Mukul Kumar Mar 6 at 17:42

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",":)"));
share|improve this answer

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!

share|improve this answer
1  
repeat is not experimental. It was validated by ES6 committee. Only its implementation is experimental. –  Florent Mar 6 at 11:36
    
Okay, implementationally experimental.. Updated accordingly... But nevertheless, I did it without repeat... –  WallyWest Mar 6 at 11:44
1  
This never outputs 255 smileys. –  Neil Mar 7 at 0:28
1  
@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. –  xfix Mar 7 at 16:37
    
Ah yes, good point... A quick change of one character should fix this... Voila! –  WallyWest Mar 9 at 5:53

Pure ZSH - 32

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

Output 1:

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

Output 2:

:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

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