9d:T789,## Problem Statement There is a dictionary containing words from an alien language for which we don’t know the ordering of the letters. Write a method to find the correct order of the letters in the alien language. It is given that the input is a valid dictionary and there exists an ordering among its letters. **Example 1**: ``` Input: Words: ["ba", "bc", "ac", "cab"] Output: bac Explanation: Given that the words are sorted lexicographically by the rules of the alien language, so from the given words we can conclude the following ordering among its characters: 1. From "ba" and "bc", we can conclude that 'a' comes before 'c'. 2. From "bc" and "ac", we can conclude that 'b' comes before 'a' From the above two points, we can conclude that the correct character order is: "bac" ``` **Example 2**: ``` Input: Words: ["cab", "aaa", "aab"] Output: cab Explanation: From the given words we can conclude the following ordering among its characters: 1. From "cab" and "aaa", we can conclude that 'c' comes before 'a'. 2. From "aaa" and "aab", we can conclude that 'a' comes before 'b' From the above two points, we can conclude that the correct character order is: "cab" ``` **Example 3**: ``` Input: Words: ["ywx", "wz", "xww", "xz", "zyy", "zwz"] Output: ywxz Explanation: From the given words we can conclude the following ordering among its characters: 1. From "ywx" and "wz", we can conclude that 'y' comes before 'w'. 2. From "wz" and "xww", we can conclude that 'w' comes before 'x'. 3. From "xww" and "xz", we can conclude that 'w' comes before 'z' 4. From "xz" and "zyy", we can conclude that 'x' comes before 'z' 5. From "zyy" and "zwz", we can conclude that 'y' comes before 'w' From the above five points, we can conclude that the correct character order is: "ywxz" ``` **Constraints:** - `1 <= words.length <= 100` - `1 <= words[i].length <= 100` - `words[i]` consists of only lowercase English letters.9e:T72b,from collections import deque class Solution: def findOrder(self, words): if len(words) == 0: return "" # a. Initialize the graph inDegree = {} # count of incoming edges graph = {} # adjacency list graph for word in words: for character in word: inDegree[character] = 0 graph[character] = [] # b. Build the graph for i in range(0, len(words)-1): # find ordering of characters from adjacent words w1, w2 = words[i], words[i + 1] for j in range(0, min(len(w1), len(w2))): parent, child = w1[j], w2[j] if parent != child: # if the two characters are different # put the child into it's parent's list graph[parent].append(child) inDegree[child] += 1 # increment child's inDegree break # only the first different character between the two words will help us # find the order # c. Find all sources i.e., all vertices with 0 in-degrees sources = deque() for key in inDegree: if inDegree[key] == 0: sources.append(key) # d. For each source, add it to the sortedOrder and subtract one from all of its # children's in-degrees if a child's in-degree becomes zero, add it to sources queue sortedOrder = [] while sources: vertex = sources.popleft() sortedOrder.append(vertex) for child in graph[vertex]: # get the node's children to decrement their in-degrees inDegree[child] -= 1 if inDegree[child] == 0: sources.append(child) # if sortedOrder doesn't contain all characters, there is a cyclic dependency between # characters, therefore, we'll not be able to find the correct ordering of characters if len(sortedOrder) != len(inDegree): return "" return ''.join(sortedOrder) 9f:T61b,public class DriverCode { public static TestCaseRunResult RunTestCase(Queue inputStream) throws InvalidInputException, InvalidOutputException { if (inputStream.size() < 1) { throw new InvalidInputException(); } ArrayList testInput = new ArrayList(); testInput.add(inputStream.peek()); inputStream.remove(); Type type0 = new TypeToken(){}.getType(); String[] words = Parser.parse(testInput.get(0),type0); Solution sol = new Solution(); String result = sol.findOrder(words); ArrayList userOutput = new ArrayList(); String outputType = "String"; userOutput.add(Parser.toString(result,outputType)); return new TestCaseRunResult(testInput, userOutput); } public static TestCaseVerificationResult VerifyTestCaseResult( ArrayList userOutput, Queue expectedOutputStream ) throws InvalidInputException , InvalidOutputException { if (userOutput.isEmpty()) { throw new InvalidOutputException(); } assert expectedOutputStream.size() >= 1; ArrayList expectedOutput = new ArrayList(); expectedOutput.add(expectedOutputStream.peek()); expectedOutputStream.remove(); Type type = new TypeToken(){}.getType(); boolean passed = expectedOutput.equals(userOutput); return new TestCaseVerificationResult(passed, expectedOutput); } } a0:T994,import java.util.*; class Solution { public String findOrder(String[] words) { if (words == null || words.length == 0) return ""; // a. Initialize the graph HashMap inDegree = new HashMap<>(); // count of incoming edges for every vertex HashMap> graph = new HashMap<>(); // adjacency list graph for (String word : words) { for (char character : word.toCharArray()) { inDegree.put(character, 0); graph.put(character, new ArrayList()); } } // b. Build the graph for (int i = 0; i < words.length - 1; i++) { // find ordering of characters from adjacent words String w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < Math.min(w1.length(), w2.length()); j++) { char parent = w1.charAt(j), child = w2.charAt(j); if (parent != child) { // if the two characters are different graph.get(parent).add(child); // put the child into it's parent's list inDegree.put(child, inDegree.get(child) + 1); // increment child's inDegree break; // only the first different character between the two words will help // us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees Queue sources = new LinkedList<>(); for (Map.Entry entry : inDegree.entrySet()) { if (entry.getValue() == 0) sources.add(entry.getKey()); } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue StringBuilder sortedOrder = new StringBuilder(); while (!sources.isEmpty()) { Character vertex = sources.poll(); sortedOrder.append(vertex); // get the node's children to decrement their in-degrees List children = graph.get(vertex); for (Character child : children) { inDegree.put(child, inDegree.get(child) - 1); if (inDegree.get(child) == 0) sources.add(child); } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.length() != inDegree.size()) return ""; return sortedOrder.toString(); } } a1:T7cd,class Solution { findOrder(words) { if (words.length === 0) { return ''; } // a. Initialize the graph const inDegree = {}; // count of incoming edges const graph = {}; // adjacency list graph words.forEach((word) => { for (let i = 0; i < word.length; i++) { inDegree[word[i]] = 0; graph[word[i]] = []; } }); // b. Build the graph for (let i = 0; i < words.length - 1; i++) { // find ordering of characters from adjacent words let w1 = words[i], w2 = words[i + 1]; for (let j = 0; j < Math.min(w1.length, w2.length); j++) { let parent = w1[j], child = w2[j]; if (parent !== child) { // if the two characters are different // put the child into it's parent's list graph[parent].push(child); inDegree[child] += 1; // increment child's inDegree break; // only the first different character between the two words will help us // find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees const sources = []; const chars = Object.keys(inDegree); chars.forEach((key) => { if (inDegree[key] === 0) { sources.push(key); } }); // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue let sortedOrder = []; while (sources.length > 0) { let vertex = sources.shift(); sortedOrder.push(vertex); // get the node's children to decrement their in-degrees graph[vertex].forEach((child) => { inDegree[child] -= 1; if (inDegree[child] === 0) { sources.push(child); } }); } // if sortedOrder doesn't contain all characters, there is a cyclic dependency between // characters, therefore, we'll not be able to find the correct ordering of characters if (sortedOrder.length !== chars.length) { return ''; } return sortedOrder.join(''); } } a2:T94e,using namespace std; #include #include #include #include #include class Solution { public: string findOrder(const vector &words) { if (words.empty() || words.empty()) { return ""; } // a. Initialize the graph unordered_map inDegree; // count of incoming edges for every vertex unordered_map> graph; // adjacency list graph for (auto word : words) { for (char character : word) { inDegree[character] = 0; graph[character] = vector(); } } // b. Build the graph for (int i = 0; i < words.size() - 1; i++) { // find ordering of characters from adjacent words string w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < min(w1.length(), w2.length()); j++) { char parent = w1[j], child = w2[j]; if (parent != child) { // if the two characters are different graph[parent].push_back(child); // put the child into it's parent's list inDegree[child]++; // increment child's inDegree break; // only the first different character between the two words will help // us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees queue sources; for (auto entry : inDegree) { if (entry.second == 0) { sources.push(entry.first); } } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue string sortedOrder; while (!sources.empty()) { char vertex = sources.front(); sources.pop(); sortedOrder += vertex; vector children = graph[vertex]; // get the node's children to decrement their in-degrees for (char child : children) { inDegree[child]--; if (inDegree[child] == 0) { sources.push(child); } } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.length() != inDegree.size()) { return ""; } return sortedOrder; } }; a3:T574,namespace csharp.dynamic { using csharp.pkg; public class DriverCode { public static TestCaseRunResult RunTestCase(Queue inputStream) { if (inputStream.Count < 1) { throw new InvalidInputException(); } List testInput = new List(); testInput.Add(inputStream.Peek()); inputStream.Dequeue(); Type type0 = typeof(string[]); string[] words = Parser.Parse(testInput[0], type0); Solution sol = new Solution(); string result = sol.findOrder(words); List userOutput = new List(); string outputType = "string"; userOutput.Add(Parser.ToString(result, outputType)); return new TestCaseRunResult(testInput, userOutput); } public static TestCaseVerificationResult VerifyTestCaseResult( List userOutput, Queue expectedOutputStream ) { if (userOutput.Count == 0) { throw new InvalidOutputException(); } List expectedOutput = new List(); expectedOutput.Add(expectedOutputStream.Peek()); expectedOutputStream.Dequeue(); Type type = typeof(string); bool passed = expectedOutput.SequenceEqual(userOutput); return new TestCaseVerificationResult(passed, expectedOutput); } }} a4:Ta2c,using System; using System.Collections.Generic; using System.Text; public class Solution { public string findOrder(string[] words) { if (words == null || words.Length == 0) return ""; // a. Initialize the graph Dictionary inDegree = new Dictionary(); Dictionary> graph = new Dictionary>(); foreach (string word in words) { foreach (char character in word) { if (!inDegree.ContainsKey(character)) { inDegree[character] = 0; } if (!graph.ContainsKey(character)) { graph[character] = new List(); } } } // b. Build the graph for (int i = 0; i < words.Length - 1; i++) { // find ordering of characters from adjacent words string w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < Math.Min(w1.Length, w2.Length); j++) { char parent = w1[j], child = w2[j]; if (parent != child) { graph[parent].Add(child); inDegree[child] += 1; break; } } } // c. Find all sources i.e., all vertices with 0 in-degrees Queue sources = new Queue(); foreach (KeyValuePair entry in inDegree) { if (entry.Value == 0) sources.Enqueue(entry.Key); } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue StringBuilder sortedOrder = new StringBuilder(); while (sources.Count > 0) { char vertex = sources.Dequeue(); sortedOrder.Append(vertex); List children = graph[vertex]; foreach (char child in children) { inDegree[child] -= 1; if (inDegree[child] == 0) sources.Enqueue(child); } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.Length != inDegree.Count) return ""; return sortedOrder.ToString(); } } a5:T5a0,package main import ("fmt" "os") type DriverCode struct{} func (s *DriverCode) RunTestCase(inputStream *[]string) (*TestCaseRunResult, error) { if inputStream != nil { slice := *inputStream length := len(slice) if length < 1 { return nil, NewInvalidInputException() } } testInput := []string{(*inputStream)[0]} *inputStream = (*inputStream)[1:] parser := Parser{} words, err0 := parser.parse(testInput[0], "[]string", "") if err0 != nil { return nil, err0 } var wordsParsed []string = words.([]string) sol := Solution{} result := sol.findOrder(wordsParsed) userParsedOutput, errOutput := parser.toString(result, "string", "") if errOutput != nil { fmt.Fprintf(os.Stderr, "Runtime error: %v", errOutput) return nil, errOutput } userOutput := []string{userParsedOutput} return NewTestCaseRunResult(testInput, userOutput), nil } func (s *DriverCode) VerifyTestCaseResult(userOutput []string, expectedOutputStream *[]string) (*TestCaseVerificationResult, error) { if len(userOutput) == 0 { return nil, NewInvalidOutputException() } if len(*expectedOutputStream) < 1 { return nil, NewInvalidOutputException() } expectedOutput := []string{(*expectedOutputStream)[0]} *expectedOutputStream = (*expectedOutputStream)[1:] parser := Parser{} passed := parser.StringSliceEqual(expectedOutput, userOutput) return NewTestCaseVerificationResult(passed, expectedOutput), nil } a6:T83f, type Solution struct{} func (s *Solution) findOrder(words []string) string { if words == nil || len(words) == 0 { return "" } // a. Initialize the graph inDegree := make(map[byte]int) // count of incoming edges for every vertex graph := make(map[byte][]byte) // adjacency list graph for _, word := range words { for i := range word { character := word[i] inDegree[character] = 0 graph[character] = []byte{} } } // b. Build the graph for i := 0; i < len(words)-1; i++ { // find ordering of characters from adjacent words w1, w2 := words[i], words[i+1] for j := 0; j < min(len(w1), len(w2)); j++ { parent, child := w1[j], w2[j] if parent != child { // if the two characters are different graph[parent] = append(graph[parent], child) // put the child into its parent's list inDegree[child]++ // increment child's inDegree break // only the first different character between the two words will help us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees sources := []byte{} for key, value := range inDegree { if value == 0 { sources = append(sources, key) } } // d. For each source, add it to the sortedOrder and subtract one from all of its children's in-degrees // if a child's in-degree becomes zero, add it to sources slice sortedOrder := []byte{} for len(sources) > 0 { vertex := sources[0] sources = sources[1:] sortedOrder = append(sortedOrder, vertex) // get the node's children to decrement their in-degrees children := graph[vertex] for _, child := range children { inDegree[child]-- if inDegree[child] == 0 { sources = append(sources, child) } } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if len(sortedOrder) != len(inDegree) { return "" } return string(sortedOrder) } func min(a, b int) int { if a < b { return a } return b } a7:T86b,## Problem Statement There is a dictionary containing words from an alien language for which we don’t know the ordering of the letters. Given a list of strings `words` from the alien language's dictionary. All strings in words are `sorted lexicographically` by the rules of this new language. Return a string of the `unique` letters in the new alien language `sorted` in `lexicographically` increasing order by the new language's rules. It is given that the input is a valid dictionary and there exists an ordering among its letters. **Example 1**: ``` Input: Words: ["ba", "bc", "ac", "cab"] Output: bac Explanation: Given that the words are sorted lexicographically by the rules of the alien language, so from the given words we can conclude the following ordering among its characters: 1. From "ba" and "bc", we can conclude that 'a' comes before 'c'. 2. From "bc" and "ac", we can conclude that 'b' comes before 'a' From the above two points, we can conclude that the correct character order is: "bac" ``` **Example 2**: ``` Input: Words: ["cab", "aaa", "aab"] Output: cab Explanation: From the given words we can conclude the following ordering among its characters: 1. From "cab" and "aaa", we can conclude that 'c' comes before 'a'. 2. From "aaa" and "aab", we can conclude that 'a' comes before 'b' From the above two points, we can conclude that the correct character order is: "cab" ``` **Example 3**: ``` Input: Words: ["ywx", "wz", "xww", "xz", "zyy", "zwz"] Output: ywxz Explanation: From the given words we can conclude the following ordering among its characters: 1. From "ywx" and "wz", we can conclude that 'y' comes before 'w'. 2. From "wz" and "xww", we can conclude that 'w' comes before 'x'. 3. From "xww" and "xz", we can conclude that 'w' comes before 'z' 4. From "xz" and "zyy", we can conclude that 'x' comes before 'z' 5. From "zyy" and "zwz", we can conclude that 'y' comes before 'w' From the above five points, we can conclude that the correct character order is: "ywxz" ``` **Constraints:** - `1 <= words.length <= 100` - `1 <= words[i].length <= 100` - `words[i]` consists of only lowercase English letters.a8:T72b,from collections import deque class Solution: def findOrder(self, words): if len(words) == 0: return "" # a. Initialize the graph inDegree = {} # count of incoming edges graph = {} # adjacency list graph for word in words: for character in word: inDegree[character] = 0 graph[character] = [] # b. Build the graph for i in range(0, len(words)-1): # find ordering of characters from adjacent words w1, w2 = words[i], words[i + 1] for j in range(0, min(len(w1), len(w2))): parent, child = w1[j], w2[j] if parent != child: # if the two characters are different # put the child into it's parent's list graph[parent].append(child) inDegree[child] += 1 # increment child's inDegree break # only the first different character between the two words will help us # find the order # c. Find all sources i.e., all vertices with 0 in-degrees sources = deque() for key in inDegree: if inDegree[key] == 0: sources.append(key) # d. For each source, add it to the sortedOrder and subtract one from all of its # children's in-degrees if a child's in-degree becomes zero, add it to sources queue sortedOrder = [] while sources: vertex = sources.popleft() sortedOrder.append(vertex) for child in graph[vertex]: # get the node's children to decrement their in-degrees inDegree[child] -= 1 if inDegree[child] == 0: sources.append(child) # if sortedOrder doesn't contain all characters, there is a cyclic dependency between # characters, therefore, we'll not be able to find the correct ordering of characters if len(sortedOrder) != len(inDegree): return "" return ''.join(sortedOrder) a9:T61b,public class DriverCode { public static TestCaseRunResult RunTestCase(Queue inputStream) throws InvalidInputException, InvalidOutputException { if (inputStream.size() < 1) { throw new InvalidInputException(); } ArrayList testInput = new ArrayList(); testInput.add(inputStream.peek()); inputStream.remove(); Type type0 = new TypeToken(){}.getType(); String[] words = Parser.parse(testInput.get(0),type0); Solution sol = new Solution(); String result = sol.findOrder(words); ArrayList userOutput = new ArrayList(); String outputType = "String"; userOutput.add(Parser.toString(result,outputType)); return new TestCaseRunResult(testInput, userOutput); } public static TestCaseVerificationResult VerifyTestCaseResult( ArrayList userOutput, Queue expectedOutputStream ) throws InvalidInputException , InvalidOutputException { if (userOutput.isEmpty()) { throw new InvalidOutputException(); } assert expectedOutputStream.size() >= 1; ArrayList expectedOutput = new ArrayList(); expectedOutput.add(expectedOutputStream.peek()); expectedOutputStream.remove(); Type type = new TypeToken(){}.getType(); boolean passed = expectedOutput.equals(userOutput); return new TestCaseVerificationResult(passed, expectedOutput); } } aa:T994,import java.util.*; class Solution { public String findOrder(String[] words) { if (words == null || words.length == 0) return ""; // a. Initialize the graph HashMap inDegree = new HashMap<>(); // count of incoming edges for every vertex HashMap> graph = new HashMap<>(); // adjacency list graph for (String word : words) { for (char character : word.toCharArray()) { inDegree.put(character, 0); graph.put(character, new ArrayList()); } } // b. Build the graph for (int i = 0; i < words.length - 1; i++) { // find ordering of characters from adjacent words String w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < Math.min(w1.length(), w2.length()); j++) { char parent = w1.charAt(j), child = w2.charAt(j); if (parent != child) { // if the two characters are different graph.get(parent).add(child); // put the child into it's parent's list inDegree.put(child, inDegree.get(child) + 1); // increment child's inDegree break; // only the first different character between the two words will help // us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees Queue sources = new LinkedList<>(); for (Map.Entry entry : inDegree.entrySet()) { if (entry.getValue() == 0) sources.add(entry.getKey()); } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue StringBuilder sortedOrder = new StringBuilder(); while (!sources.isEmpty()) { Character vertex = sources.poll(); sortedOrder.append(vertex); // get the node's children to decrement their in-degrees List children = graph.get(vertex); for (Character child : children) { inDegree.put(child, inDegree.get(child) - 1); if (inDegree.get(child) == 0) sources.add(child); } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.length() != inDegree.size()) return ""; return sortedOrder.toString(); } } ab:T7cd,class Solution { findOrder(words) { if (words.length === 0) { return ''; } // a. Initialize the graph const inDegree = {}; // count of incoming edges const graph = {}; // adjacency list graph words.forEach((word) => { for (let i = 0; i < word.length; i++) { inDegree[word[i]] = 0; graph[word[i]] = []; } }); // b. Build the graph for (let i = 0; i < words.length - 1; i++) { // find ordering of characters from adjacent words let w1 = words[i], w2 = words[i + 1]; for (let j = 0; j < Math.min(w1.length, w2.length); j++) { let parent = w1[j], child = w2[j]; if (parent !== child) { // if the two characters are different // put the child into it's parent's list graph[parent].push(child); inDegree[child] += 1; // increment child's inDegree break; // only the first different character between the two words will help us // find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees const sources = []; const chars = Object.keys(inDegree); chars.forEach((key) => { if (inDegree[key] === 0) { sources.push(key); } }); // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue let sortedOrder = []; while (sources.length > 0) { let vertex = sources.shift(); sortedOrder.push(vertex); // get the node's children to decrement their in-degrees graph[vertex].forEach((child) => { inDegree[child] -= 1; if (inDegree[child] === 0) { sources.push(child); } }); } // if sortedOrder doesn't contain all characters, there is a cyclic dependency between // characters, therefore, we'll not be able to find the correct ordering of characters if (sortedOrder.length !== chars.length) { return ''; } return sortedOrder.join(''); } } ac:T94e,using namespace std; #include #include #include #include #include class Solution { public: string findOrder(const vector &words) { if (words.empty() || words.empty()) { return ""; } // a. Initialize the graph unordered_map inDegree; // count of incoming edges for every vertex unordered_map> graph; // adjacency list graph for (auto word : words) { for (char character : word) { inDegree[character] = 0; graph[character] = vector(); } } // b. Build the graph for (int i = 0; i < words.size() - 1; i++) { // find ordering of characters from adjacent words string w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < min(w1.length(), w2.length()); j++) { char parent = w1[j], child = w2[j]; if (parent != child) { // if the two characters are different graph[parent].push_back(child); // put the child into it's parent's list inDegree[child]++; // increment child's inDegree break; // only the first different character between the two words will help // us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees queue sources; for (auto entry : inDegree) { if (entry.second == 0) { sources.push(entry.first); } } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue string sortedOrder; while (!sources.empty()) { char vertex = sources.front(); sources.pop(); sortedOrder += vertex; vector children = graph[vertex]; // get the node's children to decrement their in-degrees for (char child : children) { inDegree[child]--; if (inDegree[child] == 0) { sources.push(child); } } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.length() != inDegree.size()) { return ""; } return sortedOrder; } }; ad:T574,namespace csharp.dynamic { using csharp.pkg; public class DriverCode { public static TestCaseRunResult RunTestCase(Queue inputStream) { if (inputStream.Count < 1) { throw new InvalidInputException(); } List testInput = new List(); testInput.Add(inputStream.Peek()); inputStream.Dequeue(); Type type0 = typeof(string[]); string[] words = Parser.Parse(testInput[0], type0); Solution sol = new Solution(); string result = sol.findOrder(words); List userOutput = new List(); string outputType = "string"; userOutput.Add(Parser.ToString(result, outputType)); return new TestCaseRunResult(testInput, userOutput); } public static TestCaseVerificationResult VerifyTestCaseResult( List userOutput, Queue expectedOutputStream ) { if (userOutput.Count == 0) { throw new InvalidOutputException(); } List expectedOutput = new List(); expectedOutput.Add(expectedOutputStream.Peek()); expectedOutputStream.Dequeue(); Type type = typeof(string); bool passed = expectedOutput.SequenceEqual(userOutput); return new TestCaseVerificationResult(passed, expectedOutput); } }} ae:Ta2c,using System; using System.Collections.Generic; using System.Text; public class Solution { public string findOrder(string[] words) { if (words == null || words.Length == 0) return ""; // a. Initialize the graph Dictionary inDegree = new Dictionary(); Dictionary> graph = new Dictionary>(); foreach (string word in words) { foreach (char character in word) { if (!inDegree.ContainsKey(character)) { inDegree[character] = 0; } if (!graph.ContainsKey(character)) { graph[character] = new List(); } } } // b. Build the graph for (int i = 0; i < words.Length - 1; i++) { // find ordering of characters from adjacent words string w1 = words[i], w2 = words[i + 1]; for (int j = 0; j < Math.Min(w1.Length, w2.Length); j++) { char parent = w1[j], child = w2[j]; if (parent != child) { graph[parent].Add(child); inDegree[child] += 1; break; } } } // c. Find all sources i.e., all vertices with 0 in-degrees Queue sources = new Queue(); foreach (KeyValuePair entry in inDegree) { if (entry.Value == 0) sources.Enqueue(entry.Key); } // d. For each source, add it to the sortedOrder and subtract one from all of its // children's in-degrees if a child's in-degree becomes zero, add it to sources queue StringBuilder sortedOrder = new StringBuilder(); while (sources.Count > 0) { char vertex = sources.Dequeue(); sortedOrder.Append(vertex); List children = graph[vertex]; foreach (char child in children) { inDegree[child] -= 1; if (inDegree[child] == 0) sources.Enqueue(child); } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if (sortedOrder.Length != inDegree.Count) return ""; return sortedOrder.ToString(); } } af:T5a0,package main import ("fmt" "os") type DriverCode struct{} func (s *DriverCode) RunTestCase(inputStream *[]string) (*TestCaseRunResult, error) { if inputStream != nil { slice := *inputStream length := len(slice) if length < 1 { return nil, NewInvalidInputException() } } testInput := []string{(*inputStream)[0]} *inputStream = (*inputStream)[1:] parser := Parser{} words, err0 := parser.parse(testInput[0], "[]string", "") if err0 != nil { return nil, err0 } var wordsParsed []string = words.([]string) sol := Solution{} result := sol.findOrder(wordsParsed) userParsedOutput, errOutput := parser.toString(result, "string", "") if errOutput != nil { fmt.Fprintf(os.Stderr, "Runtime error: %v", errOutput) return nil, errOutput } userOutput := []string{userParsedOutput} return NewTestCaseRunResult(testInput, userOutput), nil } func (s *DriverCode) VerifyTestCaseResult(userOutput []string, expectedOutputStream *[]string) (*TestCaseVerificationResult, error) { if len(userOutput) == 0 { return nil, NewInvalidOutputException() } if len(*expectedOutputStream) < 1 { return nil, NewInvalidOutputException() } expectedOutput := []string{(*expectedOutputStream)[0]} *expectedOutputStream = (*expectedOutputStream)[1:] parser := Parser{} passed := parser.StringSliceEqual(expectedOutput, userOutput) return NewTestCaseVerificationResult(passed, expectedOutput), nil } b0:T83f, type Solution struct{} func (s *Solution) findOrder(words []string) string { if words == nil || len(words) == 0 { return "" } // a. Initialize the graph inDegree := make(map[byte]int) // count of incoming edges for every vertex graph := make(map[byte][]byte) // adjacency list graph for _, word := range words { for i := range word { character := word[i] inDegree[character] = 0 graph[character] = []byte{} } } // b. Build the graph for i := 0; i < len(words)-1; i++ { // find ordering of characters from adjacent words w1, w2 := words[i], words[i+1] for j := 0; j < min(len(w1), len(w2)); j++ { parent, child := w1[j], w2[j] if parent != child { // if the two characters are different graph[parent] = append(graph[parent], child) // put the child into its parent's list inDegree[child]++ // increment child's inDegree break // only the first different character between the two words will help us find the order } } } // c. Find all sources i.e., all vertices with 0 in-degrees sources := []byte{} for key, value := range inDegree { if value == 0 { sources = append(sources, key) } } // d. For each source, add it to the sortedOrder and subtract one from all of its children's in-degrees // if a child's in-degree becomes zero, add it to sources slice sortedOrder := []byte{} for len(sources) > 0 { vertex := sources[0] sources = sources[1:] sortedOrder = append(sortedOrder, vertex) // get the node's children to decrement their in-degrees children := graph[vertex] for _, child := range children { inDegree[child]-- if inDegree[child] == 0 { sources = append(sources, child) } } } // if sortedOrder doesn't contain all characters, there is a cyclic dependency // between characters, therefore, we will not be able to find the correct ordering // of the characters if len(sortedOrder) != len(inDegree) { return "" } return string(sortedOrder) } func min(a, b int) int { if a < b { return a } return b } 9:["$","$L5e",null,{"document":{"latestDocument":{"tags":[],"updated":"2025-02-27T05:47:33.366Z","sections":[],"outline":[]},"_id":"63a5c810923d029fb1c4ad5d","owners":["636b1d083b22faa3e89b243a"],"createdAt":"2022-12-23T15:02:28.007Z","updatedAt":"2025-02-27T05:47:33.366Z","rvn":0,"oldVersions":[{"addedByAi":false,"document":{"updated":"2022-12-23T15:24:00.852Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$5f"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"$60","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"$61","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"$62","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"$63","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$64"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0bc","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0bb","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"$65","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"$66","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"$67","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"$68","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c2","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0bd","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Time Complexity\n\n\nIn step ‘d’, each task can become a source only once and each edge (a rule) will be accessed and removed once. Therefore, the time complexity of the above algorithm will be O(V+E), where ‘V’ is the total number of different characters and ‘E’ is the total number of the rules in the alien language. Since, at most, each pair of words can give us one rule, therefore, we can conclude that the upper bound for the rules is O(N) where ‘N’ is the number of words in the input. So, we can say that the time complexity of our algorithm is O(V+N).\n\n## Space Complexity\n\nThe space complexity will be O(V+N), since we are storing all of the rules for each character in an adjacency list."},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0c3","collapse":[]}],"_id":"63aeaeb0018424531e014a52","tags":[]},"versionTimestamp":"2022-12-23T15:35:32.186Z","_id":"63aeaeb0018424531e014a51"},{"addedByAi":false,"document":{"updated":"2022-12-23T15:24:00.852Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$69"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n\n public static void main(String[] args) {\n String result = Solution.findOrder(new String[] { \"ba\", \"bc\", \"ac\", \"cab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"cab\", \"aaa\", \"aab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\" });\n System.out.println(\"Character order: \" + result);\n }\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"\ndef find_order(words):\n # TODO: Write your code here\n return \"\"\n\ndef main():\n print(\"Character order: \" + find_order([\"ba\", \"bc\", \"ac\", \"cab\"]))\n print(\"Character order: \" + find_order([\"cab\", \"aaa\", \"aab\"]))\n print(\"Character order: \" + find_order([\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"]))\n\n\nmain()\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass AlienDictionary {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n\nint main(int argc, char *argv[]) {\n string result = AlienDictionary::findOrder(vector{\"ba\", \"bc\", \"ac\", \"cab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"cab\", \"aaa\", \"aab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"});\n cout << \"Character order: \" << result << endl;\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"\nfunction find_order(words) {\n // TODO: Write your code here\n return '';\n}\n\n\n\nconsole.log(`Character order: ${find_order(['ba', 'bc', 'ac', 'cab'])}`);\n\nconsole.log(`Character order: ${find_order(['cab', 'aaa', 'aab'])}`);\n\nconsole.log(`Character order: ${find_order(['ywx', \"wz\", 'xww', 'xz',\n'zyy', 'zwz'])}`);\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$6a"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0bc","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0bb","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"$6b","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"$6c","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"$6d","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"$6e","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c2","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0bd","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Time Complexity\n\n\nIn step ‘d’, each task can become a source only once and each edge (a rule) will be accessed and removed once. Therefore, the time complexity of the above algorithm will be O(V+E), where ‘V’ is the total number of different characters and ‘E’ is the total number of the rules in the alien language. Since, at most, each pair of words can give us one rule, therefore, we can conclude that the upper bound for the rules is O(N) where ‘N’ is the number of words in the input. So, we can say that the time complexity of our algorithm is O(V+N).\n\n## Space Complexity\n\nThe space complexity will be O(V+N), since we are storing all of the rules for each character in an adjacency list."},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0c3","collapse":[]}],"_id":"63b76ea32e9ab8a622f08ccb","tags":[]},"versionTimestamp":"2022-12-30T09:26:08.861Z","_id":"63b76ea32e9ab8a622f08cca"},{"addedByAi":false,"document":{"updated":"2022-12-23T15:24:00.852Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$6f"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n\n public static void main(String[] args) {\n String result = Solution.findOrder(new String[] { \"ba\", \"bc\", \"ac\", \"cab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"cab\", \"aaa\", \"aab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\" });\n System.out.println(\"Character order: \" + result);\n }\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"\ndef find_order(words):\n # TODO: Write your code here\n return \"\"\n\ndef main():\n print(\"Character order: \" + find_order([\"ba\", \"bc\", \"ac\", \"cab\"]))\n print(\"Character order: \" + find_order([\"cab\", \"aaa\", \"aab\"]))\n print(\"Character order: \" + find_order([\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"]))\n\n\nmain()\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass AlienDictionary {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n\nint main(int argc, char *argv[]) {\n string result = AlienDictionary::findOrder(vector{\"ba\", \"bc\", \"ac\", \"cab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"cab\", \"aaa\", \"aab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"});\n cout << \"Character order: \" << result << endl;\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"\r\nfunction find_order(words) {\r\n // TODO: Write your code here\r\n return '';\r\n}\r\n\r\n\r\n\r\nconsole.log(`Character order: ${find_order(['ba', 'bc', 'ac', 'cab'])}`);\r\n\r\nconsole.log(`Character order: ${find_order(['cab', 'aaa', 'aab'])}`);\r\n\r\nconsole.log(`Character order: ${find_order(['ywx', \"wz\", 'xww', 'xz',\r\n'zyy', 'zwz'])}`);\r\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$70"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0bc","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0bb","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"$71","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"$72","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"$73","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"$74","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c2","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0bd","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Time Complexity\n\n\nIn step ‘d’, each task can become a source only once and each edge (a rule) will be accessed and removed once. Therefore, the time complexity of the above algorithm will be O(V+E), where ‘V’ is the total number of different characters and ‘E’ is the total number of the rules in the alien language. Since, at most, each pair of words can give us one rule, therefore, we can conclude that the upper bound for the rules is O(N) where ‘N’ is the number of words in the input. So, we can say that the time complexity of our algorithm is O(V+N).\n\n## Space Complexity\n\nThe space complexity will be O(V+N), since we are storing all of the rules for each character in an adjacency list."},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0c3","collapse":[]}],"_id":"63b965f17dd925f2efb760f2","tags":[]},"versionTimestamp":"2023-01-06T00:43:15.941Z","_id":"63b965f17dd925f2efb760f1"},{"addedByAi":false,"document":{"updated":"2022-12-23T15:24:00.852Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$75"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n\n public static void main(String[] args) {\n String result = Solution.findOrder(new String[] { \"ba\", \"bc\", \"ac\", \"cab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"cab\", \"aaa\", \"aab\" });\n System.out.println(\"Character order: \" + result);\n\n result = Solution.findOrder(new String[] { \"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\" });\n System.out.println(\"Character order: \" + result);\n }\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"\ndef find_order(words):\n # TODO: Write your code here\n return \"\"\n\ndef main():\n print(\"Character order: \" + find_order([\"ba\", \"bc\", \"ac\", \"cab\"]))\n print(\"Character order: \" + find_order([\"cab\", \"aaa\", \"aab\"]))\n print(\"Character order: \" + find_order([\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"]))\n\n\nmain()\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass AlienDictionary {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n\nint main(int argc, char *argv[]) {\n string result = AlienDictionary::findOrder(vector{\"ba\", \"bc\", \"ac\", \"cab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"cab\", \"aaa\", \"aab\"});\n cout << \"Character order: \" << result << endl;\n\n result = AlienDictionary::findOrder(vector{\"ywx\", \"wz\", \"xww\", \"xz\", \"zyy\", \"zwz\"});\n cout << \"Character order: \" << result << endl;\n}\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"\r\nfunction find_order(words) {\r\n // TODO: Write your code here\r\n return '';\r\n}\r\n\r\n\r\n\r\nconsole.log(`Character order: ${find_order(['ba', 'bc', 'ac', 'cab'])}`);\r\n\r\nconsole.log(`Character order: ${find_order(['cab', 'aaa', 'aab'])}`);\r\n\r\nconsole.log(`Character order: ${find_order(['ywx', \"wz\", 'xww', 'xz',\r\n'zyy', 'zwz'])}`);\r\n","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$76"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0bc","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0bb","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"$77","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"$78","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"$79","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"$7a","userCodeHighlight":[],"solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":false,"showSubmitButton":false,"showRunButton":true,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c2","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0bd","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Time Complexity\n\n\nIn step ‘d’, each task can become a source only once and each edge (a rule) will be accessed and removed once. Therefore, the time complexity of the above algorithm will be O(V+E), where ‘V’ is the total number of different characters and ‘E’ is the total number of the rules in the alien language. Since, at most, each pair of words can give us one rule, therefore, we can conclude that the upper bound for the rules is O(N) where ‘N’ is the number of words in the input. So, we can say that the time complexity of our algorithm is O(V+N).\n\n## Space Complexity\n\nThe space complexity will be O(V+N), since we are storing all of the rules for each character in an adjacency list."},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0c4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0c3","collapse":[]}],"_id":"63dc958216c4e8a379f58ed8","tags":[]},"versionTimestamp":"2023-01-07T12:30:42.012Z","_id":"63dc958216c4e8a379f58ed7"},{"addedByAi":false,"document":{"updated":"2022-12-23T15:24:00.852Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$7b"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$7c","solutionCode":"$7d","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$7e","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$7f","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$80","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]}],"_id":"650978cd72a0549f20e88dc2","tags":[]},"versionTimestamp":"2022-12-23T15:24:00.852Z","_id":"650978cd72a0549f20e88dc1"},{"addedByAi":false,"document":{"updated":"2023-10-23T17:32:28.326Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$81"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$82","solutionCode":"$83","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$84","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$85","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$86","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"},{"driverCodeGenerated":"NOT_GENERATED","language":"csharp","userCode":"using System;\nusing System.Collections.Generic;\nusing System.Text;\n\npublic class Solution\n{\n public string findOrder(string[] words)\n {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$87","solutionCode":"$88","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]}],"_id":"6536ae2dccd2f08ea093f784","tags":[]},"versionTimestamp":"2023-10-23T17:32:28.326Z","_id":"6536ae2dccd2f08ea093f783"},{"addedByAi":false,"document":{"updated":"2023-11-28T02:46:03.299Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$89"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"executeWithCustomClasses":false,"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$8a","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public static String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$8b","solutionCode":"$8c","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$8d","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n static string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$8e","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"csharp","userCode":"using System;\nusing System.Collections.Generic;\nusing System.Text;\n\npublic class Solution\n{\n public string findOrder(string[] words)\n {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$8f","solutionCode":"$90","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"go","userCode":"\ntype Solution struct{}\n\nfunc (s *Solution) findOrder(words []string) string {\n\t// TODO: Write your code here\n return \"\"\n}\n\n","userCodeHighlight":[],"driverCode":"$91","solutionCode":"$92","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"productList":[],"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","_id":"63a5cac4923d029fb1c4b0b5","collapse":[]}],"_id":"6565546cfc8584ae127b5b42","tags":[]},"versionTimestamp":"2023-11-28T02:46:03.299Z","_id":"6565546cfc8584ae127b5b41"},{"addedByAi":false,"document":{"updated":"2023-12-27T21:25:00.462Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$93"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","productList":[],"_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","productList":[],"_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$94","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$95","solutionCode":"$96","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$97","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$98","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"csharp","userCode":"using System;\nusing System.Collections.Generic;\nusing System.Text;\n\npublic class Solution\n{\n public string findOrder(string[] words)\n {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$99","solutionCode":"$9a","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"go","userCode":"\ntype Solution struct{}\n\nfunc (s *Solution) findOrder(words []string) string {\n\t// TODO: Write your code here\n return \"\"\n}\n\n","userCodeHighlight":[],"driverCode":"$9b","solutionCode":"$9c","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","productList":[],"_id":"63a5cac4923d029fb1c4b0b5","collapse":[]}],"_id":"658c962c5f190e083fad5077","tags":[]},"versionTimestamp":"2023-12-27T21:25:00.462Z","_id":"658c962c5f190e083fad5076"},{"addedByAi":false,"document":{"updated":"2024-03-21T11:12:13.360Z","sections":[{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$9d"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","productList":[],"_id":"63a5cac4923d029fb1c4b0b1","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","productList":[],"_id":"63a5cac4923d029fb1c4b0b3","collapse":[]},{"databaseExercise":{"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false,"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[]},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$9e","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$9f","solutionCode":"$a0","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$a1","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$a2","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"csharp","userCode":"using System;\nusing System.Collections.Generic;\nusing System.Text;\n\npublic class Solution\n{\n public string findOrder(string[] words)\n {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$a3","solutionCode":"$a4","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"go","userCode":"\ntype Solution struct{}\n\nfunc (s *Solution) findOrder(words []string) string {\n\t// TODO: Write your code here\n return \"\"\n}\n\n","userCodeHighlight":[],"driverCode":"$a5","solutionCode":"$a6","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","productList":[],"_id":"63a5cac4923d029fb1c4b0b5","collapse":[]}],"_id":"65fc160dd89ffcb1b0ceea0a","tags":[]},"versionTimestamp":"2024-03-21T11:12:13.360Z","_id":"65fc160dd89ffcb1b0ceea09"},{"addedByAi":false,"document":{"updated":"2024-07-24T17:35:14.722Z","sections":[{"databaseExercise":{"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"$a7"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b2","sectionType":"markdown","productList":[],"collapse":[],"_id":"63a5cac4923d029fb1c4b0b1"},{"databaseExercise":{"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[],"exampleTestCases":[],"internalTestCases":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"markdown":{"text":"## Try it yourself \nTry solving this question here:"},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0b4","sectionType":"markdown","productList":[],"collapse":[],"_id":"63a5cac4923d029fb1c4b0b3"},{"databaseExercise":{"script":[],"databaseSchema":[],"exampleTestData":[],"internalTestData":[],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":false,"showRunButton":false,"showSolutionButton":false,"showSolutionCode":false,"skipOutputVerification":false},"webExercise":{"makeReadOnly":false,"showSolutionCode":false,"code":[]},"codeExercise":{"code":[{"driverCodeGenerated":"NOT_GENERATED","language":"python3","userCode":"from collections import deque\n\nclass Solution:\n def findOrder(self, words):\n # TODO: Write your code here\n return \"\"\n","userCodeHighlight":[],"driverCode":"def RunTestCase(inputStream: deque):\n if len(inputStream) < 1:\n raise InvalidInputException()\n\n testInput: List[str] = [inputStream.popleft()]\n words = Parser.parse(testInput[0],'List[str]')\n\n sol = Solution()\n userResult = sol.findOrder(words)\n\n userOutput: List[str] = [Parser.toStr(userResult,'str')]\n\n return TestCaseRunResult(testInput=testInput, userOutput=userOutput)\n\ndef VerifyTestCaseResult(userOutput: List[str], expectedOutputStream: deque) -> TestCaseVerificationResult:\n if len(userOutput) == 0:\n raise InvalidInputException()\n assert len(expectedOutputStream) >= 1\n\n # consume lines from expectedOutputStream\n expectedOutput: List[str] = [expectedOutputStream.popleft()]\n\n # Method#1 (compare using strings)\n passed: bool = userOutput == expectedOutput\n\n return TestCaseVerificationResult(passed, expectedOutput)","solutionCode":"$a8","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2451"},{"driverCodeGenerated":"NOT_GENERATED","language":"java","userCode":"import java.util.*;\n\nclass Solution {\n public String findOrder(String[] words) {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$a9","solutionCode":"$aa","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"javascript","userCode":"class Solution {\n\n findOrder(words) {\n // TODO: Write your code here\n return '';\n }\n}\n","userCodeHighlight":[],"driverCode":"RunTestCase = function(inputStream) {\n if (inputStream.length < 1) {\n throw new InvalidInputException();\n }\n // consume input lines required for this test\n let testInput = inputStream.splice(0,1);\n const words = parse(testInput[0],'Array');\n let sol = new Solution();\n let userResult = sol.findOrder(words);\n let userOutput = [];\n userOutput.push(toStr(userResult,'string'));\n\n return {\n testInput: testInput,\n userOutput: userOutput,\n };\n}\n\nVerifyTestCaseResult = function(userOutput, expectedOutputStream) {\n if (userOutput.length == 0) {\n throw new InvalidOutputException();\n }\n assert(expectedOutputStream.length >= 1);\n let expectedOutput = expectedOutputStream.splice(0, 1);\n\n const passed = JSON.stringify(userOutput) == JSON.stringify(expectedOutput);\n\n return {\n passed: passed,\n expectedOutput: expectedOutput,\n };\n}","solutionCode":"$ab","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472059"},{"driverCodeGenerated":"NOT_GENERATED","language":"cpp","userCode":"using namespace std;\n\n#include \n#include \n#include \n#include \n#include \n\nclass Solution {\npublic:\n string findOrder(const vector &words) {\n // TODO: Write your code here\n return \"\";\n }\n};\n","userCodeHighlight":[],"driverCode":"TestCaseRunResult RunTestCase(queue& inputStream) {\n if (inputStream.size() < 1) {\n throw InvalidInputException();\n }\n vector testInput;\n testInput.push_back(inputStream.front()); inputStream.pop();\n auto words = parseString>(testInput[0]);\n Solution sol;\n std::string result = sol.findOrder(words);\n\n vector userOutput;\n userOutput.push_back(toString(result));\n return TestCaseRunResult(testInput, userOutput);\n}\n\nTestCaseVerificationResult VerifyTestCaseResult(const vector& userOutput, queue& expectedOutputStream) {\n if (userOutput.empty()) {\n throw InvalidOutputException();\n }\n ASSERT(expectedOutputStream.size() >= 1);\n vector expectedOutput;\n expectedOutput.push_back(expectedOutputStream.front());\n expectedOutputStream.pop();\n bool passed = userOutput[0].compare(expectedOutput[0]) == 0;\n return TestCaseVerificationResult(passed, expectedOutput);\n}\n","solutionCode":"$ac","solutionCodeHighlight":[],"_id":"6388d17620aeb9f745472058"},{"driverCodeGenerated":"NOT_GENERATED","language":"csharp","userCode":"using System;\nusing System.Collections.Generic;\nusing System.Text;\n\npublic class Solution\n{\n public string findOrder(string[] words)\n {\n // TODO: Write your code here\n return \"\";\n }\n}\n","userCodeHighlight":[],"driverCode":"$ad","solutionCode":"$ae","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"},{"driverCodeGenerated":"NOT_GENERATED","language":"go","userCode":"\ntype Solution struct{}\n\nfunc (s *Solution) findOrder(words []string) string {\n\t// TODO: Write your code here\n return \"\"\n}\n\n","userCodeHighlight":[],"driverCode":"$af","solutionCode":"$b0","solutionCodeHighlight":[],"_id":"636b1d083b22faa3e89b2450"}],"exampleTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"}],"internalTestCases":[{"input":"[\"ba\",\"bc\",\"ac\",\"cab\"]\n","expectedOutput":"\"bac\"\n","_id":"63b877d6a4deb0091e9f8d00"},{"input":"[\"cab\",\"aaa\",\"aab\"]\n","expectedOutput":"\"cab\"\n","_id":"63b877d6a4deb0091e9f8d01"},{"input":"[\"ywx\",\"wz\",\"xww\",\"xz\",\"zyy\",\"zwz\"]\n","expectedOutput":"\"ywxz\"\n","_id":"63b877d6a4deb0091e9f8d02"},{"input":"[\"z\",\"x\",\"y\"]\n","expectedOutput":"\"zxy\"\n","_id":"63b877d6a4deb0091e9f8d03"},{"input":"[\"aaa\",\"aab\",\"aac\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d04"},{"input":"[\"zxy\",\"yxx\",\"xxz\"]\n","expectedOutput":"\"zyx\"\n","_id":"63b877d6a4deb0091e9f8d06"},{"input":"[\"z\",\"z\",\"z\"]\n","expectedOutput":"\"z\"\n","_id":"63b877d6a4deb0091e9f8d07"},{"input":"[\"ab\",\"ba\"]\n","expectedOutput":"\"ab\"\n","_id":"63b877d6a4deb0091e9f8d09"},{"input":"[\"abc\",\"bca\",\"cab\"]\n","expectedOutput":"\"abc\"\n","_id":"63b877d6a4deb0091e9f8d10"}],"makeReadOnly":false,"showExecuteButton":true,"showSubmitButton":true,"showRunButton":false,"showSolutionButton":false,"executeWithCustomClasses":false,"showSolutionCode":false,"skipOutputVerification":false},"quiz":{"options":[]},"slider":{"images":[]},"input":{"type":"text"},"sectionId":"63a5cac4923d029fb1c4b0ba","sectionType":"codeExercise","productList":[],"collapse":[],"_id":"63a5cac4923d029fb1c4b0b5"}],"_id":"66a13b52521793bd94b061b9","tags":[]},"versionTimestamp":"2024-07-24T17:35:14.722Z","_id":"66a13b52521793bd94b061b8"}],"__v":0,"draftDocuments":[]},"title":"Alien Dictionary (hard)","url":"document/grokking-the-coding-interview/63a5c810923d029fb1c4ad5d","courseId":"636b1d083b22faa3e89b243a"}]