[Question]
  [
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
 
 
---
 This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/41600/edit) 
This is a challenge of practicing golf optimization in Python -- reusable tricks and shortcuts to shave off a few characters. Many will be familiar to Python golfers and use common ideas from the [Python Tips](https://codegolf.stackexchange.com/q/54/20260). Some of these use Python-specific features that you might not know exist unless you've seen them, so do take a look at the tips if you're stuck.
**Goal:**
 There are ten problems, each a reference snippet of Python code for you to optimize and a description of the code does. Your goal is rewrite it to be shorter but still functionally-equivalent. 
Your score, which you're trying to minimize, is the total length of your code all the snippets. The length of the reference snippets is 150. Tiebreaker is earliest post.
**Posting answers:** For each problem, post your code and its character count. You can post the reference snippet if you didn't find something shorter. It's intended that you don't look at others' answers when you post yours. Please spoiler-tag each individual problem including the individual character counts. You can leave the total count revealed. Feel free now to unspoiler your solution or post new unspoilered solutions.
**Details on legality:** Functional equivalence means the code can be replaced in a program without affecting its behavior (ignoring things like memory usage and operator precedence as part of an expression). Expressions should produce values that are equivalent by `==`. Note that `1.0==1==True`. Your code should have no side-effects unless otherwise stated. I don't intend the problems to be version-specific, but just in case, you can specify a Python version for each problem.
**Problem 1:** Keep iterating as long as the list `L` has at least 7 elements
```
# 16 chars
while len(L)>=7:
```
**Problem 2**: Check whether two floats `x` and `y` are both positive.
```
# 11 chars
x>0 and y>0
```
**Problem 3**: If Boolean `b` is true, remove the first element of `L`. Otherwise, leave it unchanged.
```
# 12 chars
if b:L=L[1:]
```
**Problem 4**: Check if all elements of a non-empty list `L` of numbers are equal. For this problem, it's OK to modify the list.
```
# 22 chars
all(x==L[0]for x in L)
```
**Problem 5**: Append a number `n` to the end of a list `L` only if `L` already contains that number.
```
# 16 chars
if n in L:L+=[n] 
```
**Problem 6**: Express the sign of a float `x`: `+1` for positive, `0` for 0, `-1` for negative.
```
# 20 chars
abs(x)/x if x else 0
```
**Problem 7** Continue a loop as long as the first element of `L`, a list of Booleans, is `True`. Also stop if `L` is empty.
```
# 17 chars
while L and L[0]:
```
**Problem 8**: Continue a loop as long as `n` is greater than 1. The number `n` is guaranteed to be a positive integer.
```
# 10 chars
while n>1:
```
**Problem 9**: Check if an integer represented as a string `s` is negative (i.e, starts with '-').
```
# 9 chars
s[0]=='-'
```
**Problem 10**: Convert a Boolean `b` to `"Win"`/`"Lose"`, with `True`->`"Win"` and `False`->`"Lose"`.
```
# 17 chars
["Lose","Win"][b]
```
---
**Warning:** Spoilers below, don't scroll down if you want to solve these yourself.
If you just want to know the optimal score for a problem:
Problem 1: 
> 
> 12
> 
> 
> 
Problem 2: 
> 
> 5
> 
> 
> 
Problem 3: 
> 
> 7
> 
> 
> 
Problem 4: 
> 
> 13
> 
> 
> 
Problem 5: 
> 
> 13
> 
> 
> 
Problem 6: 
> 
> 8
> 
> 
> 
Problem 7: 
> 
> 12
> 
> 
> 
Problem 8: 
> 
> 9
> 
> 
> 
Problem 9: 
> 
> 5
> 
> 
> 
Problem 10: 
> 
> 15
> 
> 
> 
  
[Answer]
# Total: 104 101 99 chars
## Problem 1
> 
>  12 chars  
> 
> `while L[6:]:`
> 
> 
> 
## Problem 2
> 
>  5 chars  
> 
> `x>0<y`
> 
> 
> 
## Problem 3
> 
>  7 chars  
> 
> `L=L[b:]`
> 
> 
> 
## Problem 4
> 
>  13 chars  
> 
> `len(set(L))<2`  
> 
> `L[1:]==L[:-1]`
> 
> 
> 
## Problem 5
> 
>  13 chars  
> 
> `L+=set(L)&{n}`
> 
> 
> 
## Problem 6
> 
>  11 chars  
> 
> `(x>0)-(x<0)`  
> 
>   
> 
>  8 chars (Python 2)  
> 
> `cmp(x,0)`
> 
> 
> 
## Problem 7
> 
>  12 chars  
> 
> `while[.5]<L:`
> 
> 
> 
## Problem 8
> 
>  9 chars  
> 
> `while~-n:`
> 
> 
> 
## Problem 9
> 
>  5 chars  
> 
> `s<'.'`
> 
> 
> 
## Problem 10
> 
>  15 chars  
> 
> `'LWoisne'[b::2]`
> 
> 
> 
[Answer]
# Total size: ~~128~~ ~~122~~ ~~120~~ ~~117~~ ~~116~~ ~~115~~ ~~111~~ ~~107~~ 104
## Problem 1
Keep iterating as long as the list `L` has at least 7 elements.
> 
>  15 chars  
> 
> `while len(L)>6:`  
> 
>  (Yes, I could save 3 bytes on this, but I accidentally saw the solution Sp3000's answer, so I won't claim those three bytes.)
> 
> 
> 
## Problem 2
Check whether two floats `x` and `y` are both positive.
> 
>  5 chars  
> 
> `x>0<y`
> 
> 
> 
## Problem 3
If Boolean `b` is true, remove the first element of `L`. Otherwise, leave it unchanged.
> 
>  7 chars  
> 
> `L=L[b:]`
> 
> 
> 
## Problem 4
Check if all elements of a non-empty list `L` of numbers are equal. For this problem, it's OK to modify the list.
> 
>  13 chars  
> 
> `L[1:]==L[:-1]`
> 
> 
> 
## Problem 5
Append a number `n` to the end of a list `L` only if `L` already contains that number.
> 
>  15 chars  
> 
> `L+=[n]*(n in L)`  
> 
>  or  
> 
> `L+=[n][:n in L]`
> 
> 
> 
## Problem 6
Express the sign of a float `x`: `+1` for positive, `0` for 0, `-1` for negative.
> 
>  8 chars, **Python 2**  
> 
> `cmp(x,0)`  
> 
>  According to docs this might return any positive/negative value, but consensus is it always returns -1, 0, 1.
> 
> 
> 
## Problem 7
Continue a loop as long as the first element of `L`, a list of Booleans, is `True`. Also stop if `L` is empty.
> 
>  12 chars  
> 
> `while[1]<=L:`
> 
> 
> 
## Problem 8
Continue a loop as long as `n` is greater than 1. The number `n` is guaranteed to be a positive integer.
> 
>  9 chars  
> 
> `while~-n:`
> 
> 
> 
## Problem 9
Check if an integer represented as a string `s` is negative (i.e, starts with '-').
> 
>  5 chars  
> 
> `s<'.'`
> 
> 
> 
## Problem 10
Convert a Boolean `b` to `"Win"`/`"Lose"`, with `True`->`"Win"` and `False`->`"Lose"`.
> 
>  15 chars  
> 
> `"LWoisne"[b::2]`
> 
> 
> 
[Answer]
# Total: ~~106~~ ~~104~~ 102 chars
## Problem 1
> 
>  12 chars  
> 
> `while L[6:]:`
> 
> 
> 
## Problem 2
> 
>  5 chars  
> 
> `x>0<y`  
> 
>  Huzzah for comparison chaining
> 
> 
> 
## Problem 3
> 
>  7 chars  
> 
> `L=L[b:]`  
> 
>  Good old implicit conversion
> 
> 
> 
## Problem 4
> 
>  13  
> 
> `len(set(L))<2`  
>   
> 
>  Alternatively:  
> 
> `L[1:]==L[:-1]`  
>   
> 
>  Stupid way to get the negation of what we want in Python 2:  
> 
> `","in`set(L)``  
>   
> 
>  I'm not sure what the relevance of "it's OK to modify the list" is though, because the best I can think of is 14 chars (and is actually wrong):  
> 
> `L==[L.pop()]+L`
> 
> 
> 
## Problem 5
> 
>  13 chars  
> 
> `L+={n}&set(L)`  
> 
>  Doing funky things with sets
> 
> 
> 
## Problem 6
> 
>  11 chars  
> 
> `(x>0)-(x<0)`  
> 
> 
> 
> 
## Problem 7
> 
>  12 chars  
> 
> `while[1]<=L:`  
> 
>  Uses lexicographical order of lists
> 
> 
> 
## Problem 8
> 
>  9 chars  
> 
> `while~-n:`
> 
> 
> 
## Problem 9
> 
>  5 chars  
> 
> `s<"."`  
> 
>  Uses lexicographical ordering of strings
> 
> 
> 
## Problem 10
> 
>  15 chars  
> 
> `"LWoisne"[b::2]`  
>   
> 
>  Alternatively:  
> 
> `b*"Win"or"Lose"`
> 
> 
> 
[Answer]
## Total: 99 bytes
**Problem 1**
> 
>  *12 bytes*  
> 
> `while L[6:]:`
> 
> 
> 
**Problem 2**
> 
>  *5 bytes*  
> 
> `x>0<y`
> 
> 
> 
**Problem 3**
> 
>  *7 bytes*  
> 
> `L=L[b:]`
> 
> 
> 
**Problem 4**
> 
>  *13 bytes*  
> 
> `len(set(L))<2`  
> 
>   
> 
> *14 byte alternatives*  
> 
> `min(L)==max(L)`  
> 
> `set(L)=={L[0]}`
> 
> 
> 
**Problem 5**
> 
>  *13 bytes*  
> 
> `L+=set(L)&{n}`
> 
> 
> 
**Problem 6**
> 
>  *8 bytes*  
> 
> `cmp(x,0)`
> 
> 
> 
**Problem 7**
> 
>  *12 bytes*  
> 
> `while[1]<=L:`
> 
> 
> 
**Problem 8**
> 
>  *9 bytes*  
> 
> `while~-n:`
> 
> 
> 
**Problem 9**
> 
>  *5 bytes*  
> 
> `s<'.'`
> 
> 
> 
**Problem 10**
> 
>  *15 bytes*  
> 
> `b*"Win"or"Lose"`  
> 
>  - or -  
> 
> `"LWoisne"[b::2]`
> 
> 
> 
[Answer]
> 
>  1: 12   
> 
> `while L[6:]:`   
> 
>  2: 5   
> 
> `y>0<x`   
> 
>  3: 7   
> 
> `L=L[b:]`   
> 
>  4: 15   
> 
> `L==L[:1]*len(L)`   
> 
>  5: 15   
> 
> `L+=[n]*(n in L)` or `L+=[n][:n in L]`   
> 
>  6: 11   
> 
>  This is the only one for which an idiomatic expression did not immediately leap to my mind, but I think I found the right answer. Edit: Nope, it was horrible.   
> 
> `(x>0)-(x<0)`   
> 
>  7: 12   
> 
> `while[1]<=L:`   
> 
>  Or if the program is completed after that, `while L[0]` is nice.   
> 
>  8: 9   
> 
> `while~-n:`   
> 
>  9: 5   
> 
>  Many strings would work here but the "naive method" is funny.   
> 
> `s<'0'`   
> 
>  10: 15   
> 
> `'LWoisne'[b::2]`   
> 
> 
> 
> 
Total: 106
[Answer]
## Total size: ~~123 121 120~~ 116
**#1**
> 
>  (12) `while L[6:]:`
> 
> 
> 
**#2**
> 
>  (10) `min(x,y)>0`
> 
> 
> 
**#3**
> 
>  (7) `L=L[b:]`
> 
> 
> 
**#4**
> 
>  (13) `len(set(L))<2` or `L[1:]==L[:-1]`
> 
> 
> 
**#5**
> 
>  (15) `L+=[n]*(n in L)`
> 
> 
> 
**#6**
> 
>  (14) `x and abs(x)/x` or (inspired by Claudiu's solution after giving up) `x and(x>0)*2-1`
> 
> 
> 
**#7**
> 
>  (15) `while[0]<L[:1]:`
> 
> 
> 
**#8**
> 
>  (9) `while~-n:`
> 
> 
> 
**#9**
> 
>  (5) `s<'.'`
> 
> 
> 
**#10**
> 
>  (15) `b*"Win"or"Lose"`
> 
> 
> 
[Answer]
# Total: 121
First attempts:
## Problem 1
> 
>  15 chars  
> 
> `while len(L)>6:`
> 
> 
> 
## Problem 2
> 
>  5 chars  
> 
> `x>0<y`
> 
> 
> 
## Problem 3
> 
>  7 chars  
> 
> `L=L[b:]`
> 
> 
> 
## Problem 4
> 
>  13 chars  
> 
> `len(set(L))<2`
> 
> 
> 
## Problem 5
> 
>  16 chars  
> 
> `if n in L:L+=[n]`
> 
> 
> 
## Problem 6
> 
>  16 chars  
> 
> `x and(1,-1)[x<0]`
> 
> 
> 
## Problem 7
> 
>  16 chars  
> 
> `while(L+[0])[0]:`
> 
> 
> 
## Problem 8
> 
>  10 chars  
> 
> `while n>1:`
> 
> 
> 
## Problem 9
> 
>  8 chars  
> 
> `s[0]<'0'`
> 
> 
> 
## Problem 10
> 
>  15 chars  
> 
> `"LWoisne"[b::2]`
> 
> 
> 
]