Table of Contents

String to Int - Atoi

intmyAtoi(String s) {// Base conditionif (s.length<1) {return0;  }// MAX and MIN values for integersfinalint max=2147483647;finalint min=-2147483648;  s= s.trim();// Counterint i=0;// Flag to indicate if the number is negativebool isNegative= s.startsWith("-");// Flag to indicate if the number is positivebool isPositive= s.startsWith("+");if (isNegative) {    i++;  }elseif (isPositive) {    i++;  }// This will store the converted numberdouble number=0;// Loop for each numeric character in the sing iff numeric characters are leading// characters in the singwhile (i< s.length&&      s[i].codeUnitAt(0)>='0'.codeUnitAt(0)&&      s[i].codeUnitAt(0)<='9'.codeUnitAt(0)) {    number= number*10+ (s[i].codeUnitAt(0)-'0'.codeUnitAt(0));    i++;  }// Give back the sign to the converted number  number= isNegative?-number: number;if (number< min) {return min;  }if (number> max) {return max;  }return number.round();}

Is Palindrome

boolisPalindrome(int x) {finalString str= x.toString();return str== str.split('').reversed.join().toString();}

Regular Expression Matching

boolisMatch(String s,String p) {finalRegExp regExp=RegExp(p);return regExp.stringMatch(s)== s;}

Container with most water

intmaxArea(List<int> height) {int max=0;int left=0;int right= height.length-1;while (left< right) {final res=min(height[left], height[right])* (right- left);if (res> max) max= res;if (height[left]< height[right]) {      left++;    }else {      right--;    }  }return max;}

Integer to Roman

StringintToRoman(intnum) {// Define roman values and symbolsfinalList<int> values= [1000,500,100,50,10,5,1];finalList<String> romanSymbols= ['M','D','C','L','X','V','I'];List<String> result= [];for (int index=0; index< values.length; index++) {finalint romanValue= values[index];finalint div= (num/ romanValue).floor();if (div>0) {num-= div* romanValue;      result.addAll(List.generate(          div,          (i)=> romanSymbols[index],        ),      );    }if (index< values.length-1) {for (int j= index+1; j< values.length; j++) {if (values[j].toString()[0]=='1') {finalint nextValue= values[j];finalint combine2Symbols= romanValue- nextValue;if (num>= combine2Symbols&&num% combine2Symbols<= nextValue) {num-= combine2Symbols;            result.add(romanSymbols[j]);            result.add(romanSymbols[index]);          }        }      }    }  }return result.join();}

Validate Stack Sequences

boolvalidateStackSequences(List<int> pushed,List<int> popped) {List<int> current= [];int indexPush=0;int indexPop=0;while (indexPush< pushed.length-1|| indexPop< popped.length-1) {if (current.contains(popped[indexPop])) {if (current.last== popped[indexPop]) {        current.removeLast();        indexPop++;      }else {returnfalse;      }    }else {      current.add(pushed[indexPush]);      indexPush++;    }  }returntrue;}

Reverse Nodes in k-Group

ListNode?reverseKGroup(ListNode? head,int k) {finalList<int> values=mergeValue(head, []);finalList<List<int>> chunks= [];for (int i=0; i< values.length; i+= k) {var end= (i+ k< values.length)? i+ k: values.length;    chunks.add(values.sublist(i, end));  }finalList<int> result= [];  chunks.forEach((e) {if (e.length== k)      result.addAll(e.reversed);else      result.addAll(e);  });returnlinkedNodes(result);}List<int>mergeValue(ListNode? head,List<int> result) {if (head==null)return result;returnmergeValue(head.next, [...result, head.val]);}ListNodelinkedNodes(List<int> values) {List<ListNode> nodes= values.map((e)=>ListNode(e)).toList();for (int i=0; i< nodes.length-1; i++) {    nodes[i].next= nodes[i+1];  }return nodes.first;}

Substring with Concatenation of All Words

List<int>findSubstring(String s,List<String> words) {if (words.isEmpty|| s.isEmpty|| words.first.isEmpty)return [];finalList<int> startIndexs= [];finalint k= words.first.length;finalint lengthOfMatchWords= words.length* k;final listCloned= words.map((e)=> e).toList();  listCloned.sort();if (s.length< lengthOfMatchWords)return [];for (final wordin words.toSet().toList()) {finalRegExp regExp=RegExp('(?=($word))');finalIterable<Match> matches= regExp.allMatches(s);if (matches.isEmpty)break;for (final matchin matches) {if (match.start+ lengthOfMatchWords<= s.length) {finalString subString= s.substring(          match.start,          match.start+ lengthOfMatchWords,        );finalList<String> chunks= [];for (int i=0; i< subString.length; i+= k) {var end= (i+ k< subString.length)? i+ k: subString.length;          chunks.add(subString.substring(i, end));        }        chunks.sort();// Check match with requimentsif (chunks.join()== listCloned.join()&&!startIndexs.contains(match.start)) {          startIndexs.add(match.start);        }      }    }  }  startIndexs.sort();return startIndexs;}

Longest Valid Parentheses

intlongestValidParentheses(String s) {if (s.isEmpty)return0;int longest=0;finalList<int> stack= [-1];for (int i=0; i< s.length; i++) {// Openif (s[i]=='(') {      stack.add(i);    }else {if (stack.isNotEmpty) stack.removeLast();if (stack.isNotEmpty) {        longest=max(longest, i- stack.last);      }else {        stack.add(i);      }    }  }return longest;}

Merge k Sorted Lists

ListNode?mergeKLists(List<ListNode?> lists) {List<int> merge= [];for (final listin lists) {    merge.addAll(mergeValue(list, []));  }  merge.sort();returnlinkedNodes(merge);}// UtilsList<int>mergeValue(ListNode? head,List<int> result) {if (head==null)return result;returnmergeValue(head.next, [...result, head.val]);}ListNode?linkedNodes(List<int> values) {if (values.isEmpty)returnnull;List<ListNode> nodes= values.map((e)=>ListNode(e)).toList();for (int i=0; i< nodes.length-1; i++) {    nodes[i].next= nodes[i+1];  }return nodes.first;}

Kids With the Greatest Number of Candies

List<bool>kidsWithCandies(List<int> candies,int extraCandies) {finalList<int> clone= candies.map((e)=> e).toList();  clone.sort((a, b)=> b- a);int greatest= clone.first;finalList<bool> result= candies.map((e) {return e+ extraCandies>= greatest;  }).toList();return result;}

Sudoku Solver

voidsolveSudoku(List<List<String>> board) {_solver(board);}bool_solver(List<List<String>> board) {for (int i=0; i< board.length; i++) {for (int j=0; j< board.length; j++) {if (board[i][j]=='.') {for (int k=1; k<=9; k++) {if (_isValid(board, i, j, k)) {            board[i][j]='$k';if (_solver(board))returntrue;          }        }        board[i][j]='.';returnfalse;      }    }  }print(board);returntrue;}bool_isValid(List<List<String>> board,int row,int col,int k) {for (int i=0; i<9; i++) {if (board[row][i]=='$k'|| board[i][col]=='$k') {returnfalse;    }  }final m= (col/3).floor()*3;final n= (row/3).floor()*3;for (int i=0; i<3; i++) {for (int j=0; j<3; j++) {if (board[n+ i][m+ j]=='$k') {returnfalse;      }    }  }returntrue;}

First Missing Positive

intfirstMissingPositive(List<int> nums) {  nums= nums.where((e)=> e>0).toSet().toList();  nums.sort();if (nums.isEmpty|| nums.first!=1)return1;for (int index=1; index< nums.length; index++) {if (nums[index]- nums[index-1]!=1) {return nums[index-1]+1;    }  }return nums.last+1;}

Trapping rain water

inttrap(List<int> height) {if (height.length<2)return0;List<int> left=List.generate(height.length, (index)=>0);List<int> right=List.generate(height.length, (index)=>0);int result=0;  left.first= height.first;for (int i=1; i< height.length; i++) {    left[i]=max(left[i-1], height[i]);  }  right.last= height.last;for (int i= height.length-2; i>=0; i--) {    right[i]=max(right[i+1], height[i]);  }for (int i=0; i< height.length; i++) {    result+=min(left[i], right[i])- height[i];  }return result;}

Wildcard Matching

boolisMatch(String s,String p) {if (p.replaceAll("*","").length> s.length)returnfalse;List<bool> flags=List.generate(s.length+1, (index)=>false);  flags.first=true;for (int i=1; i< s.length;++i) {    flags[i]=false;  }for (int i=1; i<= p.length;++i) {String char= p[i-1];if (char=='*') {for (int j=1; j<= s.length;++j) {        flags[j]= flags[j-1]|| flags[j];      }    }else {for (int j= s.length; j>=1;--j) {        flags[j]= flags[j-1]&& (char=='?'|| char== s[j-1]);      }    }    flags[0]= flags[0]&& char=='*';  }return flags[s.length];}

N Queens

List<List<String>>solveNQueens(int n) {finalList<List<String>> result= [];finalList<List<String>> board=List.generate(    n,    (index)=>List.generate(n, (index)=>"."),  );place(0,0,0,0, board, result);return result;}voidplace(int i,int vert,int ldiag,int rdiag,List<List<String>> board,List<List<String>> result,) {if (i== board.length) {List<String> res= [];for (final rowin board) res.add(row.join());    result.add(res);return;  }for (int j=0; j< board.length; j++) {int verticalMask=1<< j,        leftMask=1<< (i+ j),        rightMask=1<< (board.length- i-1+ j);if ((vert& verticalMask)+ (ldiag& leftMask)+ (rdiag& rightMask)>0)continue;    board[i][j]='Q';place(i+1, vert| verticalMask, ldiag| leftMask, rdiag| rightMask, board, result);    board[i][j]='.';  }}

Valid number

boolisNumber(String s) {if (s=="Infinity"|| s=="-Infinity"|| s=="+Infinity")returnfalse;returnnum.tryParse(s)!=null;}

Text Justification

List<String>fullJustify(List<String> words,int maxWidth) {finalList<String> result= [];String temp='';for (int index=0; index< words.length; index++) {finalString word= words[index];if (temp.length+ word.length+ (temp.isEmpty?0:1)<= maxWidth) {      temp+='${temp.isEmpty ?'' :' '}$word';    }else {if (temp.trim().isNotEmpty) {        result.add(temp.trim());      }      temp= word;    }if (index== words.length-1&& temp.isNotEmpty) {      result.add(temp.trim());    }  }returnfillSpace(result, maxWidth);}List<String>fillSpace(List<String> words,int maxWidth) {for (int i=0; i< words.length; i++) {finalString word= words[i];if (word.length< maxWidth) {finalList<String> splits= word.split(' ');if (splits.length<2|| i== words.length-1) {        words[i]=            word+List.generate(maxWidth- word.length, (index)=>' ').join();      }else {int leftSpace= maxWidth- word.length+ splits.length-1;String temp='';for (int j=0; j< splits.length; j++) {finaldouble div= leftSpace/ (splits.length- j);int avgSpace= div.round();if (leftSpace/ avgSpace>0) {            avgSpace= div.ceil();          }if (j==0) {            temp+= splits[j];          }elseif (leftSpace>0) {finalint cal= leftSpace< avgSpace? leftSpace: avgSpace;            temp+='${List.generate(cal, (index) =>' ').join()}${splits[j]}';            leftSpace-= cal;          }        }        words[i]= temp;      }    }  }return words;}

3 Sum

List<List<int>>threeSum(List<int> nums) {  nums.sort();finalList<List<int>> result= [];for (int i=0; i< nums.length-2; i++) {if (i>0&& nums[i]== nums[i-1])continue;int left= i+1;int right= nums.length-1;while (left< right) {finalint sum= nums[i]+ nums[left]+ nums[right];if (sum==0) {        result.add([nums[i], nums[left], nums[right]]);// remove duplicatewhile (left< nums.length-1&& nums[left]== nums[left+1]) left++;while (right>0&& nums[right]== nums[right-1]) right--;        left++;        right--;      }elseif (sum<0) {        left++;      }else {        right--;      }    }  }return result;}

3 Sum Closest

intthreeSumClosest(List<int> nums,int target) {int result=-1;int diff=-1;for (int i=0; i< nums.length-2; i++) {int left= i+1;int right= nums.length-1;while (left< right) {finalint sum= nums[i]+ nums[left]+ nums[right];if (diff<0|| (sum- target).abs()< diff) {        diff= (sum- target).abs();        result= sum;      }if (diff==0) {return result;      }if (right== left+1) {        left++;        right= nums.length-1;      }else {        right--;      }    }  }return result;}

Letter combinations of a phone number

constMap<int,List<String>> chars= {2: ['a','b','c'],3: ['d','e','f'],4: ['g','h','i'],5: ['k','j','l'],6: ['m','n','o'],7: ['p','q','r','s'],8: ['t','u','v'],9: ['w','x','y','z'],};List<String>letterCombinations(String digits) {if (digits.isEmpty)return [];finalList<String> result= [];lookupChar(0,"", digits.length, digits, result);return result;}voidlookupChar(int index,String res,int length,String digits,List<String> result,) {if (index== digits.length)    result.add(res);else {finalList<String> letters= chars[int.parse(digits[index])]!;for (int i=0; i< letters.length; i++) {lookupChar(index+1, res+ letters[i], length, digits, result);    }  }}

Jump Game II

intjump(List<int> nums) {if (nums.isEmpty)return0;int result=0;int maxNumber=0;int cur=0;for (var i=0; i< nums.length-1; i++) {    maxNumber=max(maxNumber, i+ nums[i]);if (i== cur) {      result++;      cur= maxNumber;    }  }return result;}