If I have a list as:  x = [1,2,3,4,5,6,7,8,9,10]   Is there a function or package that lets you specify the length of the combinations you're interested in without losing the remaining elements of the list?   For example, if I was interested in all combinations of length 4, could I return something like:  [[1,2,3,4],[5,6,7,8],[9,10]] [[1,2,3,4],[5,6,7,8],[9],[10]]   I have been using itertools.combination to get the first list, which is great, but I'm looking for a way to keep the remaining list information into account.  NOTE: I'm not looking for anyone to write code for me to solve it if that's what's required. I'm just asking in case someone knows of a similar function that might help.
740
I have a list of arbitrary length, and I need to split it up into equal size chunks and operate on it. There are some obvious ways to do this, like keeping a counter and two lists, and when the second list fills up, add it to the first list and empty the second list for the next round of data, but this is potentially extremely expensive.  I was wondering if anyone had a good solution to this for lists of any length, e.g. using generators.  I was looking for something useful in itertools but I couldn't find anything obviously useful. Might've missed it, though.  Related question:
34678
I've a List of this type List> that contains this  List&lt;int&gt; A = new List&lt;int&gt; {1, 2, 3, 4, 5}; List&lt;int&gt; B = new List&lt;int&gt; {0, 1}; List&lt;int&gt; C = new List&lt;int&gt; {6}; List&lt;int&gt; X = new List&lt;int&gt; {....,....};   I want to have all combinations like this  1-0-6 1-1-6 2-0-6 2-1-6 3-0-6   and so on.  According to you is This possibile to resolve using Linq?
78279
I'm sure there's a simpler way of doing this that's just not occurring to me.  I'm calling a bunch of methods that return a list.  The list may be empty.  If the list is non-empty, I want to return the first item; otherwise, I want to return None.  This code works:  my_list = get_list() if len(my_list) &gt; 0: return my_list[0] return None   It seems to me that there should be a simple one-line idiom for doing this, but for the life of me I can't think of it.  Is there?  Edit:  The reason that I'm looking for a one-line expression here is not that I like incredibly terse code, but because I'm having to write a lot of code like this:  x = get_first_list() if x:     # do something with x[0]     # inevitably forget the [0] part, and have a bug to fix y = get_second_list() if y:     # do something with y[0]     # inevitably forget the [0] part AGAIN, and have another bug to fix   What I'd like to be doing can certainly be accomplished with a function (and probably will be):  def first_item(list_or_none):     if list_or_none: return list_or_none[0]  x = first_item(get_first_list()) if x:     # do something with x y = first_item(get_second_list()) if y:     # do something with y   I posted the question because I'm frequently surprised by what simple expressions in Python can do, and I thought that writing a function was a silly thing to do if there was a simple expression could do the trick.  But seeing these answers, it seems like a function is the simple solution.
61415
This question has an inverse:     What would be the most efficient way to translate a combination of $k$-tuple into its positions within the $\left(\!\!\binom{n}{k}\!\!\right)$ combinations? I need this to be fast for combinations of $\left(\!\!\binom{70}{7}\!\!\right)$ order of magnitude - very large, but not exceeding 2 billion (fits into int32 maximum value).  Below is an example of $\left(\!\!\binom{6}{3}\!\!\right)$, where the aim is to quickly translate (a, d, f) tuple to value 9, while in the real problem $k$ ranges between 5 and 8.  $$\begin{array} {cccccc|c} a&amp;b&amp;c&amp;d&amp;e&amp;f&amp;^{combination}/_{sort\_order}&amp; \\\hline x&amp;x&amp;x&amp; &amp; &amp; &amp;1\\ x&amp;x&amp; &amp;x&amp; &amp; &amp;2\\ x&amp;x&amp; &amp; &amp;x&amp; &amp;3\\ x&amp;x&amp; &amp; &amp; &amp;x&amp;4\\ x&amp; &amp;x&amp;x&amp; &amp; &amp;5\\ x&amp; &amp;x&amp; &amp;x&amp; &amp;6\\ x&amp; &amp;x&amp; &amp; &amp;x&amp;7\\ x&amp; &amp; &amp;x&amp;x&amp; &amp;8\\ x&amp; &amp; &amp;x&amp; &amp;x&amp;9\\ x&amp; &amp; &amp; &amp;x&amp;x&amp;10\\ .&amp;.&amp;.&amp;.&amp;.&amp;.&amp;.\\  &amp; &amp; &amp;x&amp;x&amp;x&amp;20\\ \end{array}$$  I know that I could pre-calculate all the combinations and reverse the lookup dictionary. However, such dictionary would not be efficient in terms of memory usage. Therefore I am looking for either calculation-based approach, or a more efficient data structure to perform this mapping.
40270
I need to calculate no of possible substrings containing "00" as a substring. I know the length of the binary string.  Eg: for a string of length 4, possible substrings are: 0000 0001 0010 0011 0100 1000 1001 1100  I just need the number of possible combinations, not enumerate all of them.
112190
This question is a part of a TopCoder problem. I am learning algorithms, and just got stuck at this (not homework).  Suppose we have a set $A$ of integer elements, such that $n(A) = a$ (number of elements in $A$ is $a$). Now we have some $n$ blanks, each of which can be filled using the $a$ elements in A, repetition allowed. I want to find out the total number of such sequences of length $n$ which are in non decreasing order, and can be formed using the elements in $A$.  My thoughts reduce this problem to a dynamic programming approach, but I just wanted to find out if a straightforward formula is possible or not. Thanks.
6976
What's the simplest, most standard, and/or most efficient way to split a List into two sub-Lists in Java? It's OK to mutate the original List, so no copying should be necessary. The method signature could be  /** Split a list into two sublists. The original list will be modified to  * have size i and will contain exactly the same elements at indices 0   * through i-1 as it had originally; the returned list will have size   * len-i (where len is the size of the original list before the call)   * and will have the same elements at indices 0 through len-(i+1) as   * the original list had at indices i through len-1.  */ &lt;T&gt; List&lt;T&gt; split(List&lt;T&gt; list, int i);   [EDIT] List.subList returns a view on the original list, which becomes invalid if the original is modified. So split can't use subList unless it also dispenses with the original reference (or, as in Marc Novakowski's answer, uses subList but immediately copies the result).
82341
example:  a_list = [1, 2, 3] a_list.len() # doesn't work len(a_list) # works   Python being (very) object oriented, I don't understand why the 'len' function isn't inherited by the object.  Plus I keep trying the wrong solution since it appears as the logical one to me
69080
$${2\choose 2} {10\choose 3}+{3 \choose 2}{9 \choose 3}+{4 \choose 2}{8 \choose 3}+{5 \choose 2}{7 \choose 3}+{6 \choose 2}{6 \choose 3}+{7 \choose 2}{5 \choose 3}+{8 \choose 2}{4 \choose 3}+{9 \choose 2}{3 \choose 3}={13 \choose 6}$$   I am supposed to get the answer ${13\choose 6}$. I wonder if there is any formula for combination addition like this or are there some tricks to do this?
113672
For example:  &gt;&gt;&gt; x = [1, 1, 2, 'a', 'a', 3] &gt;&gt;&gt; unique(x) [1, 2, 'a', 3]   Assume list elements are hashable.  Clarification: The result should keep the first duplicate in the list. For example, [1, 2, 3, 2, 3, 1] becomes [1, 2, 3].
27093
I occasionally see the list slice syntax used in Python code like this:  newList = oldList[:]   Surely this is just the same as:  newList = oldList   Or am I missing something?
63961
Recently I wrote a function to generate certain sequences with nontrivial constraints. The problem came with a natural recursive solution. Now it happens that, even for relatively small input, the sequences are several thousands, thus I would prefer to use my algorithm as a generator instead of using it to fill a list with all the sequences.  Here is an example. Suppose we want to compute all the permutations of a string with a recursive function. The following naive algorithm takes an extra argument 'storage' and appends a permutation to it whenever it finds one:  def getPermutations(string, storage, prefix=""):    if len(string) == 1:       storage.append(prefix + string)   # &lt;-----    else:       for i in range(len(string)):          getPermutations(string[:i]+string[i+1:], storage, prefix+string[i])  storage = [] getPermutations("abcd", storage) for permutation in storage: print permutation   (Please don't care about inefficiency, this is only an example.)  Now I want to turn my function into a generator, i.e. to yield a permutation instead of appending it to the storage list:  def getPermutations(string, prefix=""):    if len(string) == 1:       yield prefix + string             # &lt;-----    else:       for i in range(len(string)):          getPermutations(string[:i]+string[i+1:], prefix+string[i])  for permutation in getPermutations("abcd"):    print permutation   This code does not work (the function behaves like an empty generator).  Am I missing something? Is there a way to turn the above recursive algorithm into a generator without replacing it with an iterative one?
4130
Python's  function returns the sum of numbers in an iterable.  sum([3,4,5]) == 3 + 4 + 5 == 12   I'm looking for the function that returns the product instead.  somelib.somefunc([3,4,5]) == 3 * 4 * 5 == 60   I'm pretty sure such a function exists, but I can't find it.
10593
What's the easiest way to use a linked list in python? In scheme, a linked list is defined simply by '(1 2 3 4 5). Python's lists, [1, 2, 3, 4, 5], and tuples, (1, 2, 3, 4, 5), are not, in fact, linked lists, and linked lists have some nice properties such as constant-time concatenation, and being able to reference separate parts of them. Make them immutable and they are really easy to work with!
47902
How do I calculate the number of options for $k$ different balls in $n$ cells, with at least $1$ ball in each cell?   Lets say $6$ different balls in $3$ different cells, with at least $1$ ball in each cell.   like this:  $$x_1+x_2+x_3 = 6$$  I would like to see an explanation please and not just the answer.  Thanks!
39998
Python provides a nice method for getting length of an eager iterable, len(x) that is. But I couldn't find anything similar for lazy iterables represented by generator comprehensions and functions. Of course, it is not hard to write something like:  def iterlen(x):   n = 0   try:     while True:       next(x)       n += 1   except StopIteration: pass   return n   But I can't get rid of a feeling that I'm reimplementing a bicycle.  (While I was typing the function, a thought struck my mind: maybe there really is no such function, because it "destroys" its argument. Not an issue for my case, though).  P.S.: concerning the first answers - yes, something like len(list(x)) would work too, but that drastically increases the usage of memory.  P.P.S.: re-checked... Disregard the P.S., seems I made a mistake while trying that, it works fine. Sorry for the trouble.
57035
If I want to find how many possible ways there are to choose k out of n elements I know you can use the simple formula below:  $$ \binom{n}{k} = \frac{n! }{ k!(n-k)! } .$$  What if I want to go the other way around though?  That is, I know I want to have $X$ possible combinations, and I want to find all the various pairs of $n$ and $k$ that will give me that number of combinations.  For example, if the number of combinations I want is $3$, I want a formula/method to find that all the pairs that will result in that number of combinations are $(3,1)$ and $(3,2)$  I know I could test all the possible pairs, but this would be impractical for large numbers.  But perhaps there's no easier way of doing this then the brute force approach?