Summary
Logical indexing involves using boolean conditions inside indexing brackets to selectively return only those rows of a data structure that meet specified criteria.

General domain of usage
Data frame manipulation and filtering in data analysis

**Logisk indexering** möjliggör filtrering av rader i en data frame baserat på **villkor**. Istället för att komma ihåg radnummer anger du logiska uttryck, och endast rader där villkoret är `TRUE` returneras.

name <- c("Alex", "Julia", "Finn")
age <- c(24, 43, 32)
gender <- c("M", "F", "M")
test <- data.frame(name, age, gender)

# People older than 30
test[test$age > 30, ]
# Males only
test[test$gender == 'M', ]

Villkoret ska placeras i radindexpositionen inom hakparenteser (`[condition, ]`).

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Виконуємо user_code.R, отримуємо res$logs
#  2) Кожний CASE — окремий dynamic_test(...)
# =====================================================================

library(testthat)
source(testthat::test_path("helper-run_user_code.R"), local = TRUE)

# Ідентифікація файлу користувача
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)
user_file <- candidates[file.exists(candidates)][1]
if (is.na(user_file)) stop("user_code.R not found")

# Виконання коду з обмеженням обсягу виводу
logs_full <- utils::capture.output(source(user_file, echo = FALSE, print.eval = TRUE))
out <- trimws(substr(paste(logs_full, collapse = " "), 1, 1000))  # максимум 1000 символів

# ---------- CASE 1 ----------
{
  fastest <- mtcars[mtcars$qsec < 16, ]
  ok <- all(rownames(fastest) %in% c("Duster 360", "Camaro Z28", "Ford Pantera L", "Ferrari Dino", "Maserati Bora"))

  dynamic_test(
    ok,
    "Filtering mtcars[qsec < 16] returns correct rows (fastest cars)",
    sprintf("Expected rows: Duster 360, Camaro Z28, Ford Pantera L, Ferrari Dino, Maserati Bora. Got: %s",
            paste(rownames(fastest), collapse = ", "))
  )
}

# ---------- CASE 2 ----------
{
  six_cyl <- mtcars[mtcars$cyl == 6, ]
  ok <- all(rownames(six_cyl) %in% c("Mazda RX4", "Mazda RX4 Wag", "Hornet 4 Drive",
                                     "Valiant", "Merc 280", "Merc 280C", "Ferrari Dino"))

  dynamic_test(
    ok,
    "Filtering mtcars[cyl == 6] returns correct rows (6-cylinder cars)",
    sprintf("Expected 7 rows: Mazda RX4, Mazda RX4 Wag, Hornet 4 Drive, Valiant, Merc 280, Merc 280C, Ferrari Dino. Got: %s",
            paste(rownames(six_cyl), collapse = ", "))
  )
}

# ---------- CASE 3 ----------
{
  ok <- grepl("Duster 360", out) &&
        grepl("Camaro Z28", out) &&
        grepl("Ferrari Dino", out) &&
        grepl("Mazda RX4", out) &&
        grepl("Hornet 4 Drive", out) &&
        grepl("Valiant", out)

  dynamic_test(
    ok,
    "Console output contains names of fastest and 6-cylinder cars",
    sprintf("Expected output to include Duster 360, Camaro Z28, Ferrari Dino, Mazda RX4, Hornet 4 Drive, Valiant. Actual (first 300 chars): %s",
            substr(out, 1, 300))
  )
}

# ---------- CASE 4 ----------
{
  # розділяємо аутпут на два датафрейми по повторному заголовку
  parts <- strsplit(out, "mpg cyl disp hp drat wt qsec vs am gear carb")[[1]]
  part1 <- if (length(parts) >= 2) parts[2] else out
  part2 <- if (length(parts) >= 3) parts[3] else out

  # перевіряємо, що у першій частині (fastest cars) є типові моделі
  fast_ok <- grepl("Duster 360", part1) &&
             grepl("Camaro Z28", part1) &&
             grepl("Ford Pantera L", part1) &&
             grepl("Ferrari Dino", part1) &&
             grepl("Maserati Bora", part1)

  # перевіряємо, що у другій частині (6 cylinders) є типові моделі
  cyl6_ok <- grepl("Mazda RX4", part2) &&
             grepl("Mazda RX4 Wag", part2) &&
             grepl("Hornet 4 Drive", part2) &&
             grepl("Valiant", part2) &&
             grepl("Merc 280", part2) &&
             grepl("Merc 280C", part2) &&
             grepl("Ferrari Dino", part2)

  ok <- fast_ok && cyl6_ok

  dynamic_test(
    ok,
    "Console output contains both filtered data frames with correct car names",
    sprintf("Expected first output to include Duster 360... and second to include Mazda RX4... Actual (first 400 chars): %s",
            substr(out, 1, 400))
  )
}


test_hidden.R

# =====================================================================
# ВСПОМОГАТЕЛЬНЫЕ ХЕЛПЕРЫ ДЛЯ ТЕСТОВ
#
# Файл называется helper-*.R: testthat автоматически подхватывает такие
# файлы перед выполнением любых тестов в каталоге tests/testthat.
# =====================================================================

# -----------------------------------------------------------------------------
# run_user_code(...)
#  - безопасно запускает user_code.R в отдельном окружении (env)
#  - перехватывает ВЕСЬ вывод (stdout): как результаты выражений, так и print()/cat()
#  - возвращает:
#       values  — список запрошенных переменных (по именам из аргумента capture)
#       logs    — вектор строк перехваченного вывода
#       env     — окружение, где выполнялся user_code (можно исследовать при необходимости)
#
# ПАРАМЕТРЫ:
#   file        — путь к user_code.R
#   capture     — character-вектор имён переменных, которые нужно извлечь после выполнения
#   inject      — список объектов/функций, которые нужно «подложить» в среду исполнения
#                 (можно использовать для моков/маскировки опасных функций: system, file.remove и т.д.)
#   echo        — печатать код при исполнении (обычно FALSE)
#   print.eval  — ПЕЧАТАТЬ РЕЗУЛЬТАТЫ ВЫРАЖЕНИЙ. Ключевая опция, чтобы строки вида
#                 `prices['Armchair']` попадали в stdout без явного print().
#
# БЕЗОПАСНОСТЬ:
#   - В базовом R нет полноценной «песочницы». Мы изолируем код в новом env,
#     но ОС-доступ не блокируется магически.
#   - Для задач онлайн-платформы можно частично «глушить» опасные вызовы через inject,
#     например:
#       inject = list(
#         system      = function(...) stop("system disabled"),
#         file.remove = function(...) stop("file.remove disabled")
#       )
# -----------------------------------------------------------------------------
run_user_code <- function(
  file = "user_code.R",
  capture = character(0),
  inject = list(),
  echo = FALSE,
  print.eval = TRUE
) {
  # Бросаем явную ошибку, если файла нет (проще диагностировать)
  stopifnot(file.exists(file))

  # Изолированное окружение: parent=baseenv() (без лишних пользовательских объектов сверху)
  env <- new.env(parent = baseenv())

  # Подмешиваем моки/данные в окружение (при необходимости)
  if (length(inject)) list2env(inject, envir = env)

  # ВАЖНО: перехватываем весь вывод выполнения файла.
  # source(..., local=env, echo, print.eval) исполняет код ВНУТРИ env.
  # print.eval=TRUE заставляет R печатать результаты выражений (как в консоли),
  # что позволяет проверять «голые» выражения без print().
  logs <- utils::capture.output(
    base::source(file, local = env, echo = echo, print.eval = print.eval)
  )

  # Собираем запрошенные значения переменных
  values <- setNames(vector("list", length(capture)), capture)
  for (nm in capture) {
    if (exists(nm, envir = env, inherits = FALSE)) {
      values[[nm]] <- get(nm, envir = env, inherits = FALSE)
    } else {
      values[[nm]] <- NULL
    }
  }

  list(values = values, logs = logs, env = env)
}

# -----------------------------------------------------------------------------
# dynamic_test(condition, success, failure)
#  - Создаёт ОДИН тест с «динамическим» названием.
#  - Если condition=TRUE → тест называется success.
#  - Если condition=FALSE → тест называется failure, и тест проваливается.
#  - Используем настоящую expectation (expect_true(TRUE)), чтобы репортёры всегда
#    печатали имя успеха (TAP, progress и т.д.).
# -----------------------------------------------------------------------------
dynamic_test <- function(condition, success, failure) {
  if (isTRUE(condition)) {
    testthat::test_that(success, {
      testthat::expect_true(TRUE)
    })
  } else {
    testthat::test_that(failure, {
      testthat::fail(failure)
    })
  }
}
# =====================================================================

helper-run_user_code.R

Få en gedigen förståelse för R, ett av de mest använda språken för dataanalys. Utforska grundläggande datatyper och endimensionella värden, och gå sedan vidare till flerdimensionella strukturer, inklusive matriser, data frames och listor. Bygg de färdigheter som krävs för att använda R effektivt inom statistisk analys och datadrivna beslutsprocesser.

Lär dig grunderna i R-syntax, såsom aritmetik, variabler, utskriftsfunktioner och kommentarer. Fördjupa förståelsen av beräkningslogik genom övningar.

Utforska R:s datatyper och förstå deras roll i datahantering. Utveckla färdigheter i att arbeta med vektorer som grundläggande strukturer för att organisera och analysera information.

Utveckla förmågan att hantera kategoriska data effektivt. Upptäck hur man strukturerar, grupperar och tolkar värden genom att omvandla rådata till tydliga kategorier.

Förstå hur man representerar och arbetar med strukturerad tvådimensionell data. Bygg upp säkerhet i att transformera, märka och tillämpa operationer på matriser för analytiska uppgifter.

Behärska den mest använda datastrukturen i R för tabellinformation. Lär dig att organisera, transformera och extrahera insikter från dataset för att stödja datadrivna beslut.

Lär dig hur listor går utöver vektorer genom att lagra element av olika typer och längder. Utveckla förmågan att skapa, komma åt och modifiera listor för att organisera komplexa datastrukturer.

Logisk Indexering

Exempel

Lösning