Last Person to Fit in the Bus solution and explanation

import sqlite3

con = sqlite3.connect(':memory:')
con.execute('''CREATE TABLE Queue (person_id INT, person_name TEXT, weight INT, turn INT)''')
con.executemany('''INSERT INTO Queue (person_id,person_name,weight,turn) VALUES (?,?,?,?)''',
                [(5, 'Alice', 250, 1),
                 (4, 'Bob', 175, 5),
                 (3, 'Alex', 350, 2),
                 (6, 'John Cena', 400, 3),
                 (1, 'Winston', 500, 6),
                 (2, 'Marie', 200, 4)])

query = '''
WITH CumulativeWeight AS (
    SELECT person_id, person_name, weight, turn,
           SUM(weight) OVER (ORDER BY turn) AS running_total
    FROM Queue
)
SELECT person_name 
FROM CumulativeWeight
WHERE running_total <= 1000
ORDER BY turn DESC
LIMIT 1;
'''

cursor = con.cursor()
cursor.execute(query)
result = cursor.fetchone()
print(result[0])

class Person:
    def __init__(self, person_id, person_name, weight, turn):
        self.person_id = person_id
        self.person_name = person_name
        self.weight = weight
        self.turn = turn


def last_person_to_fit(queue):
    queue.sort(key=lambda x: x.turn)
    total_weight = 0
    for i, person in enumerate(queue):
        if total_weight + person.weight > 1000:
            return queue[i - 1].person_name
        total_weight += person.weight
    return queue[-1].person_name


queue = [Person(5, "Alice", 250, 1), Person(4, "Bob", 175, 5), Person(3, "Alex", 350, 2),
         Person(6, "John Cena", 400, 3), Person(1, "Winston", 500, 6), Person(2, "Marie", 200, 4)]

print(last_person_to_fit(queue))

import java.util.ArrayList;
import java.util.Collections;

class Person implements Comparable<Person> {
    int person_id;
    String person_name;
    int weight;
    int turn;

    Person(int id, String name, int weight, int turn) {
        this.person_id = id;
        this.person_name = name;
        this.weight = weight;
        this.turn = turn;
    }

    @Override
    public int compareTo(Person other) {
        return this.turn - other.turn;
    }
}

public class BusFitting {
    public static String lastPersonToFit(ArrayList<Person> queue) {
        Collections.sort(queue);
        int total_weight = 0;
        for (Person person : queue) {
            if (total_weight + person.weight > 1000) {
                return queue.get(queue.indexOf(person) - 1).person_name;
            }
            total_weight += person.weight;
        }
        return queue.get(queue.size() - 1).person_name;
    }

    public static void main(String[] args) {
        ArrayList<Person> queue = new ArrayList<>();
        queue.add(new Person(5, "Alice", 250, 1));
        queue.add(new Person(4, "Bob", 175, 5));
        queue.add(new Person(3, "Alex", 350, 2));
        queue.add(new Person(6, "John Cena", 400, 3));
        queue.add(new Person(1, "Winston", 500, 6));
        queue.add(new Person(2, "Marie", 200, 4));

        System.out.println(lastPersonToFit(queue));
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Person {
    int person_id;
    string person_name;
    int weight;
    int turn;
};

bool compare(Person a, Person b) {
    return a.turn < b.turn;
}

string lastPersonToFit(vector<Person>& queue) {
    sort(queue.begin(), queue.end(), compare);
    int total_weight = 0;
    for (int i = 0; i < queue.size(); ++i) {
        if (total_weight + queue[i].weight > 1000) {
            return queue[i - 1].person_name;
        }
        total_weight += queue[i].weight;
    }
    return queue.back().person_name;
}

int main() {
    vector<Person> queue = {{5, "Alice", 250, 1}, {4, "Bob", 175, 5}, {3, "Alex", 350, 2}, 
                            {6, "John Cena", 400, 3}, {1, "Winston", 500, 6}, {2, "Marie", 200, 4}};
    cout << lastPersonToFit(queue) << endl;
    return 0;
}

class Person {
    constructor(person_id, person_name, weight, turn) {
        this.person_id = person_id;
        this.person_name = person_name;
        this.weight = weight;
        this.turn = turn;
    }
}

function lastPersonToFit(queue) {
    queue.sort((a, b) => a.turn - b.turn);
    let totalWeight = 0;
    for (let i = 0; i < queue.length; i++) {
        if (totalWeight + queue[i].weight > 1000) {
            return queue[i - 1].person_name;
        }
        totalWeight += queue[i].weight;
    }
    return queue[queue.length - 1].person_name;
}

const queue = [
    new Person(5, "Alice", 250, 1),
    new Person(4, "Bob", 175, 5),
    new Person(3, "Alex", 350, 2),
    new Person(6, "John Cena", 400, 3),
    new Person(1, "Winston", 500, 6),
    new Person(2, "Marie", 200, 4)
];

console.log(lastPersonToFit(queue));

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int person_id;
    char person_name[30];
    int weight;
    int turn;
} Person;

int compare(const void *a, const void *b) {
    return ((Person *)a)->turn - ((Person *)b)->turn;
}

char* last_person_to_fit(Person *queue, int n) {
    qsort(queue, n, sizeof(Person), compare);
    int total_weight = 0;
    for (int i = 0; i < n; ++i) {
        if (total_weight + queue[i].weight > 1000) {
            return queue[i - 1].person_name;
        }
        total_weight += queue[i].weight;
    }
    return queue[n - 1].person_name;
}

int main() {
    Person queue[] = {{5, "Alice", 250, 1}, {4, "Bob", 175, 5}, {3, "Alex", 350, 2}, 
                      {6, "John Cena", 400, 3}, {1, "Winston", 500, 6}, {2, "Marie", 200, 4}};
    int n = 6;
    printf("%s\n", last_person_to_fit(queue, n));
    return 0;
}

using System;
using System.Collections.Generic;

public class Person {
    public int PersonId { get; set; }
    public string PersonName { get; set; }
    public int Weight { get; set; }
    public int Turn { get; set; }
}

public class Program {
    public static string LastPersonToFit(List<Person> queue) {
        queue.Sort((a, b) => a.Turn.CompareTo(b.Turn));
        int totalWeight = 0;
        for (int i = 0; i < queue.Count; i++) {
            if (totalWeight + queue[i].Weight > 1000) {
                return queue[i - 1].PersonName;
            }
            totalWeight += queue[i].Weight;
        }
        return queue[^1].PersonName;
    }

    public static void Main() {
        List<Person> queue = new List<Person> {
            new Person { PersonId = 5, PersonName = "Alice", Weight = 250, Turn = 1 },
            new Person { PersonId = 4, PersonName = "Bob", Weight = 175, Turn = 5 },
            new Person { PersonId = 3, PersonName = "Alex", Weight = 350, Turn = 2 },
            new Person { PersonId = 6, PersonName = "John Cena", Weight = 400, Turn = 3 },
            new Person { PersonId = 1, PersonName = "Winston", Weight = 500, Turn = 6 },
            new Person { PersonId = 2, PersonName = "Marie", Weight = 200, Turn = 4 }
        };
        Console.WriteLine(LastPersonToFit(queue));
    }
}

SELECT person_name
FROM (
    SELECT person_name, weight,
           SUM(weight) OVER (ORDER BY turn ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as cumulative_weight
    FROM Queue
    ORDER BY turn
) sub
WHERE cumulative_weight <= 1000
ORDER BY cumulative_weight DESC
LIMIT 1;