int main(void){
int n,k;
while(scanf("%d%d",&n,&k)!=EOF&&n>0&&k>0){
char *result=getPermutation(n,k);
puts(result);
}
return 0;
}
vector<vector<int>> permuteUnique(vector<int>& nums)
{
vector< vector<int> > permutations;
if (nums.empty())
{
return permutations;
}
sort(nums.begin(), nums.end());
getPermutation(nums, 0, permutations);
return permutations;
}
int main(int arg, char *argv[]) {
// insert code here...
printf("LeetCode 060 Permutation Sequence, C ...\n\n");
int n = 3;
int k = 6;
char *s = getPermutation(n, k);
printf("%s\n", s);
return 0;
}
int main() {
{
int n = 4;
int factor = 1;
for (int i = 2; i <= n; ++i) factor *= i;
for (int i = 0; i < factor; ++i) {
char* res = getPermutation(n, i);
printf("%s\n", res);
free(res);
}
puts("");
}
{
char* res = getPermutation(8, 8590);
printf("%s\n", res);
free(res);
puts("");
}
system("PAUSE");
return 0;
}
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> res;
int n = nums.size();
if (n == 0) {
return res;
}
vector<int> perm;
getPermutation(nums, 0, n, perm, res);
return res;
}
void getPermutation(vector<int>& nums, int start, int end,
vector<int>& perm, vector<vector<int>>& res) {
if (perm.size() == end) {
res.push_back(perm);
}
for (int i = start; i < end; i++) {
swap(nums[start], nums[i]);
perm.push_back(nums[start]);
getPermutation(nums, start + 1, end, perm, res);
perm.pop_back();
swap(nums[start], nums[i]);
}
}
int main() {
int N, orders[120][5], i, j, p, q, tmp, tmpi, rank[120], curMin, curMinIdx, in[100][5];
char str[120][5];
getPermutation(str);
generateOrders(orders, str);
char buf[10];
while(scanf("%d", &N) && N) {
for(i=0; i<N; i++) {
scanf("%s", buf);
tmp = 0;
for(p=0; p<5; p++)
in[i][buf[p]-'A'] = p;
}
memset(rank, 0, sizeof(rank));
for(i=0; i<120; i++) {
for(j=0; j<N; j++) {
tmp = 0;
for(p=0; p<4; p++) {
for(q=p+1; q<5; q++) {
tmpi = (orders[i][p]-orders[i][q])*(in[j][p]-in[j][q]);
if(tmpi<0)
tmp++;
}
}
rank[i] += tmp;
}
}
curMin = rank[0];
curMinIdx = 0;
for(i=1; i<120; i++) {
if(curMin > rank[i]) {
curMin = rank[i];
curMinIdx = i;
}
}
for(i=0; i<5; i++)
printf("%c", str[curMinIdx][i]);
printf(" is the median ranking with value %d.\n", curMin);
}
return 0;
}
Ogre::Technique* GBufferSchemeHandler::handleSchemeNotFound(unsigned short schemeIndex,
const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex,
const Ogre::Renderable* rend)
{
Ogre::MaterialManager& matMgr = Ogre::MaterialManager::getSingleton();
Ogre::String curSchemeName = matMgr.getActiveScheme();
matMgr.setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
Ogre::Technique* originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend);
matMgr.setActiveScheme(curSchemeName);
Ogre::Technique* gBufferTech = originalMaterial->createTechnique();
gBufferTech->removeAllPasses();
gBufferTech->setSchemeName(schemeName);
Ogre::Technique* noGBufferTech = originalMaterial->createTechnique();
noGBufferTech->removeAllPasses();
noGBufferTech->setSchemeName("NoGBuffer");
for (unsigned short i=0; i<originalTechnique->getNumPasses(); i++)
{
Ogre::Pass* originalPass = originalTechnique->getPass(i);
PassProperties props = inspectPass(originalPass, lodIndex, rend);
if (!props.isDeferred)
{
//Just copy the technique so it gets rendered regularly
Ogre::Pass* clonePass = noGBufferTech->createPass();
*clonePass = *originalPass;
continue;
}
Ogre::Pass* newPass = gBufferTech->createPass();
MaterialGenerator::Perm perm = getPermutation(props);
const Ogre::MaterialPtr& templateMat = mMaterialGenerator.getMaterial(perm);
//We assume that the GBuffer technique contains only one pass. But its true.
*newPass = *(templateMat->getTechnique(0)->getPass(0));
fillPass(newPass, originalPass, props);
}
return gBufferTech;
}
int main(int argc, char** argv) {
struct timeval tvStart, tvEnd;
char* ret;
int n = atoi(argv[1]);
int k = atoi(argv[2]);
gettimeofday(&tvStart, NULL);
ret = getPermutation(n, k);
gettimeofday(&tvEnd, NULL);
printf("getPermutation(%d, %d): '%s'\n", n, k, ret);
int ds = tvEnd.tv_sec - tvStart.tv_sec;
int dus = tvEnd.tv_usec - tvStart.tv_usec;
if (dus < 0) {
ds--;
dus += 1000000;
}
printf("Time %d.%06d, getPermutation\n", ds, dus);
return 0;
}
void getPermutation(vector<int> &_nums, int _begin, vector< vector<int> > &_permutations)
{
const int numsSize = _nums.size();
if (_begin == numsSize - 1)
{
_permutations.push_back(_nums);
return;
}
for (int curInd = _begin; curInd < numsSize; curInd++)
{
if (!isSwap(_nums, _begin, curInd))
{
continue;
}
swap(_nums[_begin], _nums[curInd]);
getPermutation(_nums, _begin + 1, _permutations);
swap(_nums[_begin], _nums[curInd]);
}
}
Scheme GtGenerator::generate(const TruthTable& table)
{
n = 0;
float time = 0;
{
AutoTimer timer(&time);
checkPermutationValidity(table);
tie(n, permutation) = getPermutation(table);
}
debugLog("GtGenerator::generate()-dump-permutation-creation-time", [=](ostream& out)->void
{
out << "Permutation creation time: ";
out << setiosflags(ios::fixed) << setprecision(2) << time / 1000;
out << " sec" << endl;
});
debugLog("GtGenerator::generate()-dump-permutation", [&](ostream& out)->void
{
out << "Permutation (non-fixed points number is " << permutation.getElementCount() << ")\n";
out << permutation << endl;
});
Scheme scheme;
if (permutation.length())
{
Scheme::iterator targetIter = scheme.end();
shared_ptr<PartialGtGenerator> partialGenerator(new PartialGtGenerator());
partialGenerator->setPermutation(permutation, n);
partialGenerator->prepareForGeneration();
while (partialGenerator)
partialGenerator = reducePermutation(partialGenerator, n, &scheme, &targetIter);
}
return scheme;
}
