10 PRINT CHR$(205.5+RND(1)); : GOTO 10 in PHP (or anything else, for that matter)

Question

Just had a 'spirited' conversation with a co-worker about the succinctness of the following BASIC statement:

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

It's the title of this book, and will simply print a sequence of / and \ characters, alternating between the two randomly, resulting in a pattern similar to this:

(Image borrowed from http://www.flickr.com/photos/rndmcnlly/5058442151/sizes/o/in/photostream/)

Being of a PHP proclivity, we wondered what the most compact way of writing the same thing in PHP would be, and came up with this:

while(1) { echo chr(47 + 45 * rand(0,1)); }

chr(47) is a / character, and chr(92) is a \. So the statement echo chr(47 + 45 * rand(0,1)); will randomly alternate between the two, ad nauseam.

In a language of your choosing, write the shortest program or function to output an infinite random sequence of \ and / characters, where each character has an equal probability of being chosen.

Answer 1

PowerShell, 108 90 86 54 53 37 36 bytes

for(){Write-Host "\/"[(Random 2)]-n}

Try it online!

Answer 2

Java 8, 60 59 54 53 bytes

v->{for(;;)System.out.write(Math.random()<.5?47:92);}

-1 byte thanks to @BenjaminUrquhart by replacing print with write, so '/' can be 47.

Explanation:

Try it online (times out after 60 sec).

v->{                     // Method with empty unused parameter and no return-type
  for(;;)                //  Loop indefinitely
    System.out.write(    //   Print:
      Math.random()<.5?  //    If the random decimal value in range [0,1) is below 0.5:
       47                //     Print forward slash
      :                  //    Else:
       92);}             //     Print backward slash

Answer 3

Cubix, 10 bytes

Du\'^>o$/;

Watch it run

    D u
    \ '
^ > o $ / ; . .
. . . . . . . .
    . .
    . .

Was an interesting one to do as i haven't played with the random direction generator much.

• ^D redirect to the random direction pointer

Directed north

• o\> loops around the cube, print empty stack and redirecting back into the print commands (stack is empty)

Directed west

• ^ redirected back into the random direction pointer

Directed south

• \'/> reflected to the east, push / onto the stack and redirect into the print commands

Directed east

• u'\> uturn to the right, push \ onto the stack and redirect into the print commands

Print commands

• o$/;^ output top of stack, skip over the reflect, pop from the stack and redirect into the random direction pointer

Answer 4

Python, 61 bytes

from random import*
while 1:print('/\\'[randint(0,1)],end='')

Pretty self explanatory. Had to use the double backslash since backslashes are escape characters in Python.

Try it Online!

Answer 5

R, 33

Just interested to see whether this can be made smaller.

while(1)cat(sample(c('/','\\'),1))

Answer 6

JavaScript (Node.js), 59 55 54 bytes

Original Answer

while(1){process.stdout.write(Math.random()>=0.5?"/":"\\")}

-4 bytes thanks to manatwork

while(1)process.stdout.write(Math.random()<.5?"/":"\\")

-1 byte thanks to Conor O'Brien

for(;;)process.stdout.write(Math.random()<.5?"/":"\\")

Answer 7

BRASCA, 13 12 bytes

1[`/\`1?#$o]

Try it online!

Explanation

1[         ]  - While 1:
  `/\`       -   Push \ and /
      1?      -   Push rand(0,1)
        #$    -   If truthy, swap the top two items, else skip.
          o   -   Print it!

Answer 8

Add++, 19 bytes

D,f,,"\/"BX
Dx,$f,o

Try it online!

How it works

D,f,,    ; Define a function, f
    "\/" ; Push "\/"
    BX   ; Random choice

Dx,      ; Do, while x:
   $f,   ; Set x to the result of f
   o     ; Output with no newline

Answer 9

Python 3, 52 51 bytes

from random import*
while 1:print(end=choice('\/'))

Try it online!

Saves at least 9 bytes over other python solutions here.

Edit: saved a byte via ayreguitar's comment

Answer 10

I guess you can use recursion.

function slashes() {echo chr(47 + 45 * rand(0,1)); slashes();}

---

I guess you can use recursion.

function slashes() {echo chr(47 + 45 * rand(0,1)); slashes();}

---

...

Answer 11

Perl

This one looks funny for me :

perl -pe '$_="~"ge$_?"/":"\\"' </dev/urandom

(Sorry to be out of subject here. I know this is not PHP)

Answer 12

Powershell, 37 bytes

for(){Write-Host(Random("\","/"))-N}

unfortunately there seem to be no shorter aliases for Write-Host that don't cause a new line after every char.

Answer 13

Fission, 12 bytes

[#"\"R
W\"/"

Try it online!

Answer 14

Tcl, 53 bytes

while 1 {puts -nonewline [expr rand()<.5?"/":"\\\\"]}

Try it online!

Answer 15

Perl 6, 23 bytes

loop {<\ />.pick.print}

• loop loops forever.
• <\ /> is a list of the strings \ and /.
• .pick picks one of the two strings randomly.
• .print prints that random string.

Answer 16

Pyth - 12 9 bytes

#@,\/\\O2

Tested without loop code because the online interpreter dislikes infinite loops

Explanation:

#@,\/\\O2
#             Repeat until Error
 @            Implicitly print item number
       O2     random number between zero and two exclusive
  ,           of two item list containing
   \/         One character string /
     \\       One character string \

Answer 17

Add++, 24 bytes

+1
W,R2,-1,*45,+47,H,x:1

Try it online!

Answer 18

q/kdb+, 18 bytes

Solution:

while[1;1"\\/"1?2]

Explanation:

A simple while(true) loop...

while[1;1"\\/"1?2] / the solution
while[1;         ] / while true do ...
              1?2  / 1 choose 2 (0 or 1)
         "\\/"     / string \/, index in at 0 or 1
        1          / print to stdout without newline

Extras:

Another 18 byte solution: {1"\\/"1?2}\[::;1]

Answer 19

MathGolf, 8 bytes

1Æû\/wq∟

Try it online!

Explanation

1          push 1
 Æ     ∟   do-while-true without popping using 5 operators
  û\/      push "\/"
     w     random char from string
      q    print without newline

Implicit popping doesn't seem to be working as intended when using do-while-true, or any other loop type. With this working correctly, the first 1 could be removed.

For a "working" 7-byter, you could do t{û\/wq, which replaces the do-while-true with a simple for loop, and begins the script by pushing the current timestamp in milliseconds to the stack. Currently, that means about \$1.56*10^{12}\$ iterations, which is "infinite" for most applications. However, this is not a valid answer, so the official answer is still 8 bytes.

Answer 20

APL (Dyalog Unicode), 12 bytes

→≢⍞←'/\'[?2]

Try it online!

Tradfn body that prints indefinitely.

Thanks to @Adám for 5 bytes, and for pointing out that, with a little bit of CSS magic, TIO can print the actual pattern like in the image.

How:

→≢⍞←'/\'[?2] ⍝ Tradfn body
         ?2  ⍝ Roll (randomly select) an integer between 1 and 2
        [  ] ⍝ Use the result to index...
    '/\'     ⍝ ...the string containing the two slashes
  ⍞←         ⍝ Print it to the same line
 ≢           ⍝ Tally the result (yields 1)
→            ⍝ then 'goto' that line

Answer 21

Runic Enchantments, 13 bytes

`/-R`A*+k$!;

Try it online!

Slightly ungolfed for readability, with spaces to separate operational segments:

'/  2'RA  '- *+k $ !;

The difference of 45 is encoded in the - char literal, as chars are implicitly converted to integers when fed into a operator expecting a number value.

2'RA randomly generates a 0 or a 1, multiplied against the - and added to the / char resulting in either / or \, which is then printed after being coerced back to a char from an int. In the golfed version the  (0x02) serves as the 2.

Then the program loops forever by skipping the terminator, !;.

Answer 22

><>, 12 bytes

x!\"/!
^o< <

Try it online!

The idea here is to use x in combination with the ^ below to both loop and choose a random horizontal direction. If the IP goes left from the x, it will skip the mirror / and quote the string "\!x!/", reflect upwards with \, wrapping around to the <, which redirects the IP to output the result and begin the loop again. If the IP goes right from the x, a similar thing will happen.

This is all thanks to the nice happenstance that / and \ are control flow modifiers in ><>, allowing us to save a ".

An alternative solution for 13 bytes is slightly more generic and generates a lot fewer side effects.

xa!o"/\"o!a
^

(You can replace the as with spaces; I have them placed here for clarity. In production code, you would want to do this replacement to avoid unnecessary stack population.)

Answer 23

Clojure, 34 bytes

(loop[](pr(rand-nth"\\/"))(recur))

Answer 24

Zsh, 42 bytes

for ((;;))printf ${(#)$((RANDOM%2?47:92))}

try it online

Answer 25

AppleSoft BASIC, 33 bytes

33 bytes, verified here

1?MID$("\/",RND(1)+1.5,1);:GOTO1

35 bytes, using CHR$ conversion similar to C64.

1?chr$(47+45*int(2*rnd(1)));:goto1

Answer 26

Factor + qw, 33 bytes

[ qw{ / \ } random write t ] loop

Try it online!

Answer 27

Lua 5.4, 49 bytes

::a::io.write(2>math.random(2)and"\\"or"/")goto a

Try it online!

Answer 28

Yabasic, 27 bytes

-1 byte thanks to @ayreguitar

Mid$("\/",...) is used over Chr$() as the character codes for / and \ are 47 and 92, respectively.

While the GoTo structure of the original could easily be used for this yabasic answer, Do...Loop ends up being shorter due to the the structure of the Mid$ call.

Do?Mid$("\/",Ran(3),1);Loop

Try it online!

Answer 29

Rust, 143 bytes, std only

use std::hash::*;fn main(){loop{print!("{}",b"/\\"[std::collections::hash_map::RandomState::new().build_hasher().finish()as usize%2]as char);}}

Attempt This Online!

This mess is because the Rust stdlib (at the time of writing) has no "proper" RNG API. So, I had to use the workaround described here to get a random number.

Answer 30

Go, 78 bytes (fixed seed)

package main
import."math/rand"
func main(){for{print(string(`/\`[Intn(2)]))}}

Attempt This Online!

Prints to STDERR.

Random seed, 107 bytes

package main
import(."math/rand";."time")
func main(){Seed(Now().Unix())
for{print(string(`/\`[Intn(2)]))}}

Attempt This Online!

Also prints to STDERR.