Merge branch 'dev' into infiltrators

doc/source/guidesandtips/recommendedbitnodeorder.rst

@@ -280,7 +280,7 @@ Description
     In this BitNode:
 
     * Your stats are significantly decreased
-    * You cannnot purchase additional servers
+    * You cannot purchase additional servers
     * Hacking is significantly less profitable
 
 Source-File

package.json

@@ -17,8 +17,7 @@
     "@mui/icons-material": "^5.0.3",
     "@mui/material": "^5.0.3",
     "@mui/styles": "^5.0.1",
-    "@types/bcrypt": "^5.0.0",
+    "@mui/system": "^5.0.3",
-    "@types/bcryptjs": "^2.4.2",
     "acorn": "^8.4.1",
     "acorn-walk": "^8.1.1",
     "arg": "^5.0.0",
@@ -26,10 +25,8 @@
     "better-react-mathjax": "^1.0.3",
     "clsx": "^1.1.1",
     "date-fns": "^2.25.0",
-    "electron-config": "^2.0.0",
     "escodegen": "^1.11.0",
     "file-saver": "^1.3.8",
-    "fs": "^0.0.1-security",
     "jquery": "^3.5.0",
     "js-sha256": "^0.9.0",
     "jszip": "^3.7.0",
@@ -57,6 +54,7 @@
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.1",
     "@testing-library/cypress": "^8.0.1",
     "@types/acorn": "^4.0.6",
+    "@types/bcryptjs": "^2.4.2",
     "@types/escodegen": "^0.0.7",
     "@types/file-saver": "^2.0.3",
     "@types/jquery": "^3.5.14",
@@ -66,14 +64,14 @@
     "@types/react-beautiful-dnd": "^13.1.2",
     "@types/react-dom": "^17.0.9",
     "@types/react-resizable": "^1.7.3",
-    "@typescript-eslint/eslint-plugin": "^4.22.0",
+    "@typescript-eslint/eslint-plugin": "^5.20.0",
-    "@typescript-eslint/parser": "^4.22.0",
+    "@typescript-eslint/parser": "^5.20.0",
     "babel-jest": "^27.0.6",
     "babel-loader": "^8.0.5",
     "cypress": "^8.3.1",
     "electron": "^14.2.4",
     "electron-packager": "^15.4.0",
-    "eslint": "^7.24.0",
+    "eslint": "^8.13.0",
     "file-loader": "^6.2.0",
     "fork-ts-checker-webpack-plugin": "^6.3.3",
     "html-webpack-plugin": "^3.2.0",
@@ -90,11 +88,10 @@
     "typescript": "^4.2.4",
     "webpack": "^4.46.0",
     "webpack-cli": "^3.3.12",
-    "webpack-dev-middleware": "^3.7.3",
     "webpack-dev-server": "^3.11.2"
   },
   "engines": {
-    "node": ">=8 || <=9"
+    "node": ">=14"
   },
   "homepage": "https://github.com/danielyxie/bitburner",
   "repository": {

src/Terminal/commands/cd.ts

@@ -30,6 +30,10 @@ export function cd(
         terminal.error("Invalid path. Failed to change directories");
         return;
       }
+      if (terminal.cwd().length > 1 && dir === "..") {
+        terminal.setcwd(evaledDir);
+        return;
+      }
 
       const server = player.getCurrentServer();
       if (!containsFiles(server, evaledDir)) {

src/Terminal/ui/TerminalInput.tsx

@@ -401,7 +401,7 @@ export function TerminalInput({ terminal, router, player }: IProps): React.React
           onKeyDown: onKeyDown,
         }}
       ></TextField>
-      <Popper open={possibilities.length > 0} anchorEl={terminalInput.current} placement={"top-end"}>
+      <Popper open={possibilities.length > 0} anchorEl={terminalInput.current} placement={"top-start"}>
         <Paper sx={{ m: 1, p: 2 }}>
           <Typography classes={{ root: classes.preformatted }} color={"primary"} paragraph={false}>
             Possible autocomplete candidates:

src/data/codingcontracttypes.ts

@@ -1306,4 +1306,154 @@ export const codingContractTypesMetadata: ICodingContractTypeMetadata[] = [
       return parseInt(ans, 10) === HammingDecode(data);
     },
   },
+  {
+    name: "Proper 2-Coloring of a Graph",
+    difficulty: 7,
+    numTries: 5,
+    desc: (data: [number, [number, number][]]): string => {
+      return [
+        `You are given the following data, representing a graph:\n`,
+        `${JSON.stringify(data)}\n`,
+        `Note that "graph", as used here, refers to the field of graph theory, and has`,
+        `no relation to statistics or plotting.`,
+        `The first element of the data represents the number of vertices in the graph.`,
+        `Each vertex is a unique number between 0 and ${data[0] - 1}.`,
+        `The next element of the data represents the edges of the graph.`,
+        `Two vertices u,v in a graph are said to be adjacent if there exists an edge [u,v].`,
+        `Note that an edge [u,v] is the same as an edge [v,u], as order does not matter.`,
+        `You must construct a 2-coloring of the graph, meaning that you have to assign each`,
+        `vertex in the graph a "color", either 0 or 1, such that no two adjacent vertices have`,
+        `the same color. Submit your answer in the form of an array, where element i`,
+        `represents the color of vertex i. If it is impossible to construct a 2-coloring of`,
+        `the given graph, instead submit an empty array.\n\n`,
+        `Examples:\n\n`,
+        `Input: [4, [[0, 2], [0, 3], [1, 2], [1, 3]]]\n`,
+        `Output: [0, 0, 1, 1]\n\n`,
+        `Input: [3, [[0, 1], [0, 2], [1, 2]]]\n`,
+        `Output: []`,
+      ].join(" ");
+    },
+    gen: (): [number, [number, number][]] => {
+      //Generate two partite sets
+      const n = Math.floor(Math.random() * 5) + 3;
+      const m = Math.floor(Math.random() * 5) + 3;
+
+      //50% chance of spawning any given valid edge in the bipartite graph
+      const edges: [number, number][] = [];
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < m; j++) {
+          if (Math.random() > 0.5) {
+            edges.push([i, n + j]);
+          }
+        }
+      }
+
+      //Add an edge at random with no regard to partite sets
+      let a = Math.floor(Math.random() * (n + m));
+      let b = Math.floor(Math.random() * (n + m));
+      if (a > b) [a, b] = [b, a]; //Enforce lower numbers come first
+      if (a != b && !edges.includes([a, b])) {
+        edges.push([a, b]);
+      }
+
+      //Randomize array in-place using Durstenfeld shuffle algorithm.
+      function shuffle(array: any[]): void {
+        for (let i = array.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [array[i], array[j]] = [array[j], array[i]];
+        }
+      }
+
+      //Replace instances of the original vertex names in-place
+      const vertexShuffler = Array.from(Array(n + m).keys());
+      shuffle(vertexShuffler);
+      for (let i = 0; i < edges.length; i++) {
+        edges[i] = [vertexShuffler[edges[i][0]], vertexShuffler[edges[i][1]]];
+        if (edges[i][0] > edges[i][1]) {
+          //Enforce lower numbers come first
+          [edges[i][0], edges[i][1]] = [edges[i][1], edges[i][0]];
+        }
+      }
+
+      //Shuffle the order of the edges themselves, as well
+      shuffle(edges);
+
+      return [n + m, edges];
+    },
+    solver: (data: [number, [number, number][]], ans: string): boolean => {
+      //Case where the player believes there is no solution
+      if (ans == "[]") {
+        //Helper function to get neighbourhood of a vertex
+        function neighbourhood(vertex: number): number[] {
+          const adjLeft = data[1].filter(([a, _]) => a == vertex).map(([_, b]) => b);
+          const adjRight = data[1].filter(([_, b]) => b == vertex).map(([a, _]) => a);
+          return adjLeft.concat(adjRight);
+        }
+
+        //Verify that there is no solution by attempting to create a proper 2-coloring.
+        const coloring: (number | undefined)[] = Array(data[0]).fill(undefined);
+        while (coloring.some((val) => val === undefined)) {
+          //Color a vertex in the graph
+          const initialVertex: number = coloring.findIndex((val) => val === undefined);
+          coloring[initialVertex] = 0;
+          const frontier: number[] = [initialVertex];
+
+          //Propogate the coloring throughout the component containing v greedily
+          while (frontier.length > 0) {
+            const v: number = frontier.pop() || 0;
+            const neighbors: number[] = neighbourhood(v);
+
+            //For each vertex u adjacent to v
+            for (const id in neighbors) {
+              const u: number = neighbors[id];
+
+              //Set the color of u to the opposite of v's color if it is new,
+              //then add u to the frontier to continue the algorithm.
+              if (coloring[u] === undefined) {
+                if (coloring[v] === 0) coloring[u] = 1;
+                else coloring[u] = 0;
+
+                frontier.push(u);
+              }
+
+              //Assert u,v do not have the same color
+              else if (coloring[u] === coloring[v]) {
+                //If u,v do have the same color, no proper 2-coloring exists, meaning
+                //the player was correct to say there is no proper 2-coloring of the graph.
+                return true;
+              }
+            }
+          }
+        }
+
+        //If this code is reached, there exists a proper 2-coloring of the input
+        //graph, and thus the player was incorrect in submitting no answer.
+        return false;
+      }
+
+      //Sanitize player input
+      const sanitizedPlayerAns: string = removeBracketsFromArrayString(ans);
+      const sanitizedPlayerAnsArr: string[] = sanitizedPlayerAns.split(",");
+      const coloring: number[] = sanitizedPlayerAnsArr.map((val) => parseInt(val));
+
+      //Solution provided case
+      if (coloring.length == data[0]) {
+        const edges = data[1];
+        const validColors = [0, 1];
+        //Check that the provided solution is a proper 2-coloring
+        return edges.every(([a, b]) => {
+          const aColor = coloring[a];
+          const bColor = coloring[b];
+          return (
+            validColors.includes(aColor) && //Enforce the first endpoint is color 0 or 1
+            validColors.includes(bColor) && //Enforce the second endpoint is color 0 or 1
+            aColor != bColor //Enforce the endpoints are different colors
+          );
+        });
+      }
+
+      //Return false if the coloring is the wrong size
+      else return false;
+    },
+  },
 ];