Regex backreferences and assertions problems

Regex/README.md

@@ -46,8 +46,20 @@ Problem | Java | Javascript | Python
 [Matching_Word_Boundaries](pdf/matching-word-boundaries.pdf) | [Solution](java/Matching_Word_Boundaries.java) | [Solution](javascript/Matching_Word_Boundaries.js) | [Solution](python/Matching_Word_Boundaries.py)
 ___
 ### Backreferences
+Problem | Java | Javascript | Python
+:---: | :---: | :---: | :---:
+[Backreferences_To_Failed_Groups](pdf/backreferences-to-failed-groups.pdf) | [Solution](java/Backreferences_To_Failed_Groups.java) | N/A | N/A
+[Branch_Reset_Groups](pdf/branch-reset-groups.pdf) | [Solution](java/Branch_Reset_Groups.java) | N/A | N/A
+[Forward_References](pdf/forward-references.pdf) | [Solution](java/Forward_References.java) | N/A | N/A
+[Mathcing_Same_Text_Again_Again](pdf/matching-same-text-again-again.pdf) | [Solution](java/Matching_Same_Text_Again_Again.java) | N/A | N/A
 ___
 ### Assertions
+Problem | Java | Javascript | Python
+:---: | :---: | :---: | :---:
+[Negative_Lookahead](pdf/negative-lookahead.pdf) | [Solution](java/Negative_Lookahead.java) | [Solution](javascript/Negative_Lookahead.js) | [Solution](python/Negative_Lookahead.py)
+[Negative_Lookbehind](pdf/negative-lookbehind.pdf) | [Solution](java/Negative_Lookbehind.java) | N/A | [Solution](python/Negative_Lookbehind.py)
+[Positive_Lookahead](pdf/positive-lookahead.pdf) | [Solution](java/Positive_Lookahead.java) | [Solution](javascript/Positive_Lookahead.js) | [Solution](python/Positive_Lookahead.py)
+[Positive_Lookbehind](pdf/positive-lookbehind.pdf) | [Solution](java/Positive_Lookbehind.java) | N/A | [Solution](python/Positive_Lookbehind.py)
 ___
 ### Applications
 Problem | Java | Javascript | Python

Regex/java/Backreferences_To_Failed_Groups.java

@@ -0,0 +1,28 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
+        Regex_Test tester = new Regex_Test();
+        tester.checker("^\\d{2}(-?)(\\d{2}\\1){2}\\d{2}$"); // Use \\ instead of using \
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        System.out.println(m.find());
+    }
+
+}

Regex/java/Branch_Reset_Groups.java

@@ -0,0 +1,29 @@
+import java.io.*;
+import java.util.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
+        Regex_Test tester = new Regex_Test();
+        tester.checker("^\\d{2}((-)|(---)|(\\.)|(:))(\\d{2}\\1?){3}$"); // Use \\ instead of using \
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        System.out.println(m.find());
+    }
+
+}

Regex/java/Forward_References.java

@@ -0,0 +1,28 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("^(\\2tic|(tac))+$"); // Use \\ instead of using \
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        System.out.println(m.find());
+    }
+
+}

Regex/java/Matching_Same_Text_Again_Again.java

@@ -0,0 +1,28 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("^([a-z])(\\w)(\\s)(\\W)(\\d)(\\D)([A-Z])([A-Za-z])([AEIOUaeiou])(\\S)\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10$"); // Use \\ instead of using \
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        System.out.println(m.find());
+    }
+
+}

Regex/java/Negative_Lookahead.java

@@ -0,0 +1,32 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("(.)(?!\\1)"); //Use '\\' instead of '\'.
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        int Count = 0;
+        while(m.find()){
+            Count += 1;
+        }
+        System.out.format("Number of matches : %d",Count);
+    }
+
+}

Regex/java/Negative_Lookbehind.java

@@ -0,0 +1,32 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("(?<![aeiouAEIOU])."); //Use '\\' instead of '\'.
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        int Count = 0;
+        while(m.find()){
+            Count += 1;
+        }
+        System.out.format("Number of matches : %d",Count);
+    }
+
+}

Regex/java/Positive_Lookahead.java

@@ -0,0 +1,32 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("o(?=oo)"); //Use '\\' instead of '\'.
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        int Count = 0;
+        while(m.find()){
+            Count += 1;
+        }
+        System.out.format("Number of matches : %d",Count);
+    }
+
+}

Regex/java/Positive_Lookbehind.java

@@ -0,0 +1,32 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+
+        Regex_Test tester = new Regex_Test();
+        tester.checker("(?<=[13579])\\d"); //Use '\\' instead of '\'.
+
+    }
+}
+
+class Regex_Test {
+
+    public void checker(String Regex_Pattern){
+
+        Scanner Input = new Scanner(System.in);
+        String Test_String = Input.nextLine();
+        Pattern p = Pattern.compile(Regex_Pattern);
+        Matcher m = p.matcher(Test_String);
+        int Count = 0;
+        while(m.find()){
+            Count += 1;
+        }
+        System.out.format("Number of matches : %d",Count);
+    }
+
+}

Regex/javascript/Negative_Lookahead.js

@@ -0,0 +1,18 @@
+var Regex_Pattern = /(.)(?!\1)/g;	//Do not delete `/` and `/g`.
+
+function processData(Test_String) {
+    //Enter your code here
+    var Array = Test_String.match(Regex_Pattern);
+    console.log("Number of matches :", Array.length);
+}
+
+process.stdin.resume();
+process.stdin.setEncoding("ascii");
+_input = "";
+process.stdin.on("data", function (input) {
+    _input += input;
+});
+
+process.stdin.on("end", function () {
+   processData(_input);
+});

Regex/javascript/Positive_Lookahead.js

@@ -0,0 +1,18 @@
+var Regex_Pattern = /o(?=oo)/g;	//Do not delete `/` and `/g`.
+
+function processData(Test_String) {
+    //Enter your code here
+    var Array = Test_String.match(Regex_Pattern);
+    console.log("Number of matches :", Array.length);
+}
+
+process.stdin.resume();
+process.stdin.setEncoding("ascii");
+_input = "";
+process.stdin.on("data", function (input) {
+    _input += input;
+});
+
+process.stdin.on("end", function () {
+   processData(_input);
+});

Regex/python/Negative_Lookahead.py

@@ -0,0 +1,9 @@
+Regex_Pattern = r"(.)(?!\1)"	# Do not delete 'r'.
+
+import re
+
+Test_String = input()
+
+match = re.findall(Regex_Pattern, Test_String)
+
+print("Number of matches :", len(match))

Regex/python/Negative_Lookbehind.py

@@ -0,0 +1,9 @@
+Regex_Pattern = r"(?<![aeiouAEIOU])."	# Do not delete 'r'.
+
+import re
+
+Test_String = input()
+
+match = re.findall(Regex_Pattern, Test_String)
+
+print("Number of matches :", len(match))

Regex/python/Positive_Lookahead.py

@@ -0,0 +1,9 @@
+Regex_Pattern = r'o(?=oo)'	# Do not delete 'r'.
+
+import re
+
+Test_String = input()
+
+match = re.findall(Regex_Pattern, Test_String)
+
+print("Number of matches :", len(match))

Regex/python/Positive_Lookbehind.py

@@ -0,0 +1,9 @@
+Regex_Pattern = r"(?<=[13579])\d"	# Do not delete 'r'.
+
+import re
+
+Test_String = input()
+
+match = re.findall(Regex_Pattern, Test_String)
+
+print("Number of matches :", len(match))