# Question
Title: 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

# Answer
> 30 votes
# GolfScript, 12 characters

```
":)"256rand*

```

Nothing really interesting here.

# Answer
> 53 votes
# JavaScript (ES6), 25

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

```

**Outputs (REPL):**

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

```

# Answer
> 31 votes
## C - 116 (including artistic whitespace)

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

```

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

**Boring version:**

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

```

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

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

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

```

# Answer
> 30 votes
# Scala REPL 1337

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

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

```

## Output 1

```
res32: String = :)
```

## Output 2

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

## Output 3

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

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

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

```

# Answer
> 17 votes
## Python 23

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

```

**Demo**

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

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

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

```

# Answer
> 13 votes
# Java 72 lines 1,832 bytes and ~50 seconds runtime

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

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

public class EnterpriseJavaSolution {

    public static class BodyPart {

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

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

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

    }

    public static class Eyes extends BodyPart {

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

    }

    public static class Mouth extends BodyPart {

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

    }

    public static class Face extends BodyPart {

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

    }

    public static void main (String[] args) {

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

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

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

    }

}

```

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

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

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

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

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

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

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

```

# Answer
> 12 votes
# PowerShell 21, 17

```
":)"*(Random 256)

```

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

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

# Answer
> 11 votes
## 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

# Answer
> 11 votes
# 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)<sup>255</sup> = 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<sup>-122</sup>`. The number of atoms in the universe is about `10<sup>80</sup>`. The Planck length, the smallest measurable length (as in the universe does not allow for smaller), is `1.616199(97) × 10<sup>-35</sup> m`. This means that if this number were the size of the Planck length, the Planck length would be about

```
`8.5×10<sup>59</sup> × diameter of the observable universe (93 billion light-years)`
```

First output:

```
:)

```

Second output:

```
:):)

```

Third output:

```
:):):):):)

```

---

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

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

```

---

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

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

```

# Answer
> 8 votes
# J - 18 char

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

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

```

Explained:

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

Examples:

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

```

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

```
':)'$~2*?256

```

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

# Answer
> 7 votes
# Ruby, 18

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

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

```

`:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)`

`:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)`

`:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)`

# Answer
> 7 votes
## perl ~~20~~, 17 characters

Thanks to skibrianski for shaving 3 characters.

```
say":)"x rand 256

```

Sample execution:

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

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

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

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

```

# Answer
> 6 votes
# PHP | 30 bytes

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

```

# Answer
> 5 votes
# Python 2.7 - 45 bytes

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

```

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

The (slightly) more idiomatic way to do this is

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

```

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

Three sample outputs:

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

```
:):):):):):):):):):):):):):):)

```

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 5 votes
# Mathematica 35

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

```

---

**Examples**

# Answer
> 5 votes
# Pure Bash, 41

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

```

Sample outputs:

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

```

# Answer
> 5 votes
## APL: 12 characters

```
(?255)⍴⊂':)'

```

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

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

# Answer
> 5 votes
# Python - 21

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

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

```

And some example runs:

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

```

# Answer
> 4 votes
## Groovy (37 29 characters, @Michaël Demey's suggestion)

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

```

*The initial solution was:*

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

```

# Answer
> 4 votes
## R, 34

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

```

# Answer
> 4 votes
# Pure ZSH - 32

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

```

Output 1:

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

Output 2:

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 3 votes
# C++ 104 84 107

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

```

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

**#1**

```
:):):):):):):):):):):):):):):):):):):):):):)

```

**#2**

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

**#3**

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 3 votes
## Javascript - 51 characters

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

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

```

4 Outputs:

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

```
:):):):):):):)

```

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 3 votes
# (PHP/Python/Perl/Javascript/others)-Polyglot - 0 bytes

---

---

Output 1:

Output 2:

Output 3:

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

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

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

# Answer
> 3 votes
# 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:

`:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)`

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

---

Complete program (104 chars):

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

```

---

Original method (92 chars):

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

```

# Answer
> 3 votes
**Ruby (25 Chars)**

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

```

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

# Answer
> 3 votes
# JavaScript, 44 bytes

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

```

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

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

```
alert(Array(Date.now()%257).join(':)'))

```

# Answer
> 3 votes
**q - 17 bytes**

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

```

or a second way:

```
(2*rand 255)#":)"

```

# Answer
> 3 votes
# JavaScript (pre-ES6) 45

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

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

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

```

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

# Answer
> 3 votes
## R 37

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

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

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

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

```

Tested on R-Fiddle.

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 3 votes
### Julia, 23

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

```

Usage:

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

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

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

```

# Answer
> 3 votes
Haskell (50)

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

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

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

```

# Answer
> 3 votes
# Perl 6 (~~20~~ 18 bytes (I'm going to ignore scoring system, it's silly))

```
say ":)"x 256.rand

```

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

Sample:

```
glitchmr@feather ~> perl6 -e 'say ":)"x 256.rand'
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)
glitchmr@feather ~> perl6 -e 'say ":)"x 256.rand'
:):):):):):):):):):):):)

```

# Answer
> 3 votes
## 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)

```

# Answer
> 2 votes
# PHP - 32

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

```

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

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

```

Whichever suits you best

# Answer
> 2 votes
# C: 44 (39 if sloppy)

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

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

```

Fixed at expense of 5 chars:

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

```

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

# Answer
> 2 votes
## Java - 84

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

```

Fairly long, but interesting.

# Answer
> 2 votes
Excel Speadsheet Formula (also works in Google docs) - 21

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

```

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

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

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

# Answer
> 2 votes
# Brainfuck (shell support) - 49/62

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

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

```

Compile this to a file `a` and execute

```
./a</dev/random

```

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

```
a</dev/random

```

62 bytes in total, guaranteed randomness.

## 1st output

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# 2nd output

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# 3rd output

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 2 votes
**Python 3, 38 bytes.**

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

```

**OUTPUTS**

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

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

```

# Answer
> 2 votes
## x86 DOS Assembly - ~~27~~ 25

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

`B42CCD210FAFCA32EDBA1601B409E304CD21E2FCCD203A2924`

In more readable ASM:

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

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

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

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

    ; End
    int 020h

    ; Our smile
Smile:
    db ':)$'

```

Sample output:

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

```

**EDIT** Changed to int 020h per DocMax

# Answer
> 2 votes
**JavaScript**

Can't you just do something like this?

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

```

# Answer
> 1 votes
# Javascript (on nodejs repl) - 47 chars

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

output #1

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

output #2

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

output #3

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 1 votes
## C: 62

(61 characters plus newline)

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

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

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

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

```

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

# Answer
> 1 votes
## Coreutils and Bash 36

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

```

I borrowed the creative use of `RANDOM` from @DigitalTrauma.

Testing:

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

```

> :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

```

> :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

```

> :):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

# Answer
> 1 votes
**JAVA 61**

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

```

Output:

```
:):):):):):):):):):):):):):):):):):):):):)

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

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

```

# Answer
> 1 votes
# Python - 40

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

```

output:

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

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

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

```

# Answer
> 1 votes
**PHP - 28**

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

```

or

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

```

These are 30 if you include `<?`

# Answer
> 1 votes
**Windows Powershell - ~~30~~ 21**

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

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

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

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

```

# Answer
> 1 votes
**Python 116**

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

```

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

# Answer
> 1 votes
# Lua, 36

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

```

Sample output:

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

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

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

```

# Answer
> 1 votes
# Bash, 14-45 bytes

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

This fork bomb is sad because it can never explode.

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

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

```

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

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

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

```

# Answer
> 1 votes
# Python - 42 chars

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

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

output:

```
:):):):):):):):):):):):):):):):):):):):)

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

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

```

# Answer
> 1 votes
# Scala repl short 29

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

```

### First output:

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

```

### Second output

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

```

### Third output

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

```

I love scala =)

# Answer
> 1 votes
# PHP 28

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

```

# Output 1

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Output 2

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Output 3

```
:):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)

```

# Answer
> 1 votes
# Clojure

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

```

# Answer
> 1 votes
```
import random
x=random.randint(0,255)
print(':)'*x)

```

# Answer
> 1 votes
# C# - 162

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

```

Pretty Print:

```
using System;
using System.Linq;

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

```

Output:

1

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

2

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

3

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

# Answer
> 1 votes
# C++ - ~~76~~ 72

(counting the newline as one character)

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

```

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

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

```

Output examples:

```
:):):):):):):)

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

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

```

# Answer
> 1 votes
**Python 3.x** 47

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

```

as Doorknob said, boring.

# Answer
> 1 votes
**BASH** 34 characters

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

```

*I had to use a `head` in my code ;)*

# Answer
> 1 votes
# Simplex v.0.5, 17 bytes

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

```

Technically, this compiles to the following Simplex code:

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

```

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

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

```

FYI, the chance of getting one `:)` is:

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

# Answer
> 0 votes
# Python, 16 characters

```
print ":)"*id(1)

```

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

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

```

Add four bytes and mod it by 256. Woo.

# Answer
> 0 votes
# Extended BrainFuck: 13

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

```

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

Compilation:

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

```

3 runs:

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

```

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

```
sudo apt-get install bf

```

Also it can be compiled from source

# BrainFuck: 51

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

```

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

# Answer
> 0 votes
# SQL, 79

Because, why not

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

```

# Answer
> 0 votes
# Cobra - 60

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

```

# Batch - 60

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

```

# Answer
> 0 votes
## Ruby - 15 bytes

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

```
p":)"*rand(255)

```

which prints something like

```
":):):):):):):):):):):):):):):):):):):):)"

```

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

```
puts":)"*rand(255)

```

# Answer
> 0 votes
# AppleScript, 52 bytes

So, uh, yeah.

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

I think this is fairly self explanatory.

# Answer
> 0 votes
# CJam, 12 11 10 chars

```
Y8#mr":)"*

```

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

# Answer
> 0 votes
# Hassium, 47 Bytes

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

```

Run and see expanded online here

# Answer
> 0 votes
# Microscript II, 10 bytes

```
":)"s256R*

```

# Answer
> 0 votes
## 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)^':)' "")
":):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):):)"

```

---
Tags: code-golf, string, random
---


title: Contaminated Squares

text:
# Question
Title: Contaminated Squares
### Introduction

Let's observe the following square, consisting only of the digits `0 - 9`:

```
1034
4167
8414
3542

```

The outer shell of this square is:

```
1034
4  7
8  4
3542

```

It contains zeros, so we need to *peel* off the outer shell, leaving:

```
16
41

```

The outer shell of this square is:

```
16
41

```

It does **not** contain any zeros and is therefore a ***non-contaminated*** square. So basically, the **definition** of a non-contaminated square is when the **outer shell** of the square contains *no* zeros.

### The Task

Given a square of digits (containing only non-negative integers) in any reasonable format, output the **largest non-contaminated square** by constantly peeling off the outer shell, in any reasonable format.

### Test cases

Test case 1:

```
Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

```

Test case 2:

```
Input         Output

123           123
204           204
346           346

```

Test case 3:

```
Input         Output

101           1
010
101

```

Test case 4:

```
Input         Output

000           (none)
000
000

```

This is , so the submission with the least amount of bytes wins!

# Answer
> 6 votes
# Jelly, ~~19~~ 16 bytes

```
Fœ^F}P
ḊṖZµ⁺⁸ßç?

```

Try it online! or verify all test cases.

### How it works

```
ḊṖZµ⁺⁸ßç?  Main link. Argument: M (2D list)

Ḋ          Dequeue; remove the first row.
 Ṗ         Pop; remove the last row.
  Z        Zip; transpose rows with columns.
   µ       Combine the chain to the left into a link.
    ⁺      Copy the link, executing it twice.
           The copy removes the first and last column and restores the orientation.
       ç?  If the helper link returns a non-zero integer:
     ⁸       Return M unmodified.
      ß      Else, recursively call the main link on the "peeled" M.

Fœ^F}P     Helper link. Arguments: P ("peeled" M), M (unmodified)

F          Flatten P.
   F}      Flatten M.
 œ^        Perform multiset symmetric difference, removing the elements of P from
           the elements of M, respecting multiplicities, leaving precisely the
           elements of the outer shell.
     P     Return the product of the remaining elements.

```

# Answer
> 8 votes
# JavaScript, ~~105~~ 97 bytes

Saved 8 bytes thanks to @Patrick Roberts!

```
l=a=>a.slice(1,-1)
p=a=>l(a).map(l)
c=a=>a.join``.replace(/[^0]/g,"")
s=a=>c(p(a))<c(a)?s(p(a)):a

```

Defines function `s`, which returns a 2D array of integers when provided a 2D array of integers as input.

### How it Works

* function `l`: given an array `a`, returns a copy without its first and last indexes.
* function `p`: given a 2D array `a`, calls `l` to remove the first and last row, then for each remaining row calls `l` to remove the fist and last column. This performs the onion peeling.
* function `c`: given a 2D array `a`, returns a string that only contains the `0`s in the stringified form of `a`.
* function `s`: given a 2D array `a`, calls `c` on the peeled form of the array given by `p`, and on the array itself. Compares these strings lexicographically to determine if the peeled form has less `0`s than the original. If it does, then the original is contaminated, so call `s` recursively on the peeled form. Otherwise return the original.

# Answer
> 7 votes
## Retina, ~~60~~ 57 bytes

Byte count assumes ISO 8859-1 encoding. The trailing linefeed is significant.

```
+`(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)(^.+¶|¶.+$|.?\b.?)

```

Try it online!

### Explanation

Due to the trailing linefeed, this finds all matches of the regex after the ``` and removes them from the input. Due to the leading `+` this is done repeatedly until the output stops changing (which will be because the regex will stop matching).

As for the regex itself, it consists of two parts:

```
(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)

```

This part checks whether there's a `0` anywhere in the outer shell. It does this by moving the regex engine's "cursor" to the beginning of the string with a lookbehind (we use `[^_]` to match both digits and linefeeds):

```
(?<=...^[^_]*)

```

And then from that position we use a lookahead to find a `0` either in the first line, adjacent to a linefeed, or in the last line:

```
(?=.*0|[^_]+(¶0|0¶|0.*$))

```

Then the actual match will consist either of the first line (including its trailing linefeed), the last line (including its leading linefeed) or the first or last character of a line, where we abuse the word boundary `\b` as a beginning/end of line anchor:

```
(^.+¶|¶.+$|.?\b.?)

```

# Answer
> 6 votes
# MATL, ~~26~~ 21 bytes

```
t"t5LY)y5LZ)h?}6Lt3$)

```

Input is in the following format

```
[1 0 3 4; 4 1 6 7; 8 4 1 4; 3 5 4 2]

```

So the other four test cases are

```
[1 2 3 4; 2 3 4 5; 3 4 5 6; 4 5 6 7]
[1 0 1; 0 1 0; 1 0 1]
[1 2 3; 2 0 4; 3 4 6]
[0 0 0; 0 0 0; 0 0 0]

```

The program errors in the last test case, but produces the correct output (which is nothing). Thanks to @Dennis for noticing!

Try it online!. Or verify all test cases (this includes wrapping code).

### Explanation

This iterates as many times as the number of columns in the input matrix, which is more than enough. At each iteration, the shell is removed or kept depending on its values.

```
t            % Take a matrix as input. Duplicate
"            % For each column (i.e. repeat that many times)
  t5LY)      %   Duplicate top of the stack. Extract first and last rows
  y5LZ)      %   Duplicate the element below the top. Extract first and last columns
  h          %   Concatenate the two arrays into a row vector
  ?          %   If all its entries are non-zero: do nothing
  }          %   Else
    6Lt3$)   %     Get the central part
             % End if, end for. Implicitly display

```

# Answer
> 5 votes
# Pyth, 19 bytes

```
.W}\0.-`H`JutCPG2HJ

```

Test suite

```
.W}\0.-`H`JutCPG2HJ
.W                     While the first function returns true, apply the second
                       function, starting with the input.
           u    2H     Apply the following twice to the input:
              PG       Remove the last row
             C         Transpose
            t          Remove the first row
                       This removes the outermost shell.
          J            Save it to J
         `             Stringify the matrix
       `H              Stringify the input
     .-                Multiset difference
  }\0                  Check if there is a '0' in the resulting string.
                  J    If that succeeds, update the current value to J.
                       When it fails, return the current value.

```

# Answer
> 4 votes
## JavaScript (ES6), 74 bytes

```
f=s=>/^.*0|0\n|\n0|0.*$/.test(s)?f(s.replace(/^.*\n?|.(.*).|\n.*$/g,"$1")):s

```

Takes input in the form of a string with newlines separating each row (but no leading or trailing newline). Explanation: `/^.*0|0\n|\n0|0.*$/` is a regexp that matches contaminated squares, while `/^.*\n?|.(.*).|\n.*$/` matches that parts of the square that need to be deleted, except for the `(.*)` which needs to be kept. (This is shorter than looking ahead or behind for the newline character.)

# Answer
> 4 votes
## Perl 5, 63 + 3 = 66 bytes

```
$_=<>;s/\A.*\n?|^.|.$|\n.*\Z//mg while/\A.*0|0$|^0|0.*\Z/;print

```

Requires the `-0` flag. Input should *not* contain a trailing newline character.

# Answer
> 3 votes
## Pyke, 29 bytes

```
"D3lt%sBR,"2*ER3*I
/)tOmtmOr;

```

Try it here!

Also 29 bytes

```
QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

```

Try it here!

# Answer
> 2 votes
# Pyth, ~~31~~ 30 bytes

```
L+hbeb.W!*F+1iRTs+yHyMHPtmPtdZ

```

Test suite. (The last testcase errors)

Improvement: made part the outer-loop extractor a function (`L+hbeb`).

# Previous 31-byte version:

```
.W!*F+1iRTs++hHm+hdedHeHPtmPtdZ

```

## How it works:

The code is basically: while the product of the outershell is zero, peel it.

Let us analyze the main code (Q is implicit here):

```
.W<lambda:H><lambda:Z>Q

```

Start from `Q` (input), `while` first lambda, perform second lambda.

The first part would be the lambda in `H`:

```
!*F+1iRTs++hHm+hdedHeH

```

The second part would be the lambda in `Z`:

```
PtmPtdZ

```

### The first part

```
!*F+1iRTs++hHm+hdedHeH

```

Let us analyze this:

```
s++hHm+hdedHeH

s++             Concatenate:
   hH              1. the first row
     m+hdedH       2. the first and last item of each row
            eH     3. the last row

```

Since Pyth uses prefix notation, this would then get evaluated:

```
!*F+1iRT

     iRT  Convert each to integer
 *F+1     Product
!         Negate. If any element of the outer shell is zero, this would return 1.

```

### The second part

```
PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

```

# Answer
> 2 votes
# Mathematica, 78 bytes

```
NestWhile[#[[a=2;;-2,a]]&,#,Count[{#[[b={1,-1}]],#[[;;,b]]},0,3]>0&]~Check~{}&

```

Anonymous function, takes input as a matrix. Ignore any errors that may result during execution.

---
Tags: code-golf, number
---


title: Find the Words on the Grid!

text:
# Question
Title: Find the Words on the Grid!
Write a program or function that extracts a word from a wordsearch using its start and end coordinates.

# The Input

Your program or function should accept three parameters: the *start coordinate*, the *end coordinate*, and a *wordsearch* from which to extract the word.

* The *start coordinate* can be taken in any format.

+ **It will always be an integer**
    + The bottom left of the grid is (0, 0)
    + You will not be provided with coordinates that go outside the bounds of the grid
    + You will not be provided with coordinates that are not vertical, horizontal, or perfectly diagonal to each other, such as (7, 0) and (0, 6).
* The *end coordinate* will be taken in the same format as the *start coordinate*
* The *wordsearch* will be a **string**, or your language's closest equivalent

+ It will be a grid of characters separated by a **single space**, with **each row on a newline**. It can have any height or width - which can be different - but **it will always be a rectangle**. For example:

    ```
    A G O A T C A T
    E A T M E N O W
    W O R D S E A R
    A K L L K J H G
    N P L F G H F D
    A S P L K J H G
    O P I L F G H J
    T F A S E J K L

    ```

    ```
    J H P B L D J L T
    F J L N F N P W H
    W P R D T F J R Q
    J L L L L J H H W
    N P L F H H F D S
    J T P L L J H H K
    P P J L F H H J N
    L F J T F J L L O

    ```

# The Output

You should output a **string**, or your language's closest equivalent. As no wordsearches in real life ever ask to find a single letter, you may output nothing if the coordinates are the same.

# Examples and Test Cases

```
First Grid Above:
(0, 4) and (4, 0) --> "APPLE"

(4, 0) and (0, 4) --> "ELPPA"

(1, 7) and (4, 7) --> "GOAT"

(0, 5) and (7, 5) --> "WORDSEAR"

(0, 6) and (5, 6) --> "EATMEN"

(0, 6) and (0, 7) --> "EA"

(7, 0) and (0, 7) --> "LHJGLRAA"

----------

Second Grid Above:
(1, 0) and (8, 7) --> "FJLHJJWT"

(1, 4) and (4, 4) --> "LLLL"

(1, 4) and (1, 4) --> "L" or ""
```

# Answer
# JavaScript (ES6) 108

```
(x,y,t,u,g)=>eval("for(g=g.split`\n`.reverse(),r=g[y][2*x];x-t|y-u;)r+=g[y+=u<y?-1:u>y][2*(x+=t<x?-1:t>x)]")

```

**Less golfed**

```
(x,y,t,u,g)=>{
    g=g.split`\n`.reverse();
    for(r = g[y][2*x]; x-t | y-u; )
        r+=g[y += u<y ? -1 : u>y][2*( x += t<x ? -1 : t>x)];
    return r
}

```
> 2 votes

# Answer
# Python 3.5 using Numpy, 251 bytes:

```
def r(t,y,z):import numpy;l=numpy.array([[*i.split()]for i in z.split('\n')]);A,B,C,D=t[0],y[0],t[1],y[1];p=[1,-1];a=p[A>B];b=p[C>D];n=range(A,B+a,a);m=range(C,D+b,b);w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])];return w

```
* Takes **input** in the following format:

```
print(''.join(r((start1,start2),(end1,end2),'''grid''')))

```
* **Outputs** in the format of a string (e.g. `APPLE`) as long as the function is called using the format above. Otherwise, a list containing each letter (e.g. `['A','P','P','L','E']`) is returned.

Will golf more over time where and when I can.

Try It Online! (Ideone) (Here, input is taken such that the grid is surrounded with double quotes (`""`) and input on one line, with `\n`s between each line of the grid. Then, the points are provided in a simple tuple form, with the starting on the second line, and the end on the third.)

## Ungolfed code along with Explanation

```
def r(t,y,z):
    import numpy
    l=numpy.array([[*i.split()]for i in z.split('\n')])
    A,B,C,D=t[0],y[0],t[1],y[1]
    p=[1,-1]
    a=p[A>B]
    b=p[C>D]
    n=range(A,B+a,a)
    m=range(C,D+b,b)
    w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]
    return w

```

For the purposes of this explanation, assume this program was run with the inputs `((0,4),(4,0))` and the first grid of the question. Here, I will go through the 2 main parts of the code:

* `l=numpy.array([[*i.split()]for i in z.split('\n')])`

Here, `l` is a numpy array containing each line of the input in a separate "list". For instance, the first grid in the question, which is:

```
A G O A T C A T
E A T M E N O W
W O R D S E A R
A K L L K J H G
N P L F G H F D
A S P L K J H G
O P I L F G H J
T F A S E J K L

```

returns this numpy array:

```
[['A' 'G' 'O' 'A' 'T' 'C' 'A' 'T']
 ['E' 'A' 'T' 'M' 'E' 'N' 'O' 'W']
 ['W' 'O' 'R' 'D' 'S' 'E' 'A' 'R']
 ['A' 'K' 'L' 'L' 'K' 'J' 'H' 'G']
 ['N' 'P' 'L' 'F' 'G' 'H' 'F' 'D']
 ['A' 'S' 'P' 'L' 'K' 'J' 'H' 'G']
 ['O' 'P' 'I' 'L' 'F' 'G' 'H' 'J']
 ['T' 'F' 'A' 'S' 'E' 'J' 'K' 'L']]

```
* `w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]`

This is the main list of the function in which all of the letters corresponding to each point on the grid is found. Here, `i` corresponds to either each integer in `n`, which is a range object containing every number in the range `start1=>end1+1` in increments of `+1` if `start1<end1` or `-1` if the opposite is true. However, `i` only corresponds to this as long as `start1` does not equal `end1`. Otherwise `start1` is returned as many times as the length of `m`, where `m` is a range object containing each integer in the range `start2=>end2+1` with the same conditions as `n`, and `p` corresponds to every integer in `m`. That being said, let us now walk through this step by step:

+ `l[:,i]` basically returns a row vector for each column, `i`, in the array, `l`. for instance, `l[:,0]` would return:

    ```
    ['A' 'E' 'W' 'A' 'N' 'A' 'O' 'T']

    ```

    `l[:,1]` would return:

    ```
    ['G' 'A' 'O' 'K' 'P' 'S' 'P' 'F']

    ```

    so on and so forth. You can read more about different ways of indexing in numpy, including this method, here.
    + Then, after that, the function reverses each array returned, using `l[:,i][::-1]`, since each array is indexed from left to right, but since the point `0,0` on the grid in on the lower left hand corner of the grid, reversing each array would return the index values as if they were being looked for from right to left. For instance, `l[:,0][::-1]` would return:

    ```
    ['T' 'O' 'A' 'N' 'A' 'W' 'E' 'A']

    ```
    + After this, the function then indexes through that reversed array for the index value corresponding to `p`, which is your letter, and then adds that to the list being created. For instance, `l[:,0][::-1][4]`, which corresponds to point `(0,4)`, would return `A`.
    + This process keeps on repeating and adding new values to the list until the range objects are exhausted.

After all that, the output, which is list `w`, is finally returned. In this case, that would be `APPLE` if called with `print(''.join(r((0,4),(4,0),'''The Grid''')))` or `['A','P','P','L','E']` if it is called without `''.join()`. Either way, it returns the correct answer, and we are done!
> 0 votes

---
Tags: code-golf, string, grid, word-search
---


title: Expand roots into a polynomial

text:
# Question
Title: Expand roots into a polynomial
## Challenge

Given the roots of a polynomial separated by spaces as input, output the expanded form of the polynomial.

For example, the input

```
1 2

```

represents this equation:

```
(x-1)(x-2)

```

And should output:

```
x^2-3x+2

```

The exact format of output is not important, it can be:

```
1x^2+-3x^1+2x^0

```

or:

```
0 0 0
1x^3+0x^2+0x^1+0

```

or:

```
3 14 15 92
1x^4+-124x^3+3241x^2+-27954x^1+57960

```

## Scoring/Rules

* `eval` and likes are disallowed.
* You may use any version of Python *or any other language*.

# Answer
# Jelly, 15 bytes

```
Æṛ‘Ė’Uj€“x^”j”+

```

This uses `Æṛ` to construct the coefficients of a monic polynomial with given roots. Try it online!

### How it works

```
Æṛ‘Ė’Uj€“x^”j”+  Main link. Argument: A (list of roots)

Æṛ               Yield the coefficients of a monic polynomial with roots A.
  ‘              Increment each root by 1.
   Ė             Enumerate the roots, yielding
                 [[1, coeff. of x^0 + 1], ... [n + 1, coeff. of x^n + 1]].
    ’            Decrement all involved integers, yielding
                 [[0, coeff. of x^0], ... [n, coeff. of x^n]].
     U           Upend to yield [[coeff. of x^0, 0], ... [coeff. of x^n, n]].
      j€“x^”     Join each pair, separating by 'x^'.
            j”+  Join the pairs, separating by '+'.

```

## Alternate version, 24 bytes

```
1WW;ð0;_×µ/‘Ė’Uj€“x^”j”+

```

This uses no polynomial-related built-ins. Try it online!

### How it works

```
1WW;ð0;_×µ/‘Ė’Uj€“x^”j”+  Main link. Argument: A (list of roots)

1WW                       Yield [[1]].
   ;                      Concatenate with A.
    ð    µ/               Reduce [[1]] + A by the following, dyadic chain:
     0;                     Prepend a zero to the left argument (initially [1]).
                            This multiplies the left argument by "x".
        ×                   Take the product of both, unaltered arguments.
                            This multiplies the left argument by "r", where r is
                            the root specified in the right argument.
      _                     Subtract.
                            This computes the left argument multiplied by "x-r".
           ‘Ė’Uj€“x^”j”+  As before.

```
> 3 votes

# Answer
# MATL, 29 bytes

```
ljU"1@_hX+]tn:Pqv'+%gx^%g'wYD

```

Input is an array with the roots.

*EDITS:*

* *(May 20, 2016): the `X+` function has been removed, as `Y+` includes its functionality. So in the above code replace `X+` by `Y+`.*
* *(September 29, 2017): due to changes in the `YD` function, `w` in the above code should be removed.*

*The following link includes those changes.*

**Try it online!**

### Explanation

This applies repeated convolution with terms of the form `[1, -r]` where `r` is a root.

```
l          % push number 1
jU         % take input string. Convert to number array
"          % for each root r
  1        %   push number 1
  @_       %   push -r
  h        %   concatenate horizontally
  X+       %   convolve. This gradually builds array of coefficients
]          % end for each
tn:Pq      % produce array [n-1,n-2,...,0], where n is the number of roots
v          % concatenate vertically with array of coefficients
'+%gx^%g'  % format string, sprintf-style
w          % swap
YD         % sprintf. Implicitly display

```
> 4 votes

# Answer
# Ruby, 155 bytes

Anonymous function, input is an array of the roots.

Prints from lowest power first, so calling `f[[1,2]]` (assuming you assigned the function to `f`) returns the string `"2x^0+-3x^1+1x^2"`.

```
->x{j=-1
x.map{|r|[-r,1]}.reduce{|a,b|q=a.map{|c|b=[0]+b
b.map{|e|e*c}[1..-1]}
q.pop.zip(*q).map{|e|(e-[p]).reduce(:+)}}.map{|e|"#{e}x^#{j+=1}"}.join('+')}

```
> 2 votes

# Answer
## Python 3, 453 bytes (Spaces removed and more) -\> 392 bytes

```
import functools
import operator
print([('+'.join(["x^"+str(len(R))]+[str(q)+"x^"+str(r)if r>0else"{0:g}".format(q)for r,q in enumerate([sum(functools.reduce(operator.mul,(-int(R[n])for n,m in enumerate(j)if int(m)==1),1)for j in[(len(R)-len(bin(i)[2:]))*'0'+bin(i)[2:]for i in range(1,2**len(R))]if sum(1-int(k) for k in j)==p)for p in range(len(R))]) ][::-1]))for R in[input().split()]][0])

```

Check This link, Will help understand the reason behind those two imports.
> 1 votes

# Answer
# Haskell, 99

```
l%r=zipWith(-)(0:l)$map(r*)l++[0]
f e='0':do(c,i)<-zip(foldl(%)[1]e)[0..];'+':show c++"x^"++show i

```

prints the lower powers first, with an additional `0+` at the start. for example:

```
>f [1,1]
"0+1x^0+-2x^1+1x^2"

```

The function computes the coefficients by progressively adding more roots, like convolutions, but without the builtin.

Then we use the list monad to implicitly `concat` all of the different monomials.
> 0 votes

# Answer
## Sage, 38 bytes

```
lambda N:prod(x-t for t in N).expand()

```

Try it online

This defines an unnamed lambda that takes an iterable of roots as input and computes the product `(x-x_n) for x_n in roots`, then expands it.
> 0 votes

# Answer
# Mathematica, 26 bytes

```
Expand@Product[x-k,{k,#}]&

```

Mathematica has powerful polynomial builtins.

## Usage

```
  f = Expand@Product[x-k,{k,#}]&
  f@{3, 14, 15, 92}
x^4 - 124 x^3 + 3241 x^2 - 27954 x + 57960

```
> 0 votes

# Answer
## JavaScript (ES6), 96 bytes

```
a=>a.map(x=>r.map((n,i)=>(r[i]-=x*a,a=n),++j,r.push(a=0)),r=[j=1])&&r.map(n=>n+`x^`+--j).join`+`

```
> 0 votes

---
Tags: code-golf, polynomials
---


title: Split a Shakespeare Script

text:
# Question
Title: Split a Shakespeare Script
Mr. William Shakespeare wrote plays. A lot of plays. In this tarball containing every single one of his works, each one of his plays is one long file.
It needs to be split into Scenes for a stage production. Because actors are impatient, your code needs to be as short as possible.

## Task:

Your task is to write a program or function to split the plays contained in this file into separate files, numbered sequentially starting from `1`, where each one contains a scene. You should retain all whitespace and titles.

### Input:

Input will be a single play via `stdin`, or the filename as a parameter. You can choose. The play will look something like:

```
 TITUS ANDRONICUS

    DRAMATIS PERSONAE

SATURNINUS  son to the late Emperor of Rome, and afterwards
    declared Emperor.

BASSIANUS   brother to Saturninus; in love with Lavinia.

TITUS ANDRONICUS    a noble Roman, general against the Goths.

MARCUS ANDRONICUS   tribune of the people, and brother to Titus.

LUCIUS  |
    |
QUINTUS |
    |  sons to Titus Andronicus.
MARTIUS |
    |
MUTIUS  |

Young LUCIUS    a boy,
[...]
ACT I

SCENE I Rome. Before the Capitol.

    [The Tomb of the ANDRONICI appearing; the Tribunes
    and Senators aloft. Enter, below, from one side,
    SATURNINUS and his Followers; and, from the other
    side, BASSIANUS and his Followers; with drum and colours]

SATURNINUS  Noble patricians
[...]
ACT I

SCENE II    A forest near Rome. Horns and cry of hounds heard.

    [Enter TITUS ANDRONICUS, with Hunters, &c., MARCUS,
    LUCIUS, QUINTUS, and MARTIUS]

TITUS ANDRONICUS    The hunt is up, the morn is bright and grey,
    The fields are
[...]
ACT II

SCENE I Rome. Before the Palace.

    [Enter AARON]

AARON   Now climbeth Tamora
[...]
```

### Output:

The output should look something like this:

```
ACT I

SCENE I Rome. Before the Capitol.

    [The Tomb of the ANDRONICI appearing; the Tribunes
    and Senators aloft. Enter, below, from one side,
    SATURNINUS and his Followers; and, from the other
    side, BASSIANUS and his Followers; with drum and colours]

SATURNINUS  Noble patricians...
```

```
ACT I

SCENE II    A forest near Rome. Horns and cry of hounds heard.

    [Enter TITUS ANDRONICUS, with Hunters, &c., MARCUS,
    LUCIUS, QUINTUS, and MARTIUS]

TITUS ANDRONICUS    The hunt is up, the morn is bright and grey,
    The fields are...
```

```
ACT II

SCENE I Rome. Before the Palace.

    [Enter AARON]

AARON   Now climbeth Tamora ...
```

etc.

Output either into numbered files, or to the `stdout` stream (returning for functions) with a deliminator of your choice.

## Bonuses:

* 10% If you save the bit before Act 1 into file `0`. Note: It must not break if the bit before Act 1 is empty.
* 15% If you can take both `stdin` and a file path parameter inputs
* 20% If you can output both into files and to `stdout` / return.
* ~~**200 reputation** if you can make the smallest SPL program.~~ This bounty has been awarded.

## Leaderboards

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

```
# Language Name, N bytes

```

where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:

```
# Ruby, <s>104</s> <s>101</s> 96 bytes

```

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:

```
# Perl, 43 + 2 (-p flag) = 45 bytes

```

You can also make the language name a link which will then show up in the leaderboard snippet:

```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

```

```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```

```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table><script>var QUESTION_ID=68997,OVERRIDE_USER=43394;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?([\d\.]+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;</script>
```

# Answer
> 39 votes
## Shakespeare Programming Language 1.2.1, ~~930~~ ~~895~~ 887 - 10% = 798.3 bytes

```
G.Ajax,a.Puck,a.Page,a.Ford,a.Act I:a.Scene I:a.[Enter Ajax and Puck]Puck:Open thy mind.Ajax:Open thy mind.[Exit Puck][Enter Page]Ajax:Open thy mind.SCENE II:b.[Exeunt][Enter Puck and Ajax]Ajax:Am I as fat as the sum of the cube of a big big cat and a cat?Puck:If not,let us return to scene III.Am I as fat as the sum of you and a big cat?[Exit Puck][Enter Page]Page:If not,let us return to scene III.Am I as fat as the sum of the sum of the cube of a big big cat and a big big big big cat and a big big cat?[Exit Page][Enter Ford]Ajax:If not,let us return to scene III.You is a big big big big big big cat.Speak thy mind.Scene III:c.[Exeunt][Enter Ajax and Puck]Puck:Speak thy mind.You is as fat as I.[Exit Ajax][Enter Page]Page:You is as fat as I.Puck:Open thy mind.Is you as fat as a hog?[Exit Page][Enter Ajax]Puck:If not,let us return to Scene II.Speak thy mind.Ajax:Speak thy mind.

```

Ungolfed and rewritten in Sharkspearean language:

```
Four Gentlemen of Verona.

Ajax, a master code-golfer with years of experience.
Puck, a young Java programmer and a strong believer in object-oriented design patterns.
Page, a rapscallion of ill repute.
Ford, a car manufacturer.

Act I: A one-act masterpiece.

Scene I: In which many minds are opened, possibly via the consumption of psychadelic drugs.
[Enter Ajax and Puck]
Puck: Open thy mind.
Ajax: Open thy mind.
[Exit Puck]
[Enter Page]
Ajax: Open thy mind.

SCENE II: In which things are compared.
[Exeunt]
[Enter Puck and Ajax]
Ajax: Am I as hairy as the sum of the cube of a furry purple chihuahua and a summer's day?
Puck: If not, let us proceed to scene III. Am I as half-witted as the sum of you and a cunning squirrel?
[Exit Puck]
[Enter Page]
Page: If not,let us proceed to scene III. Am I as delicious as the sum of the sum of the cube of a warm healthy hamster and a proud handsome charming noble nose and a big old aunt?
[Exit Page]
[Enter Ford]
Ajax: If not, let us proceed to scene III. You are the cube of a tiny small pony. Speak thy mind.

Scene III: In which minds are spoken.
[Exeunt]
[Enter Ajax and Puck]
Puck: Speak thy mind. You are as smelly as I.
[Exit Ajax]
[Enter Page]
Page: You are as oozing as I.
Puck: Open thy mind. Are you as disgusting as a Microsoft?
[Exit Page]
[Enter Ajax]
Puck: If not,let us return to Scene II. Speak thy mind.
Ajax:Speak thy mind.

```

In C-like psuedocode:

```
Scene_I:
    Ajax = getchar()
    Puck = getchar()
    Page = getchar()
Scene_II:
    if(Ajax != 'A')
        goto Scene_III
    if(Puck != 'C')
        goto Scene_III
    if(Page != 'T')
        goto Scene_III
    Ford = '@'
    putchar(Ford)
Scene_III:
    putchar(Ajax)
    Ajax = Puck
    Puck = Page
    Page = getchar()
    if(Page != -1)
        goto Scene_II
    putchar(Ajax)
    putchar(Puck)

```

Requires the input file contains at least 3 characters. Uses "@" as a delimiter and reports results to stdout. I'm taking the 10% bonus since the part before the first scene will be before the first "@", much like Martin Büttner's solution above.

The way it works is to put a "@" if it sees three characters "ACT" in a row. Note this means it would transform "ENACTED" into "EN@ACTED". This can be fixed at the cost of a few hundred bytes, but luckily it seems every "ACT" in the given plays (at least the few I checked) was the beginning of a scene.

Tested with the 1.2.1 SPL linked above. I'm not sure if it will work on the web interpreter. The script used for testing was:

```
#!/bin/bash
set -e
SCRIPT_DIR=`dirname "$0"`
cd "$SCRIPT_DIR"
spl/bin/spl2c <splits.spl >splits.c
gcc -O2 -Wall -Wno-unused -I./spl/include -L./spl/lib -lm -lspl -o splits splits.c
./splits <measureforemeasure >measure.split.txt

```

The "esoteric" parts of the SPL once you get past the syntax are the shuffling of variables on "stage" (generally, you only want to have two characters on stage at a time) and the representation of constant numbers. There are 6 word lists of import that come with the distribution: positive adjectives, neutral adjectives, negative adjectives, positive nouns, neutral nouns, and negative nouns. A positive/neutral noun (ie plum or stone wall) is 1, and a negative noun (ie flirt-gill or Microsoft) is -1. Positive/neutral adjectives (ie embroidered or bottomless) multiply the number by 2, and negative adjectives (ie fat-kidneyed or fatherless) multiply by -2. The word lists are sadly rather limited, with only 10-20 entries each.

At my next meeting, I'll be suggesting we move all our production code to Shakespeare because it's far more expressive than Scala.

# Answer
> 13 votes
## Retina, 9 - 10% = 8.1 bytes

Byte count assumes ISO 8859-1 encoding.

```
¶ACT
=$0

```

Inserts a `=` (as a delimiter) in front of every `ACT` that is preceded by a linefeed and followed by a space.

Try it online! (But you'll have to copy in the input yourself due to its size.)

# Answer
> 4 votes
# awk, 51 * .9 * .85 * .8 = 31.2

Splits into multiple files. Outputs on `stdout` separated by a `=`.

```
/^ACT/{f++;$0="="$0}{system("echo \""$0"\">>"f*1)}1

```

# Answer
> 3 votes
# JavaScript ES6, 28 - 10% = 25.2 bytes

```
s=>s.replace(/\nACT/g,"=$&")

```

Not even the JS shell has file I/O so this can't qualify for the -20% bonus

Try it online here (you'll have to paste the input in yourself)

# Answer
> 3 votes
## Perl, 66 - 10% - 20% = 47.52 bytes

```
BEGIN{open(S,">0");}++$?,open(S,">$?"),print"=\n"if/^ACT/;print S

```

Added one for the `-p` option.

# Answer
> 1 votes
# Ruby, 30 - 10% - 15% = ~~23.715~~ 22.95 bytes

Splits input on `$`. 15% bonus applies because Ruby redirects `$<` to point at the file passed into `ARGV` by default if it's supplied, or `STDIN` if not.

-1 byte by leveraging `gsub` similar to @Downgoat ES6 solution but I'm still leveraging the hope that `ACT` only ever appears at the ACT labels and not inside any other word, just because

```
$><<$<.read.gsub("ACT","$ACT")

```

Also, my **41.004** (originally 67) byte solution that also does file output. Starring probably the only time the `each` command saves bytes over `map` in Ruby, because `each` returns the array passed in unadulterated after running its block, unlike `map`.

```
i=-1;$><<$<.read.split(/(?=ACT)/).each{|s|open("#{i+=1}",?w)<<s}*?$

```

---
Tags: code-golf, string
---


# Question
Title: How to find the item in a list whose f(item) is the smallest?
I have a list, `l` and a function `f`. `f` is not strictly increasing or decreasing. How can I find the item in the list whose `f(item)` is the smallest? For example, let's say the list is:

```
l = [1, 2, 3, 4]

```

and `list(f(x)for x in l)` is:

```
[2, 9, 0, 3]

```

`f(3)` is smaller than f of any of the other ones, so it should print "3". What's the shortest way to do this? I initially tried:

```
min(f(x) for x in l)

```

But this gives `0`, not `3`. If I was shooting for readability, not brevity, I would do:

```
index = 0
smallest = f(l[0])
for i in range(len(l)):
    value = f(l[i])
    if value < smallest:
        smallest = value
        index = i

```

This is fine, but horrendous for code-golf. Even if it was golfed

```
i,s=0,f(l[0])
for x in range(len(l)):
 v=f(l[x])
 if v<s:s,i=v,x

```

This is a bad solution. The shortest solution I can think of is:

```
g=[f(x)for x in l];print(l[g.index(min(g))])

```

(44 bytes) How can I golf this down further?

# Answer
> 10 votes
## Use `key` property of `min`

As @vaultah said, use `min(l,key=f)`. `min(l,key=f)` takes the minimum of `f(i)` for `i` in `l`.

It is also possible to apply this to `max`, and `sorted`. For example, `max(l,key=f)` is the maximum of `f(i)` for `i` in `l`. For `sorted`, the usage would be: `sorted(l,key=f)`.

---
Tags: code-golf, tips, python
---


# Question
Title: Restricted average (arithmetic mean) – i.e. without obvious built-ins
### Introduction

The arithmetic mean is defined as being equal to the sum of the numerical values of each and every observation divided by the total number of observations. Symbolically, if we have a data set containing the values *a*1,…,*an*. The arithmetic mean *A* is defined by the formula

### Objective

The challenge here is, given a non-empty list of observations, to calculate the arithmetic mean without any built-ins for mean, sum, division, or count. All other operations are allowed, e.g. median, product, multiplication, and sequence generation.

If your language cannot process lists without knowing the number of elements it has, you may use a counting built-in for such (looping, loading, etc.) purpose **only**, but not for the actual computation.

### Test cases

`[5]``5`
`[1,-2]``-0.5`
`[6,1,3]``3.333333333`

If your language can handle complex numbers:

`[5,1+3i]``3+1.5i`

# Answer
# Pyth, 13 bytes

```
l@*F^L2Qhe.ek

```

Try it online!

Uses exponential arithmetic to replace sum and division.

Uses enumerate to find number of elements.
> 1 votes

# Answer
# Retina, ~~46~~ 37 bytes

```
+`x;
;x
;x
;;:x
;
x
^(x+):(\1)*x*
$#2

```

Try it online!

It's quite a trouble not to use arithmetic...
> 1 votes

---
Tags: code-golf, arithmetic, restricted-source, counting, statistics
---


# Question
Title: Find the last three words of each paragraph if they are shorter than 20 characters in total
Based on my SO question, but more specifically:

Find a RegEx such that, given a text where paragraphs end with an empty line (or `$` at the very end), match the up to twenty last characters of a paragraph excluding the `\r` or `$` but no more than three *complete* "words" including the "separators" in between and the punctuation following it. The following constraints apply:

* "words" also include abbreviations and the like (and thus punctuation), i.e. "i.e." and "non-trivial" count as one word each
* whitespaces are "separators"
* isolated dashes do not count as "words" but as "separators"
* "separators" *before* the first word must not be included
* trailing punctuation counts to that limit, but not the leading one nor the linebreaks and `$` that must not be in the matching group
* whether trailing punctuation is included in the match or not is up to you

Some examples:

> The early bird catches the **worm. Two words.**
>
> But only if they got **up - in time.**
>
> Here we have a supercalifragilisticexpialidocious **etc. sentence.**
>
> **Short words.**
>
> Try accessing the **.html now, please.**
>
> Vielen Dank **und viele Grüße.**
>
> Did **any-one try this?**

Score is given in bytesteps: bytes multiplied by amount of steps according to https://regex101.com, but there are three penalties:

* if the upper limit of words cannot *trivially*+ be modified: +10%
* if the upper limit of character count cannot *trivially*+ be modified: +10%
* failure to handle unicode used in actual words: add the percentage of world population speaking the language according to Wikipedia the failing word stems from. Example: Failing to match the German word "Grüße" as a word =\> +1.39%. Whether you consider a language's letters as single characters or count the bytes to utf8-encode them is up to you. The penalty does not have to be applied before someone actually provides a counter-example, so feel free to demote your competitors ;)

Since this is my first challenge, please suggest any clarifications. I assume means there are no "loopholes" to exclude.

---

+ With *trivially* modified I mean expressions such as `{0,2}` and `{21}` are valid but repeating something three times (which would have to be re-repeated to increase the amount words) is not.

# Answer
> 3 votes
# ~~37 bytes * 1403 steps = 51911 bytesteps~~

# ~~34 bytes * 1036 steps = 35224 bytesteps~~

# 37 bytes * 666 steps = 24642 bytesteps

```
(?<!\S)(?!.{21})\S+(( | - )\S+){0,2}$

```

Verify it here!

---
Tags: string, code-challenge, parsing, regular-expression
---