Create a sequence between two letters

Question

I want to create a sequence between two letters let's say "b" and "f". So the output is

"b" "c" "d" "e" "f"

For numbers, we can do

2:6 #which gives output as 
[1] 2 3 4 5 6

Is there an easy way to do this with letters as well?

I have gone through Generate a sequence of characters from 'A'-'Z' but this produces all the letters and not sequence between specific letters.

My current solution is,

indx <- which(letters %in% c("b", "f")); 
letters[indx[1] : indx[2]]

#[1] "b" "c" "d" "e" "f"

This works but I am curious if there is an easy way to do this or a function in any of the package that I have missed?

Note: I do not want letters[2:6] as I do not know 2 and 6 beforehand. It could be between any two letters.

Answer 1

This would be another base R option:

letters[(letters >= "b") & (letters <= "f")]
# [1] "b" "c" "d" "e" "f"

Answer 2

You can create your own function:

`%:%` <- function(l, r) {
    intToUtf8(seq(utf8ToInt(l), utf8ToInt(r)), multiple = TRUE)
}

Usage:

"b" %:% "f"
# [1] "b" "c" "d" "e" "f"

"f" %:% "b"
# [1] "f" "e" "d" "c" "b"

"A" %:% "D"
# [1] "A" "B" "C" "D"

Answer 3

Another option with match, seq and do.call:

letters[do.call(seq, as.list(match(c("b","f"), letters)))]

which gives:

[1] "b" "c" "d" "e" "f"

---

Making a function of this such that it works with both lower-case and upper-case letters:

char_seq <- function(lets) {
  switch(all(grepl("[[:upper:]]", lets)) + 1L,
         letters[do.call(seq, as.list(match(lets, letters)))],
         LETTERS[do.call(seq, as.list(match(lets, LETTERS)))])
}

the output of this:

> char_seq(c("b","f"))
[1] "b" "c" "d" "e" "f"

> char_seq(c("B","F"))
[1] "B" "C" "D" "E" "F"

This function can be extended with checks on the correctness of the input:

char_seq <- function(lets) {
  g <- grepl("[[:upper:]]", lets)
  if(length(g) != 2) stop("Input is not of length 2")
  if(sum(g) == 1) stop("Input does not have all lower-case or all upper-case letters")
  switch(all(g) + 1L,
         letters[do.call(seq, as.list(match(lets, letters)))],
         LETTERS[do.call(seq, as.list(match(lets, LETTERS)))])
}

resulting in proper error-messages when the input is not correct:

> char_seq(c("B"))
Error in char_seq(c("B")) : Input is not of length 2

> char_seq(c("b","F"))
Error in char_seq(c("b", "F")) : 
  Input does not have all lower-case or all upper-case letters

Answer 4

Playing with UTF, something like:

intToUtf8(utf8ToInt("b"):utf8ToInt("f"), multiple = TRUE)
# [1] "b" "c" "d" "e" "f"

Answer 5

Why not?

letters[which(letters == 'b') : which(letters == 'f')]

Answer 6

Perhaps using the raw versions of letters and then converting back to character could be used to define an infix function analogous to ":"

 `%c:%` <- function(x,y) { strsplit( rawToChar(as.raw(
     seq(as.numeric(charToRaw(x)), as.numeric(charToRaw(y))))), "" )[[1]]}
>  'a' %c:% 'g'
[1] "a" "b" "c" "d" "e" "f" "g"

I'm certainly not claiming this satisfies the request for "an easy way to do this" and I'm not even certain it would be more efficient, but it does introduce a couple of potentially useful functions.

Answer 7

Iknow it is frowned upon, but here is an eval(parse(...)) solution

LETTERS[eval(parse(text = paste(which(LETTERS %in% c('B', 'F')), collapse = ':')))]
#[1] "B" "C" "D" "E" "F"

Answer 8

First things first: your code

which(letters %in% c("b", "f"))

Is a valid but convoluted way of writing

match(c('b', 'f'), letters)

(Why “convoluted”? Because %in% is a wrapper around match for a specific use-case, which explicitly turns the numeric index into a logical value, i.e. the inverse operation of which.)

Next, you can of course use the result and convert it into a range via idx[1L] : idx[2L] and there’s nothing wrong with that in this case. But R has an idiomatic way of expressing the concept of calling a function using a vector as its parameters: do.call:

do.call(`:`, as.list(match(c('b', 'f'), letters)))

Or, equivalently:

do.call(seq, as.list(match(c('b', 'f'), letters)))

{purrr} allows us to do the same without the as.list:

purrr::invoke(seq, match(c('b', 'f'), letters))

And, finally, we subset:

letters[purrr::invoke(seq, match(c('b', 'f'), letters))]

Answer 9

You can use grep and letters and the pattern [b-f].

grep("[b-f]", letters, value = TRUE)
#[1] "b" "c" "d" "e" "f"

letters[grep("[b-f]", letters)]
#[1] "b" "c" "d" "e" "f"

letters[grepl("[b-f]", letters)]
#[1] "b" "c" "d" "e" "f"

And for a decreasing sequence you can use in addition rev

rev(grep("[b-f]", letters, value = TRUE))
#[1] "f" "e" "d" "c" "b"

or using match.

letters[match("b", letters) : match("f", letters)]
#[1] "b" "c" "d" "e" "f"

Answer 10

A compact solution using match

library(magrittr)

a <- "b"
b <- "f"

letters %>% .[match(a,.):match(b,.)]
#> [1] "b" "c" "d" "e" "f"

^{Created on 2021-12-30 by the reprex package (v2.0.1)}