0
$\begingroup$

There is another way to calculate

Permutations [{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}]

without triggering an error, I have 3 GB of RAM with WIN 7

Edit:

This short code is the one that broke my head for a while, are 11 variables that must meet a very specific condition, their difference must be 1. either can take the 11 values, hence all permutations, this code is an adaptation of another code I saw here, which helps me to what I need.

juan[{a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_}] := 
 Abs[Differences /@ ({{a, b}, {a, c}, {b, c}, {b, f}, {b, e}, {c, 
   e}, {c, f}, {c, g}, {d, f}, {d, g}, {e, b}, {e, a}, {e, f}, {e,
    i}, {e, h}, {f, g}, {f, j}, {f, i}, {f, h}, {g, i}, {g, 
   j}, {h, i}, {h, k}, {i, j}, {i, k}, {j, k}})] // Flatten
*(*per = Permutations[Range@11]*) (this line is calculated as 799    consecutive files in HD thanks to the collaboration of  rasher)
(*per=Import["C:\\Users\\M\\Desktop\\per.txt"]*)(as I upload the files   sequentially and that its securities are passing the variable "per" and will be prosecuted.?)
Select[per, FreeQ[juan@#, 1] &]
$\endgroup$
9
  • 2
    $\begingroup$ Do you need them "all at once"? Combinatorica package will generate them with incremental capability. A description of why you need this and what you'll do with it will help responses... $\endgroup$
    – ciao
    Mar 26 '15 at 3:12
  • $\begingroup$ There are about 40,000,000 such permutations. What are you planning to do with them if you were able to compute them all? $\endgroup$
    – m_goldberg
    Mar 26 '15 at 3:19
  • $\begingroup$ I need only permutations to work with them a "txt" with someone who has more than 3GB would be great $\endgroup$ Mar 26 '15 at 4:35
  • $\begingroup$ @juanmuñoz: Well, that's going to be about 4500 pages in small print - I'm off to the office depot to get some print cartridges and paper... where shall I send it to? In all seriousness, answering the already asked questions of what you need to do will probably lead to more efficient means... $\endgroup$
    – ciao
    Mar 26 '15 at 4:55
  • $\begingroup$ Probable duplicate: (1283) $\endgroup$
    – Mr.Wizard
    Mar 26 '15 at 7:13
3
$\begingroup$

This will write the permutations to permutations.txt in list blocks of ~50,000 each.

Quiet@Block[{$ContextPath}, Needs["Combinatorica`"]]

len = 11
numchunk = 1000

chunks = Partition[Clip[FindDivisions[{0, len! - 1, 1}, numchunk],
                  {0, len! - 1}, {0,len! - 1}], 2, 1] // 
                  (# + Join[{{0, 0}}, ConstantArray[{1, 0}, Length@# - 1]]) &;

Monitor[(chunk = #; (Combinatorica`UnrankPermutation[#, 11] & /@ 
        Range @@ chunk) >> 
      "permutations-" <> ToString[First@#] <> "-" <> 
       ToString[Last@#] <> ".txt") & /@ chunks;, chunk]

Will take about an hour, I'd ventue...

If you must have equal sized files, you'll want to create your own chunks, since FindDivisions uses a heuristic that usually won't meet that criteria, e.g. in your case for 11 length:

p = Partition[Range[1, 102089*392, 102089] - 1, 2, 1];
p[[1]] = p[[1]] - {0, 1};
p[[2 ;;, 1]] = p[[2 ;;, 1]] + 1;
chunks = p;

Will create files all with same # of permutations (about 100k).

$\endgroup$
6
  • $\begingroup$ processed at this time $\endgroup$ Mar 26 '15 at 16:37
  • $\begingroup$ You can modify the code to go save files sequentially, ie per1.txt per2.txt .......... pern.txt , I got a "txt" of 2.5GB $\endgroup$ Mar 27 '15 at 1:41
  • $\begingroup$ I've noticed that the file is cut at the end, you know why this happens, not all permutations are recorded, if I could record each piece as a sequential files fixed size would be great $\endgroup$ Mar 29 '15 at 5:58
  • $\begingroup$ @juanmuñoz: I'll take a look - didn't miss any when tested... $\endgroup$
    – ciao
    Mar 29 '15 at 5:59
  • $\begingroup$ @juanmuñoz: No, there's no problem. Unless the number of permutations is exactly divisible by # of chunks, there will be a different # of perms. in last result - but this gets them all. I updated it so you can control length of perms. and number of chunks, you can take it from there. Each chunk will create a file "Permutations-x-y.txt" where x and y are start and end chunk values. Note it will overwrite any existing file with same name(s). $\endgroup$
    – ciao
    Mar 29 '15 at 6:13
0
$\begingroup$

This will generate it in ~300 MB chunks. Takes about 30 seconds. You can work out what to do with the chunks.

Do[
 chunk = Prepend[#, i] & /@
   Permutations[
    DeleteCases[Range@11, i]
   ];
 doSomethingWithChunk[chunk],
 {i, 11}];
$\endgroup$
4
  • $\begingroup$ doSomethingWithChunk , this instruction mark me error , any idea? $\endgroup$ Mar 26 '15 at 16:37
  • $\begingroup$ It's called pseudocode. You need to write your own function. E.g. sendChunkToMyFriend. $\endgroup$
    – djp
    Mar 26 '15 at 19:08
  • $\begingroup$ Can you help me build the function, I am new at this $\endgroup$ Mar 26 '15 at 19:52
  • $\begingroup$ No, as the original comments indicate you are almost certainly approaching this problem inefficiently. Mathematica is not the right tool for this job. $\endgroup$
    – djp
    Mar 27 '15 at 8:05

Not the answer you're looking for? Browse other questions tagged or ask your own question.