C :

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

#define MAXLEN 100000
char str[MAXLEN + 1];
char tmp[MAXLEN + 1];

size_t get_revole_max (const char str[], size_t len);
        bool isok (const char str[], size_t len, const char used[], size_t len_used);
bool better (const char str[], size_t len, size_t times, size_t best);
        int get_value (const char str[], size_t len, size_t times, size_t pos);

int main (void)
{
        size_t t;
        scanf ("%zd", &t);
        for ( ; t > 0; --t)
        {
                size_t len;
                scanf ("%zd ", &len);
                gets (str);
                size_t revole_max = get_revole_max (str, len);
                size_t best = 0;
                for (size_t i = 1; i <= revole_max; ++i)
                {
                        if (better (str, len, i, best))
                        {
                                best = i;
                        }
                }
                printf ("%zd\n", best);
        }
        return 0;
}
size_t get_revole_max (const char str[], size_t len)
{
        memset (tmp, 0, MAXLEN + 1);
        for (size_t i = 0; str[i] != '\0'; ++i)
        {
                tmp[i] = str[i];
                if (isok (str, len, tmp, i + 1))
                {
                        return i;
                }
        }
}
bool isok (const char str[], size_t len, const char used[], size_t len_used)
{
        if (len % len_used != 0 || len < len_used)
        {
                return false;
        }
        else
        {
                for (size_t pos = 0; pos < len; pos = pos + len_used)
                {
                        //printf ("%s --- %s\n", str, used);
                        if (strncmp (str + pos, used, len_used) != 0)
                        {
                                return false;
                        }
                }
                return true;
        }
}
bool better (const char str[], size_t len, size_t times, size_t best)
{
        for (size_t i = 0; i < len; ++i)
        {
                int v1 = get_value (str, len, times, i);
                int v2 = get_value (str, len, best, i);
//              printf ("%c - %c\n", v1, v2);
                if (v1 > v2)
                {
                        return false;
                }
                if (v1 < v2)
                {
                        return true;
                }
        }
        return false;
}
int get_value (const char str[], size_t len, size_t times, size_t pos)
{
        return str[(pos + times) % len];
}

C++ :

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define MAXN 200010

char str[MAXN];

int min_string(int l)
{
	int i=0,j=1,k;
	memcpy(str+l,str,l);
	while(j<l)
	{
		k=0;
		while(k<l&&str[j+k]==str[i+k])k++;
		if(k==l)
			break;
		if(str[j+k]<str[i+k])
			i=max(j+1,i+k+1);
		else
			j=j+k+1;
		if(i>j)
			swap(i,j);
	}
	return i;
}

int main()
{
	int t,l;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%s",&l,str);
		printf("%d\n",min_string(l));
	}
	return 0;
}

Pascal :

program p1056;
var a:array[1..100000] of char;
    minc,c:char;
    t,i,j,k,n,ii,jj,kk:longint;
begin
  readln(t);
  for k:=1 to t do
  begin
    read(n); read(c);
    minc:=chr(255);
    for i:=1 to n do
     begin
      read(a[i]);
      if a[i]<minc then
       begin
         minc:=a[i];
         j:=i;
       end;
     end;
    readln;
    for i:=j+1 to n do
     if a[i]=a[j] then
      begin
        ii:=i;
        jj:=j;
        kk:=0;
        while (a[ii]=a[jj]) and (kk<n) do
        begin
          ii:=ii+1;
          jj:=jj+1;
          if ii>n then ii:=1;
          if jj>n then jj:=1;
          kk:=kk+1;
        end;
        if kk<n then
          if a[ii]<a[jj] then j:=i
          else continue;
      end;
    writeln(j-1);
   end;
end.