---

Хорошо, вот программы, которые принимают ввод через `input()` и выводят ответ через `print()`, без работы с файлами:

## Задача 1: Бусы

```python
# Бусы
N = int(input())
M = int(input())
X = int(input())

beads = []
for _ in range(N):
    beads.append(int(input()))

result = 0
last_x_pos = -1
second_last_x_pos = -1

for right in range(N):
    if beads[right] == X:
        second_last_x_pos = last_x_pos
        last_x_pos = right
    
    # Считаем подотрезки, оканчивающиеся в позиции right
    if last_x_pos != -1:
        min_left = second_last_x_pos + 1 if second_last_x_pos != -1 else 0
        max_left = last_x_pos
        
        if min_left <= max_left:
            result += (max_left - min_left + 1)

print(result)
```

## Задача 2: Мониторы

```python
# Мониторы
data = list(map(int, input().split()))
N = data[0]
K = data[1]
monitors = data[2:2+N]

half = N // 2

# Функция для проверки возможности достичь целевой громкости
def can_achieve(target):
    needed = 0
    for i in range(half):
        needed += max(0, target - monitors[i])
    return needed <= K

# Бинарный поиск по ответу
left = monitors[0]
right = monitors[0] + K + 1

while left < right:
    mid = (left + right + 1) // 2
    if can_achieve(mid):
        left = mid
    else:
        right = mid - 1

print(left)
```

## Задача 3: Клумба

```python
# Клумба
s, p = map(int, input().split())

count = 0

# Перебираем все возможные значения a
for a in range(1, int(s**0.5) + 1):
    # Для заданного a, максимальное b = s // a
    max_b = s // a
    
    # Перебираем b от a до max_b (чтобы избежать дублирования a×b и b×a)
    for b in range(a, max_b + 1):
        area = a * b
        perimeter = 2 * (a + b)
        
        if area <= s and perimeter <= p:
            count += 1

print(count)
```

## Задача 4: Дрон

```python
# Дрон
x, y, a, b, m, d = map(int, input().split())

def distance_to_point(pos):
    return abs(pos)

def distance_between_points(pos1, pos2):
    return abs(pos1 - pos2)

# Проверка возможности доставки обоих контейнеров одним рейсом
def can_deliver_both(pos1, mass1, pos2, mass2):
    if mass1 + mass2 > m:
        return False
    
    # Рассчитываем минимальное расстояние для маршрута 0 → pos1 → pos2 → 0
    route1 = distance_to_point(pos1) + distance_between_points(pos1, pos2) + distance_to_point(pos2)
    # Рассчитываем минимальное расстояние для маршрута 0 → pos2 → pos1 → 0
    route2 = distance_to_point(pos2) + distance_between_points(pos2, pos1) + distance_to_point(pos1)
    
    min_distance = min(route1, route2)
    return min_distance <= d

# Проверка возможности доставки одного контейнера
def can_deliver_single(pos, mass):
    if mass > m:
        return False
    
    distance = 2 * distance_to_point(pos)
    return distance <= d

# Проверяем все возможные варианты
# 1. Оба контейнера в одном рейсе
if can_deliver_both(x, a, y, b):
    print(1)
else:
    # 2. Разные рейсы
    trips = 0
    delivered = [False, False]
    
    # Проверяем возможность доставить каждый по отдельности
    if can_deliver_single(x, a):
        trips += 1
        delivered[0] = True
    
    if can_deliver_single(y, b):
        trips += 1
        delivered[1] = True
    
    # Если оба доставлены по отдельности
    if delivered[0] and delivered[1]:
        print(2)
    elif not (delivered[0] or delivered[1]):
        # Если ни один не может быть доставлен
        print(-1)
    else:
        # Если только один может быть доставлен
        print(2)
```

## Задача 5: Водяные часы

```python
# Водяные часы
import math

v, a, b, n = map(int, input().split())

# Считаем сколько раз добавлялась вода
add_count = n // a if n >= a else 0

# Считаем сколько раз вытекала вода
remove_count = n // b if n >= b else 0

if a == b:
    # Если периоды равны, вода не меняется
    final_volume = v
else:
    # Находим НОК
    lcm_ab = a * b // math.gcd(a, b)
    
    # Количество моментов времени, когда оба события происходят одновременно
    simultaneous_count = n // lcm_ab if n >= lcm_ab else 0
    
    # Финальный объём = начальный + добавления - удаления
    # Каждое одновременное событие было учтено и в добавлении, и в удалении
    final_volume = v + add_count - remove_count + simultaneous_count

print(final_volume)
```

Все программы:
1. Принимают ввод через `input()`
2. Обрабатывают данные в соответствии с условиями задач
3. Выводят ответ через `print()`
4. Не используют работу с файлами напрямую
5. Содержат необходимые вспомогательные функции для удобства решения