Apply now accolite // check your eligibility criteria

📌Good opportunity For 25,26 batch


✅Apply Link:
https://talenttitan.com/candidates/hiring-drives/bounteous-campus-hiring/#job-appiy-form

✅Direct assessment


📌Send this form to your TPO to add the college, and ask them to fill it out.

https://docs.google.com/forms/d/e/1FAIpQLSfozNWU67Overy0zBP4pA-pR2bcuW_dditbVRlqFVhUWF_Rvg/viewform

📌Channel link:
https://chat.whatsapp.com/K5I2JqrGT500M3Nt0rM6As?mode=ems_copy_t

Accolite codes Are Available 🎯

DM @Mrtrueliving_ix

Plagfree coding ✓

🕊️ Remembering Ratan Tata Sir

A true legend who inspired millions through his kindness, humility, and vision.
You taught us that success means nothing without compassion and honesty.
Your legacy will live forever in every heart you touched. ❤️

Gone from our sight, but never from our hearts.💔🫡🙏
— @Mrtrueliving_ix

#RatanTata #LegendLivesOn #InspirationForever

Infosys Sp trainee sending test Mails...check ✅

DM for placement Help @Mrtrueliving_ix

🚀 Form Alternating String – TCS CodeVita Round 1 (Zone 1)


---

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

int main() {
string s;
cin >> s;
int n = s.length(), mrtrueliving_ix = 0;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];

// 🔥 Join Telegram Channel for more codes: https://t.me/Code_alphix 🔥

int le = s[0] - '0', pl = v[0];
for (int i = 1; i < n; ++i) {
if (s[i] - '0' == le) {
mrtrueliving_ix += min(pl, v[i]);
pl = max(pl, v[i]);
} else {
le = s[i] - '0';
pl = v[i];
}
}
cout << mrtrueliving_ix;
return 0;
}


--
✅ 100% Correct Solution (C++)
💬 @Mrtrueliving_ix
📚 More codes: @Code_alphix

import heapq
from collections import defaultdict

def roll_e(t, l, f):
    b = 7 - t
    e = 7 - l
    w = l
    n = 7 - f
    s = f
    nt = w
    nw = b
    ne = t
    nb = e
    nn = n
    ns = s
    nl = nw
    nf = ns
    return (nt, nl, nf)

def roll_w(t, l, f):
    b = 7 - t
    e = 7 - l
    w = l
    n = 7 - f
    s = f
    nt = e
    nw = t
    ne = b
    nb = w
    nn = n
    ns = s
    nl = nw
    nf = ns
    return (nt, nl, nf)

def roll_s(t, l, f):
    b = 7 - t
    e = 7 - l
    w = l
    n = 7 - f
    s = f
    nt = n
    nb = s
    nn = b
    ns = t
    ne = e
    nw = w
    nl = nw
    nf = ns
    return (nt, nl, nf)

def roll_n(t, l, f):
    b = 7 - t
    e = 7 - l
    w = l
    n = 7 - f
    s = f
    nt = s
    nb = n
    nn = t
    ns = b
    ne = e
    nw = w
    nl = nw
    nf = ns
    return (nt, nl, nf)

def main():
    n = int(input().strip())
    pl = []
    for _ in range(n):
        a, b, d = input().strip().split()
        pl.append((int(a), int(b), d))
    
    pl.sort(key=lambda x: (x[0], x[1]))
    
    pid = {1: (0, 0)}
    idp = {(0, 0): 1}
    
    dr = {"right": (1, 0), "left": (-1, 0), "top": (0, 1), "down": (0, -1)}
    
    for a, b, d in pl:
        if a not in pid:
            continue
        x, y = pid[a]
        dx, dy = dr[d]
        nx, ny = x + dx, y + dy
        if (nx, ny) in idp:
            oid = idp[(nx, ny)]
            del pid[oid]
        idp[(nx, ny)] = b
        pid[b] = (nx, ny)
    
    g = defaultdict(list)
    for c, (x, y) in pid.items():
        for d, (dx, dy) in dr.items():
            nx, ny = x + dx, y + dy
            if (nx, ny) in idp:
                g[c].append((idp[(nx, ny)], d))
    
    s, d = map(int, input().strip().split())
    t, l, f = map(int, input().strip().split())
    
    pq = []
    heapq.heappush(pq, (0, s, t, l, f))
    dist = defaultdict(lambda: float('inf'))
    dist[(s, t, l, f)] = 0
    
    while pq:
        cst, u, t, l, f = heapq.heappop(pq)
        if u == d:
            print(cst)
            return
        if cst > dist[(u, t, l, f)]:
            continue
        for v, dr in g[u]:
            if dr == "right":
                nt, nl, nf = roll_e(t, l, f)
            elif dr == "left":
                nt, nl, nf = roll_w(t, l, f)
            elif dr == "top":
                nt, nl, nf = roll_n(t, l, f)
            elif dr == "down":
                nt, nl, nf = roll_s(t, l, f)
            nc = cst + nt
            if nc < dist[(v, nt, nl, nf)]:
                dist[(v, nt, nl, nf)] = nc
                heapq.heappush(pq, (nc, v, nt, nl, nf))
    
    print(-1)

if __name__ == "__main__":
    main()

Roll the dice ✓

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

map<char,int> led={{'0',0b1111110},{'1',0b0110000},{'2',0b1101101},{'3',0b1111001},{'4',0b0110011},
                   {'5',0b1011011},{'6',0b1011111},{'7',0b1110000},{'8',0b1111111},{'9',0b1111011}};

bool valid(string t){
    int h=stoi(t.substr(0,2)),m=stoi(t.substr(3,2));
    return h>=1&&h<=12&&m>=0&&m<60;
}

int diffCost(string a,string b,int X,int Y){
    int h1=stoi(a.substr(0,2)),m1=stoi(a.substr(3,2));
    int h2=stoi(b.substr(0,2)),m2=stoi(b.substr(3,2));
    int hd=abs(h1-h2);hd=min(hd,12-hd);
    int md=abs(m1-m2);md=min(md,60-md);
    return hd*60*X+md*Y;
}

int main(){
    string time;cin>>time;
    int X,Y;cin>>X>>Y;
    vector<int> idx={0,1,3,4};
    string best="";int bestCost=INT_MAX;
    for(int i:idx){
        char c=time[i];
        for(int d='0';d<='9';d++){
            if(d==c!led.count(c)!led.count(d))continue;
            int x=led[c]^led[d];
            if(__builtin_popcount(x)==1){
                string t=time;t[i]=d;
                if(valid(t)){
                    int cost=diffCost(time,t,X,Y);
                    if(cost<bestCost||(cost==bestCost&&t<best)){
                        best=t;bestCost=cost;
                    }
                }
            }
        }
    }
    if(best=="")cout<<"No closest valid time possible";
    else cout<<best;
    return 0;
}

Interview bit // codevita ✓

TCS codevita ✓

#include <bits/stdc++.h>
using namespace std;
https://t.me/Code_alphix
struct Command{int existing,newCube;string dir;};
int main(){
    int N;cin>>N;
    vector<Command> cmds(N);
 https://t.me/Code_alphix
    for(int i=0;i<N;i++)cin>>cmds[i].existing>>cmds[i].newCube>>cmds[i].dir;

    /* =========================================
       💡 Verified Solution 💯
       Question: Nidhi Construction
       Contest: TCS CodeVita
       Telegram Page: https://t.me/Mrtrueliving_ix
       ========================================= */
 https://t.me/Code_alphix
    int query;cin>>query;
    sort(cmds.begin(),cmds.end(),[](const Command&a,const Command&b){
        if(a.existing==b.existing)return a.newCube<b.newCube;
        return a.existing<b.existing;
    });
 https://t.me/Code_alphix
    map<pair<int,int>,int> grid;
    map<int,pair<int,int>> pos;
    pos[cmds[0].existing]={0,0};
    grid[{0,0}]=cmds[0].existing;
 https://t.me/Code_alphix
    for(auto &cmd:cmds){
        if(pos.find(cmd.existing)==pos.end())continue;
        int x=pos[cmd.existing].first,y=pos[cmd.existing].second;
        if(cmd.dir=="top"||cmd.dir=="up")x--;
        else if(cmd.dir=="down")x++;
        else if(cmd.dir=="left")y--;
        else if(cmd.dir=="right")y++;
        if(grid.count({x,y})){int old=grid[{x,y}];pos.erase(old);}
        grid[{x,y}]=cmd.newCube;
        pos[cmd.newCube]={x,y};
https://t.me/Code_alphix
    }
    if(pos.find(query)==pos.end()){cout<<"-1 -1 -1 -1";return 0;}
    auto [x,y]=pos[query];
    vector<pair<int,int>>dirs={{x-1,y},{x+1,y},{x,y-1},{x,y+1}};

https://t.me/Code_alphix
    for(int i=0;i<4;i++){
        if(grid.count(dirs[i]))cout<<grid[dirs[i]]<<" ";
        else cout<<"-1 ";
    }
    return 0;
}

- @Mrtrueliving_ix @Mrtrueliving_ix

Virtusa Hackthon test pattern - R1


DM for slots booking

@Mrtrueliving_ix @Mrtrueliving_ix