Wiki: R

Basics

Looping

The usual for(x in ...) is usually used, but array manipulation is often used to golf bytes off. For example:

for(x in commandArgs(1))write(x*50,1)
write(commandArgs(1)*50,1,1)

Output

There are two ways to output, cat and write:

write(...,1)
cat(...,"
")

When outputting with paste0 to join a vector into a string by nothing:

write(paste0(vector),1)
cat(vector,"
",sep="")

If you are outputting three args to cat, you can abuse the sep function, but note only strings can be used in it and that x and y cannot be vectors and have to be strings or this won't work:

cat(x,"/",y,sep="")
cat(x,y,sep="/")

If statements

The if statements that are commonly used:

"if"(cond,x,y)
c(y,x)[1+(cond)]

"if" usually beats using vector indexing because you don't need to put >0, and using a list requires turning the condition into an integer and adding 1 since R uses base 1-index vectors.

Vector indexing is occasionally used though in replacement of rep. Say we want to print a string if a condition is true:

rep(str,cond)
str[cond]

Using [] will ensure that if the condition is true it will return the entire string and if not nothing. This works with multiple items too:

cat(paste0(rep(c("o",str),cond)))
cat(paste0(c("o",str)[cond]))
cat(c("o",str)[cond],sep="")

Builtins

R, as a statistical language, has tons of builtins and functions that are very useful when golfing. Here are some of them:

seq
diff
rle                # Run Length Encoding
embed
gl                 # Generate factors by specifying the pattern of their levels
letters            # 'a','b','c'...
LETTERS            # 'A','B','C'...
month.abb          # 'Jan','Feb','Mar'...
month.name         # 'January','February','March'...
T                  # TRUE
F                  # FALSE

T and F are very powerful because you don't need to initialize a variable to 1 or 0 at the start of your code.

Aliases

We can define short aliases for functions using backticks for two arguments using primitive operators:

`+`=paste
x+y                # paste(x,y)

(There is a way to define a short alias for functions with 3 or more arguments)

Coercion

Some examples of using coercion to avoid using long functions:

as.integer("19")
("19":1)[1]
el("19":1)

as.character(19)
paste(19)

`outer` function

outer is a fairly strong function. It takes the two arrays and applies a vectorized function. It acts like Julia's array manipulation feature:

x=1:3
println(x*x')

# [1 2 3; 2 4 6; 3 6 9]

In R:

x=1:3
write(outer(x,x,"*"),1)

# 1 2 3 2 4 6 3 6 9

You can place any operator or function (with quotes around it) in the third argument for outer.

outer(X,Y,"*") can also be rewritten as:

X%*%t(Y)           # %*% is matrix vector multiplication

Or even better:

X%o%Y

`rep()` alternatives

Even though rep() is already fairly short, we can save a few more bytes by using : and vector recycling.

Repeating n zeroes (n>0) - !1:n or 0*1:n instead of rep(0,n)

Repeating n ones - !!1:n instead of rep(1,n)

Repeating x n times - x+!1:n instead of rep(x,n)

Using modular arithmetic to avoid `each` args in `rep`

There aren't too many uses of this, but when you encounter one, you will probably need some creativity to come up with some "formula".

Generating the vector c(-1,-1,-1,0,0,0,1,1,1) is easily done with rep(-1:1,e=3), but you can use modular arithmetic to save bytes:

-3:5%/%3

Random Tips

Use <- instead of = to remove brackets, so while(x<-...) instead of while((x=...))
Length of vector: sum(v|1) instead of length(x)
Last element of vector: tail(x,1) instead of x[length(x)]
"if": "if"(x<y,7,9) instead of if(x<y)7 else 9
el to extract an item from a list with strsplit: so el(strsplit(x,"")) instead of strsplit(x,"")[[1]]
floor: x%/%9 instead of floor(x/9)
Map: Map(function,vector) instead of sapply(vector,function)

Packers

3:1

eval(parse(t=intToUtf8(outer(utf8ToInt("..."),97:99,`%%`)+32)))

2:1

eval(parse(t=iconv("...",,"utf16")))