public float main_calculator(string ss) { TOkenizer obj1 = new TOkenizer(ss); Stack <float> nstack = new Stack <float>(); Stack <string> ostack = new Stack <string>(); while (obj1.is_finished()) { Token _res = obj1.getToken(); if (_res.Type == TokenType.enumeric) { number_value = _res.Value; if (!obj1.is_finished()) { nstack.Push(float.Parse(number_value)); break; } _res = obj1.getToken(); while (_res.Type == TokenType.enumeric) { number_value += _res.Value; if (!obj1.is_finished()) { break; } _res = obj1.getToken(); } nstack.Push(float.Parse(number_value)); } if (ostack.Count() == 0 && obj1.is_finished()) { ostack.Push(_res.Value); } else if (ostack.Count() != 0 && obj1.is_finished()) { string char_pop = ostack.Peek(); int com_res = compare_chars(_res.Value, char_pop); if (com_res == 1) { ostack.Push(_res.Value); } else { char_pop = ostack.Pop(); while (compare_chars(_res.Value, char_pop) != 1 || ostack.Count() != 0) { number1 = nstack.Pop(); number2 = nstack.Pop(); nstack.Push(calcalator(char_pop)); if (ostack.Count() == 0) { break; } char_pop = ostack.Pop(); } ostack.Push(_res.Value); } } } while (ostack.Count() != 0) { string char_pop = ostack.Pop(); number1 = nstack.Pop(); number2 = nstack.Pop(); nstack.Push(calcalator(char_pop)); result = calcalator(char_pop); } return(result); }
private bool finished; //Totuusarvo onko algoritmi valmis. public Dijkstra(int[,] matriisi, int s, int target) { start = s; Matriisi = matriisi; //Alustetaan kaikki taulukot. visited = new int[(int)Math.Sqrt(matriisi.Length)]; distance = new int[visited.Length]; via = new int[visited.Length]; inde = new List <int>(); path = new Stack <int>(); finished = false; for (int i = 0; i < distance.Length; i++) { //Alustetaan alla olevien taulukoiden erikoisarvot. distance[i] = int.MaxValue; visited[i] = -1; via[i] = -1; } inde.Clear(); current = start; int[] tdistance = new int[visited.Length]; int round = 0; //Aloitetaan algoritmi. while (finished != true) { if (current == start) //Jos tarkasteltava piste on aloituspiste niin sen etäisyys asetetaan nollaksi. { distance[current] = 0; via[current] = -1; } for (int i = 0; i < distance.Length; i++) { if (Matriisi[current, i] != 0 && Matriisi[current, i] + distance[current] < distance[i]) { //Jos tarkasteltavan pisteen ja i:n väli on 0 välissä ei ole linkkiä. //Jos tarkasteltavan pisteen ja i:n väli on < kuin niinden välinen etäisyys asetetaan uusi etäisyys. distance[i] = distance[current] + Matriisi[current, i]; via[i] = current; //asetetaan perittävä piste } } tdistance = (int[])distance.Clone(); //Kloonataan etäisyyslista. Array.Sort(tdistance); //Väliaikainen etäisyyslista lajitellaan. visited[round] = current; //Vierailtujenlistaan lisätään tarkasteltu piste. for (int i = 0; i < tdistance.Length; i++) //Silmukka, jossa katsotaan väliaikaislistan pituus. { inde.Clear(); //Tyhjennetään inde-lista. int former = current; //Asetetaan muutosmuuttuja for (int j = 0; j < distance.Length; j++) { if (distance[j] == tdistance[i]) //Tarkastellaan lyhimmästä pisimpään järjestyksessä, mikä seuraavan tarkastelupisteen tulee olla. { inde.Add(j); //Lisätään kandidaatit listaan inde } } foreach (int value in inde) //Käydään läpi inde lista { if (tdistance[i] >= distance[current] && Array.IndexOf(visited, value) == -1 && value != -1) //Jos väliaikaisetäisyys on >= tarkasteltava etäisyys JA vierailtujentaulukosta ei löydy kyseistä inde-listassa olevaa arvoa JA arvo != -1 { current = value; //Asetetaan uudeksi tarkasteltavaksi pisteeksi inde-listan tämänhetkinen arvo. break; } } if (former != current) { break; } //Jos muutosmuuttujan ja tarkasteltavan pisteen välillä on ero on tarkasteltava piste vaihtunut. } if (Array.IndexOf(visited, -1) == -1) { finished = true; } //Jos vierailtujen lista on täynnä on algoritmi valmis. round++; } Console.WriteLine("Vertex: Distance: Via:"); //Tulostetaan selvästi luettava lista. Console.WriteLine("---------------------------"); for (int i = 0; i < visited.Length; i++) { Console.Write(" {0} ", i); Console.Write("{0} ", distance[i]); if (via[i] == -1) { Console.WriteLine(" "); } else { Console.WriteLine(via[i]); } Console.WriteLine("---------------------------"); } while (true) //Tulostetaan polku lähtöpisteestä päätepisteeseen. { path.Push(target); if (target == start) { break; } target = via[target]; } while (path.Count() != 0) { Console.Write("{0}, ", path.Pop()); } }
public void DFS(List<DirectedNode> nodelist, int goalNodeid) { Stack<DirectedNode> stack = new Stack<DirectedNode>(); stack.Push(nodelist[0]); DirectedNode frontiernode; int[] adjlist; while (stack.Count() != 0) { frontiernode = stack.Pop(); adjlist = frontiernode.adjnodes; if (adjlist == null) { continue; } foreach (int i in adjlist) { stack.Push(nodelist[i]); node previousnode = nodelist[nodelist[i].PreviousNodeid]; float edgeweight = ConsoleApplication1.Driver.distance(frontiernode, nodelist[i]); float newdistance = frontiernode.ShortestDistanceTo + edgeweight; if (nodelist[i].ShortestDistanceTo == 0) { nodelist[i].ShortestDistanceTo = newdistance; nodelist[i].PreviousNodeid = frontiernode.id; } else if (newdistance < nodelist[i].ShortestDistanceTo) { nodelist[i].ShortestDistanceTo = newdistance; nodelist[i].PreviousNodeid = frontiernode.id; } else { } } } int prevNodeId = goalNodeid - 1; Console.Write("Path: " + prevNodeId); while (prevNodeId != 0) { Console.Write(" <- " + nodelist[prevNodeId].PreviousNodeid); prevNodeId = nodelist[prevNodeId].PreviousNodeid; } Console.Write("\nDistance: " + nodelist[goalNodeid - 1].ShortestDistanceTo); }
static void Main(string[] args) { Dictionary <string, int> myDictionary = new Dictionary <string, int>(); Queue <string> myQueue = new Queue <string>(); Stack <string> stkMyStack = new Stack <string>(); bool error = true; int menuchoice = 0; /****************************************************************************************************************************/ /****************************************************************************************************************************/ /************************************* MAIN MENU *********************************************/ /****************************************************************************************************************************/ /****************************************************************************************************************************/ /****************************************************************************************************************************/ while (menuchoice != 4) { Console.WriteLine("MENU"); Console.WriteLine("Please enter the number that you want to do:"); Console.WriteLine("1. Stack"); Console.WriteLine("2. Queue"); Console.WriteLine("3. Dicitonary"); Console.WriteLine("4. Exit"); error = true; while (error == true) { try { menuchoice = int.Parse(Console.ReadLine()); error = false; } catch { Console.WriteLine("Invalid Entry"); Console.WriteLine("Please enter a number between 1-4"); } } switch (menuchoice) { case 1: /****************************************************************************************************************************/ /************************************* STACK MENU *********************************************/ /****************************************************************************************************************************/ /****************************************************************************************************************************/ while (menuchoice != 7) { menuchoice = 0; Console.WriteLine("STACK MENU"); Console.WriteLine("Please enter the number that you want to do:"); Console.WriteLine("1. Add one item to Stack"); Console.WriteLine("2. Add Huge List of Items to Stack"); Console.WriteLine("3. Display Stack"); Console.WriteLine("4. Delete from Stack"); Console.WriteLine("5. Clear Stack"); Console.WriteLine("6. Search Stack"); Console.WriteLine("7. Return to Main Menu"); error = true; while (error == true) { try { menuchoice = int.Parse(Console.ReadLine()); error = false; } catch { Console.WriteLine("Invalid Entry"); Console.WriteLine("Please enter a number between 1-4"); } } switch (menuchoice) { case 1: Console.WriteLine("Adding one item......"); Console.Write("Please add one item"); string sMyString = Console.ReadLine(); stkMyStack.Push(sMyString); break; case 2: Console.WriteLine("Adding Huge List of Items......"); for (int i = 0; i < 2000; i++) { string sNewEntry = ("New Entry " + i); stkMyStack.Push(sNewEntry); } break; case 3: Console.WriteLine("Display........"); for (int iCount = 0; iCount < stkMyStack.Count(); iCount++) { Console.WriteLine(stkMyStack.ElementAt(iCount)); } break; case 4: Console.WriteLine("Delete........."); Stack <string> stkDelStack = new Stack <string>(); Console.Write("Please enter which item you would like to delete: "); string sItem = Console.ReadLine(); while (sItem != stkMyStack.Peek()) { stkDelStack.Push(stkMyStack.Pop()); } stkMyStack.Pop(); for (int iCounter = 0; iCounter < stkDelStack.Count(); iCounter++) { stkMyStack.Push(stkDelStack.Pop()); } break; case 5: Console.WriteLine("Clear........"); stkMyStack.Clear(); break; case 6: Console.WriteLine("Search........"); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); Console.WriteLine("Please enter an item you would like to search for: "); string sSearch = Console.ReadLine(); sw.Start(); for (int i = 0; i < stkMyStack.Count(); i++) { if (stkMyStack.ElementAt(i).Equals(sSearch)) { Console.WriteLine(stkMyStack.ElementAt(i)); sw.Stop(); Console.WriteLine("It took " + sw.Elapsed + " seconds to complete this search."); } else { Console.WriteLine("We could not find that item."); } } break; case 7: Console.WriteLine("Going back to Main Menu......."); break; //go to main menu default: Console.WriteLine("Sorry, invalid selection"); break; } } break; /****************************************************************************************************************************/ /************************************* QUEUE MENU *********************************************/ /****************************************************************************************************************************/ /****************************************************************************************************************************/ case 2: while (menuchoice != 7) { menuchoice = 0; Console.WriteLine("QUEUE MENU"); Console.WriteLine("Please enter the number that you want to do:"); Console.WriteLine("1. Add one item to Queue"); Console.WriteLine("2. Add Huge List of Items to Queue"); Console.WriteLine("3. Display Queue"); Console.WriteLine("4. Delete from Queue"); Console.WriteLine("5. Clear Queue"); Console.WriteLine("6. Search Queue"); Console.WriteLine("7. Return to Main Menu"); error = true; while (error == true) { try { menuchoice = int.Parse(Console.ReadLine()); error = false; } catch { Console.WriteLine("Invalid Entry"); Console.WriteLine("Please enter a number between 1-4"); } } switch (menuchoice) { case 1: //Add one item to Queue Console.WriteLine("Enter a name or something."); string iInput = Console.ReadLine(); myQueue.Enqueue(iInput); break; case 2: //Add Huge List of Items to Queue myQueue.Clear(); int iCount = 0; while (iCount < 2000) { myQueue.Enqueue("New Entry " + iCount); iCount++; } break; case 3: //Display Queue foreach (string value in myQueue) { Console.WriteLine(value); } break; case 4: //Delete from Queue Console.WriteLine("Which queue item do you want to delete?"); int iQueueDelete = 0; try { iQueueDelete = int.Parse(Console.ReadLine()); } catch { Console.WriteLine("Invalid Entry"); Console.WriteLine("Please enter a number from your queue."); } List <string> listOfWhatWontBeDeletedFromQueue = new List <string>(); int iListCount = 1; while (iListCount < iQueueDelete) { listOfWhatWontBeDeletedFromQueue.Add(myQueue.Dequeue()); iListCount++; } myQueue.Dequeue(); foreach (string value in listOfWhatWontBeDeletedFromQueue) { myQueue.Enqueue(value); } break; case 5: //Clear Queue myQueue.Clear(); break; case 6: //Search Queue Console.WriteLine("What item would you like to see if the queue contains?"); string iQueueSearch = Console.ReadLine(); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); if (myQueue.Contains(iQueueSearch)) { Console.WriteLine("Yes, the queue had that."); } else { Console.WriteLine("No, the queue didn't have that."); } sw.Start(); Console.WriteLine("It took " + sw.ElapsedMilliseconds + " milliseconds to figure that out."); break; case 7: //Return to Main Menu break; default: Console.WriteLine("Sorry, invalid selection"); break; } } break; case 3: /****************************************************************************************************************************/ /************************************* DICTIONARY MENU *****************************************/ /****************************************************************************************************************************/ /****************************************************************************************************************************/ while (menuchoice != 7) { //Declare variables string sUserResponse; int iUserResponse; int iCount = 0; int iCounter = 0; menuchoice = 0; Console.WriteLine("DICTIONARY MENU"); Console.WriteLine("Please enter the number that you want to do:"); Console.WriteLine("1. Add one item to Dictionary"); Console.WriteLine("2. Add Huge List of Items to Dictionary"); Console.WriteLine("3. Display Dictionary"); Console.WriteLine("4. Delete from Dictionary"); Console.WriteLine("5. Clear Dictionary"); Console.WriteLine("6. Search Dictionary"); Console.WriteLine("7. Return to Main Menu"); error = true; while (error == true) { try { menuchoice = int.Parse(Console.ReadLine()); error = false; } catch { Console.WriteLine("Invalid Entry"); Console.WriteLine("Please enter a number between 1-4"); } } switch (menuchoice) { case 1: //Prompt user for them to enter in a string and record the response Console.WriteLine("\nPlease enter a string"); sUserResponse = Console.ReadLine(); //Add the response to the myDictionary object along with a value myDictionary.Add(sUserResponse, iCount++); break; case 2: //Clear all of the contents of the dictionary myDictionary.Clear(); //Load up each dictionary item up to 2000 for (iCount = 0; iCount <= 2000; iCount++) { myDictionary.Add("New Entry " + iCount, iCount); } //Reset the iCount back to 0 iCount = 0; break; case 3: //Display the contents of the dictionary Console.WriteLine("\nThis is the contents of the Dictionary"); foreach (KeyValuePair <string, int> entry in myDictionary) { Console.WriteLine(entry.Key.PadRight(20, ' ') + entry.Value); } Console.WriteLine(); break; case 4: //Prompt for user input of what they want to delete from the dictionary Console.WriteLine("\nWhat would you like to Delete from the Dictionary? \nHere is the List: \n"); //Display the dictionary so they can see their options foreach (KeyValuePair <string, int> entry in myDictionary) { Console.WriteLine(entry.Key); } //Record the user response and then delete the request item from the Dictionary Console.WriteLine(); sUserResponse = Console.ReadLine(); myDictionary.Remove(sUserResponse); break; case 5: //Clear the whole dictionary myDictionary.Clear(); break; case 6: //Prompt the user for what string they want to look for. Console.WriteLine("\nPlease enter the string you are searching for: "); sUserResponse = Console.ReadLine(); //Display the results of the search if (myDictionary.ContainsKey(sUserResponse)) { Console.WriteLine("\nYou found " + sUserResponse + "! Here is the value: " + myDictionary[sUserResponse] + "\n"); } else { Console.WriteLine("\nString not found!"); } break; case 7: Console.WriteLine("Going back to Main Menu......."); break; //go to main menu default: Console.WriteLine("Sorry, invalid selection"); break; } } break; case 4: break; //end default: Console.WriteLine("Sorry, invalid selection"); break; } } }
public static SanitizeResult sanitizer(String html, Regex allowedTags, Regex forbiddenTags, bool isConsiderAllowedTag = false) { SanitizeResult ret = new SanitizeResult(); Stack <String> openTags = new Stack <string>(); if (String.IsNullOrEmpty(html)) { return(ret); } List <String> tokens = tokenize(html); // ------------------- LOOP for every token -------------------------- for (int i = 0; i < tokens.Count; i++) { String token = tokens[i]; bool isAcceptedToken = false; Match startMatcher = tagStartPattern.Match(token); Match endMatcher = tagClosePattern.Match(token); //-------------------------------------------------------------------------------- COMMENT <!-- ......... --> if (commentPattern.Match(token).Success) { ret.val = ret.val + token + (token.EndsWith("-->") ? "" : "-->"); ret.invalidTags.Add(token + (token.EndsWith("-->") ? "" : "-->")); continue; //-------------------------------------------------------------------------------- OPEN TAG <tag .........> } else if (startMatcher.Success) { //tag name extraction String tag = startMatcher.Groups[1].Value.ToLower(); //----------------------------------------------------- FORBIDDEN TAG <script .........> if (forbiddenTags.Match(tag).Success) { ret.invalidTags.Add("<" + tag + ">"); continue; // -------------------------------------------------- WELL KNOWN TAG } else if (allowedTags.Match(tag).Success) { if (!isConsiderAllowedTag) { ret.invalidTags.Add("<" + tag + ">"); continue; } String cleanToken = "<" + tag; String tokenBody = startMatcher.Groups[2].Value; //first test table consistency //table tbody tfoot thead th tr td if ("thead".Equals(tag) || "tbody".Equals(tag) || "tfoot".Equals(tag) || "tr".Equals(tag)) { if (openTags.Select(t => t == "table").Count() <= 0) { ret.invalidTags.Add("<" + tag + ">"); continue; } } else if ("td".Equals(tag) || "th".Equals(tag)) { if (openTags.Count(t => t == "tr") <= 0) { ret.invalidTags.Add("<" + tag + ">"); continue; } } // then test properties //Match attributes = attributesPattern.Match(tokenBody); var attributes = attributesPattern.Matches(tokenBody); bool foundURL = false; // URL flag foreach (Match attribute in attributes) //while (attributes.find()) { String attr = attribute.Groups[1].Value.ToLower(); String val = attribute.Groups[2].Value; if (val.Contains("&{")) { ret.invalidTags.Add(attr + " " + val); } // we will accept href in case of <A> else if ("a".Equals(tag) && "href".Equals(attr)) { // <a href="......"> try { var url = new Uri(val); if (url.Scheme == Uri.UriSchemeHttp || url.Scheme == Uri.UriSchemeHttps || url.Scheme == Uri.UriSchemeMailto) { foundURL = true; } else { ret.invalidTags.Add(attr + " " + val); val = ""; } } catch { ret.invalidTags.Add(attr + " " + val); val = ""; } } else if ((tag == "img" || tag == "embed") && "src".Equals(attr)) { // <img src="......"> try { var url = new Uri(val); if (url.Scheme == Uri.UriSchemeHttp || url.Scheme == Uri.UriSchemeHttps) { foundURL = true; } else { ret.invalidTags.Add(attr + " " + val); val = ""; } } catch { ret.invalidTags.Add(attr + " " + val); val = ""; } } else if ("href".Equals(attr) || "src".Equals(attr)) { // <tag src/href="......"> skipped ret.invalidTags.Add(tag + " " + attr + " " + val); continue; } else if (attr == "width" || attr == "height") { // <tag width/height="......"> Regex r = new Regex("\\d+%|\\d+$"); if (!r.Match(val.ToLower()).Success) { // test numeric values ret.invalidTags.Add(tag + " " + attr + " " + val); continue; } } else if ("style".Equals(attr)) { // <tag style="......"> // then test properties var styles = stylePattern.Matches(val); String cleanStyle = ""; foreach (Match style in styles) //while (styles.find()) { String styleName = style.Groups[1].Value.ToLower(); String styleValue = style.Groups[2].Value; // suppress invalid styles values if (forbiddenStylePattern.Match(styleValue).Success) { ret.invalidTags.Add(tag + " " + attr + " " + styleValue); continue; } // check if valid url Match urlStyleMatcher = urlStylePattern.Match(styleValue); if (urlStyleMatcher.Success) { try { String url = urlStyleMatcher.Groups[1].Value; var uri = new Uri(url); if (!(uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)) { ret.invalidTags.Add(tag + " " + attr + " " + styleValue); continue; } } catch { ret.invalidTags.Add(tag + " " + attr + " " + styleValue); continue; } } cleanStyle = cleanStyle + styleName + ":" + encode(styleValue) + ";"; } val = cleanStyle; } else if (attr.StartsWith("on")) { // skip all javascript events ret.invalidTags.Add(tag + " " + attr + " " + val); continue; } else { // by default encode all properies val = encode(val); } cleanToken = cleanToken + " " + attr + "=\"" + val + "\""; } cleanToken = cleanToken + ">"; isAcceptedToken = true; // for <img> and <a> if ((tag == "a" || tag == "img" || tag == "embed") && !foundURL) { isAcceptedToken = false; cleanToken = ""; } token = cleanToken; // push the tag if require closure and it is accepted (otherwise is encoded) if (isAcceptedToken && !(standAloneTags.Match(tag).Success || selfClosed.Match(tag).Success)) { openTags.Push(tag); } // -------------------------------------------------------------------------------- UNKNOWN TAG } else { //ret.invalidTags.Add(token); //ret.val = ret.val + token; continue; } // -------------------------------------------------------------------------------- CLOSE TAG </tag> } else if (endMatcher.Success) { String tag = endMatcher.Groups[1].Value.ToLower(); //is self closing if (selfClosed.Match(tag).Success) { ret.invalidTags.Add(token); continue; } if (forbiddenTags.Match(tag).Success) { ret.invalidTags.Add("/" + tag); continue; } if (!allowedTags.Match(tag).Success) { //ret.invalidTags.Add(token); //ret.val = ret.val + token; continue; } else { String cleanToken = ""; // check tag position in the stack int pos = -1; bool found = false; foreach (var item in openTags) { pos++; if (item == tag) { found = true; break; } } // if found on top ok if (found) { for (int k = 0; k <= pos; k++) { //pop all elements before tag and close it String poppedTag = openTags.Pop(); cleanToken = cleanToken + "</" + poppedTag + ">"; isAcceptedToken = true; } } token = cleanToken; } } ret.val = ret.val + token; if (isAcceptedToken) { ret.html = ret.html + token; //ret.text = ret.text + " "; } else { String sanToken = htmlEncodeApexesAndTags(token); ret.html = ret.html + sanToken; ret.text = ret.text + htmlEncodeApexesAndTags(removeLineFeed(token)); } } // must close remaining tags while (openTags.Count() > 0) { //pop all elements before tag and close it String poppedTag = openTags.Pop(); ret.html = ret.html + "</" + poppedTag + ">"; ret.val = ret.val + "</" + poppedTag + ">"; } //set boolean value ret.isValid = ret.invalidTags.Count == 0; return(ret); }
private String[] Parse(String s) { String[] s1 = new String[s.Length]; Stack <String> st = new Stack <String>(); int i = 0; s = s.Replace("ln", "l"); s = s.Replace("cos", "c"); s = s.Replace("sin", "s"); int t = 0; for (int j = 0; j < s.Length; j++) { String c = s[j] + ""; if (functionCheek(c)) { t = 1; } if (numberCheek(c)) { s1[i] = c; while (s.Length > j + 1 && numberCheek(s[j + 1] + "")) { j++; s1[i] += s[j]; } i++; } else if (operatorCheek(c)) { while (!(st.Count() == 0)) { if (priority(st.Peek()) >= priority(c)) { s1[i] = st.Peek(); st.Pop(); i++; } else { break; } } st.Push(c); } else if ((c == "(" || functionCheek(c)) && t == 1) { st.Push(c); } else if (c == ")" && t == 1) { while (st.Peek() != "(") { s1[i] = st.Peek(); st.Pop(); i++; } st.Pop(); if (functionCheek(st.Peek())) { s1[i] = st.Peek(); st.Pop(); i++; } t = 0; } else if (c == "(") { st.Push(c); } else if (c == ")") { while (st.Peek() != "(") { s1[i] = st.Peek(); st.Pop(); i++; } st.Pop(); } } while (!(st.Count() == 0)) { s1[i] = st.Peek(); st.Pop(); i++; } return(s1); }