# 10 PRINT CHR$(205.5+RND(1)); : GOTO 10 in PHP (or anything else, for that matter) 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.

• You can lose the {} braces, but that's about as concise as you can make it. Dec 7, 2012 at 16:23
• This is cool. What font can be used to get a similar image? Dec 9, 2012 at 19:24
• This (picture) reminds me of the first "program" I ever wrote on my commodore 64 straight out of the manual :) ah happy days
– Dale
Apr 9, 2013 at 13:31
• @daniero I think the actual typeface is called Terminal, but I found it online as "Windows Command Prompt" codepen.io/nickforddesign/pen/WMqQdM?editors=0110 Mar 5, 2018 at 20:49
• It's a general pro tip: for(;;) is always shorter than a while Jul 13, 2021 at 15:49

# 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!

# R, 33

Just interested to see whether this can be made smaller.

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


# JavaScript (Node.js), 5955 54 bytes

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?"/":"\\")

• Welcome to the site! Mar 21, 2018 at 20:30
• No need for braces around a single instruction block; in JavaScript the 0 integer part can be left out; reverse the conditional to use single character operator: while(1)process.stdout.write(Math.random()<.5?"/":"\\"). Mar 21, 2018 at 20:32
• @manatwork Thanks! Updated. Mar 22, 2018 at 15:17
• You can also write for(;;) instead of while(1) Mar 22, 2018 at 15:19
• Thank you as well. Added. Mar 22, 2018 at 15:41

# 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!



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


# 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

• Nice use of end! But as @Jonathan Frech pointed out in the first Python entry, no need to escape the \ if you reverse the order, saving 1 byte: while 1:print(end=choice('\/')) Jul 2, 2022 at 21:50

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();}


...

• stack space is not infinite. Dec 7, 2012 at 16:25
• @codaddict so it will timeout. Dec 7, 2012 at 16:26
• Assuming a considerably high timeout your snippet is not equivalent to the OP's. Dec 7, 2012 at 16:31
• @codaddict lol the OPs times out as well. it is an infinite loop! Dec 7, 2012 at 16:31
• Yours would create a run time error before the timeout. Dec 7, 2012 at 16:33

chopped off one character:

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


then remove the curly braces:

while(1) echo chr(2+45*rand(1,2));


another trick, with the same length:

while(1) echo chr(rand()%2*45+47);

• Due to the algorithm it employs, rand()%2 will result in an alternation of 0s and 1s. Not incredibly random. You'd need to use rand(0,1) or mt_rand()%2 instead. Dec 8, 2012 at 15:06

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

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

# Fission, 12 bytes

[#"\"R
W\"/"


Try it online!

# Tcl, 53 bytes

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


Try it online!

# 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.
• instead of loop, you can use xx*
– Jo King
Jul 20, 2019 at 13: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 \


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


Try it online!

# 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]

# Japt, 9 bytes

iOo"/\\"ö


Try it

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

# APL (Dyalog Unicode), 12 bytes

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


Try it online!

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

• This is eligible for 200 rep, no?
Jul 24, 2019 at 20:18
• @Adám is it? I've no idea why it would. Jul 24, 2019 at 20:37
• This.
Jul 24, 2019 at 20:38
• Oh, I see. I guess it is, then? There were no answers in any APL flavour before mine, and it meets all the conditions in the post. I'll add my request to it. Jul 24, 2019 at 20:49
• Cool, and feel free to dig up any of your posts from since February. I have way too much rep.
Jul 24, 2019 at 20:51

# Runic Enchantments, 13 bytes

/-RA*+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, !;.

# ><>, 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.)

## Clojure, 34 bytes

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


# Zsh, 42 bytes

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


try it online

# 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  # Factor + qw, 33 bytes [ qw{ / \ } random write t ] loop  Try it online! # Lua 5.4, 49 bytes ::a::io.write(2>math.random(2)and"\\"or"/")goto a  Try it online! • also 49 bytes: ::a::io.write(({"\\","/"})[math.random(2)])goto a – c-- Apr 29 at 23:35 # 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 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!

• I don't know Yabasic, but from the TIO link you can save a byte by using "\/" instead of "/\\", like you can in Python (and I guess this works in some other languages) Aug 29, 2022 at 20:45

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

# Mathematica - 36 Bytes

Barebones with no formatting. I don't know why the slashes are different thickness

Grid@RandomChoice[{"/","\\"},5{8,5}]


• Welcome to Code Golf, and nice answer! Looks like the thickness just has to do with the font, since it's only the backslashes that are thicker. Sep 29, 2022 at 17:44

# Python, 66 bytes

import random
while 1:print(chr(47+random.randint(0,1)*45),end='')


Try it online!

Ungolfed:

import random
while True:
slash_calc = 47 + random.randint(0, 1) * 45
print(chr(slash_calc), end='')