Participez au défi sur les palindromes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package defi6; 
  
public class Defi6 { 
  
	private boolean isPalindrome(char[] a, int i, int j) { 
		int l = j - i; 
		for (int x = i; x <= i + l / 2; x++) { 
			if (a[x] != a[j - (x - i)]) { 
				return false; 
			} 
		} 
		return true; 
	} 
  
	private String extractPalyndrome(String s) { 
		char[] a = s.toCharArray(); 
		String candidate = null; 
		for (int i = 0; i < a.length; i++) { 
			for (int j = i; j < a.length; j++) { 
				if (a[j] == a[i] && isPalindrome(a, i, j)) { 
					String pal = s.substring(i, j + 1); 
					if (candidate == null 
							|| pal.length() > candidate.length()) { 
						candidate = pal; 
					} 
				} 
			} 
		} 
		return candidate; 
	} 
  
	public static void main(String[] args) { 
		System.out.println(new Defi6().extractPalyndrome("abbbccacc")); 
	} 
  
}

1
2
3
sub palindrome {
  return [sort { length $b <=> length $a } $_[0] =~ /((.+).?(??{ reverse "$2" }))/gx]->[0];
}

1
2
$ perl -e '$aa = "tooiuertreuioot toot azertyuioppoiuytreza";sub palindrome { return [sort { length $b <=> length $a } $aa =~ /((.+
).?(??{ reverse "$2" }))/gx]->[0] } print palindrome($aa)'

1
2
3
isPalindrome s = s == reverse s 
allSubstrings = concatMap (init . tails) . inits 
longest = maximumBy (comparing length) . filter isPalindrome . allSubstrings

longest = maximumBy (comparing length) . filter isPalindrome . allSubstrings

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
module Main () where 
import Data.List 
import Data.Ord 
import Data.ByteString.Char8 hiding (map) 
import qualified Data.ByteString.Char8 as B 
  
data Pal = P !Int !Int deriving (Show) 
  
expand :: ByteString -> Pal -> ByteString 
expand bs (P start end) = fst . B.splitAt (end - start) . snd . B.splitAt start $ bs 
  
grow :: ByteString -> Pal -> Pal 
grow bs p@(P start end) 
    | start == 0  
      || end == B.length bs 
      || bs `index` (start-1) /= bs `index` end = p  
    | otherwise                                 = grow bs (P (start - 1) (end + 1)) 
  
seeds :: ByteString -> [Pal] 
seeds bs | B.null bs = [] 
         | otherwise = go (B.head bs) 0 1 
    where 
      go c start end  
          | end == B.length bs = [P start end] 
          | c == nextChar      = go c start (end + 1) 
          | otherwise          = P start end : go nextChar end (end + 1) 
          where nextChar = bs `index` end 
  
longest :: ByteString -> ByteString 
longest bs = expand bs . maximumBy (comparing lengthPal) . map (grow bs) . seeds $ bs 
    where lengthPal (P s e) = e - s 
  
main :: IO () 
main = print . longest =<< B.getContents