Operacje na znakach i tekstach

Znaki i ich kodowanie

Znaki służące w różnych językach do tworzenia testu pisanego są tak samo, jak liczby, kodowane w systemie binarnym w 1-3 bajtach złożonych z 8, 16, 32 lub 64 bitów. O ile dla liczb przyjęto system dwójkowy ich kodowania, to dla znaków określono z góry ich kody binarne. Z informatycznego punktu widzenia cyfry arabskie są także znakami, ale zapisane bez cudzysłowu są przekształcane na inny kod binarny niż zapisane w cudzysłowie.

Od początku globalizacji, czyli momentu gdy powstała publiczna sieć “Internet” starano się by standard definiowania różnych znaków za pomocą kodów binarnych był taki sam na całym świecie. System ten nosi nazwę unikod (unicode). Dwa standardy definiowania znaków, jakie wytworzyły się do tej pory, Unicode oraz ISO 10646 różnią się w drobnych kwestiach. Unikod jest rozszerzeniem systemu kodowania znaków ASCII stosowanym do zapisu programów sterujących pracą komputera. Znaki ASCII zajmują 7 bitów pojedynczego bajtu, mają zatem kod binarny odpowiadający którejś z liczb od 0 do 2⁷-1 czyli 127. Wśród tych znaków początkowych 31 pozycji oraz pozycję 127 zajmują znaki sterujące (przesunięcia, cofnięcia, wymazywanie, wstawianie znaków, przejścia do nowej linijki itp.). Kolejne pozycje zajmują znaki, które znajdują się na klawiaturze.

Ponieważ każdemu bajtowi z określonym kodem binarnym odpowiada zarówno liczba jak i jakiś znak, program R wymaga by znaki i teksty były inaczej pisane niż liczby. Znaki i teksty należy zapisać w cudzysłowie.

> "a"
[1] "a"
> "aaa"
[1] "aaa"
> "aa aaa"
[1] "aa aaa"
> "32178"
[1] "32178"
> ""a""
Error: unexpected symbol in "a"

Program pokazuje pewne ograniczenia R. Znak cudzysłowu nie może być zapisany jako znak bezpośrednio z klawiatury.

Każdemu znakowi zapisanemu w cudzysłowie odpowiada pewien kod binarny, a temu kodowi odpowiada unikod. Aby zobaczyć liczbę (w systemie dziesiętnym) jaka odpowiada znakowi należy użyć funkcji utf8ToInt(). Aby liczbom przypisać określony unikod należy użyć funkcji intToUtf8().

> utf8ToInt("a")
[1] 97
> intToUtf8(123)
[1] "{"

Liczbom (a właściwie ich kodom binarnym) od 32 do 127 odpowiadają następujące znaki ASCII.

Liczba

Znak

)

Liczba

Znak

3

4

5

6

7

8

9

:

;

<

=

>

?

Liczba

Znak

@

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

Liczba

Znak

P

Q

R

S

T

U

V

W

X

Y

Z

[

\

]

^

_

Liczba

Znak

'

a

b

c

d

e

f

g

h

i

j

k

l

m

n

o

Liczba

Znak

p

q

r

s

t

u

v

w

x

y

z

{

|

}

~

Znajdują się tu wszystkie znaki, które możemy wpisać z klawiatury amerykańskiej (a taką posługujemy się w Polsce).

Funkcja intToUtf8() pokazuje nam znaki unikodu dla wszystkich liczb, którym przypisano jakiś znak. Przykładowo dla liczb powyżej 20224 pojawiają się znaki pisma chińskiego

> intToUtf8(1134)
Ѯ
> intToUtf8(20534)
㓞
> intToUtf8(20634)
㕂

Niekiedy wywołanie tej funkcji powoduje wyświetlenie się kodu znaku według notacji unicode (zestaw liter i cyfr w cudzysłowie zaczynający się od \u). Wtedy, by wyświetlił się znak (bez cudzysłowów) należy użyć funkcji cat().

Dwuznaki

Przy programach tworzących automatycznie jakieś komunikaty potrzebny jest znakowy system wskazujący na uruchamianie określonych znaków sterujących. W wielu językach (np. Latex) stosuje się do tego dwuznaki zaczynające się od “\”. W R zastosowanie znalazły następujące dwuznaki to:

• “\n” służący do łamania tekstu (przenoszenia fragmentu za znakiem do kolejnej linijki konsoli). Wykorzystywany jest przede wszystkim wraz z funkcją cat(),
• “\t” tabulator wykorzystywany do tworzenia tabel,
• “\\” służący do napisania znaku \ w wyświetlanym tekście

Wszystkie dwuznaki związanie są z funkcją cat() używaną do wyświetlania komunikatów programu. Wyświetla ona tekst bez cudzysłowów, ale jednocześnie kursor pozostaje w tej samej linijce. Aby kursor przeszedł do nowej linijki należy wprowadzić w obrębie tekstu (przed końcowym “) po przecinku dwuznak \n, który jest przetwarzany na znak sterujący: “przejdź do następnej linijki na jej początek”.

> cat("Ala ma kota \n a kot ma Alę")
Ala ma kota
a kot ma Alę>
> cat("Ala ma kota \n a kot ma Alę \n")
Ala ma kota
a kot ma Alę
> cat("Ala ma kota\na kot ma Alę\n")
Ala ma kota
a kot ma Alę

Funkcja cat() powoduje wyświetlenie tekstu, ale w tej samej linijce zostaje kursor konsoli. Aby uzyskać przejrzyste komunikaty należy stosować na jej końcu dwuznak “\n”.

Jak wspomniano w poprzednim podrozdziale funkcja intToUtf8() niekiedy zamiast znaku pokazuje numer unikodu tego znaku. Użycie funkcji cat() uwidacznia ten znak.

> intToUtf8(11134)
[1] "\ub7e"
> cat(intToUtf8(11134))
⭾> cat(intToUtf8(11134),"\n")
⭾
>

Dwuznak “\t” jest odpowiednikiem tabulatora. Przeznacza on na kolejne teksty 7 znaków lub wielokrotność 8 minus 1 i rozpoczyna ich pisanie od początku przeznaczonego miejsca. W rezultacie przy stosowaniu podziału takiego tekstu na linijki tworzy się tabela.

> cat("a ab abc abcd \nabcd abc ab a\n")
 a ab abc abcd
abcd abc ab a
> cat("a\t ab\t abc\t abcd \nabcd\t abc\t ab\t a\n")
a       ab      abc     abcd
abcd    abc     ab      a

Konieczność napisania znaku \ w komunikacie programu powoduje, że musimy użyć dwuznaku “\\”. Wygląda to następująco:

> cat("\\/\\/\\/\\\n")
 \/\/\/\
> cat("W tym systemie operacyjnym stosuje się znak \\ do adresowania!\n")
W tym systemie operacyjnym stosuje się znak \ do adresowania!

Tekst

Znaki służą przede wszystkim do tworzenia tekstu. Program R jest w minimalnym stopniu używany jako edytor tekstowy i to tylko wtedy gdy w skomplikowany sposób przekształcany jest jakiś tekst. Często jednak R zawiera funkcje (np. funkcje statystyczne), które wyświetlają się wraz z komunikatami. Te komunikaty to wyświetlane zmienne tekstowe.

Tekst jest po prostu ciągiem znaków umieszczonym w cudzysłowie.

> R jesteś super programem!
BŁĄD: nieoczekiwany symbol in " R jesteś"
> "R jednak nie jesteś super programem"
[1] "R jednak nie jesteś super programem"
> # Wyjaśniam, że R nie jest super programem
>

Dłuższy tekst można zapisać w kilku linijkach. Dopóki nie pojawi się cudzysłów, program będzie oczekiwał dalszego ciągu tekstu. Przetwarza go jednak na obiekt jednolinijkowy z dwuznakiem \n w miejscu gdzie naciśnięto enter.

> "Ach, to nie było warte
+ by sny tym karmić uparte"
"Ach, to nie było warte\nby sny tym karmić uparte"

Do wyświetlania tekstu służą omówiona wcześniej funkcja cat() oraz funkcja print(). Działają one nieco inaczej. Funkcja print() standardowo wyświetla tekst w cudzysłowie. Opcja quote=FALSE powoduje, że tekst pojawia się bez cudzysłowu. Jest niewrażliwa na dwuznak \n. Natomiast przy podziale tekstu na dwie linijki, wstawia go w miejsce znaku enter.

> print("a aa aaa aaaa aaaaa aaaaaa") 
[1] "a aa aaa aaaa aaaaa aaaaaa"
> print("a aa aaa aaaa aaaaa aaaaaa", quote=FALSE) 
[1] a aa aaa aaaa aaaaa aaaaaa
> print("a aa aaa \n aaaa aaaaa aaaaaa", quote=FALSE)
[1] a aa aaa \n aaaa aaaaa aaaaaa 
> print("a aa aaa
+ aaaa aaaaa aaaaaa", quote=FALSE)
[1] a aa aaa\naaaa aaaaa aaaaaa 
> print("a","aa") 
Błąd w poleceniu 'print.default("a", "aa")':niepoprawny argument 'digit
Dodatkowo: Komunikat ostrzegawczy:
W poleceniu 'print.default("a", "aa")':
pojawiły się wartości NA na skutek przekształcenia

Największa różnica między funkcją cat() a funkcją print() polega na tym, że pierwsza z nich tylko wyświetla tekst i ten obraz nie może być przyporządkowany żadnemu obiektowi. Natomiast to, co powstanie po użyciu funkcji print(), może być traktowane jako obiekt.

W R nie przewidziano działań na tekstach. Poprawne wyświetlanie tekstu w wielu linijkach, znajdywanie podtekstu, łączenie tekstów i inne operacje wykonuje się używając funkcji tekstowych.

Relacje między znakami i tekstami.

Już w starożytności pojawiła się potrzeba zastosowania porządku w zbiorze liter (stworzono alfabet) oraz słów (porządek leksykalny). Wiele osób wie, że w porządku alfabetycznym znaki cyfr poprzedzają znaki liter, litery małe poprzedzają duże. Obecnie w encyklopediach internetowych swoje hasła mają poszczególne znaki interpunkcyjne, nawiasy, pauzy, znaki działań matematycznych i inne znaki występujące na klawiaturze. Porządek między tymi symbolami nie jest już tak powszechnie znany i program R może wyjaśnić wiele wątpliwości.

Do sprawdzenia, czy dany znak jest w porządku alfabetycznym przed/po innym znakiem używamy relacji < i >.

> ","<"."
[1] TRUE
> "@"<"!"
[1] FALSE

Porządek wyznaczony przez kolejne miejsca w unikodzie dla liter nie jest zgodny z porządkiem alfabetycznym. W unikodzie duże litery poprzedzają małe (przy czym Z < a), podczas gdy w porządku alfabetycznym zawsze mała litera jest przed dużą literą, ale obie są mniejsze od małej, następnej litery w alfabecie. Najwięcej wątpliwości wzbudza porządek liter z dodatkowymi znaczkami (kreskami, kropkami na literą, przekreśleniami itp.). Ich porządek jest ustalony przez opcje systemu operacyjnego związane z ustawieniami lokalnymi, a dokładnie językiem stosowanym w R zadeklarowanym podczas instalacji. W polskojęzycznym R obowiązuje znany nam porządek ustalony dla wszystkich polskich liter (ą, ć, ę, ł, ń, ó, ś, ż, ź) ale nie dla wszystkich liter nie używanych w języku polskim jest on jednoznaczny. Można to sprawdzić.

> intToUtf8(261)
[1] "ą"
> intToUtf8(261)=="ą"
[1] TRUE
> intToUtf8(261)>"A"
[1] TRUE
> intToUtf8(261)>"b"
[1] FALSE
> intToUtf8(192)
[1] "À"
> intToUtf8(192)=="A"
[1] FALSE
> intToUtf8(192)<"A"
[1] FALSE
> intToUtf8(192)>"A"
[1] FALSE
> intToUtf8(192)<"b"
[1] TRUE

Tego typu relacja jest także porządkiem tylko nieliniowym. Po prostu nie jest określona między pewnymi parami znaków. Spełnia jednak warunek antysymetryczności (jeżeli X jest w relacji z Y to nieprawdą jest, że Y jest w relacji z X) i jest przechodnia (jeżeli X jest w relacji z Y i Y jest w relacji z Z to X jest w relacji z Z).

W porządku leksykalnym przy porównaniu dwóch tekstów sprawdzane są znaki na tych samych pozycjach i pozycja danego słowa jest taka sama jak pozycja pierwszej pary różniących się znaków, przy czym brak znaku poprzedza wszystkie znaki. Dlatego też “10”<“2” i “folder11” poprzedza “folder2” ale występuje za “folder1” w katalogach komputerowych. Obecnie wiele witryn internetowych umożliwia stosowanie prawie wszystkich znaków występujących na klawiaturze do tworzenia NIKów (loginów) logujących się użytkowników. NIKi te na serwerach muszą zostać uporządkowane, choćby po to by łatwiej było sprawdzać, czy nowa, rejestrująca się osoba nie chce używać istniejącego już NIKu. Stosuje się tu porządek leksykalny, przy czym poszczególne znaki na klawiaturze mają następujące pozycje:

‘ < – < ! < # < $ < % < & < ( < ) < * < , < . < / < : < ; < ? < @ < [ < \ < ] < ^ < _ < ` < { < | < } < ~ < + < < < = < > < 0 < 1 < 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < a < A < b < B < c < C < d < D < e < E < f < F < g < G < h < H < i < I < j < J < k < K < l < L < m < M < n < N < o < O < p < P < q < Q < r < R < s < S < t < T < u < U < v < V < w < W < x < X < y < Y < z < Z

Między pokazanymi znakami mają swoje miejsce jeszcze inne znaki używane np. w języku polskim. Przykładowo A < ą < Ą < b. Porzadek miedzy narodowymi symbolami ustalany jest dla każdego jezyka i system operacyjny komputera ma go zapisanego w swoich opcjach. Pracując na nie własnym komputerze za granicą (albo w Polsce ale z systemem dostosowanym do innego języka) polski porządek alfabetyczny może być nie wykrywany prawidłowo.

Funkcje tekstowe

Funkcja is.character() służy do sprawdzenia, czy jakiś obiekt jest symbolem lub napisem (typu character). Funkcja as.character() pozwala na przekształcenie liczby na napis. Funkcja as.numeric() przekształca napisy mające postać liczby na liczby.

> # funkcja is.character()
> is.character(pi)
[1] FALSE
> is.character(TRUE)
[1] FALSE
> is.character("TRUE")
[1] TRUE
> # funkcja as.character()
> as.character(pi)
[1] "3.14159265358979"
> # funkcja as.numeric()
> as.numeric("4.78654")
[1] 4.78654
> as.numeric(" 4.78654 ")
[1] 4.78654
> as.numeric("4,78654")
[1] NA
Warning message:
NAs introduced by coercion

Funkcja nchar() pozwala na wyliczenie ilości znaków składających się na tekst.

> # funkcja nchar()
> nchar("abcde")
[1] 5
> nchar("abcde abc")
[1] 9
> substr("abcde abc", 3, nchar("abcde abc"))
[1] "cde abc"

Funkcja cat() zamienia liczby na teksty oraz skleja teksty występujące po przecinku rozdzielając je w tekście wynikowym spacją. Aby zmienić sposób sklejania tekstów należy użyć opcji sep=”z”, gdzie z jest wybranym znakiem.

> cat("abc", "acb", "bac", "bca", "cab", "cba \n")
[1] abc acb bac bca cab cba 
> cat("abc", "acb", "bac", "bca", "cab", "cba \n", sep=",")
[1] abc,acb,bac,bca,cab,cba 
> cat("abc", "acb", "bac", "bca", "cab", "cba \n", sep=intToUtf8(10311))
[1] abc⡇acb⡇bac⡇bca⡇cab⡇cba 
> cat("abc", "acb", "bac", "bca", "cab", "cba \n", sep="\t")
[1] abc     acb     bac     bca     cab     cba 
> cat("abc", "acb", "bac", "bca", "cab", "cba \n", sep="")
[1] abcacbbacbcacabcba 

Funkcja cat() posiada jeszcze opcje fill=FALSE/TRUE oraz labels=… o wartościach tekstowych. Bardzo długi tekst bez dwuznaku \n zostaje jednolinijkowym tekstem i znaczna jego część jest niewidoczna, gdy fill=FALSE, a jest to wprowadzane standardowo. Opcja fill=TRUE powoduje, że ten tekst automatycznie podzieli dzieli się (głównie w miejscu spacji) na kilka linijek. Można te linijki oznaczyć znakami wpisanymi do opcji labels.

> cat("abcd", "abdc", "acbd", "acdb", "adbc", "adcb",
+ "bacd","badc","bcad","bcda", "bdac", "bdca",
+ "cabd", "cadb", "cbad", "cbda", "cdab", "cdba",
+ "dabc", "dacb", "dbac", "dbca", "dcab", "dcba \n")
abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba d$
> cat("abcd", "abdc", "acbd", "acdb", "adbc", "adcb",
+ "bacd","badc","bcad","bcda", "bdac", "bdca",
+ "cabd", "cadb", "cbad", "cbda", "cdab", "cdba",
+ "dabc", "dacb", "dbac", "dbca", "dcab", "dcba \n", fill=TRUE)
abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba
dabc dacb dbac dbca dcab dcba
> cat("abcd", "abdc", "acbd", "acdb", "adbc", "adcb",
+ "bacd","badc","bcad","bcda", "bdac", "bdca",
+ "cabd", "cadb", "cbad", "cbda", "cdab", "cdba",
+ "dabc", "dacb", "dbac", "dbca", "dcab", "dcba \n", fill=TRUE, labels="#")
# abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba
# dabc dacb dbac dbca dcab dcba

Kolejne linijki mogą być numerowane. Wystarczy napisać na przykład labels=c(“1″,”2″,”3″,”4″,”5”). Gdy powstanie mniej niż 5 linijek (np. 3) dostaną one oznaczenia 1, 2 i 3. Gdy powstanie więcej niż 5 linijek – kolejne oznaczenia będą się powtarzać. Ciąg wpisany do labels może być dowolnie długi i składać się z dowolnych znaków lub tekstów w dowolnej kolejności.

Funkcja print() wyświetla tekst albo liczbę, ale nie skleja różnych tekstów i tekstów z liczbami. Poza tym po wyświetleniu zawartości kursor przechodzi zawsze do nowej linijki.

> print("abc", "acb", "bac", "bca", "cab", "cba \n")
Błąd w poleceniu 'print.default("abc", "acb", "bac", "bca", "cab", "cba \n")':   invalid printing digits -2147483648
Dodatkowo: Komunikat ostrzegawczy:
W poleceniu 'print.default("abc", "acb", "bac", "bca", "cab", "cba \n")':
pojawiły się wartości NA na skutek przekształcenia
> print("abc \n")
[1] "abc \n"
> print("abc")
[1] "abc"
> print(123)
[1] 123

Jedna z opcji funkcji print() jest opcja logiczna quote=FALSE/TRUE. Zastosowanie wartości FALSE powoduje, że teksty wyswietlą się bez cudzysłowów. Jest to wygodne w tworzeniu różnych komunikatów. Opcja ta nie działa dla liczb.

> print("abc")
[1] "abc"
> print("abc", quote=FALSE)
[1] abc
> print(123, quote=TRUE)
[1] 123

Funkcja print() służy przede wszystkim do wyświetlania złożonych “obiektów” kryjących się za jakimiś literałami. Większość jej opcji słuzy do różnego rodzaju pokazywania tych obiektów. W odróżnieniu od funkcji cat(), wynikiem działania funkcji print() jest także wielkość, która można przypisać jakiemuś literałowi, czyli R-owy “obiekt”.

Do łączenia tekstów, a także tekstu z liczbami, służy funkcja paste(). Jej najpopularniejszą opcją jest sep=”z”, gdzie z jest znakiem rozdzielającym łączone słowa.

> # funkcja paste()
> paste("Ala ma", 3, "koty i", 4, "myszoskoczki." )
[1] "Ala ma 3 koty i 4 myszoskoczki."
> paste("Ala", "Ola","Ela", "Ula")
[1] "Ala Ola Ela Ula"
> paste("Ala", "Ola", "Ela", "Ula", sep=",")
[1] "Ala,Ola,Ela,Ula"
> paste("Ala", "Ola", "Ela", "Ula", sep=", ")
[1] "Ala, Ola, Ela, Ula"

Efektem działania funkcji paste() jest tekst, który może być przyporządkowany obiektowi.

Funkcją odwrotną do paste(), przy pomocy której możemy podzielić tekst, jest funkcja strsplit(). Jej obowiązkową opcją jest split=””, gdzie miedzy cudzysłowami dajemy znal, który nam rozdzieli tekst.

> # funkcja strsplit()
> strsplit("Ala ma 3 koty i 4 myszoskoczki.", split="i")
[[1]]
[1] "Ala ma 3 koty " " 4 myszoskoczk" "." 
strsplit("Ala ma 3 koty i 4 myszoskoczki.", split=" ")
[[1]]
[1] "Ala"           "ma"            "3"           "koty"            "i"           "4"
[2] "myszoskoczki."
strsplit("Ala ma 3 koty i 4 myszoskoczki.", split="")
[[1]]
[1] "A" "l" "a" " " "m" "a" " " "3" " " "k" "o" "t" "y" " " "i" " " "4" " " "m"
[20] "y" "s" "z" "o" "s" "k" "o" "c" "z" "k" "i" "."

Wynikiem działania tej funkcji jest złożona struktura, tzw lista wyjaśniona dalej. Funkcja ta działa bowiem najczęściej na ciągach tekstowych dzieląc odpowiednio każdy element tego ciągu na jakiś krótszy ciąg. By się one nie pomieszały zapamiętane są w bardziej skomplikowany sposób.

Funkcje substr(tekst,n₁,n₂) oraz substring(tekst,n₁,n₂) pozwalają na wyciąganie podtekstu z większego tekstu, jako ciągu znaków od znaku n₁ do znaku n₂.

> # funkcja substr()
> substr("abcdefgh", 1,3)
[1] "abc"
> substring("abcdefgh", 2,4)
[1] "bcd"
> substr("abcdefgh", 2,14)
[1] "bcdefgh"
> substr("abcdefgh", 12,14)
[1] ""

Do sprawdzenia, czy jakiś tekst jest podtekstem dłuższego tekstu służy funkcja grepl(). Jej wartością jest prawda (TRUE) lub fałsz (FALSE). Drugi argument tej funkcji może być wektorem. Funkcja zwraca wtedy wektor wartości logicznych pokazujących, w których wyrazach wektora znaleziono dany tekst.

> # funkcja grepl()
> grepl("bc","abcde")
[1] TRUE
> grepl("bd", "abcde")
[1] FALSE

Inne przydatne funkcje tekstowe to sub() oraz gsub(). Obie pozwalają na zamianę w tekście jednego znaku lub krótkiego tekstu na inny, tylko sub() robi to tylko dla pierwszego napotkanego znaku/subtekstu, a gsub() dla wszystkich wskazanych znaków/tekstów. Budowa tych funkcji jest taka sama: sub(“z1″,”z2”,tekst), gdzie znak “z1” jest znakiem/subtekstem szukanym w tekście i zamienianym na znak/subtekst “z2”. Ponieważ wynikiem takich zamian są także listy, podajemy sposób na powrót z listy do tekstu – funkcję unlist().

> # funkcja sub() i gsub()
> sub("o","re","Ala ma 3 koty i 4 myszoskoczki.")
[[1]]
[1] "Ala ma 3 krety i 4 myszoskoczki." 
> unlist(sub("o","re","Ala ma 3 koty i 4 myszoskoczki."))
[1] "Ala ma 3 krety i 4 myszoskoczki."
> gsub("o","re","Ala ma 3 koty i 4 myszoskoczki.")
[[1]]
[1] "Ala ma 3 krety i 4 myszreskreczki." 
> unlist(gsub("o","re","Ala ma 3 koty i 4 myszoskoczki."))
[1] "Ala ma 3 krety i 4 myszreskreczki."

Ponieważ przy znajdywaniu pierwszego znaku/subtekstu wykorzystana jest funkcja logiczna, można w tym miejscu użyć wyrażeń logicznych i zamienić jedna instrukcja kilka różnych znaków/subtekstów.

> # funkcja sub() i gsub()
> unlist(sub("o|i","re","Ala ma 3 koty i 4 myszoskoczki."))
[1] "Ala ma 3 krety i 4 myszoskoczki." 
> unlist(gsub("o|i","re","Ala ma 3 koty i 4 myszoskoczki."))
[1] "Ala ma 3 krety i 4 myszreskreczkre." 

Ważne by między znakiem a | nie stosować spacji, bo są wtedy wyszukiwane dwuznaki ze spacją na końcu lub na początku wskazanego znaku.