added previous files

Author: abdul awal

another_fiel_for_test.dart

@@ -0,0 +1,33 @@
+class Solution {
+  int calculate(String s) {
+    int ans = 0;
+    int num = 0;
+    int sign = 1;
+    List<int> stack = [];
+    stack.add(sign);
+
+    for (int i = 0; i < s.length; i++) {
+      final char = s[i];
+
+      if (RegExp(r'\d').hasMatch(char)) {
+        num = num * 10 + int.parse(char);
+      } else if (char == '(') {
+        stack.add(sign);
+      } else if (char == ')') {
+        stack.removeLast();
+      } else if (char == '+' || char == '-') {
+        ans += sign * num;
+        sign = (char == '+' ? 1 : -1) * stack.last;
+        num = 0;
+      }
+    }
+
+    return ans + sign * num;
+  }
+}
+
+void main() {
+  Solution sl = Solution();
+
+  print(sl.calculate('(1+(4+5+2)-3)+(6+8)'));
+}

basic_calculator.dart

@@ -0,0 +1,5 @@
+void main(){
+
+  final num = int.parse('1111', radix: 2);
+  print(num);
+}

binary_divisibility.dart

@@ -0,0 +1,29 @@
+def elder_age(m, n, l, t):
+    # arithmic series sum
+    def s(a1, a2):
+        return 0 if a1 > a2 else (a1 + a2) * (a2 - a1 + 1) // 2
+    # edge till 2^k
+    def edge(x):
+        ret = 1
+        while ret < x: ret *= 2
+       # print(ret)
+        return ret
+
+    m, n  = min(m , n), max(m, n)
+    em, en = edge(m), edge(n)
+    if m == 0 or l >= en - 1: return 0
+    if em == en:
+        return (s(0, em - l - 1) * (m + n - em) + elder_age(em - m, en - n, l, t)) % t
+    else:
+        em = en // 2
+        goal_s1 = s(0, en - l - 1) * m 
+        s1_small = (en - n) * s(max (em - l, 0), en - l - 1)
+        if l <= em: # no +0s,        true FANS  /O-O\
+            small = elder_age(em - m, en - n, 0, t) + (em - l) * (em - m) * (en - n) 
+        else:       # with some +0s, fake FANS  
+            small = elder_age(em - m, en - n, l - em, t)
+        return (goal_s1 - s1_small + small) % t
+    
+print(elder_age(115,510,291,255))
+
+#m = 5, n = 5, l = 1, t = 25

elder.py

@@ -0,0 +1,25 @@
+int elderAge(int n, int m, int k, int newp) {
+  // Step 1: Generate the initial grid based on XOR of row and column indices
+   int sum = 0;
+  
+  // Compute the sum directly without creating the grid
+  for (int i = 0; i < n; i++) {
+    for (int j = 0; j < m; j++) {
+      int value = i ^ j;
+      int adjustedValue = value - k;
+      if (adjustedValue < 0) {
+        adjustedValue = 0;
+      }
+      sum += adjustedValue;
+    }
+  }
+
+  // Handle the time constraint
+  return sum % newp;
+
+}
+
+void main() {
+  // Example usage
+  print(elderAge(5, 8, 1, 100)); // Output: 5
+}

immortal_problem.dart

@@ -0,0 +1,74 @@
+import 'dart:collection';
+
+double evaluate(String expression) {
+  // Helper function to evaluate simple expressions without parentheses
+  double evalSimple(String exp) {
+    // Use a queue to process operators with the correct precedence
+    Queue<String> tokens = Queue.from(exp.split(RegExp(r'(\D)')).where((e) => e.isNotEmpty));
+    Queue<String> operators = Queue.from(exp.split(RegExp(r'(\d+\.?\d*)')).where((e) => e.isNotEmpty));
+
+    // Function to perform an operation
+    double operate(double left, String operator, double right) {
+      switch (operator) {
+        case '+':
+          return left + right;
+        case '-':
+          return left - right;
+        case '*':
+          return left * right;
+        case '/':
+          return left / right;
+        default:
+          throw ArgumentError('Unknown operator: $operator');
+      }
+    }
+
+    // Stack to handle multiplication and division first
+    Queue<double> values = Queue<double>();
+    values.add(double.parse(tokens.removeFirst()));
+    
+    while (tokens.isNotEmpty) {
+      String operator = operators.removeFirst();
+      double value = double.parse(tokens.removeFirst());
+      
+      if (operator == '*' || operator == '/') {
+        double prevValue = values.removeLast();
+        values.add(operate(prevValue, operator, value));
+      } else {
+        values.add(value);
+        operators.addFirst(operator);
+      }
+    }
+
+    double result = values.removeFirst();
+    
+    while (operators.isNotEmpty) {
+      String operator = operators.removeFirst();
+      double value = values.removeFirst();
+      result = operate(result, operator, value);
+    }
+
+    return result;
+  }
+
+  // Helper function to handle parentheses
+  double evalParentheses(String exp) {
+    while (exp.contains('(')) {
+      exp = exp.replaceAllMapped(RegExp(r'\(([^()]+)\)'), (match) {
+        return evalSimple(match.group(1)!).toString();
+      });
+    }
+    return evalSimple(exp);
+  }
+
+  return evalParentheses(expression.replaceAll(' ', ''));
+}
+
+void main() {
+  // Test cases
+  print(evaluate("1-1")); // Output: 0
+  print(evaluate("1 -1")); // Output: 0
+  print(evaluate("1- -1")); // Output: 2
+  print(evaluate("6 + -(4)")); // Output: 2
+  print(evaluate("(2 / (2 + 3.33) * 4) - -6")); // Output: 7.2009...
+}

mathematical_expression.dart

@@ -0,0 +1,88 @@
+//https://www.hackerrank.com/challenges/matrix-script/problem
+import 'dart:core';
+
+void main() {
+//   List<String> matrix = [
+// //5 9
+//     '#%\$r%r\$n ',
+//     'O%Mi\$iTi\$',
+//     'yiaxsprt ',
+//     'est%ctiy#',
+//     '  t c i %',
+//   ];
+  //Output: #Oye is Mattrix sccript Triinity  $ #%
+
+
+ List<String> matrix = [
+  //7 3
+'Tsi',
+'h%x',
+'i #',
+'sM ',
+'\$a ',
+'#t%',
+'ir!',
+ ];
+//Output: This is Matrix#  %!
+
+//   List<String> matrix = [
+// //4,6
+//     'T%Mic&',
+//     'h%axr%',
+//     'iit#p!',
+//     'ssrst&'
+//   ];
+
+//output: This isMatrix scrpt&%!&
+
+// List<String> matrix =[
+//   ///4 6
+// '#%\$r%r',
+// 'I%Mi\$i',
+// 'tiaxsp',
+// '#st%ct',
+// ];
+//  //Output: #It is Matrix script
+
+//Input
+//4 8
+//   List<String> matrix = [
+//     '#%\$r%r\$n',
+//     'I%Mi\$iTi',
+//     'tiaxsprt',
+//     '#st%ctiy',
+//   ];
+// //Output: #It is Matrix script Trinity
+
+  int row = 7, column = 3;
+  print(matrixScript(row, column, matrix));
+}
+
+String matrixScript(int rows, int column, List<String> matrix) {
+  // Rotate the matrix
+  List<List<String>> rotatedMatrix =
+      List.generate(column, (i) => List.filled(rows, ''));
+  for (int i = 0; i < rows; i++) {
+    for (int j = 0; j < column; j++) {
+      rotatedMatrix[j][i] = matrix[i][j];
+    }
+  }
+
+
+  // Flatten the rotated matrix into a single string
+  StringBuffer sample = StringBuffer();
+
+  for (List<String> subset in rotatedMatrix) {
+    for (String letter in subset) {
+      sample.write(letter);
+    }
+  }
+     print(sample.toString());
+
+  // Replace invalid characters with a space
+  String result = sample
+      .toString()
+      .replaceAllMapped(RegExp(r'(?<=\w)([^\d\w]+)(?=\w)'), (match) => ' ');
+
+  return result;
+}

matrix_script.dart

@@ -0,0 +1,71 @@
+void main() {
+
+  print("SOmethig");
+  // Example usage :
+
+  ListNode? list1 =
+      ListNode(1, ListNode(4, ListNode(5, ListNode(7, ListNode(100)))));
+  ListNode? list2 =
+      ListNode(0, ListNode(8, ListNode(50, ListNode(70, ListNode(100)))));
+  ListNode? list3 =
+      ListNode(10, ListNode(40, ListNode(50, ListNode(70, ListNode(100)))));
+
+  ListNode? list4 = ListNode(
+      100, ListNode(400, ListNode(500, ListNode(700, ListNode(1000)))));
+
+
+
+      List<ListNode?> lists = [list1,list2, list3, list4];
+
+      Solution solution = Solution();
+      ListNode? mergedList = solution.mergingSortedList(lists);
+
+      while(mergedList != null){
+        print(mergedList.val);
+        mergedList = mergedList.next;
+      }
+}
+
+class ListNode {
+  int val;
+  ListNode? next;
+  ListNode([this.val = 0, this.next]);
+}
+
+class Solution {
+  ListNode? mergingSortedList(List<ListNode?> lists) {
+   ListNode dummy = ListNode(0);
+   ListNode curr = dummy;
+
+   // storing data into heap
+
+   List<ListNode> headData= [];
+   
+   for(final list in lists){
+    if(list !=null){
+      headData.add(list);
+    }
+
+   }
+
+    headData.sort((a,b) => a.val.compareTo(b.val));
+
+
+while(headData.isNotEmpty){
+  final currentSmallVal = headData.removeAt(0);
+
+  if(currentSmallVal.next!=null){
+    headData.add(currentSmallVal.next!);
+
+        headData.sort((a,b) => a.val.compareTo(b.val));
+
+  }
+
+  curr.next = currentSmallVal;
+  curr = curr.next!;
+
+}
+return dummy.next;
+
+  }
+}

merging_sorted_list_node.dart

@@ -0,0 +1,38 @@
+void main() {
+List<String> matrix =[
+  ///4 6
+'#%\$r%r',
+'I%Mi\$i',
+'tiaxsp',
+'#st%ct',
+];
+//  //Output: #It is Matrix script
+ 
+
+  matrixScript(4, 6, matrix);
+}
+
+String matrixScript(int row, int column, List<String> matrix) {
+   //rotate the matrix
+List<List<String>> rotatedMatrix = List.generate(column, (i)=>List.filled(row, ''));
+
+for(int i =0; i<row; i++){
+  for(int j = 0; j<column; j++){
+    rotatedMatrix[j][i] = matrix[i][j];
+  }
+}
+   //list data
+
+   StringBuffer dummy = StringBuffer();
+   for(List<String> subset in rotatedMatrix){
+    for(String char in subset){
+      dummy.write(char);
+    }
+   }
+
+   print(dummy.toString());
+   //filter charactes and paces
+   String result = dummy.toString().replaceAllMapped(RegExp(r'(?<=\w)([^\d\w]+)(?=\w)'), (replace)=>' ');
+   print(result);
+  return '';
+}