Dota2 Senate solution and explanation

from collections import deque

def predict_party_victory(senate: str) -> str:
    radiant = deque()
    dire = deque()

    for i, s in enumerate(senate):
        if s == 'R':
            radiant.append(i)
        else:
            dire.append(i)

    length = len(senate)
    while radiant and dire:
        r_idx = radiant.popleft()
        d_idx = dire.popleft()
        if r_idx < d_idx:
            radiant.append(r_idx + length)
        else:
            dire.append(d_idx + length)

    return "Radiant" if radiant else "Dire"

import java.util.LinkedList;
import java.util.Queue;

public class Dota2Senate {
    public String predictPartyVictory(String senate) {
        Queue<Integer> radiant = new LinkedList<>();
        Queue<Integer> dire = new LinkedList<>();
        int n = senate.length();

        for (int i = 0; i < n; i++) {
            if (senate.charAt(i) == 'R') radiant.add(i);
            else dire.add(i);
        }

        while (!radiant.isEmpty() && !dire.isEmpty()) {
            int rIdx = radiant.poll();
            int dIdx = dire.poll();
            if (rIdx < dIdx) radiant.add(rIdx + n);
            else dire.add(dIdx + n);
        }

        return radiant.isEmpty() ? "Dire" : "Radiant";
    }
}

#include <iostream>
#include <queue>
using namespace std;

string predictPartyVictory(string senate) {
    int n = senate.size();
    queue<int> radiant, dire;
    for (int i = 0; i < n; ++i) {
        if (senate[i] == 'R') radiant.push(i);
        else dire.push(i);
    }
    while (!radiant.empty() && !dire.empty()) {
        int rIdx = radiant.front(); radiant.pop();
        int dIdx = dire.front(); dire.pop();
        if (rIdx < dIdx) radiant.push(rIdx + n);
        else dire.push(dIdx + n);
    }
    return radiant.empty() ? "Dire" : "Radiant";
}

function predictPartyVictory(senate) {
    const radiant = [];
    const dire = [];

    for (let i = 0; i < senate.length; i++) {
        if (senate.charAt(i) == 'R') {
            radiant.push(i);
        } else {
            dire.push(i);
        }
    }

    const n = senate.length;
    while (radiant.length > 0 && dire.length > 0) {
        const rIdx = radiant.shift();
        const dIdx = dire.shift();
        if (rIdx < dIdx) {
            radiant.push(rIdx + n);
        } else {
            dire.push(dIdx + n);
        }
    }

    return radiant.length > 0 ? "Radiant" : "Dire";
}

#include <stdio.h>
#define MAX_SIZE 10000
#define QUEUE_EMPTY -1

typedef struct Queue {
    int items[MAX_SIZE];
    int front, rear;
} Queue;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = -1;
}

int isEmpty(Queue* q) {
    return q->rear < q->front;
}

void enqueue(Queue* q, int value) {
    if (q->rear < MAX_SIZE - 1) {
        q->items[++q->rear] = value;
    }
}

int dequeue(Queue* q) {
    if (!isEmpty(q)) {
        return q->items[q->front++];
    }
    return QUEUE_EMPTY;
}

const char* predictPartyVictory(char* senate) {
    Queue radiantQueue, direQueue;
    initQueue(&radiantQueue);
    initQueue(&direQueue);
    for (int i = 0; senate[i] != '\0'; i++) {
        if (senate[i] == 'R') enqueue(&radiantQueue, i);
        else enqueue(&direQueue, i);
    }

    int len = strlen(senate);
    while (!isEmpty(&radiantQueue) && !isEmpty(&direQueue)) {
        int rIdx = dequeue(&radiantQueue);
        int dIdx = dequeue(&direQueue);
        if (rIdx < dIdx) enqueue(&radiantQueue, rIdx + len);
        else enqueue(&direQueue, dIdx + len);
    }
    return isEmpty(&radiantQueue) ? "Dire" : "Radiant";
}

using System;
using System.Collections.Generic;

public class Dota2Senate {
    public string PredictPartyVictory(string senate) {
        Queue<int> radiant = new Queue<int>();
        Queue<int> dire = new Queue<int>();

        for (int i = 0; i < senate.Length; i++) {
            if (senate[i] == 'R') radiant.Enqueue(i);
            else dire.Enqueue(i);
        }

        int n = senate.Length;
        while (radiant.Count > 0 && dire.Count > 0) {
            int rIdx = radiant.Dequeue();
            int dIdx = dire.Dequeue();
            if (rIdx < dIdx) radiant.Enqueue(rIdx + n);
            else dire.Enqueue(dIdx + n);
        }

        return radiant.Count > 0 ? "Radiant" : "Dire";
    }
}

function predictPartyVictory(senate: string): string {
    const n = senate.length;
    const qr: number[] = [];
    const qd: number[] = [];
    for (let i = 0; i < n; ++i) {
        if (senate[i] === 'R') {
            qr.push(i);
        } else {
            qd.push(i);
        }
    }
    while (qr.length > 0 && qd.length > 0) {
        const r = qr.shift()!;
        const d = qd.shift()!;
        if (r < d) {
            qr.push(r + n);
        } else {
            qd.push(d + n);
        }
    }
    return qr.length > 0 ? 'Radiant' : 'Dire';
}

func predictPartyVictory(senate string) string {
	n := len(senate)
	qr := []int{}
	qd := []int{}
	for i, c := range senate {
		if c == 'R' {
			qr = append(qr, i)
		} else {
			qd = append(qd, i)
		}
	}
	for len(qr) > 0 && len(qd) > 0 {
		r, d := qr[0], qd[0]
		qr, qd = qr[1:], qd[1:]
		if r < d {
			qr = append(qr, r+n)
		} else {
			qd = append(qd, d+n)
		}
	}
	if len(qr) > 0 {
		return "Radiant"
	}
	return "Dire"
}

impl Solution {
    pub fn predict_party_victory(senate: String) -> String {
        let mut qr = std::collections::VecDeque::new();
        let mut qd = std::collections::VecDeque::new();
        let n = senate.len();
        for i in 0..n {
            if let Some(char) = senate.chars().nth(i) {
                if char == 'R' {
                    qr.push_back(i);
                } else {
                    qd.push_back(i);
                }
            }
        }

        while !qr.is_empty() && !qd.is_empty() {
            let front_qr = qr.pop_front().unwrap();
            let front_qd = qd.pop_front().unwrap();
            if front_qr < front_qd {
                qr.push_back(front_qr + n);
            } else {
                qd.push_back(front_qd + n);
            }
        }
        if qr.is_empty() {
            return "Dire".to_string();
        }
        "Radiant".to_string()
    }
}