Summary  
This chapter explains how to use basic arithmetic operators (+, –, *, /) in code to perform calculations and have their results implicitly printed.

General domain of usage  
Data analysis

R is a programming language designed for statistical computing and data analysis. You use R to explore, manipulate, and visualize data, making it a popular choice for data analysts, statisticians, and researchers across many fields.

Unlike spreadsheet tools such as Excel, R lets you write arithmetic expressions directly in the console and see immediate results. This approach is similar to using a calculator, but with the added benefit of scripting and automating calculations for repeatable analysis.

Note

In R, arithmetic expressions can be written directly in the console, and the result is displayed without the need for an explicit print function.

## Arithmetic Operators
You can use the following operators for basic arithmetic:
- `+` for addition;
- `-` for subtraction;
- `*` for multiplication;
- `/` for division.

Each new operation should start on a new line.

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Один раз выполняем пользовательский файл в отдельном окружении
#     через run_user_code(...). Получаем:
#       - res$values$...  — переменные из окружения (prices, items и т.п.)
#       - res$logs        — весь печатный вывод (включая результаты выражений)
#  2) Каждый кейс — отдельный dynamic_test(...), то есть отдельная строка
#     в отчёте, с «говорящим» названием (успех/ошибка).
# =====================================================================

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

# Ищем user_code.R в двух вариантах:
#  1) в корне проекта:        ../../user_code.R  (относительно tests/testthat)
#  2) рядом с тестами:        user_code.R        (внутри tests/testthat)
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)

# Нормализуем пути, оставляем существующие
candidates_norm <- vapply(candidates, function(p) {
  tryCatch(normalizePath(p, winslash = "/", mustWork = FALSE), error = function(e) NA_character_)
}, character(1))

exists_flags <- file.exists(candidates_norm)
if (!any(exists_flags)) {
  stop(
    sprintf(
      "user_code.R not found.\nChecked paths:\n  - %s\nWorking dir: %s",
      paste(candidates, collapse = "\n  - "),
      getwd()
    )
  )
}

user_file <- candidates_norm[which(exists_flags)[1]]  # первый найденный

# Выполняем user_code.R один раз, извлекаем переменные и перехватываем вывод
res <- run_user_code(
  file       = user_file,
  capture    = character(0),  # Не захватываем переменные, только вывод
  echo       = FALSE,
  print.eval = TRUE
)

# ---------- CASE 1: 30 + 24 = 54 ----------
{
  out <- paste(res$logs, collapse = " ")
  # Match "54" as standalone number (not part of 154, 54x, etc.)
  ok  <- grepl("(^|[^0-9])54([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of 30 + 24 (54)",
    sprintf("Expected console output to include '54' (result of 30 + 24). Actual: %s", out)
  )
}

# ---------- CASE 2: 50 - 36 = 14 ----------
{
  out <- paste(res$logs, collapse = " ")
  # Match "14" as standalone number
  ok  <- grepl("(^|[^0-9])14([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of 50 - 36 (14)",
    sprintf("Expected console output to include '14' (result of 50 - 36). Actual: %s", out)
  )
}

# ---------- CASE 3: 19 * 7 = 133 ----------
{
  out <- paste(res$logs, collapse = " ")
  # Match "133" as standalone number
  ok  <- grepl("(^|[^0-9])133([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of 19 * 7 (133)",
    sprintf("Expected console output to include '133' (result of 19 * 7). Actual: %s", out)
  )
}

# ---------- CASE 4: 28 / 4 = 7 ----------
{
  out <- paste(res$logs, collapse = " ")
  # Match "7" as standalone number (not part of 17, 133, 7x, etc.)
  ok  <- grepl("(^|[^0-9])7([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of 28 / 4 (7)",
    sprintf("Expected console output to include '7' (result of 28 / 4). Actual: %s", out)
  )
}

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

This streamlined course introduces absolute beginners to the essentials of programming in R. Focusing on R syntax, variables, data types, operators, and basic control structures, it sets a solid foundation for further learning and data analysis in R.

Basic Arithmetic

Arithmetic Operators

Example

Soluzione