Flipkart | MSI Katana 15 Intel Core i7 13th Gen Gaming Laptop At Rs.76,590

Link : https://fkrt.co/iaSUQ0

FairCloud AI is hiring for Software Engineer Intern

Experience: 0 - 1 year
Stipend: coompetitive

Apply here: https://www.linkedin.com/jobs/view/4082269421/?alternateChannel=search

Capstoneco Hiring
Summer Internship
Batch: 2025/2026
Location: London, New York
Duration: 10 Weeks

Apply now:- https://www.itjobs.services/2024/11/capstoneco-hiring.html

Industrial code

int main() {
int n, m, k, d = 1, rv = 0;
cin >> n >> m;
vector<set<int>> f(n);
for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v;
f[u].insert(v);
f[v].insert(u);
}
cin >> k;
vector<bool> w(n, true);
rv = n;
while (rv < k) {
vector<bool> nw(n, false);
for (int i = 0; i < n; ++i) {
int cnt = 0;
for (int fr : f[i]) cnt += w[fr];
if (w[i] && cnt == 3) nw[i] = true;
else if (!w[i] && cnt < 3) nw[i] = true;
}
w = nw;
rv += count(w.begin(), w.end(), true);
++d;
}
cout << d;
return 0;
}
Office Rostering
C+
TCS exam

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <algorithm>

using namespace std;

struct Line {
int x1, y1, x2, y2;
};
int countCells(Line line, pair<int, int> star, bool split) {
if (line.x1 == line.x2) {
if (split) {
return min(abs(star.second - line.y1), abs(star.second - line.y2)) + 1;
}
else {
return abs(line.y1 - line.y2) + 1;
}
}
else {
if (split) {
return min(abs(star.first - line.x1), abs(star.first - line.x2)) + 1;
}
else {
return abs(line.x1 - line.x2) + 1;
}
}
}
bool intersects(Line a, Line b, pair<int, int>& intersection) {
if (a.x1 == a.x2 && b.y1 == b.y2) {
if (b.x1 <= a.x1 && a.x1 <= b.x2 && a.y1 <= b.y1 && b.y1 <= a.y2) {
intersection = {a.x1, b.y1};
return true;
}
}
if (a.y1 == a.y2 && b.x1 == b.x2) {
if (a.x1 <= b.x1 && b.x1 <= a.x2 && b.y1 <= a.y1 && a.y1 <= b.y2) {
intersection = {b.x1, a.y1};
return true;
}
}
return false;
}
int main() {
int N, K;
cin >> N;
vector<Line> lines(N);
for (int i = 0; i < N; ++i) {
cin >> lines[i].x1 >> lines[i].y1 >> lines[i].x2 >> lines[i].y2;
if (lines[i].x1 > lines[i].x2 || (lines[i].x1 == lines[i].x2 && lines[i].y1 > lines[i].y2)) {
swap(lines[i].x1, lines[i].x2);
swap(lines[i].y1, lines[i].y2);
}
}
cin >> K;
map<pair<int, int>, vector<Line>> stars;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
pair<int, int> intersection;
if (intersects(lines[i], lines[j], intersection)) {
stars[intersection].push_back(lines[i]);
stars[intersection].push_back(lines[j]);
}
}
}

int asiylam = 0;
for (auto& star : stars) {
if (star.second.size() / 2 == K) {
vector<int> intensities;
for (auto& line : star.second) {
intensities.push_back(countCells(line, star.first, true));
}
asiylam += *min_element(intensities.begin(), intensities.end());
}
}
cout << asiylam << endl;
return 0;
}

Magic Star Intensity Code
C++
TCS Exam

Tcs exam

int main() {
string s;
cin >> s;
int n = s.length(), res = 0;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
int lw = s[0] - '0', lwv = v[0];
for (int i = 1; i < n; ++i) {
if (s[i] - '0' == lw) {
res += min(lwv, v[i]);
lwv = max(lwv, v[i]);
} else {
lw = s[i] - '0';
lwv = v[i];
}
}
cout << res;
return 0;
}
Form alternating string

Change accordingly before submitting to avoid plagiarism

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
int N = int.Parse(Console.ReadLine());
var graph = new Dictionary<string, List<string>>();
var indegrees = new Dictionary<string, int>();


for (int i = 0; i < N; i++)
{
var edge = Console.ReadLine().Split();
string from = edge[0];
string to = edge[1];

if (!graph.ContainsKey(from))
graph[from] = new List<string>();
graph[from].Add(to);


if (!indegrees.ContainsKey(from))
indegrees[from] = 0;
if (!indegrees.ContainsKey(to))
indegrees[to] = 0;
indegrees[to]++;
}


var words = Console.ReadLine().Split();


var levels = new Dictionary<string, int>();
var queue = new Queue<string>();


foreach (var node in indegrees.Keys)
{
if (indegrees[node] == 0)
{
levels[node] = 1; // Root level is 1
queue.Enqueue(node);
}
}

while (queue.Count > 0)
{
var current = queue.Dequeue();
int currentLevel = levels[current];

if (graph.ContainsKey(current))
{
foreach (var neighbor in graph[current])
{
if (!levels.ContainsKey(neighbor))
{
levels[neighbor] = currentLevel + 1;
queue.Enqueue(neighbor);
}
indegrees[neighbor]--;
if (indegrees[neighbor] == 0 && !levels.ContainsKey(neighbor))
{
queue.Enqueue(neighbor);
}
}
}
}


int totalValue = 0;

foreach (var word in words)
{
if (levels.ContainsKey(word))
{
totalValue += levels[word];
}
else
{
totalValue += -1;
}
}


Console.Write(totalValue);
}
}
String Puzzle
C+

Company : NTT
Role : Intern
Qualification :Bachelor’s / Master’s
Batch : 2025 & 2026
Salary : Up to ₹ 6LPA
Experience : Fresher’s
Location : Bengaluru

Apply link : https://careers.services.global.ntt/global/en/job/NTT1GLOBALR121946EXTERNALENGLOBAL/Intern?utm_source=indeed&utm_medium=phenom-feeds


Company : Capgemini
Role : Deal Centre of Excellence
Qualification : Graduate/B Com/BAF
Batch : 2024 without any Active Backlogs
Salary : Up to ₹ 5 LPA
Experience : Fresher’s
Location : Mumbai

Apply link : https://www.capgemini.com/in-en/solutions/off-campus-drive-for-deal-centre-of-excellence-dcoe-2024-graduates/

Count press

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

int dp(string& s, vector<string>& v, unordered_map<string, int>& memo) {
if (memo.count(s)) return memo[s];

int maxRemoval = 0;

for (auto& x : v) {
size_t pos = s.find(x);
if (pos != string::npos) {
string new_string = s.substr(0, pos) + s.substr(pos + x.size());
maxRemoval = max(maxRemoval, 1 + dp(new_string, v, memo));
}
}
return memo[s] = maxRemoval;
}

int main() {
int n;
cin >> n;

vector<string> substrings(n);
for (int i = 0; i < n; ++i) {
cin >> substrings[i];
}

string mainString;
cin >> mainString;

unordered_map<string, int> memo;
cout << dp(mainString, substrings, memo);

return 0;
}


FOLDER AREA
#include <iostream>
#include <cmath>
#include <set>
#include <iomanip>
#include <vector>
#include <utility>
using namespace std;

pair<double, double> reflectPoint(double px, double py, double x1, double y1, double x2, double y2) {
double A = y2 - y1;
double B = x1 - x2;
double C = x2 * y1 - x1 * y2;
double distance = (A * px + B * py + C) / sqrt(A * A + B * B);
double reflectedX = px - 2 * distance * (A / sqrt(A * A + B * B));
double reflectedY = py - 2 * distance * (B / sqrt(A * A + B * B));
return {reflectedX, reflectedY};
}

int main() {
double area;
cout << "Enter area of the square: ";
cin >> area;

double x1, y1, x2, y2;
cout << "Enter the coordinates of the line (x1 y1 x2 y2): ";
cin >> x1 >> y1 >> x2 >> y2;

double side = sqrt(area);
vector<pair<double, double>> corners = {
{0, 0},
{0, side},
{side, side},
{side, 0}
};

set<pair<double, double>> uniquePoints(corners.begin(), corners.end());

for (const auto& corner : corners) {
auto [rx, ry] = reflectPoint(corner.first, corner.second, x1, y1, x2, y2);
uniquePoints.insert({rx, ry});
}

for (const auto& point : uniquePoints) {
cout << fixed << setprecision(2) << point.first << " " << point.second << endl;
}

return 0;
}

Segment display
#include <bits/stdc++.h>
using namespace std;

int main() {
vector<vector<string>> A = {
{"11111", "11111", "11111", "11111", "11111", "11111", "11111", "10001", "11111", "11111", "10001", "10000", "11111", "10001", "01110", "11111", "11111", "11111", "11111", "11111", "10001", "10001", "10001", "10001", "10001", "11111"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "10010", "10000", "10101", "11001", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "00000", "10001", "00000"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "10100", "10000", "10101", "10101", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "01010", "10001", "00010"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "11000", "10000", "10101", "10011", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "00000", "10001", "00000"},
{"11111", "11111", "10000", "10001", "11111", "11111", "10111", "11111", "00100", "10001", "11111", "10000", "10101", "10001", "10001", "11111", "10101", "11111", "11111", "00100", "10001", "10001", "10101", "00100", "11111", "00100"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10001", "10001", "00100", "10001", "10001", "10000", "10001", "10001", "10001", "10000", "10001", "11000", "00001", "00100", "10001", "10001", "10101", "00000", "00001", "00000"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10001", "10001", "00100", "10001", "10001", "10000", "10001", "10001", "10001", "10000", "10011", "10100", "00001", "00100", "10001", "10001", "10101", "01010", "00001", "01000"},
{"10001", "10001", "10000", "10001", "10000", "10000",