HackerRank Two Characters Solution

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int main(){
    int len; 
    scanf("%d",&len);
    char* s = (char *)malloc(512000 * sizeof(char));
    scanf("%s",s);
    if(len==1)
    {
        printf("0");
        return 0;
    }
    int maxlen=0;
    for(int i='a'; i<='z'; i++)
        for(char j='a'; j<='z'; j++)
    {
        if(i==j)
            continue;
        char target = i;
        char ntarget = j;
        int slen=0;
        for(int k=0; k<len; k++)
        {
            if(s[k]==target)
            {
                slen ++;
                
                target = (target==i)?j:i;
                ntarget = (target==i)?j:i;
                continue;
            }
            if(s[k] == ntarget)
            {
                slen = 0;
                break;
            }
        }
        maxlen = (maxlen>slen)?maxlen:slen;
    }
    
    printf("%d", maxlen);
        
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
int valid(string x) {
    const int n = x.size();
    for (int i = 1; i < n; ++i)
        if (x[i] == x[i-1])
            return false;
    return true;
}
int main() {
    int asd;
    cin>>asd;
    string s;
    cin>>s;
    int ans = 0;
    for (char a = 'a'; a <= 'z'; ++a)
    for (char b = 'a'; b <= 'z'; ++b)
    if (a != b)
    {
        if (s.find(a) == string::npos) continue;
        if (s.find(b) == string::npos) continue;
        string x;
        for (const char ch : s)
            if (ch == a || ch == b)
                x.push_back(ch);
        if (valid(x))
            ans = max(ans, (int)x.size());
    }
    printf("%d\n", ans);
}

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) {
       Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        String s=in.next();
        String res="";
        for(int i=0;i<26;i++){
            for(int j=i+1;j<26;j++){
                char a=(char)('a'+i);
                char b=(char)('a'+j);
                String cur="";
                for(int k=0;k<n;k++){
                    if (s.charAt(k)==a || s.charAt(k)==b) {
                        cur+=s.charAt(k);
                    }
                }
                if (cur.length()<res.length()) continue;
                if (isGood(cur)) res=cur;
            }
        }
        System.out.println(res.length());
    }
    public static boolean isGood(String s){
        if (s.length()==1) return false;
        for(int i=1;i<s.length();i++){
            if (s.charAt(i)==s.charAt(i-1)) return false;
        }
        return true;
    }
}

from collections import Counter
from itertools import combinations
def is_valid(S):
    c = Counter(S)
    #print c
    if len(c) != 2:
        return False
    for i in xrange(1, len(S)):
        if S[i] == S[i-1]:
            return False
    return True
def keep_letters(lista, keep):
    return filter(lambda x: x in keep, lista)
    
N = int(raw_input())
S = list(raw_input().strip())
letters = {x: 1 for x in S}
letters = list(combinations(letters.keys(), 2))
#print letters
L = list(S)
first = True
m = 0
for keep in letters:
    #print list(S)
    lista = keep_letters(list(S), keep)
    #print lista
    if is_valid(lista):
        m = max(m, len(lista))
    
    
print m
    

process.stdin.resume();
process.stdin.setEncoding('ascii');
var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;
process.stdin.on('data', function (data) {
    input_stdin += data;
});
process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});
function readLine() {
    return input_stdin_array[input_currentline++];
}
/////////////// ignore above this line ////////////////////
function isAlternating(a){
  var alternating = true;
  for (var i=0; i<a.length; i++){
    if ((i>0) && a[i] == a[i-1]){
      alternating = false;
      break;
    }
  }
  return alternating;
}
function main() {
    var len = parseInt(readLine());
    var s = readLine();
    var set = new Set();
    var arr = s.split('');
    var max = 0;
    for (let str of arr){
      set.add(str);
    }
    set = Array.from(set); 
    for (var i=0; i<set.length-1; i++){
      for (var j=i+1; j<set.length; j++){
        var setStay = new Set();
        setStay.add(set[i]);
        setStay.add(set[j]); 
        setStay = Array.from(setStay);
        var arraynew = arr.slice();
        for (let r of set){
          if (setStay.indexOf(r) > -1){
            continue;
          }
          arraynew = arraynew.filter(function(element){
            return element !== r;
          });
        }
        if (isAlternating(arraynew)){
          if (arraynew.length > max){
            max = arraynew.length;
          }
        }
      }
    }
    console.log(max);
}

object Solution {
    def check(s: String): Boolean = {
        (0 until s.length - 1).foreach{i =>
            if (s(i) == s(i + 1)) return false
        }
        true
    }
    
    def main(args: Array[String]) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution
*/
        val n = io.StdIn.readInt;
        val s = io.StdIn.readLine;
        
        val letters = s.distinct;
        val possible = letters.flatMap{c1 => 
            letters.map{c2 =>
                if (c1 != c2) {
                    val s1 = s.filter(c => (c == c1 || c == c2))
                    val isValid = check(s1)
                    if (isValid) s1
                    else ""
                }
                        else {
                            ""
                        }
            }
        }
        if (possible.filter(x => x != "").isEmpty) println(0)
        else {
            println(possible.maxBy(_.length).length)
        }
    }
}

uses math;
var
s:ansistring;
a:array['a'..'z']of longint;
x,y,l:char;
kt:boolean;
kq,i,j,n:longint;
begin
readln(n);
readln(s);
for i:=1 to n do
    inc(a[s[i]]);
for x:='a' to 'z' do
    for y:=x to 'z' do
        if ((x<>y) and (a[x]<>0) and (a[y]<>0)) then
            begin
            for i:=1 to n do
                if (s[i]=x)or(s[i]=y) then
                    begin
                    l:=s[i];
                    break;
                    end;
            kt:=true;
            for j:=i+1 to n do
                if (s[j]=x)or(s[j]=y) then
                    begin
                    if s[j]=l then 
                        begin
                        kt:=false;
                        break;
                        end;
                    l:=s[j];
                    end;
            if kt=true then kq:=max(kq,a[x]+a[y]);
            end;
write(kq);
end.