phase 1 done?!

ofmeans · ofmeans · commit 077d529e7c49 · 2024-11-10T18:57:11.000-08:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -92,9 +92,14 @@
     "*.tcc": "cpp",
     "memory_resource": "cpp",
     "stop_token": "cpp",
-    "cfloat": "cpp"
+    "cfloat": "cpp",
+    "__verbose_abort": "cpp",
+    "execution": "cpp",
+    "print": "cpp",
+    "variant": "cpp"
   },
   "lldb.displayFormat": "auto",
   "lldb.dereferencePointers": true,
   "lldb.showDisassembly": "auto",
+  "C_Cpp.errorSquiggles": "disabled",
 }
diff --git a/MODULE.bazel b/MODULE.bazel
@@ -0,0 +1,6 @@
+###############################################################################
+# Bazel now uses Bzlmod by default to manage external dependencies.
+# Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel.
+#
+# For more details, please check https://github.com/bazelbuild/bazel/issues/18958
+###############################################################################
diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock
diff --git a/README.md b/README.md
@@ -241,8 +241,8 @@ Chevron
 Time taken by function: 2 ms
 ```
 
-- What is the runtime of your algorithm? 
-- (Optional) Can you do it faster than `O(n)`?
+- What is the runtime of your algorithm? 8 ms 
+- (Optional) Can you do it faster than `O(n)`? 
 
 ## Item 2-1: Find the place's coordinates in the Map (Phase 1)
 
diff --git a/WORKSPACE b/WORKSPACE
@@ -33,12 +33,12 @@ git_repository(
 
 new_local_repository(
 	name = "opencv",
-	path = "/opt/homebrew/Cellar/opencv/4.9.0_5",
+	path = "/opt/homebrew/Cellar/opencv/4.10.0_12",
 	build_file = "opencv.BUILD",
 )
 
 new_local_repository(
     name = "ncurses",
-    path = "/opt/homebrew/Cellar/ncurses/6.4",
+    path = "/opt/homebrew/Cellar/ncurses/6.5",
     build_file = "ncurses.BUILD",
 )
diff --git a/src/lib/trojanmap.cc b/src/lib/trojanmap.cc

Original file line number	Diff line number	Diff line change
`@@ -33,12 +33,12 @@ git_repository(`
`33`	`33`
`34`	`34`	`new_local_repository(`
`35`	`35`	`name = "opencv",`
`36`		`- path = "/opt/homebrew/Cellar/opencv/4.9.0_5",`
	`36`	`+ path = "/opt/homebrew/Cellar/opencv/4.10.0_12",`
`37`	`37`	`build_file = "opencv.BUILD",`
`38`	`38`	`)`
`39`	`39`
`40`	`40`	`new_local_repository(`
`41`	`41`	`name = "ncurses",`
`42`		`- path = "/opt/homebrew/Cellar/ncurses/6.4",`
	`42`	`+ path = "/opt/homebrew/Cellar/ncurses/6.5",`
`43`	`43`	`build_file = "ncurses.BUILD",`
`44`	`44`	`)`
-Original file line number
+Diff line change
  * @param  {std::string} id : location id
  * @return {double}         : latitude
  */
 -double TrojanMap::GetLat(const std::string &id) {
 +double TrojanMap::GetLat(const std::string &id)
 +{
   return 0;
+}
  * @param  {std::string} id : location id
  * @return {double}         : longitude
  */
 -double TrojanMap::GetLon(const std::string &id) {
 +double TrojanMap::GetLon(const std::string &id)
 +{
   return 0;
+}
  * @param  {std::string} id : location id
  * @return {std::string}    : name
  */
 -std::string TrojanMap::GetName(const std::string &id) {
 +std::string TrojanMap::GetName(const std::string &id)
 +{
   return "";
+}
  * @param  {std::string} id            : location id
  * @return {std::vector<std::string>}  : neighbor ids
  */
 -std::vector<std::string> TrojanMap::GetNeighborIDs(const std::string &id) {
 +std::vector<std::string> TrojanMap::GetNeighborIDs(const std::string &id)
 +{
   return {};
+}
  * @param  {std::string} name          : location name
  * @return {std::string}               : id
  */
 -std::string TrojanMap::GetID(const std::string &name) {
 +std::string TrojanMap::GetID(const std::string &name)
 +{
   std::string res = "";
   return res;
+}
  * @param  {std::string} name          : location name
  * @return {std::pair<double,double>}  : (lat, lon)
  */
 -std::pair<double, double> TrojanMap::GetPosition(std::string name) {
 +std::pair<double, double> TrojanMap::GetPosition(std::string name)
 +{
   std::pair<double, double> results(-1, -1);
++
 +  for (const auto &entry : data)
 +  {
 +    const Node &node = entry.second;  // retrieve current node
++
 +    // if node matches name
 +    if (node.name == name)
 +    {
 +      results.first = node.lat;  // latitude
 +      results.second = node.lon; // longitude
 +    }
 +  }
   return results;
+}
  * @param  {std::string} b          : second string
  * @return {int}                    : edit distance between two strings
  */
 -int TrojanMap::CalculateEditDistance(std::string a, std::string b) {
 +int TrojanMap::CalculateEditDistance(std::string a, std::string b)
 +{
   return 0;
+}
  * @param  {std::string} name          : location name
  * @return {std::string} tmp           : the closest name
  */
 -std::string TrojanMap::FindClosestName(std::string name) {
 +std::string TrojanMap::FindClosestName(std::string name)
 +{
   std::string tmp = ""; // Start with a dummy word
   return tmp;
+}
  * @param  {std::string} name          : partial name
  * @return {std::vector<std::string>}  : a vector of full names
  */
 -std::vector<std::string> TrojanMap::Autocomplete(std::string name) {
 +std::vector<std::string> TrojanMap::Autocomplete(std::string name)
 +{
   std::vector<std::string> results;
++
 +  // test case: input empty --> return empty vector
 +  if (name.empty())
 +  {
 +    return results;
 +  }
++
 +  // convert input string to lowercase
 +  for (size_t i = 0; i < name.length(); i++)
 +  {
 +    name[i] = tolower(name[i]); // found tolower() funciton on geeksforgeeks.org
 +  }
++
 +  // iterate through all nodes in data map
 +  for (const auto &entry : data)
 +  {
 +    const Node &node = entry.second;   // retrieve current node
 +    std::string node_name = node.name; // retreieve name of current node
++
 +    // convert node name --> lowercase
 +    std::transform(node_name.begin(), node_name.end(), node_name.begin(), ::tolower);
++
 +    // check if node name starts with string
 +    bool match = true; // assume initially matches
 +    for (size_t i = 0; i < name.length(); i++)
 +    {
 +      if (node_name[i] != name[i]) // if does not match, switch to false
 +      {
 +        match = false;
 +        break; // exit loop since mismatch found
 +      }
 +    }
++
 +    // if match found, add to vector
 +    if (match)
 +    {
 +      results.push_back(node.name);
 +    }
 +  }
 +  // return vector list
   return results;
+}
+ *
  * @return {std::vector<std::string>}  : all unique location categories
  */
 -std::vector<std::string> TrojanMap::GetAllCategories() {
 +std::vector<std::string> TrojanMap::GetAllCategories()
 +{
   return {};
+}
  * @return {std::vector<std::string>}     : ids
  */
 std::vector<std::string> TrojanMap::GetAllLocationsFromCategory(
 -    std::string category) {
 +    std::string category)
 +{
   std::vector<std::string> res;
   return res;
+}
  * names
  * @return {std::vector<std::string>}     : ids
  */
 -std::vector<std::string> TrojanMap::GetLocationRegex(std::regex location) {
 +std::vector<std::string> TrojanMap::GetLocationRegex(std::regex location)
 +{
   return {};
+}
  * The distance is in mile.
  * The distance is calculated using the Haversine formula.
  * https://en.wikipedia.org/wiki/Haversine_formula
 - *
 + *
  * @param  {std::string} a  : a_id
  * @param  {std::string} b  : b_id
  * @return {double}  : distance in mile
  */
 double TrojanMap::CalculateDistance(const std::string &a_id,
 -                                    const std::string &b_id) {
 +                                    const std::string &b_id)
 +{
   // Do not change this function
   Node a = data[a_id];
   Node b = data[b_id];
  * CalculatePathLength: Calculates the total path length for the locations
  * inside the vector.
  * We have provided the code for you. Please do not need to change this function.
 - *
 + *
  * @param  {std::vector<std::string>} path : path
  * @return {double}                        : path length
  */
 -double TrojanMap::CalculatePathLength(const std::vector<std::string> &path) {
 +double TrojanMap::CalculatePathLength(const std::vector<std::string> &path)
 +{
   // Do not change this function
   double sum = 0;
 -  for (int i = 0; i < int(path.size()) - 1; i++) {
 +  for (int i = 0; i < int(path.size()) - 1; i++)
 +  {
     sum += CalculateDistance(path[i], path[i + 1]);
+  }
   return sum;
  * @return {std::vector<std::string>}       : path
  */
 std::vector<std::string> TrojanMap::CalculateShortestPath_Dijkstra(
 -    std::string location1_name, std::string location2_name) {
 +    std::string location1_name, std::string location2_name)
 +{
   std::vector<std::string> path;
   return path;
+}
  * @return {std::vector<std::string>}       : path
  */
 std::vector<std::string> TrojanMap::CalculateShortestPath_Bellman_Ford(
 -    std::string location1_name, std::string location2_name) {
 +    std::string location1_name, std::string location2_name)
 +{
   std::vector<std::string> path;
   return path;
+}
  * path which visit all the places and back to the start point.
+ *
  * @param  {std::vector<std::string>} input : a list of locations needs to visit
 - * @return {std::pair<double, std::vector<std::vector<std::string>>} : a pair of total distance and the all the progress to get final path,
 + * @return {std::pair<double, std::vector<std::vector<std::string>>} : a pair of total distance and the all the progress to get final path,
  *                                                                      for example: {10.3, {{0, 1, 2, 3, 4, 0}, {0, 1, 2, 3, 4, 0}, {0, 4, 3, 2, 1, 0}}},
 - *                                                                      where 10.3 is the total distance,
 + *                                                                      where 10.3 is the total distance,
  *                                                                      and the first vector is the path from 0 and travse all the nodes and back to 0,
  *                                                                      and the second vector is the path shorter than the first one,
  *                                                                      and the last vector is the shortest path.
  */
 // Please use brute force to implement this function, ie. find all the permutations.
 std::pair<double, std::vector<std::vector<std::string>>> TrojanMap::TravelingTrojan_Brute_force(
 -                                    std::vector<std::string> location_ids) {
 +    std::vector<std::string> location_ids)
 +{
   std::pair<double, std::vector<std::vector<std::string>>> records;
   return records;
+}
 // Please use backtracking to implement this function
 std::pair<double, std::vector<std::vector<std::string>>> TrojanMap::TravelingTrojan_Backtracking(
 -                                    std::vector<std::string> location_ids) {
 +    std::vector<std::string> location_ids)
 +{
   std::pair<double, std::vector<std::vector<std::string>>> records;
   return records;
+}
 // Hint: https://en.wikipedia.org/wiki/2-opt
 std::pair<double, std::vector<std::vector<std::string>>> TrojanMap::TravelingTrojan_2opt(
 -      std::vector<std::string> location_ids){
 +    std::vector<std::string> location_ids)
 +{
   std::pair<double, std::vector<std::vector<std::string>>> records;
   return records;
+}
 // This is optional
 std::pair<double, std::vector<std::vector<std::string>>> TrojanMap::TravelingTrojan_3opt(
 -      std::vector<std::string> location_ids){
 +    std::vector<std::string> location_ids)
 +{
   std::pair<double, std::vector<std::vector<std::string>>> records;
   return records;
+}
  * Given CSV filename, it read and parse locations data from CSV file,
  * and return locations vector for topological sort problem.
  * We have provided the code for you. Please do not need to change this function.
 - * Example:
 + * Example:
  *   Input: "topologicalsort_locations.csv"
  *   File content:
  *    Name
  * @return {std::vector<std::string>}           : locations
  */
 std::vector<std::string> TrojanMap::ReadLocationsFromCSVFile(
 -    std::string locations_filename) {
 +    std::string locations_filename)
 +{
   std::vector<std::string> location_names_from_csv;
   std::fstream fin;
   fin.open(locations_filename, std::ios::in);
   std::string line, word;
   getline(fin, line);
 -  while (getline(fin, word)) {
 +  while (getline(fin, word))
 +  {
     location_names_from_csv.push_back(word);
+  }
   fin.close();
  * Given CSV filenames, it read and parse dependencise data from CSV file,
  * and return dependencies vector for topological sort problem.
  * We have provided the code for you. Please do not need to change this function.
 - * Example:
 + * Example:
  *   Input: "topologicalsort_dependencies.csv"
  *   File content:
  *     Source,Destination
  * @return {std::vector<std::vector<std::string>>} : dependencies
  */
 std::vector<std::vector<std::string>> TrojanMap::ReadDependenciesFromCSVFile(
 -    std::string dependencies_filename) {
 +    std::string dependencies_filename)
 +{
   std::vector<std::vector<std::string>> dependencies_from_csv;
   std::fstream fin;
   fin.open(dependencies_filename, std::ios::in);
   std::string line, word;
   getline(fin, line);
 -  while (getline(fin, line)) {
 +  while (getline(fin, line))
 +  {
     std::stringstream s(line);
     std::vector<std::string> dependency;
 -    while (getline(s, word, ',')) {
 +    while (getline(s, word, ','))
 +    {
       dependency.push_back(word);
+    }
     dependencies_from_csv.push_back(dependency);
  */
 std::vector<std::string> TrojanMap::DeliveringTrojan(
     std::vector<std::string> &locations,
 -    std::vector<std::vector<std::string>> &dependencies) {
 +    std::vector<std::vector<std::string>> &dependencies)
 +{
   std::vector<std::string> result;
 -  return result;
 +  return result;
+}
 /**
  * @param  {std::vector<double>} square: four vertexes of the square area
  * @return {bool}                      : in square or not
  */
 -bool TrojanMap::inSquare(std::string id, std::vector<double> &square) {
 +bool TrojanMap::inSquare(std::string id, std::vector<double> &square)
 +{
   return true;
+}
+-
 /**
  * GetSubgraph: Give four vertexes of the square area, return a list of location
  * ids in the squares
  * @return {std::vector<std::string>} subgraph  : list of location ids in the
  * square
  */
 -std::vector<std::string> TrojanMap::GetSubgraph(std::vector<double> &square) {
 +std::vector<std::string> TrojanMap::GetSubgraph(std::vector<double> &square)
 +{
   // include all the nodes in subgraph
   std::vector<std::string> subgraph;
   return subgraph;
  * @param {std::vector<double>} square: four vertexes of the square area
  * @return {bool}: whether there is a cycle or not
  */
 -bool TrojanMap::CycleDetection(std::vector<std::string> &subgraph, std::vector<double> &square) {
 +bool TrojanMap::CycleDetection(std::vector<std::string> &subgraph, std::vector<double> &square)
 +{
   return false;
+}
  * @param {int} k: search numbers
  * @return {std::vector<std::string>}: location name that meets the requirements
  */
 -std::vector<std::string> TrojanMap::FindNearby(std::string attributesName, std::string name, double r, int k) {
 +std::vector<std::string> TrojanMap::FindNearby(std::string attributesName, std::string name, double r, int k)
 +{
   std::vector<std::string> res;
   return res;
+}
  * @return {std::vector<std::string> }      : the shortest path
  */
 std::vector<std::string> TrojanMap::TrojanPath(
 -      std::vector<std::string> &location_names) {
 -    std::vector<std::string> res;
 -    return res;
 +    std::vector<std::string> &location_names)
 +{
 +  std::vector<std::string> res;
 +  return res;
+}
 /**
  * @param  {std::vector<std::pair<double, std::vector<std::string>>>} Q : a list of queries
  * @return {std::vector<bool> }      : existence of the path
  */
 -std::vector<bool> TrojanMap::Queries(const std::vector<std::pair<double, std::vector<std::string>>>& q) {
 -    std::vector<bool> ans(q.size());
 -    return ans;
 +std::vector<bool> TrojanMap::Queries(const std::vector<std::pair<double, std::vector<std::string>>> &q)
 +{
 +  std::vector<bool> ans(q.size());
 +  return ans;
+}
 /**
  * CreateGraphFromCSVFile: Read the map data from the csv file
  * We have provided the code for you. Please do not need to change this function.
  */
 -void TrojanMap::CreateGraphFromCSVFile() {
 +void TrojanMap::CreateGraphFromCSVFile()
 +{
   // Do not change this function
   std::fstream fin;
   fin.open("src/lib/data.csv", std::ios::in);
   std::string line, word;
   getline(fin, line);
 -  while (getline(fin, line)) {
 +  while (getline(fin, line))
 +  {
     std::stringstream s(line);
     Node n;
     int count = 0;
 -    while (getline(s, word, ',')) {
 +    while (getline(s, word, ','))
 +    {
       word.erase(std::remove(word.begin(), word.end(), '\''), word.end());
       word.erase(std::remove(word.begin(), word.end(), '"'), word.end());
       word.erase(std::remove(word.begin(), word.end(), '{'), word.end());
         n.lon = stod(word);
       else if (count == 3)
         n.name = word;
 -      else {
 +      else
 +      {
         word.erase(std::remove(word.begin(), word.end(), ' '), word.end());
 -        if (isalpha(word[0])) n.attributes.insert(word);
 -        if (isdigit(word[0])) n.neighbors.push_back(word);
 +        if (isalpha(word[0]))
 +          n.attributes.insert(word);
 +        if (isdigit(word[0]))
 +          n.neighbors.push_back(word);
+      }
       count++;
+    }