Statistics

Problem Statement for "BikeRace"

Problem Statement

A pursuit race is run on a circular track. The participants each start at the same start line, but each at a different time based upon their performance in earlier races. Whenever a rider is passed by another rider, he is eliminated from the race. If a previous rider circled the track and reached the start line at or before the time when a contestant is scheduled to start, then that contestant is eliminated at the time the rider reached the start line.

Suppose that the racers each go at a constant speed. Create a class BikeRace that contains a method eliminated that is given track, the length of the track, String[] name, the names of the contestants, a int[] start, the start times of the contestants, and a int[] speed, the speeds of the contestants. It returns a String[] giving the names of the eliminated contestants in the order in which they were eliminated. In case of simultaneous eliminations, list the simultaneously eliminated riders in alphabetical order.

track is in feet, speed is in feet per second, and start is in seconds. Element i of speed, start, and name applies to contestant i.

Definition

Class:
BikeRace
Method:
eliminated
Parameters:
int, String[], int[], int[]
Returns:
String[]
Method signature:
String[] eliminated(int track, String[] name, int[] start, int[] speed)
(be sure your method is public)

Constraints

  • track will be between 1000 and 5000 inclusive.
  • name will contain between 2 and 50 elements inclusive.
  • name, start, and speed will all contain the same number of elements.
  • Each element of name will contain between 1 and 50 characters inclusive.
  • Each character in each element of name will be an uppercase letter 'A'-'Z'.
  • The elements of name will be distinct.
  • Each element of start will be between 0 and 1000 inclusive.
  • The elements of start will be distinct.
  • Each element of speed will be between 1 and 50 inclusive.

Examples

  1. 4800

    {"A","B","C"}

    { 0, 100,180}

    {30, 30, 30}

    Returns: { "C" }

    Rider A starts at time 0 and goes 3000 feet before B starts at time 100. A passes the start line at time 160, before C can start, thereby eliminating C. But B and A can never catch each other since they are going the same speed so they are never eliminated.

  2. 3000

    {"BO","JO", "AL"}

    { 10, 0, 15 }

    { 12, 2, 10 }

    Returns: { "JO", "AL" }

    JO goes 20 feet (10 seconds at 2 feet/sec) before BO starts at time 10. JO is eliminated at time 12 since both JO and BO have gone 24 feet. AL starts at time 15 but is eventually caught by BO since BO is going at a higher speed.

  3. 3000

    {"BOBO","JOHNNY","ANNA"}

    {67,0,15}

    {50,45,3}

    Returns: { "BOBO", "ANNA" }

  4. 3000

    {"B","J","A"}

    {66,0,15}

    {50,45,3}

    Returns: { "A", "J" }

  5. 5000

    {"TOM","TOMMY","BILL","SPEEDY","JIMMY"}

    {100,120,110,0,1000}

    {50,50,50,50,50}

    Returns: { "BILL", "JIMMY", "TOM", "TOMMY" }

    SPEEDY just manages to circle the track before any of the others can start. So the other four are all eliminated at the same time, and are listed in alphabetical order.

  6. 5000

    {"ABCDEFGHIJKLMNOPQRSTUVWXYQBCDEFGHIJKLMNOPQRSTUVWXY","ABCDE"}

    {1000,999}

    {49,50}

    Returns: { "ABCDEFGHIJKLMNOPQRSTUVWXYQBCDEFGHIJKLMNOPQRSTUVWXY" }

  7. 4999

    {"A","B","C","D","BA","AB","BC","X"}

    {300,199,23,444,445,443,1000,0}

    {42,42,42,43,18,22,22,22}

    Returns: { "X", "A", "AB", "B", "BA", "BC", "D" }

  8. 1000

    {"A","B","C","D"}

    {100,200,0,1}

    {10,15,4,4}

    Returns: { "D", "C", "B" }

  9. 4000

    {"A","B","C","D","E"}

    {100,250,420,500,499}

    {10,16,50,42,50}

    Returns: { "A", "B", "D" }

  10. 4000

    {"E","D","C","B","A"}

    {100,250,420,500,499}

    {10,16,50,42,50}

    Returns: { "B", "D", "E" }

  11. 5000

    {"A","BOB","C","D"}

    {0,100,198,199}

    {20,40,1,2}

    Returns: { "A", "C", "D" }

  12. 5000

    {"A","BOB","C","D"}

    {699,698,600,500}

    {2,1,40,20}

    Returns: { "BOB", "D", "A" }

  13. 4000

    {"A","BOB","C","D"}

    {699,698,600,500}

    {2,1,40,20}

    Returns: { "BOB", "D", "A" }

  14. 3998

    {"A","BOB","C","D"}

    {699,698,600,500}

    {2,1,40,20}

    Returns: { "A", "BOB", "D" }

  15. 3999

    {"A","BOB","C","D"}

    {699,698,600,500}

    {2,1,40,20}

    Returns: { "BOB", "D", "A" }

  16. 5000

    {"ADAM","EVE","SERPENT"}

    {995,996,999}

    {1,1,1}

    Returns: { }

  17. 5000

    { "TOM", "TOMMY", "BILL", "SPEEDY", "JIMMY" }

    { 100, 120, 110, 0, 1000 }

    { 50, 50, 50, 50, 50 }

    Returns: { "BILL", "JIMMY", "TOM", "TOMMY" }

  18. 3000

    { "B", "J", "A" }

    { 66, 0, 15 }

    { 50, 45, 3 }

    Returns: { "A", "J" }

  19. 4800

    { "A", "B", "C" }

    { 0, 100, 180 }

    { 30, 30, 30 }

    Returns: { "C" }

  20. 4996

    { "B", "J", "A" }

    { 0, 10, 9 }

    { 10, 3, 3 }

    Returns: { "J", "A" }

  21. 4999

    { "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "R", "S", "T", "U", "V", "Z", "X", "Y", "W", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AR", "AS", "AT", "AU", "AV", "AZ", "AX", "AY", "AW" }

    { 100, 200, 300, 400, 299, 289, 133, 900, 999, 1, 2, 3, 4, 5, 6, 7, 8, 9, 211, 298, 297, 708, 709, 501, 502, 503, 504, 505, 506, 507, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 701, 702, 703, 704, 705, 706, 707 }

    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 4 }

    Returns: { "K", "L", "M", "N", "O", "P", "R", "S", "B", "C", "H", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY", "AZ", "D", "E", "F", "G", "I", "J", "V", "W", "X", "Y", "Z", "T" }

  22. 1000

    { "B", "C", "Q", "A", "J" }

    { 80, 60, 1000, 999, 0 }

    { 50, 25, 10, 1, 10 }

    Returns: { "A", "C", "J", "Q" }

  23. 4981

    { "A", "B", "C", "D", "E", "F", "G" }

    { 0, 1, 2, 245, 316, 819, 971 }

    { 1, 2, 42, 16, 2, 1, 47 }

    Returns: { "A", "B", "D", "E", "F", "G" }

  24. 1000

    { "A", "B", "C" }

    { 1, 2, 3 }

    { 2, 2, 50 }

    Returns: { "B", "A" }

  25. 4800

    { "B", "A", "C" }

    { 0, 2, 3 }

    { 3, 6, 12 }

    Returns: { "A", "B" }

  26. 1000

    { "A", "B", "C", "D" }

    { 1, 2, 3, 4 }

    { 1, 1, 1, 50 }

    Returns: { "C", "B", "A" }

  27. 4999

    { "A", "AA", "AAA", "AAAA", "AB", "BB", "BBB", "ABB" }

    { 0, 1, 2, 3, 999, 998, 889, 5 }

    { 1, 2, 3, 3, 50, 49, 48, 47 }

    Returns: { "A", "AA", "AAAA", "AAA", "AB", "BB", "BBB" }

  28. 1000

    { "A", "B", "C" }

    { 0, 1, 2 }

    { 2, 3, 7 }

    Returns: { "B", "A" }

  29. 1000

    { "A", "B", "C" }

    { 0, 1, 2 }

    { 1, 1, 50 }

    Returns: { "B", "A" }

  30. 1000

    { "A", "B" }

    { 0, 1 }

    { 5, 6 }

    Returns: { "A" }

  31. 1000

    { "A", "B", "C" }

    { 1, 0, 2 }

    { 1, 1, 50 }

    Returns: { "A", "B" }

  32. 1500

    { "A", "B" }

    { 500, 1000 }

    { 2, 3 }

    Returns: { "A" }

  33. 1499

    { "Z", "E", "D", "C", "B", "A", "WLEITE" }

    { 51, 49, 50, 0, 25, 30, 31 }

    { 50, 24, 50, 10, 20, 25, 25 }

    Returns: { "B", "C", "E", "WLEITE", "A" }

  34. 5000

    { "A", "B", "C", "D" }

    { 0, 10, 20, 30 }

    { 10, 5, 6, 4 }

    Returns: { "B", "D", "C" }

  35. 3000

    { "BOBO", "JOHNNY", "ANNAABHISHEK" }

    { 67, 0, 15 }

    { 50, 45, 3 }

    Returns: { "BOBO", "ANNAABHISHEK" }

  36. 4352

    { "AA", "AAB", "AAC", "ADA", "AEA", "AFA", "AGA", "AHA", "AIA", "AJA", "AKA", "ALA", "MAA", "NAA", "AOA", "PAA", "QAA", "ARA", "ASA", "ATA", "AUA", "AVA", "AWA", "AXA", "AYA", "AZA", "ASDFAA", "AFSDA", "ATHRTHA", "ASDFA", "AGERA", "ATBHRTHA", "ATCHRTHA", "ATHERTHA", "ATHRDTHA", "ATHRTHHA", "ATHRTGHA", "ATHRITHA", "ATHJRTHA", "ATHKRTHA", "ATHLRTHA", "ATHMRTHA", "ATHNRTHA", "ATHORTHA", "ATHPRTHA", "ATHWRTHA", "ATHTRTHA", "KITA", "PSINA", "TITO" }

    { 235, 176, 472, 36, 690, 895, 230, 369, 18, 266, 641, 216, 212, 753, 94, 343, 726, 203, 573, 735, 579, 566, 425, 398, 29, 759, 694, 819, 55, 356, 382, 332, 404, 716, 11, 843, 107, 582, 701, 349, 654, 621, 327, 629, 762, 623, 274, 627, 65, 632 }

    { 44, 31, 15, 18, 48, 19, 45, 6, 38, 29, 4, 40, 41, 43, 16, 41, 31, 37, 40, 18, 40, 1, 17, 50, 28, 45, 12, 25, 37, 37, 17, 32, 21, 32, 35, 38, 9, 28, 21, 26, 37, 5, 36, 21, 14, 35, 15, 18, 34, 6 }

    Returns: { "ADA", "ATHRDTHA", "AA", "AAB", "AAC", "AEA", "AFA", "AFSDA", "AGA", "AGERA", "AHA", "AJA", "AKA", "ALA", "ARA", "ASA", "ASDFA", "ASDFAA", "ATA", "ATBHRTHA", "ATCHRTHA", "ATHERTHA", "ATHJRTHA", "ATHKRTHA", "ATHLRTHA", "ATHMRTHA", "ATHNRTHA", "ATHORTHA", "ATHPRTHA", "ATHRITHA", "ATHRTHHA", "ATHTRTHA", "ATHWRTHA", "AUA", "AVA", "AWA", "AXA", "AZA", "KITA", "MAA", "NAA", "PAA", "QAA", "TITO", "AYA", "ATHRTGHA", "AOA", "PSINA", "ATHRTHA" }

  37. 1000

    { "A", "B", "C", "D", "E" }

    { 100, 5, 0, 20, 21 }

    { 3, 2, 1, 2, 3 }

    Returns: { "C", "D", "B" }

  38. 1000

    { "A", "B", "C" }

    { 0, 1, 2 }

    { 1, 1, 10 }

    Returns: { "B", "A" }

  39. 1000

    { "A", "B", "C" }

    { 110, 90, 0 }

    { 20, 11, 10 }

    Returns: { "A", "C" }

  40. 1000

    { "A", "B", "C" }

    { 450, 400, 0 }

    { 1, 1, 2 }

    Returns: { "A", "B" }

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2024, TopCoder, Inc. All rights reserved.
This problem was used for: