INSTRUKCJE WARUNKOWE

1. IF

if -> pozwala na warunkowe wykonywanie fragmentu kodu

Czy liczba jest większa od 5?

x <- 10
if (x > 5) {
  print("x jest większe od 5")
}

## [1] "x jest większe od 5"

Czy liczba jest dodatnia?

y <- -2
if (y >= 0) {
  print("y jest dodatnie")
} else {
  print("y jest ujemne")
}

## [1] "y jest ujemne"

Instrukcja warunkowa, która sprawdza kategorię temepratury

temperature <- 18
if (temperature < 0) {
  print("Mróz")
} else if (temperature < 15) {
  print("Chłodno")
} else if (temperature < 25) {
  print("Ciepło")
} else {
  print("Gorąco!")
}

## [1] "Ciepło"

Czy liczba jest parzysta?

liczba<-56
if(liczba%%2==0){
  cat("liczba jest parzysta\n")
}else{                         # ważne by "else" było od razu po "}"
  cat("liczba jest nieparzysta\n")}

## liczba jest parzysta

2. IFELSE

ifelse -> pozwala na skrócenie zapisu instrukcji warunkowej Wykorzystywnay gdy kod warunkowy jest krótki Świetnie się sprawdza do porownywania wektorów

Porównanie dwóch zmiennych

jeden<-"mama"
dwa<-"tata"
ifelse(jeden==dwa,"to samo", "inne" )

## [1] "inne"

Porównanie liczb rzeczywistych

a<-9
b<-17
ifelse(25==a+b, "prawda", "nie prawda")

## [1] "nie prawda"

wektor<-rnorm(10)
wektor

##  [1]  2.210834724 -0.091232617  0.679458520 -1.353650481 -0.007376652
##  [6] -0.373227229  0.070974365  0.310639264 -0.519643493 -0.315670004

ifelse(wektor<0, -1, 1)

##  [1]  1 -1  1 -1 -1 -1  1  1 -1 -1

PĘTLE

1. FOR

for -> stosowany, gdy liczba powtórzeń pętli jest z góry znana

Wypisz liczby od 1 do 5

for (i in 1:5) {
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Wypisz liczby od 1 do 5 i dopisz, który to krok iteracji

for(i in 1:5){
  cat(paste("krok iteracji"), paste(i, "\n" ))
}

## krok iteracji 1 
## krok iteracji 2 
## krok iteracji 3 
## krok iteracji 4 
## krok iteracji 5

Suma elementów wektora

numbers <- c(2, 4, 6, 8, 10)
sum_val <- 0
for (n in numbers) {
  sum_val <- sum_val + n
}
print(paste("Suma =", sum_val))

## [1] "Suma = 30"

liczby<- c("mama", "tata","kot")
for( i in liczby){
  cat(paste(i, "\n"))
}

## mama 
## tata 
## kot

liczby<- c("mama", "tata","kot", "pies")
for( i in (length(liczby)-1)){
  cat(paste(i, "\n"))
}

## 3

liczby<- c("mama", "tata","kot", "pies")
for( i in 1:(length(liczby)-1)){
  cat(paste(i, "\n"))
}

## 1 
## 2 
## 3

Warunek w pętli

wektor<-c(1:10)
for (n in wektor) {
  if (n %% 2 == 0) {
    print(paste(n, "jest parzyste"))
  }
}

## [1] "2 jest parzyste"
## [1] "4 jest parzyste"
## [1] "6 jest parzyste"
## [1] "8 jest parzyste"
## [1] "10 jest parzyste"

2. WHILE

while-> stosowany, gdy powtórzenia maja być wykonywane tak długo, jak długo prawdziwy jest podany warunek

Wyświetl liczby od 1 do 5

i <- 1
while (i <= 5) {
  print(i)
  i <- i + 1
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Losuj liczby do momentu trafienia 7

number <- 0
while (number != 7) {
  number <- sample(1:10, 1)
  print(paste("Wylosowano:", number))
}

## [1] "Wylosowano: 4"
## [1] "Wylosowano: 1"
## [1] "Wylosowano: 9"
## [1] "Wylosowano: 10"
## [1] "Wylosowano: 7"

print("Trafiono 7!")

## [1] "Trafiono 7!"

liczba<-7
while (liczba>0){
  cat(paste("liczba= ", liczba, "\n"))
  liczba<-liczba-2
}

## liczba=  7 
## liczba=  5 
## liczba=  3 
## liczba=  1

i <- 1
while (i < 6) {
print(i)
i = i+1
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Zatrzymaj pętle gdy i=4

i <- 1
while (i < 6) {
  print(i)
  i <- i + 1
  if (i == 4) {
    break
  }
}

## [1] 1
## [1] 2
## [1] 3

data(iris)                                               # Loading exemplifying data set
head(iris)

##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

running_index <- 1

while(is.numeric(iris[ , running_index])) {              # zaczynamy pętle
 
  iris[ , running_index] <- iris[ , running_index] + 50  # blok pętli, jeśli kolumna/zmienna jest "numeric" to dodaj 50 do wartości zmiennej
  running_index <- running_index + 1                     # przejście z jednej do drugiej kolumny/zmiennej
 
}

Wyświetl liczby od 1 do 5 omijając liczbę 3

number = 1


while(number <= 5) {
  if (number == 3) {  
    number = number + 1
                 # jesli warunek spełniony, wartość pomijana
  }
    
  # wyświetl liczby
  print(number)
    
  # przyrost wektora numer o 1
  number = number + 1  
}

## [1] 1
## [1] 2
## [1] 4
## [1] 5

FUNKCJE

Bez argumentu

hello <- function() {
  print("Witaj w świecie R!")
}
hello()

## [1] "Witaj w świecie R!"

Funkcja z argumentem

greet <- function(name) {
  paste("Cześć,", name, "!")
}
greet("Agata")

## [1] "Cześć, Agata !"

Funkcja zwracająca wartość działania

square <- function(x) {
  return(x^2)
}
square(5)

## [1] 25

Wyświetl trzykrotność największej wartości z podanego wektora

pierwsza_funkcja<-function(wektor)
{
  maximum<-max(wektor)    #szukanie maksymalnej wartości w wektorze
  wynik<-3*maximum
  wynik
}

pierwsza_funkcja(c(10,30,50,8,6,2,1,300))

## [1] 900

Prostszy zapis

druga_funkcja<-function(wektor)
{
  3*max(wektor)
}

druga_funkcja(c(10,30,50,8,6,2,1,300))

## [1] 900

Funkcja z warunkiem

check_number <- function(x) {
  if (x > 0) {
    return("dodatnia")
  } else if (x < 0) {
    return("ujemna")
  } else {
    return("zero")
  }
}
check_number(-5)

## [1] "ujemna"

Funkcja z pętlą i warunkiem (ile jest liczb parzystych? )

count_even <- function(vec) {
  count <- 0
  for (v in vec) {
    if (v %% 2 == 0) {
      count <- count + 1
    }
  }
  return(count)
}

numbers <- c(1, 2, 3, 4, 5, 6, 7)
count_even(numbers)

## [1] 3

ZADANIA

Zadanie 1

Wyświetl liczby nieparzyste od 1 do 1000 używając pętli while i instrukcji warunkowej if

number = 1

while(number <= 1000) {
  # omiń liczby, które są parzyste
  if (number %% 2 == 0) {  
    number = number + 1
    
  }
    
  # wyświetl liczby
  print(number)
    
  # przyrost wektora numer o 1
  number = number + 1  
}

Zadanie 2

Wyświetl liczby parzyste od 60 do 195 używając pętli while i instrukcji warunkowej if

number = 60

while(number <= 195) {
  if (number %% 2 != 0) {  
    number = number+1
  }
  # wyświetl liczby
  print(number)
    
  # przyrost wektora numer o 1
  number = number + 1  
}

Zadanie 3

Napisz pętlę for, która wypisze liczby od 1 do 10 oraz informację, czy są parzyste czy nie.

for (i in 1:10) {
  if (i %% 2 == 0) {
    print(paste(i, "jest parzyste"))
  } else {
    print(paste(i, "jest nieparzyste"))
  }
}

Zadanie 4

Napisz pętlę while, która będzie losować liczby z zakresu 1–6, aż wypadnie 6.

dice <- 0
count <- 0
while (dice != 6) {
  dice <- sample(1:6, 1)
  count <- count + 1
  print(paste("Rzut:", dice))
}
print(paste("Liczba rzutów:", count))

Zadanie 5

Utwórz funkcję square_plus_one(x), która zwraca wartość x^2 + 1.

square_plus_one <- function(x) {
  return(x^2 + 1)
}
square_plus_one(4)

Zadanie 6

Napisz funkcję describe_number(x), która wypisze, czy liczba jest dodatnia, ujemna, czy równa zero.

describe_number <- function(x) {
  if (x > 0) {
    return("dodatnia")
  } else if (x < 0) {
    return("ujemna")
  } else {
    return("zero")
  }
}
describe_number(-10)

Zadanie 7

Napisz funkcję sum_positive(vec), która zwraca sumę tylko dodatnich wartości wektora.

sum_positive <- function(vec) {
  suma <- 0
  for (v in vec) {
    if (v > 0) {
      suma <- suma + v
    }
  }
  return(suma)
}
sum_positive(c(-3, 2, 5, -1, 4))

## [1] 11

Zadanie 8

Napisz funkcję avg_even(vec), która oblicza średnią z liczb parzystych w wektorze.

avg_even <- function(vec) {
  even <- vec[vec %% 2 == 0]
  return(mean(even))
}
avg_even(c(1, 2, 3, 4, 5, 6))

## [1] 4

Zadanie 9

Napisz funkcję simulate_game(), która losuje liczby z zakresu 1–10 aż wypadnie 10 i zwraca liczbę prób potrzebnych do trafienia.

simulate_game <- function() {
  count <- 0
  number <- 0
  while (number != 10) {
    number <- sample(1:10, 1)
    count <- count + 1
  }
  return(count)
}
simulate_game()

## [1] 4

CIEKAWE POMOCE NAUKOWE

KONTAKT

agata.majkowska@ug.edu.pl

Podstawy_obliczeń_R elementy programowania

Majkowska Agata