1.


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Angewandte Mathematik, SS11
* Problem: 941 - Permutations
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=27&page=show_problem&problem=2520
*
* @author Benedikt Zönnchen
* @author Erik Wenzel
* @version 1.0, 29/04/2011
*
* Method : Combinatorics, Memorizing
* Status : Accepted
* Runtime: 2.103
*
* Erklärung: #Permutationen für n Elemente = n!
* Allerdings kann man die Permutationen rekrusiv aufbauen.
* Formel: Alle Permutationen von n Elementen = Alle Permutationen von n-1 Elementen * n Elemente.
* Das ist ja gerade n! = (n-1)!n. Dies können wir ausnutzten. Bsp:
* Permutationen von a b c (permutation 0 = a b c ...)
*
* 0: a b c Wir sehen das das erste Element von a nach b nach c im 2er schritt wechselt also im 2! Schritt.
* 1: a c b Ist die Permutation nun zb die 3te so wissen wir dass alle 2! das erste Element wechselt. Damit
* 2: b a c wissen wir sofort ohne die anderen Permutationen (0-4) davor durch zu machen, das das erste
* 3: b c a Element unseres Ergebnisses b sein muss! bleibt c a! nun sortieren wir erneut a c. Wir wissen
* 4: c a b nun wieder das das erste Element alle 1! wechselt. Wir wissen auch, dass wir uns an der
* 5: c b a Permutationsstelle 2 befinden da hier die b's anfgangen. Damit ist klar das wir noch 3-2 = 1
* Schritte gehen müsssen! => wir tauschen a c und sind fertig = b c a!
*
* Das gleiche Prinzip funktioniert nun auch mit langen Wörtern und hohen Permutationen!
*/

public class Main
{

public static void main(String[] args) throws IOException
{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int cases = Integer.parseInt(reader.readLine());

// berechne 21! und speicher alle 0! bis 21! ab
long[] fak = getFakArray(21);
List<Character> cArray = new ArrayList<Character>();

while(cases>0)
{
String line = reader.readLine();
long n = Long.parseLong(reader.readLine());
cases--;
cArray = new ArrayList<Character>(line.length());

while(n>=fak[line.length()])
{
n = n-(int)fak[line.length()];
}

for(int i = 0; i<line.length(); i++)
{
cArray.add(line.charAt(i));
}

// starte die Permutation
permute(fak, cArray, n);
Collections.sort(cArray);
// wenn nicht alles durchvertauscht wurde ist die liste nicht leer
// gebe dann noch den rest aus
if(!cArray.isEmpty())
{
for (Character entry : cArray)
{
System.out.print(entry);
}
}
System.out.println();
}
}

/**
* The permutation Algo
* @param fak
* @param cArray
* @param tar
*/
public static void permute(long[] fak, List<Character> cArray, long tar)
{
// sortiere erneut und beginne von vorne
Collections.sort(cArray);

int length = cArray.size();
if(tar != 0)
{
long dif, i;
dif = 0;

// gehe in die richtige Permutationsgruppe (dort wo das erste Element bei allen gleich ist)
for(i = 0; i <= length && fak[length-1]*i <= tar; i++)
{
dif = fak[length-1]*i;
}

// vertausche das erste Element mit dem richtigen neuen Element
swap(cArray, 0, (int)(i-1));

// gebe das richtige Element aus und lösche es gleich
System.out.print(cArray.remove(0));

// beginne von vorne aber mit einem Element weniger
permute(fak, cArray, tar-dif);
}
}

/**
* Swaps two entries in a List<Entr>
* @param cArray
* @param i
* @param j
*/
public static void swap(List<Character> cArray, int i, int j)
{
char tmp = cArray.get(i);
cArray.set(i, cArray.get(j));
cArray.set(j, tmp);
}

/**
* calculate the all values from 0!>=n>=limt! and return them in an Array
* @param limit
* @return limit! Array
*/
public static long[] getFakArray(int limit)
{
long[] fak = new long[limit+1];
fak[0]=1;
for(int i = 1; i<=limit; i++)
{
fak[i] = i*fak[i-1];
}
return fak;
}
}






---------------------------------------------------

1.
/**
* FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS10
* Problem: 941 - Permutations
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=11&page=show_problem&problem=882
*
* @author Evgeni Pavlidis
* @version 1.0, 06/19/2010
*
* Method : BigInteger - Unranking of permuation
* Status : Accepted
* Runtime: 1.340
*/

import java.io.*;
import java.util.*;
import java.math.*;

class Main
{
public static void main(String...args) throws Exception
{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
StringBuffer output = new StringBuffer();

int pos ,s, testCases = Integer.parseInt(reader.readLine());

BigInteger n;
BigInteger[] f = new BigInteger[20];


// precalc factorials
f[1] = n = BigInteger.ONE;
for(int i = 2; i < 20; i++)
f[i] = f[i-1].multiply(BigInteger.valueOf(i));


String input;
List<Character> list = new ArrayList<Character>();

for(int tc = 0; tc < testCases; tc++)
{
input = reader.readLine();
n = new BigInteger(reader.readLine());

list.clear();
for(int i = 0; i < input.length(); i++)
list.add(input.charAt(i));

Collections.sort(list);


// unrank permuation
for(int i = list.size()-1; i > 0; i--)
{
pos = n.divide(f[i]).intValue();
n = n.mod(f[i]);

output.append(list.get(pos));
list.remove(pos);
}

output.append(list.get(0));
output.append("\n");

}

System.out.print(output);
}
}