0

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] &]
juan muñoz
  • 309
  • 1
  • 8
  • 2
    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... – ciao Mar 26 '15 at 03:12
  • There are about 40,000,000 such permutations. What are you planning to do with them if you were able to compute them all? – m_goldberg Mar 26 '15 at 03:19
  • I need only permutations to work with them a "txt" with someone who has more than 3GB would be great – juan muñoz Mar 26 '15 at 04:35
  • @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... – ciao Mar 26 '15 at 04:55
  • Probable duplicate: (1283) – Mr.Wizard Mar 26 '15 at 07:13
  • Well it takes 3.5 GB RAM on my computer, which has 4 GB RAM. I suggest you buy some more RAM. – djp Mar 26 '15 at 09:02
  • Reviewing the answers you have given me, running one now, thanks for now – juan muñoz Mar 26 '15 at 16:35
  • It's actually not a duplicate because the Perumatations@Range@12 fails with an error message. This is unrelated. – djp Mar 26 '15 at 19:07
  • https://mathematica.stackexchange.com/a/208926/2090 – chyanog Nov 02 '19 at 13:34

2 Answers2

3

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).

ciao
  • 25,774
  • 2
  • 58
  • 139
  • processed at this time – juan muñoz Mar 26 '15 at 16:37
  • You can modify the code to go save files sequentially, ie per1.txt per2.txt .......... pern.txt , I got a "txt" of 2.5GB – juan muñoz Mar 27 '15 at 01:41
  • 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 – juan muñoz Mar 29 '15 at 05:58
  • @juanmuñoz: I'll take a look - didn't miss any when tested... – ciao Mar 29 '15 at 05:59
  • @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). – ciao Mar 29 '15 at 06:13
  • Rasher thanks for all your help, edit the question up a bit so you know because I need all these permutations. Although I tried not get my code sequentially read files and pass them to the variable "per" for calculation. My English is not my forte, sorry – juan muñoz Mar 29 '15 at 16:50
0

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}];
djp
  • 1,493
  • 14
  • 18