ru
Feedback

Не попадитесь на канал ботавода! Telemetrio находит и помечает такие каналы 👉 Хотите видеть метку — оформите подписку

ACCENTURE EXAM SOLUTIONS

ACCENTURE EXAM SOLUTIONS

Открыть в Telegram

🔥Guys plz Stop fearing for daily exams 📝 👨‍💻 @srksvk is here to help you all at lowest cost possible.💪 🌀 ” Our Only Aim Is To Let Get Placed To You In A Reputed Company 🔥Effort from our side = 💯 📱Main Channel: @coding_are 📱Tel I'd : @srksvk

Больше

📈 Аналитический обзор Telegram-канала ACCENTURE EXAM SOLUTIONS

Канал ACCENTURE EXAM SOLUTIONS (@coding_are) языкового сегмента Английский является активным участником. Сейчас сообщество объединяет 13 833 подписчиков, занимая 14 760 место в категории Образование и 28 177 место в регионе Индия.

📊 Показатели аудитории и динамика

С момента создания невідомо проект демонстрирует стремительный рост, собрав аудиторию из 13 833 подписчиков.

Согласно последним данным от 20 ноября, 2026, канал показывает стабильную активность. За последние 30 дней изменение числа участников составило -171, а за последние 24 часа — 0, при этом общий охват остаётся высоким.

  • Статус верификации: Не верифицирован
  • Уровень вовлечённости (ER): Средний показатель вовлечённости аудитории составляет 3.50%. В первые 24 часа после публикации контент обычно набирает 1.07% реакций от общего числа подписчиков.
  • Охват публикаций: В среднем каждый пост получает 484 просмотров. В течение первых суток публикация набирает 148 просмотров.
  • Реакции и взаимодействия: Аудитория активно поддерживает контент: среднее количество реакций на один пост — 1.
  • Тематические интересы: Контент сосредоточен на ключевых темах, таких как placement, gaurntee, suree, capgemini, infosy.

📝 Описание и контентная политика

Автор описывает ресурс как площадку для выражения субъективного мнения:
“🔥Guys plz Stop fearing for daily exams 📝 👨‍💻 @srksvk is here to help you all at lowest cost possible.💪 🌀 ” Our Only Aim Is To Let Get Placed To You In A Reputed Company 🔥Effort from our side = 💯 📱Main Channel: @coding_are 📱Tel I'd : @srks...”

Благодаря высокой частоте обновлений (последние данные получены 21 ноября, 2026) канал поддерживает актуальность и высокий уровень охвата публикаций. Аналитика показывает, что аудитория активно взаимодействует с контентом, что делает его важной точкой влияния в категории Образование.

13 833
Подписчики
Нет данных24 часа
-397 дней
-17130 дней
Архив постов
Hii guys 👍 How many students started exam now Giver hert to this post
29 нояб. 2024, 22:31
30 нояб. 2024, ~11:02

NEED more TCS CODEVITA ANSWERS ? Give heart to this post ❤️ Fully passed code 👍
29 нояб. 2024, 15:51
30 нояб. 2024, ~11:02

Next code loded 👇⬇️⬇️⬇️⬇️ https://t.me/codeing_are Join the group
29 нояб. 2024, 15:44
30 нояб. 2024, ~11:02

#include <iostream> #include <vector> #include <set> #include <cmath> #include <map> #include <algorithm> using namespace std; polygon using the Shoelace Theorem int calculateArea(const vector<pair<int, int>>& polygon) { int n = polygon.size(); int area = 0; for (int i = 0; i < n; i++) { int j = (i + 1) % n; area += polygon[i].first * polygon[j].second; area -= polygon[j].first * polygon[i].second; } return abs(area) / 2; } are connected bool areConnected(pair<int, int> a, pair<int, int> b, pair<int, int>& p1, pair<int, int>& p2) { return (p1 == a && p2 == b) || (p1 == b && p2 == a); } int main() { int N; cin >> N; vector<pair<int, int>> coordinates; vector<vector<pair<int, int>>> segments(N); set<pair<int, int>> points; store them as pairs for (int i = 0; i < N; i++) { int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; coordinates.push_back({x1, y1}); coordinates.push_back({x2, y2}); points.insert({x1, y1}); points.insert({x2, y2}); } vector<pair<int, int>> polygon; int maxArea = 0; to form polygons for (auto p1 = points.begin(); p1 != points.end(); ++p1) { for (auto p2 = next(p1); p2 != points.end(); ++p2) { polygon.push_back(*p1); polygon.push_back(*p2); maxArea = max(maxArea, calculateArea(polygon)); } } cout << maxArea << endl; return 0; } maximum area
29 нояб. 2024, 15:41
30 нояб. 2024, ~11:02

#include <iostream> #include <unordered_map> #include <unordered_set> #include <queue> #include <sstream> #include <vector> using namespace std; unordered_map<string, int> calculateLevels(unordered_map<string, vector<string>>& graph, const string& root) { unordered_map<string, int> levels; queue<pair<string, int>> q; q.push(make_pair(root, 1)); while (!q.empty()) { pair<string, int> current = q.front(); q.pop(); string node = current.first; int level = current.second; levels[node] = level; for (const string& child : graph[node]) { q.push(make_pair(child, level + 1)); } } return levels; } int main() { int n; cin >> n; unordered_map<string, vector<string>> graph; unordered_set<string> children; unordered_set<string> nodes; for (int i = 0; i < n; ++i) { string parent, child; cin >> parent >> child; graph[parent].push_back(child); children.insert(child); nodes.insert(parent); nodes.insert(child); } string root; for (const string& node : nodes) { if (children.find(node) == children.end()) { root = node; break; } } unordered_map<string, int> levels = calculateLevels(graph, root); cin.ignore(); string inputLine, word; getline(cin, inputLine); stringstream ss(inputLine); int totalValue = 0; while (ss >> word) { if (levels.find(word) != levels.end()) { totalValue += levels[word]; } else { totalValue += -1; } } cout << totalValue << endl; return 0; } String Puzzle Done ✅
29 нояб. 2024, 15:36
30 нояб. 2024, ~11:02

Next code loded
29 нояб. 2024, 15:29
30 нояб. 2024, ~11:02

How many writing now exam Hit ♥️?
29 нояб. 2024, 15:18
30 нояб. 2024, ~11:02

Ready for next everyone ✅
29 нояб. 2024, 15:06
30 нояб. 2024, ~11:02

from collections import deque def count_infected_neighbors(board, x, y): size = len(board) infected_count = 0 for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: if dx == 0 and dy == 0: continue nx, ny = x + dx, y + dy if 0 <= nx < size and 0 <= ny < size and board[nx][ny] == 1: infected_count += 1 return infected_count def plague_simulation(board): size = len(board) new_board = [row[:] for row in board] for x in range(size): for y in range(size): infected_count = count_infected_neighbors(board, x, y) if board[x][y] == 0 and infected_count == 3: new_board[x][y] = 1 elif board[x][y] == 1 and (infected_count < 2 or infected_count > 3): new_board[x][y] = 0 return new_board def find_path(grid_size, initial_board): board = [[1 if cell == '1' else 0 for cell in row] for row in initial_board] start_x, start_y, end_x, end_y = -1, -1, -1, -1 for x in range(grid_size): for y in range(grid_size): if initial_board[x][y] == 's': start_x, start_y = x, y board[x][y] = 0 if initial_board[x][y] == 'd': end_x, end_y = x, y board[x][y] = 0 queue = deque([(start_x, start_y, board, 0)]) visited_states = set() while queue: x, y, current_board, days = queue.popleft() if x == end_x and y == end_y: return days state = (x, y, tuple(map(tuple, current_board))) if state in visited_states: continue visited_states.add(state) next_board = plague_simulation(current_board) for dx, dy in [(0, 0), (-1, 0), (1, 0), (0, -1), (0, 1)]: nx, ny = x + dx, y + dy if 0 <= nx < grid_size and 0 <= ny < grid_size and next_board[nx][ny] == 0: queue.append((nx, ny, next_board, days + 1)) return -1 if name == "main": n = int(input()) grid = [input().strip() for _ in range(n)] print(find_path(n, grid) + 1) Plague 2050 ✅✅ Full passed✅✅
29 нояб. 2024, 15:00
30 нояб. 2024, ~11:02

Full accepted Please shared my group everyone ✅✅ https://t.me/codeing_are
29 нояб. 2024, 14:57
30 нояб. 2024, ~11:02

def rotate_layer(layer, positions, direction, odd_layer): n = len(layer) rotated = [None] * n if direction == "clockwise": for i in range(n): rotated[(i + positions) % n] = layer[i] else: # counterclockwise for i in range(n): rotated[(i - positions) % n] = layer[i] for i in range(n): if odd_layer: rotated[i] = chr(((ord(rotated[i]) - ord('A') - 1) % 26) + ord('A')) else: rotated[i] = chr(((ord(rotated[i]) - ord('A') + 1) % 26) + ord('A')) return rotated def apply_query(matrix, row, col, size): layers = [] for layer in range(size // 2): current_layer = [] for j in range(col + layer, col + size - layer): current_layer.append(matrix[row + layer][j]) for i in range(row + layer + 1, row + size - layer - 1): current_layer.append(matrix[i][col + size - layer - 1]) for j in range(col + size - layer - 1, col + layer - 1, -1): current_layer.append(matrix[row + size - layer - 1][j]) for i in range(row + size - layer - 2, row + layer, -1): current_layer.append(matrix[i][col + layer]) layers.append(current_layer) for layer_idx, layer in enumerate(layers): odd_layer = (layer_idx + 1) % 2 == 1 direction = "counterclockwise" if odd_layer else "clockwise" positions = layer_idx + 1 rotated_layer = rotate_layer(layer, positions, direction, odd_layer) idx = 0 for j in range(col + layer_idx, col + size - layer_idx): matrix[row + layer_idx][j] = rotated_layer[idx] idx += 1 for i in range(row + layer_idx + 1, row + size - layer_idx - 1): matrix[i][col + size - layer_idx - 1] = rotated_layer[idx] idx += 1 for j in range(col + size - layer_idx - 1, col + layer_idx - 1, -1): matrix[row + size - layer_idx - 1][j] = rotated_layer[idx] idx += 1 for i in range(row + size - layer_idx - 2, row + layer_idx, -1): matrix[i][col + layer_idx] = rotated_layer[idx] idx += 1 def process_matrix(n, matrix, queries): for row, col, size in queries: apply_query(matrix, row, col, size) result = ''.join(''.join(row) for row in matrix) return result n = int(input()) matrix = [list(input().strip().split()) for _ in range(n)] q = int(input().strip()) queries = [tuple(map(int, input().strip().split())) for _ in range(q)] result = process_matrix(n, matrix, queries) print(result, end="") Matrix rotation
29 нояб. 2024, 14:56
30 нояб. 2024, ~11:02

Ready for next answer 👇👇👇👇👇
29 нояб. 2024, 14:43
30 нояб. 2024, ~11:02

How many writeing exam now Hit ♥️
29 нояб. 2024, 14:39
30 нояб. 2024, ~11:02

Fully accepted ☺️
29 нояб. 2024, 14:34
30 нояб. 2024, ~11:02

def min_cost_to_form_string(substrings, main_string): inf = float('inf') dp = [inf] * (len(main_string) + 1) dp[0] = 0 # Cost to form an empty string is 0 substrings with their costs substring_cost = {} for substring, cost in substrings: substring_cost[substring] = cost for i in range(1, len(main_string) + 1): for j in range(i): sub = main_string[j:i] # Get the substring from j to i if sub in substring_cost:ue dp[i] = min(dp[i], dp[j] + substring_cost[sub]) dp[len(main_string)] if dp[len(main_string)] == inf: return "Impossible" else: return dp[len(main_string)] if name == "main": N = int(input()) substrings = [] for _ in range(N): line = input().split() substrings.append((line[0], int(line[1]))) # Append tuple (substring, cost) main_string = input().strip() result = min_cost_to_form_string(substrings, main_string) print(result) Form the string
29 нояб. 2024, 14:34
30 нояб. 2024, ~11:02

Want more code now Hit ♥️
29 нояб. 2024, 14:28
30 нояб. 2024, ~11:02

Next coding loded?
29 нояб. 2024, 14:25
30 нояб. 2024, ~11:02

Fully accepted 🔥🔥🔥
29 нояб. 2024, 14:23
30 нояб. 2024, ~11:02

#include <bits/stdc++.h> bool isInside(int x, int y, const vector<pair<int, int>>& verts) { int cross = 0, N = verts.size(); for(int i = 0; i < N; ++i){ int x1 = verts[i].first, y1 = verts[i].second; int x2 = verts[(i+1)%N].first, y2 = verts[(i+1)%N].second; if(((y1 <= y) && (y2 > y)) || ((y2 <= y) && (y1 > y))){ double ix = x1 + (double)(y - y1) * (x2 - x1) / (y2 - y1); if(ix > x) cross++; } } return (cross % 2) != 0; } int main(){ ios::sync_with_stdio(false); cin.tie(0); int N; cin >> N; vector<pair<int, int>> verts(N); int minX = INT32_MAX, maxX = INT32_MIN, minY = INT32_MAX, maxY = INT32_MIN; for(auto &p : verts){ cin >> p.first >> p.second; minX = min(minX, p.first); maxX = max(maxX, p.first); minY = min(minY, p.second); maxY = max(maxY, p.second); } int M; cin >> M; int w = maxX - minX + 1, h = maxY - minY + 1; vector<vector<int>> grid(h, vector<int>(w, 0)); for(int y = minY; y < maxY; ++y){ for(int x = minX; x < maxX; ++x){ if(isInside(x + 0.5, y + 0.5, verts)){ grid[y - minY][x - minX] = 1; } } } vector<pair<int, int>> cells; for(int i=0;i<h;i++) { for(int j=0;j<w;j++) { if(grid[i][j]==1){ cells.emplace_back(i,j); } } } sort(cells.begin(), cells.end()); int minPresses = INT32_MAX; function<void(int, vector<vector<int>>&, int)> backtrack = & { if(presses >= minPresses) return; while(idx < cells.size() && curGrid[cells[idx].first][cells[idx].second]==0){ idx++; } if(idx == cells.size()){ minPresses = min(minPresses, presses); return; } int y = cells[idx].first, x = cells[idx].second; bool canPlace = true; for(int dy=0; dy<M && canPlace; dy++){ for(int dx=0; dx<M && canPlace; dx++){ int ny = y + dy, nx = x + dx; if(ny >= h nx >= w curGrid[ny][nx]==0) canPlace = false; } } if(canPlace){ vector<vector<int>> newGrid = curGrid; for(int dy=0; dy<M; dy++){ for(int dx=0; dx<M; dx++){ int ny = y + dy, nx = x + dx; if(ny < h && nx < w) newGrid[ny][nx] = 0; } } backtrack(idx +1, newGrid, presses +1); } }; backtrack(0, grid, 0); cout << minPresses; } COUNT PRESS
29 нояб. 2024, 14:22
30 нояб. 2024, ~11:02

Plague #include <iostream> #include <vector> #include <queue> #include <set> #include <tuple> using namespace std; int countInfectedNeighbors(const vector<vector<int>>& grid, int x, int y) {     int n = grid.size();     int infected = 0;     for (int dx = -1; dx <= 1; dx++) {         for (int dy = -1; dy <= 1; dy++) {             if (dx == 0 && dy == 0) continue;             int nx = x + dx, ny = y + dy;             if (nx >= 0 && nx < n && ny >= 0 && ny < n && grid[nx][ny] == 1) {                 infected++;             }         }     }     return infected; } vector<vector<int>> simulatePlague(const vector<vector<int>>& grid) {     int n = grid.size();     vector<vector<int>> nextGrid = grid;         for (int x = 0; x < n; x++) {         for (int y = 0; y < n; y++) {             int infected = countInfectedNeighbors(grid, x, y);                         if (grid[x][y] == 0 && infected == 3) {                 nextGrid[x][y] = 1;             } else if (grid[x][y] == 1) {                 if (infected < 2 || infected > 3) {                     nextGrid[x][y] = 0;                 }             }         }     }         return nextGrid; } int solve(int n, vector<vector<char>>& initialGrid) {     vector<vector<int>> grid(n, vector<int>(n));     int startx = -1, starty = -1, destx = -1, desty = -1;         for (int x = 0; x < n; x++) {         for (int y = 0; y < n; y++) {             grid[x][y] = (initialGrid[x][y] == '1') ? 1 : 0;                         if (initialGrid[x][y] == 's') {                 startx = x;                 starty = y;                 grid[x][y] = 0;             }             if (initialGrid[x][y] == 'd') {                 destx = x;                 desty = y;                 grid[x][y] = 0;             }         }     }         queue<tuple<int, int, vector<vector<int>>, int>> q;     set<tuple<int, int, vector<vector<int>>>> visited;         q.push({startx, starty, grid, 0});         while (!q.empty()) {         auto [x, y, current_grid, days] = q.front();         q.pop();                 if (x == destx && y == desty) {             return days;         }                 auto state_key = make_tuple(x, y, current_grid);         if (visited.count(state_key)) continue;         visited.insert(state_key);                 vector<vector<int>> next_grid = simulatePlague(current_grid);                 vector<pair<int, int>> moves = {{0,0}, {-1,0}, {1,0}, {0,-1}, {0,1}};         for (auto [dx, dy] : moves) {             int nx = x + dx, ny = y + dy;                         if (nx >= 0 && nx < n && ny >= 0 && ny < n && next_grid[nx][ny] == 0) {                 q.push({nx, ny, next_grid, days + 1});             }         }     }         return -1; } int main() {     int n;     cin >> n;         vector<vector<char>> grid(n, vector<char>(n));     for (int i = 0; i < n; i++) {         for (int j = 0; j < n; j++) {             cin >> grid[i][j];         }     }         cout << solve(n, grid)+1;     return 0; } Plague 2050
29 нояб. 2024, 14:20
30 нояб. 2024, ~11:02