zadania_R.txt

1. Utwórz skrypt, który wyświetli w konsoli tekst "Witaj świecie". Wykorzystaj tryb interaktywny i tryb wsadowy.

myString <- "Hello, World!"
print(myString)
cat(myString)

2. Zakomentuj wybrany fragment kodu.

# komentarz

3*. Za pomocą funkcji class() sprawdź typ następujących wartości: TRUE, FALSE, 12.3, 5, 999, 2L, 34L, 0L, 3 + 2i, 'a' , '"good", "TRUE", '23.4'

4*. Za pomocą konstrukcji as.type (gdzie zamiast type wstawiamy żądany typ) wykonaj rzutowanie zmiennej typu string na liczbę całkowitą, liczbę zmiennoprzecinkową, a następnie wykonaj rzutowanie liczby całkowitej i zmiennoprzecinkowej na typ string

5. Utwórz wektor i sprawdź jego typ za pomocą funkcji class() oraz liczbę jego składowych za pomocą instrukcji length()

apple <- c('red','green',"yellow")
print(apple)
print(class(apple))
print(length(apple)) 

6. Utwórz i wyświetl listę

list1 <- list(c(2,5,3),21.3,sin)
print(list1)

7. Utwórz i wyświetl macierz
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

8. Utwórz i wyświetl tablicę

a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

9. Utwórz i wyświetl czynnik wektora. Sprawdź działanie funkcji nlevels.

apple_colors <- c('green','green','yellow','red','red','red','green')
factor_apple <- factor(apple_colors)
print(factor_apple)
print(nlevels(factor_apple))

10. Utwórz i wyświetl ramkę danych
BMI <- 	data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

11. Wypróbuj różne sposoby przypisywania i wyświetlania zmiennych:

#za pomocą znaku równości
var.1 = c(0,1,2,3)           

#za pomocą lewostronnego operatora przypisania
var.2 <- c("learn","R")   

#za pomocą prawostronnego operatora przypisania
c(TRUE,1) -> var.3           

#funkcja print
print(var.1)

#funkcja cat
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

12. Wczytaj i wyświetl dane osobowe wprowadzone przez użytkownika 

name = readline(prompt="Input your name: ")
age =  readline(prompt="Input your age: ")
print(paste("My name is",name, "and I am",age ,"years old."))

13*. Utwórz skrypt, który będzie przyjmować od użytkownika wartość promienia okręgu, a następnie obliczy i wyświetli obwód i pole tego okręgu.

14*. Utwórz skrypt, który będzie przyjmować od użytkownika wartości boków prostokąta, a następnie obliczy i wyświetli pole i obwód tego prostokąta.

15. Wyświetl listę wszystkich wprowadzonych zmiennych za pomocą funkcji ls(). Wykorzystaj argument pattern do ograniczenia wyświetlanych wyników

print(ls())
print(ls(pattern = "var")) 
print(ls(all.name = TRUE))

16. Za pomocą funkcji rm() usuń wybrane, a następnie wszystkie zmienne

rm(var.3)
print(var.3)

rm(list = ls())
print(ls())

17*. Utwórz dwa wektory o tym samym wymiarze, a następnie wypróbuj na nich następujące działania i nazwij je: +, -, *, /, %%, %/%, ^, 

18*. Utwórz dwa wektory o tym samym wymiarze, a następnie wypróbuj na nich następujące relacje i nazwij je: >, <, ==, <=, >=, !=, 

19*. Utwórz dwa wektory o tym samym wymiarze, a następnie wypróbuj na nich następujące operatory logiczne i nazwij je: &, |, !, &&, ||, 

20. Wypróbuj działanie operatorów specjalnych: %in% - sprawdzenie czy dany element znajduje się w danym wektorze, %*% - służy do mnożenia macierzy i jej transpozycji, : - służy do tworzenia szeregu liczb o zadanych granicach

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 
print(v2 %in% t) 

M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

v <- 2:8
print(v) 

21*. Za pomocą konstrukcji 
if(boolean_expression) {
   statement...
}
sprawdź czy wprowadzona przez użytkownika liczba jest większa od zera

22*. Za pomocą konstrukcji
if(boolean_expression) {
   statement...
} else if {
   statement...
} else {
   statement...
}
sprawdź czy liczba wprowadzona przez użytkownika jest dodatnia, ujemna, czy równa zeru

23*. W klasie przeprowadzono sprawdzian, za który uczniowie mogli otrzymać maksymalnie 50 punktów. Skala ocen w szkole jest następująca: 0-39% - ndst, 40-49% - dop, 50-69% - dst, 70-84% - db, 85-99% - bdb, 100% - cel. Utwórz skrypt z interfejsem tekstowym, który na podstawie podanej liczby punktów ze sprawdzianu wyświetli ocenę jaka się należy (skorzystaj z konstrukcji if, else if, else)

24*. Podzielmy rok na sezony zgodnie ze schematem miesięcy 1-3 - zima, 4-6 - wiosna, 7-9 - lato, 10-12 - jesień. Utwórz skrypt, który w oparciu o numer miesiąca wprowadzony przez użytkownika oreśli do jakiego sezonu należy ów miesiąc.

25*. Za pomocą konstrukcji
while (test_expression) {
   statement
}
wyświetl na ekranie 20 razy komunikat "Witaj świecie"

26*. Za pomocą konstrukcji 
for (value in vector) {
   statements
}
wyświetl na ekranie 20 razy komunikat "Witaj świecie"

27*. Napisz skrypt, który będzie wyświetlać wszystkie kolejne dzielniki wprowadzonej liczby

28*. Utwórz skrypt z interfejsem tekstowym, który pobierze od użytkownika zdanie i wyświetli w kolejnych wierszach litery tego zdania w odwróconej kolejności

29*. Utwórz skrypt z interfejsem tekstowym, który wyliczy sumę n kolejnych liczb (użytkownik podaje pierwszą i ostatnią liczbę sumy)

30*. Utwórz skrypt z interfejsem tekstowym, który przyjmie od użytkownika ile elementów chce on wprowadzić do listy, przyjmie te elementy, a następnie wyliczy ich sumę i średnią.

31*. Utwórz skrypt z interfejsem tekstowym który obliczy silnię od danego argumentu.

32*. Wypróbuj działanie kilku wbudowanych funkcji: seq(32,44), mean(25:82), sum(41:68). Opisz ich działanie

33. Utwórz i wywołaj funkcję, która będzie wyświetlać sekwencję kwadratów
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}	
new.function(6)

34. Wypróbuj działanie tej funkcji bez zadawania argumentów:
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}	

new.function()

35. Utwórz funkcję o argumentach domyślnych
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

new.function()

new.function(9,5)

36*. Za pomocą konstrukcji 
function_name <- function(arg_1, arg_2, ...) {
   Function body 
}
utwórz funkcję (lub dwie funkcje), która będzie przeliczać temperatury pomiędzy skalami Celsjusza i Fahrenheita C = (F-32)x(5/9), F = (C*9/5)+32

37*. Utwórz funckję do zamiany kilometrów na mile i na odwrót

38*. Utwórz funckję do obliczania wybranego elementu ciągu Fibonacciego

39*. Utwórz funckję do obliczania wartości trójmianu kwadratowego (funkcja jako argument przyjmuje x, a, b, c)

40*. Utwórz funkcję, która będzie obliczać średnią arytmetyczną dla podanego wektora liczb

41*. Utwórz funkcję, która będzie obliczać odchylenie standardowe średniej dla podanego wektora liczb

42. Wypróbuj następujące sposoby wprowadzania zmiennych typu string:
a <- 'Start and end with single quote'
b <- "Start and end with double quotes"
c <- "single quote ' in between double quotes"
d <- 'Double quotes " in between single quote'
e <- 'Mixed quotes" 
f <- 'Single quote ' inside single quote'
g <- "Double quotes " inside double quotes"
Które z nich są poprawne?

43. Łączenie łańcuchów znaków odbywa się za pomocą funkcji paste(..., sep = " ", collapse = NULL), gdzie ... oznacza sekwencję łańcuchów do połączenia, sep określa za pomocą jakiego znaku mają być rozdzielone, natomiast collapse usuwa spacje między łańcuchami, ale nie wewnątrz nich. Przetestuj działanie następującego skryptu

a <- "Hello"
b <- 'How'
c <- "are you? "
print(paste(a,b,c))
print(paste(a,b,c, sep = "-"))
print(paste(a,b,c, sep = "", collapse = ""))

44. Istotnym zagadnieniem jest formatowanie postaci wyniku. Przetestuj działanie następujących instrukcji:
result <- format(23.123456789, digits = 9)
print(result)

result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

result <- format(23.47, nsmall = 5)
print(result)

result <- format(6)
print(result)

result <- format(13.7, width = 6)
print(result)

result <- format("Hello", width = 8, justify = "l")
print(result)

result <- format("Hello", width = 8, justify = "c")
print(result)

45. Zamiana liter w łańcuchu na wielkie i małe odbywa się za pomocą toupper() i tolower(). Sprawdź 
result <- toupper("Changing To Upper")
print(result)

result <- tolower("Changing To Lower")
print(result)

46. Wycinanie fragmentu łańcucha odbywa się za pomocą funkcji substring(x, początek, koniec) gdzie x to wejściowy łańcuch, początek to pozycja piewszej litery a koniec to pozycja ostatniej litery do wyekstrahowania. Sprawdź działania kodu

result <- substring("Extract", 5, 7)
print(result)

47. W języku nawet pojedyńcza wartość jest traktowana jak wektor. Przykłady

print("abc");
print(12.5)
print(63L)
print(TRUE)
print(2+3i)
print(charToRaw('hello'))

48. Tworzenie wektorów o wielu składowych - przejrzyj i omów poniższe przykłady

v <- 5:13
print(v)

v <- 6.6:12.6
print(v)

v <- 3.8:11.4
print(v)

print(seq(5, 9, by = 0.4))

s <- c('apple','red',5,TRUE)
print(s)

49. Dostęp do składowych wektora odbywa się za pomoca indeksu zawartego w nawiasie kwadratowym. Sprawdź poniższy kod:

s <- c('apple','red',5,TRUE)
print(s[1])
print(s[2])
print(s[3])
print(s[4])

50. Do elemetów wektora można odnosić się za pomocą wektorów indeksów. Sprawdź i omów działanie poniższych instruckji

t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

x <- t[c(-2,-5)]
print(x)

y <- t[c(0,0,0,0,0,0,1)]
print(y)

51. Działania na wektorach - sprawdź działanie następujących instrukcji

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

multi.result <- v1*v2
print(multi.result)

divi.result <- v1/v2
print(divi.result)

52*. Utwórz funckję, która jako argument przyjmie dwa wektory oraz symbol działania i zwróci właściwy wynik działania.

53. Sprawdź co się stanie, jeśli dodasz do siebie dwa wektory o różnych długościach?

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

54. Sortowanie elementów wektora odbywa się za pomoca funkcji sort(). Sprawdź działanie następujących instrukcji

v <- c(3,8,4,5,0,11, -9, 304)

sort.result <- sort(v)
print(sort.result)

revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

55. Lista może przechowywać łańcucy znaków, wektory, wartości logiczne i liczby. Sprawdź działanie kodu

list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

56. Elementom listy można nazwać nazwy (etykiety). Sprawdź działanie kodu

list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2), list("green",12.3))
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
print(list_data)

57. Dostęp do elementów listy może odbywać się poprzez indeks w nawiasie kwadratowym oraz za pomocą operatora $ oraz nazwy elementu. Sprawdź działanie kodu

list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2), list("green",12.3))
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
print(list_data[1])
print(list_data[3])
print(list_data$A_Matrix)

58. Elementy raz zdefiniowanej listy można podmieniać. Sprawdź działanie instrukcji

list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2), list("green",12.3))
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
list_data[4] <- "New element"
print(list_data[4])
list_data[4] <- NULL
print(list_data[4])
list_data[3] <- "updated element"
print(list_data[3])

59. Listy można łączyć wstawiając je do jednej listy. Sprawdź działanie kodu.

list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")

merged.list <- c(list1,list2)

print(merged.list)

60. Listę można kowertować na wektor za pomocą instrukcji unlist(). Sprawdź działanie kodu

list1 <- list(1:5)
print(list1)

list2 <-list(10:14)
print(list2)

v1 <- unlist(list1)
v2 <- unlist(list2)

print(v1)
print(v2)

result <- v1+v2
print(result)

61*. Napisz program z interfejsem tekstowym, który będzie sprawdzać czy liczba jest pierwsza. 

62*. Napisz program z interfejsem tekstowym, który pobierze od użytkownika zestaw danych i obliczy na ich podstawie średnią arytmetyczną, medianę, dominantę, odchylenie standardowe, skośność i kurtozę.

63*. Napisz program z interfejsem tekstowym, który pobierze od użytkowników zestaw danych i wag i obliczy średnią ważoną.

64*. Napisz program z interfejsem tekstowym, który pobierze od użytkownika dwa zestawy danych i obliczy współczynnik korelacji Pearsona pomiędzy nimi.

65*. Napisz program z interfejsem tekstowym, który przyjmie dwa zestawy danych i obliczy na ich podstawie współczynniki regresji liniowej. 

66. Składnia umożliwiająca tworzenie macierzy jest następująca
matrix(data, nrow, ncol, byrow, dimnames)
gdzie data to wektor wejściowy, którego elementy stają się elementami macierzy, nrow to liczba wierszy do utworzenia, ncol to liczba kolumn do utworzenia, byrow to zmienna logiczna, gdy jest równa TRUE wejściowe elementy są uporządkowane według wierszy
dimname to nazwy przypisane do wierszy i kolumn. Sprawdź działanie następujących instrukcji
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

67. Do elementów macierzy możemy się odwołać korzystając z indeksów jej wierszy i kolumn. Sprawdź działanie poniższego kodu

rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P[1,3])
print(P[4,2])
print(P[2,])
print(P[,3])

68*. Sprawdź działanie dodawania i odejmowania macierzy o takich samych i różnych wymiarach.

69*. Sprawdź działanie mnożenia i dzielenia macierzy o takich samych i różnych wymiarach.

70. Tablice są obiektami, które mogą przechowywać dane w więcej niż dwóch wymiarach. Przeanalizuj poniższy przykład
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

71. Kolumnom i wierszom macierzy możemy nadać nazwy. Sprawdź poniższy kod

vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result) 

72. Przećwicz dostęp do elementów tablicy
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names, column.names, matrix.names))
print(result[3,,2])
print(result[1,3,1])
print(result[,,2])

73. Wykonaj operacje na tablicach

vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
array1 <- array(c(vector1,vector2),dim = c(3,3,2))
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

74. Wektor można rozłożyć na czynniki za pomocą funkcji faktor(). Sprawdź działanie poniższego kodu

data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

75. Tworząc ramkę danych z kolumną zawierającą dane tekstowe, R traktuje kolumnę tekstową jako kategorie i tworzy dla tej kolumny czynniki. Sprawdź działanie poniższego kodu

height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

input_data <- data.frame(height,weight,gender)
print(input_data)

print(is.factor(input_data$gender))

print(input_data$gender)

76. Ramka danych (data frame) jest strukturą w formie dwuwymiarowej tablicy w której każda kolumna zawiera warianty pewnej cechy, natomiast w kolejnych wierszach zawarte są kolejne wartości. Korzystając z poniższego przykładu utwórz przykładową ramkę danych

emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
		
print(emp.data)  

77*. Ramki danych pozwalają na wykonywanie wielu interesujących informacji. Sprawdź działanie funkcji str() (struktura) oraz summary() (podsumowanie).

78. Aby wydobyć z ramki danych konkretne kolumny, starczy użyć ich nazw

emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

79. Aby wydobyć z ramki dane wiersze, starczy użyć ich indeksów

emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

result <- emp.data[1:2,]
print(result)

80. Aby wydobyć elementy danych kolumn i wiersz można skorzystać z następującej konstrukcji

emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
	start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
#trzeci i piąty wiersz, 2 i 4 kolumna.
result <- emp.data[c(3,5),c(2,4)]
print(result)

81. Rozszerzanie ramki danych - dodawanie kolumny
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# dodawanie kolumny "dept"
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

82. Dodawanie wierszy za pomocą funkcji rbind()

Live Demo
# pierwsza ramka
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# druga ramka
emp.newdata <- 	data.frame(
   emp_id = c (6:8), 
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8), 
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# połączone ramki
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

83. W języku R kluczową rolę odgrywają biblioteki. 
Aby sprawdzić lokalizację pakierów R można skorzystać z instrukcji .libPaths() 
Aby sprawdzić listę wszystkich zainstalowanych pakietów można skorzystać z instrukcji library()
Aby sprawdzić aktualnie wczytanie pakiety można skorzystać z instrukcji search()
Aby zainstalować pakiet można skorzystać z instrukcji install.packages("Package Name")
Aby załadować bibliotekę można skorzystać z instrukcji library("package Name", lib.loc = "path to library")