Recherche développeur si...

import java.io.IOException;
import java.io.PrintWriter;

public class NumberSearch
{

public static void searchRepetition(String s, PrintWriter out)
{
    for (int i = 0; i < s.length() - 1; i++ )
    {
        if (s.charAt(i) == s.charAt(i + 1))
        {
            int end = exploreRepetition(s, i);
            
            out.printf("repetition of '%c' at position %d-%d (size %d)\r\n", s.charAt(i), i, end, end - i + 1);
            
            i = end;
        }
    }
}

private static int exploreRepetition(String s, int start)
{
    char c = s.charAt(start);
    
    int current = start + 2;
    
    while (current < s.length() && s.charAt(current) == c)
        current++ ;
    
    return current - 1;
}

public static void searchSymetric(String s, PrintWriter out)
{
    for (int i = 1; i < s.length() - 1; i++ )
    {
        if (s.charAt(i - 1) == s.charAt(i + 1))
        {
            int n = exploreSymetric(s, i);
            out.printf("symetric at position %d-%d (size %d)\r\n", i - n, i + n, 2 * n + 1);
        }
    }
}

private static int exploreSymetric(String s, int center)
{
    int n = 2;
    
    while (center - n >= 0 && center + n < s.length() && s.charAt(center - n) == s.charAt(center + n))
        n++ ;
    
    return n - 1;
}

public static void main(String[] args) throws IOException 
{
    PrintWriter out = new PrintWriter(System.out);
    
    out.println("TESTS");
    searchRepetition("1223445556", out); // '2' at 1-2, '4' at 4-5, '5' at 6-7
    searchSymetric("1232423", out); // 1-3, 2-6
    out.flush();
    
    String PI = "3."
        +"14159265358979323846264338327950288419716939937510" //  50
        +"58209749445923078164062862089986280348253421170679" // 100
        +"82148086513282306647093844609550582231725359408128" // 150
        +"48111745028410270193852110555964462294895493038196" // 200
        +"44288109756659334461284756482337867831652712019091" // 250
        +"45648566923460348610454326648213393607260249141273" // 300
        +"72458700660631558817488152092096282925409171536436" // 350
        +"78925903600113305305488204665213841469519415116094" // 400
        +"33057270365759591953092186117381932611793105118548" // 450
        +"07446237996274956735188575272489122793818301194912";// 500
    
    PrintWriter outPi = out; // new PrintWriter("C:/Pi.txt");
    outPi.println("\nPI");
    searchRepetition(PI, outPi);
    searchSymetric(PI, outPi);
    outPi.flush();//outPi.close();
    
    String PHI = "1."
        +"61803398874989484820458683436563811772030917980576" //  50
        +"28621354486227052604628189024497072072041893911374" // 100
        +"84754088075386891752126633862223536931793180060766" // 150
        +"72635443338908659593958290563832266131992829026788" // 200
        +"06752087668925017116962070322210432162695486262963" // 250
        +"13614438149758701220340805887954454749246185695364" // 300
        +"86444924104432077134494704956584678850987433944221" // 350
        +"25448770664780915884607499887124007652170575179788" // 400
        +"34166256249407589069704000281210427621771117778053" // 450
        +"15317141011704666599146697987317613560067087480710";// 500

    PrintWriter outPhi = out; // new PrintWriter("C:/Phi.txt");
    outPhi.println("\nPHI");
    searchRepetition(PHI, outPhi);
    searchSymetric(PHI, outPhi);
    outPhi.flush();//outPhi.close();
}
}

import java.util.ArrayList;
import java.util.SortedSet;
import java.util.TreeSet;

public class Interval implements Comparable<Interval>
{
    public final int start;
    public final int end;
    
    public Interval(int a, int b)
    {
        this.start = Math.min(a, b);
        this.end = Math.max(a, b);
    }
    
    private Interval(int start, int end, Object unused)
    {
        this.start = start;
        this.end = end;
    }
    
    public int size()
    {
        return end - start + 1;
    }
    
    public static Interval merge(Interval a, Interval b)
    {
        int szt = a.end - a.start + b.end - b.start + 2;
        int szab = b.end - a.start + 1;
        int szba = a.end - b.start + 1;
        
        switch ( (szab > 0 && szab <= szt ? 1 : 0) + (szba > 0 && szba <= szt ? 2 : 0))
        {
            case 1 :
                return new Interval(a.start, b.end, null);
            case 2 :
                return new Interval(b.start, a.end, null);
            case 3 :
                return new Interval(Math.min(a.start, b.start), Math.max(a.end, b.end), null);
            default :
                return null;
        }
    }
    
    public static SortedSet<Interval> merge(SortedSet<Interval> a, SortedSet<Interval> b)
    {
        SortedSet<Interval> x = merge(a);
        SortedSet<Interval> y = merge(b);
        x.addAll(y);
        return merge(x);
    }
    
    public static SortedSet<Interval> merge(SortedSet<Interval> set)
    {
        ArrayList<Interval> list = new ArrayList<Interval>(set);
        SortedSet<Interval> result = new TreeSet<Interval>();
        
f:      for (int i = 0, n = list.size(); i < n; i++ )
        {
            Interval a = list.get(i);
            
            Interval m = null;
            
            for (int j = i + 1; j < n; j++ )
            {
                Interval b = list.get(j);
                
                m = Interval.merge(a, b);
                
                if (m == null)
                {
                    i = j - 1;
                    result.add(a);
                    continue f;
                }
                else
                {
                    a = m;
                }
            }
            
            result.add(m == null ? a : m);
            
            break;
        }
        
        return result;
    }
    
    @Override
    public String toString()
    {
        return String.format("[%d-%d]", start, end);
    }
    
    @Override
    public int compareTo(Interval i)
    {
        return i == null ? 1 : (start == i.start ? end - i.end : start - i.start);
    }
    
    @Override
    public int hashCode()
    {
        return start << 8 + end;
    }
    
    @Override
    public boolean equals(Object o)
    {
        if (o == null)
            return false;
        if ( ! (o instanceof Interval))
            return false;
        Interval i = (Interval) o;
        return start == i.start && end == i.end;
    }
}

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.SortedSet;
import java.util.TreeSet;

public class NumberSearch
{
    public static String read(String fileName) throws IOException
    {
        return new String(Files.readAllBytes(new File(fileName).toPath()));
    }
    
    public static void write(String fileName, String text) throws IOException
    {
        Files.write(new File(fileName).toPath(), text.getBytes());
    }
    
    public static SortedSet<Interval> searchRepetition(String s)
    {
        SortedSet<Interval> result = new TreeSet<Interval>();
        
        for (int i = 0; i < s.length() - 1; i++ )
        {
            if (s.charAt(i) == s.charAt(i + 1))
            {
                int end = exploreRepetition(s, i);
                
                result.add(new Interval(i, end));
                
                i = end;
            }
        }
        
        return result;
    }
    
    private static int exploreRepetition(String s, int start)
    {
        char c = s.charAt(start);
        
        int current = start + 2;
        
        while (current < s.length() && s.charAt(current) == c)
            current++ ;
        
        return current - 1;
    }
    
    public static SortedSet<Interval> searchSymetric(String s)
    {
        SortedSet<Interval> result = new TreeSet<Interval>();
        
        for (int i = 1; i < s.length() - 1; i++ )
        {
            if (s.charAt(i - 1) == s.charAt(i + 1))
            {
                int n = exploreSymetric(s, i);
                result.add(new Interval(i - n, i + n));
            }
        }
        
        return result;
    }
    
    private static int exploreSymetric(String s, int center)
    {
        int n = 2;
        
        while (center - n >= 0 && center + n < s.length() && s.charAt(center - n) == s.charAt(center + n))
            n++ ;
        
        return n - 1;
    }
    
    public static String degroup(String str, SortedSet<Interval> groups, String html)
    {
        boolean htmlMode = html == null || html.isEmpty();
        String beforeGroup = htmlMode ? " " : " <" + html + ">";
        String afterGroup = htmlMode ? " " : "</" + html + "> ";
        
        StringBuilder sb = new StringBuilder();
        
        Interval last = new Interval(0, 0);
        for (Interval group : groups)
        {
            try
            {
                sb = sb.append(str.substring(last.end, group.start))
                       .append(beforeGroup)
                       .append(str.substring(group.start, group.end + 1))
                       .append(afterGroup);
                last = group;
            }
            catch (Exception e)
            {
                System.out.println(e);
            }
        }
        
        return sb.append(str.substring(last.end)).toString();
    }
    
    public static String search(String number, boolean display, String html)
    {
        SortedSet<Interval> setRepetition = searchRepetition(number);
        if (display)
            System.out.println(setRepetition);
        
        SortedSet<Interval> setSymetric = searchSymetric(number);
        if (display)
            System.out.println(setSymetric);
        
        SortedSet<Interval> setResult = Interval.merge(setRepetition, setSymetric);
        if (display)
            System.out.println(setResult);
        
        return degroup(number, setResult, html);
    }
    
    public static void searchOnFile(String fileNameNumber, String fileNameResult, String html) throws IOException
    {
        String number = read(fileNameNumber);
        String result = search(number, false, html);
        write(fileNameResult, result);
    }
    
    public static void main(String[] args) throws IOException
    {
        String PI = "3." 
            + "14159265358979323846264338327950288419716939937510" // 50
            + "58209749445923078164062862089986280348253421170679" // 100
            + "82148086513282306647093844609550582231725359408128" // 150
            + "48111745028410270193852110555964462294895493038196" // 200
            + "44288109756659334461284756482337867831652712019091" // 250
            + "45648566923460348610454326648213393607260249141273" // 300
            + "72458700660631558817488152092096282925409171536436" // 350
            + "78925903600113305305488204665213841469519415116094" // 400
            + "33057270365759591953092186117381932611793105118548" // 450
            + "07446237996274956735188575272489122793818301194912";// 500
        
        System.out.println(search(PI, true, null));
        
        searchOnFile("C:/phi.txt", "C:/phi.html", "b");
    }
}