Can (a==1 & a==2 & a==3) ever evaluate to TRUE?
A blogpost inspired by a Stackoverflow question: “Can (a==1 && a==2 && a==3) ever evaluate to true?”
Yesterday I run into this topic on SO, about a JavaScript question a user had during a job interview.
The question is quite straightforward:
Is it ever possible that (a==1 && a==2 && a==3) could evaluate to true, in JavaScript?
As a little challenge, I asked myself the same question, but with R (and
with a little transformation): can a==1 & a==2 & a==3 ever evaluate to
TRUE? Once I’ve found how to, I challenged
Twitter, and
was glad to read some creative answers.
One amazing thing with R is that you can achieve the same result by taking several roads. So, here are a compilation of the answers I received.
First question
Ok \#RStats nerds, here's a little enigma for your sunday :)
— Colin Fay (@\_ColinFay) January 21, 2018
How can you make:
x == 1 & x == 2 & x == 3
return
\[1\] TRUE pic.twitter.com/toV55YhjQJ
Overriding base functions
- By Philippe Chataignon :
x <- 1
`&` <- function(x,y) {T}
x == 1 & x == 2 & x == 3
## [1] TRUE
- By Quentin Read :
`&` <- function(x,y) {T}
x == 1 & x == 2 & x == 3
## [1] TRUE
Number 2
\#RStats nerd quizz number 2 :
— Colin Fay (@\_ColinFay) January 21, 2018
How would you code that?
\> x == 1 & x == 2 & x == 3
\[1\] TRUE
\> x == 3 & x == 2 & x == 1
\[1\] FALSE pic.twitter.com/Tqm0bNz1De
Overriding base functions
- By Antonios K :
x = 1; `&` <- `>`
x == 1 & x == 2 & x == 3
## [1] TRUE
x == 3 & x == 2 & x == 1
## [1] FALSE
- By Jorge Loria :
x <-1
`&` <- function(e1,e2) e1
x == 1 & x == 2 & x == 3
## [1] TRUE
x == 3 & x == 2 & x == 1
## [1] FALSE
Question 3
\#RStats nerd quizz number 3 :
— Colin Fay (@\_ColinFay) January 21, 2018
Find how to:
\> x
\[1\] 1
\> x
\[1\] 2
\> x
\[1\] 3 pic.twitter.com/dskLLHdS6d
A really nice way to frame it
make_x <- function(){
counter <- 1
inc <- function() counter <<- counter + 1
value <- function() counter
structure(list(inc = inc, value = value), class = "x")
}
print.x <- function(x){
v <-x$value()
x$inc()
print(v)
v
}
x <- make_x()
x
## [1] 1
x
## [1] 2
x
## [1] 3
- As suggested by Joel Gombin
rm(list=ls())
library(R6)
make_x <- R6Class("x",
public = list(x = 1,
print = function(){
print(self$x)
self$x <- self$x + 1
}
)
)
x <- make_x$new()
x
## [1] 1
x
## [1] 2
x
## [1] 3
x <- structure(0L, class = "x")
print.x <- function(x) print(as.integer(x <<- x + 1L ))
x
## [1] 1
x
## [1] 2
x
## [1] 3
Sadly, these three solutions don’t answer the three questions in one shot.
One answer to rule them all
One answer that can do the three at once, by Alek Vladimir Nevski.
x <- c(1,1)
`==` <- function(foo,bar){foo[1]+bar}
`&` <- function(foo,bar){
if(isTRUE(foo) || identical(foo,FALSE)){
foo+2<bar
}else{
foo < bar
}
}
class(x) <- c("myclass",class(x))
print.myclass = function(x){
t <- x[2];
x[2] <<- x[2]+1;print(t)
}
# First quizz :
x == 1 & x == 2 & x == 3
## [1] TRUE
# Second quizz :
x == 1 & x == 2 & x == 3
## [1] TRUE
x == 3 & x == 2 & x == 1
## [1] FALSE
# Third quizz :
x
## [1] 1
x
## [1] 2
x
## [1] 3
With active binding
What I had in mind from the beginning was to use active binding. I’ll let you dig into this blogpost if ever you want to know more about it, but basically we bind a function to a symbol instead of a value (which is static binding).
It is called active because each time you evaluate this symbol, R executes a function, instead of looking for a value.
So, here’s my way to answer the “Can (a==1 && a==2 && a==3) ever evaluate to true?”:
rm(list=ls())
makeActiveBinding(sym = "x", env = .GlobalEnv,
fun = function(value){
if (missing(value)) {
if (i == 3){
i <<- 1
} else {
i <<- i + 1
}
return(i)
}
}
)
i <- 0
# First quizz :
x == 1 & x == 2 & x == 3
## [1] TRUE
# Second quizz :
x == 1 & x == 2 & x == 3
## [1] TRUE
x == 3 & x == 2 & x == 1
## [1] FALSE
# Third quizz :
x
## [1] 1
x
## [1] 2
x
## [1] 3
Here, the difference is that the values are actually equal: we’re not
changing the way == or & behave - it’s the value of x that is
changing each time we’re calling it. With active binding, R is executing
the function defined in fun, a function that takes i, restarts the
counter or incremente it of 1, and returns it.
How is this interesting?
Beside being a nice R brain game, this example is a nice occasion to
introduce about the concept of binding, and remind that we are most of
the time assuming is static: most of the answers (in fact, all except
one) assume that the value of x is static, and that we should tweak
the other operators :)
Read more about binding:
What do you think?