Questa è una sfida per praticare l'ottimizzazione del golf in Python: trucchi e scorciatoie riutilizzabili per radere alcuni personaggi. Molti conosceranno i golfisti di Python e useranno idee comuni dai suggerimenti di Python . Alcuni di questi usano funzionalità specifiche di Python che potresti non sapere se non le hai viste, quindi dai un'occhiata ai suggerimenti se sei bloccato.

Obiettivo: ci sono dieci problemi, ognuno dei quali è uno snippet di riferimento del codice Python che puoi ottimizzare e una descrizione del codice. Il tuo obiettivo è riscriverlo in modo che sia più breve ma funzionalmente equivalente.

Il tuo punteggio, che stai cercando di minimizzare, è la lunghezza totale del tuo codice di tutti i frammenti. La lunghezza degli snippet di riferimento è 150. Tiebreaker è il primo post.

Invio delle risposte: per ogni problema, pubblica il tuo codice e il conteggio dei caratteri. Puoi pubblicare lo snippet di riferimento se non hai trovato qualcosa di più corto. È inteso che non guardi le risposte degli altri quando pubblichi le tue. Si prega di spoiler-tag ogni singolo problema, compresi i conteggi dei singoli personaggi. Puoi lasciare rivelato il conteggio totale. Sentiti libero di rovinare la tua soluzione o pubblicare nuove soluzioni incontaminate.

Dettagli sulla legalità: equivalenza funzionale significa che il codice può essere sostituito in un programma senza influenzarne il comportamento (ignorando cose come l'utilizzo della memoria e la precedenza dell'operatore come parte di un'espressione). Le espressioni dovrebbero produrre valori equivalenti a ==. Si noti che 1.0==1==True. Il tuo codice non dovrebbe avere effetti collaterali se non diversamente indicato. Non intendo che i problemi siano specifici della versione, ma per ogni evenienza, puoi specificare una versione di Python per ogni problema.

Problema 1: continua a ripetere finché l'elenco Lcontiene almeno 7 elementi

# 16 chars
while len(L)>=7:

Problema 2 : Verificare se due galleggianti xe ysono entrambi positivi.

# 11 chars
x>0 and y>0

Problema 3 : se Boolean bè true, rimuovere il primo elemento di L. Altrimenti, lascialo invariato.

# 12 chars
if b:L=L[1:]

Problema 4 : verificare se tutti gli elementi di un elenco Ldi numeri non vuoto sono uguali. Per questo problema, è OK per modificare l'elenco.

# 22 chars
all(x==L[0]for x in L)

Problema 5 : aggiungere un numero nalla fine di un elenco Lsolo se Lcontiene già quel numero.

# 16 chars
if n in L:L+=[n] 

Problema 6 : esprimere il segno di un float x: +1per positivo, 0per 0, -1per negativo.

# 20 chars
abs(x)/x if x else 0

Problema 7 Continua un ciclo fino a quando è il primo elemento di L, un elenco di booleani True. Fermati anche se Lè vuoto.

# 17 chars
while L and L[0]:

Problema 8 : continuare un ciclo fino a quando nè maggiore di 1. Il numero nè garantito per essere un numero intero positivo.

# 10 chars
while n>1:

Problema 9 : verifica se un numero intero rappresentato come stringa sè negativo (ovvero, inizia con '-').

# 9 chars
s[0]=='-'

Problema 10 : converti un valore booleano bin "Win"/ "Lose", con True-> "Win"e False-> "Lose".

# 17 chars
["Lose","Win"][b]

Avvertenza: spoiler di seguito, non scorrere verso il basso se si desidera risolverli da soli.

Se vuoi solo sapere il punteggio ottimale per un problema:

Problema 1:

12

Problema 2:

5

Problema 3:

7

Problema 4:

13

Problema 5:

13

Problema 6:

8

Problema 7:

12

Problema 8:

9

Problema 9:

5

Problema 10:

15

Totale: 104 101 99 caratteri

Problema 1

12 caratteri
while L[6:]:

Problema 2

5 caratteri
x>0<y

Problema 3

7 caratteri
L=L[b:]

Problema 4

13 caratteri
len(set(L))<2
L[1:]==L[:-1]

Problema 5

13 caratteri
L+=set(L)&{n}

Problema 6

11 caratteri
(x>0)-(x<0)

8 caratteri (Python 2)
cmp(x,0)

Problema 7

12 caratteri
while[.5]<L:

Problema 8

9 caratteri
while~-n:

Problema 9

5 caratteri
s<'.'

Problema 10

15 caratteri
'LWoisne'[b::2]

Dimensione totale: 128 122 120 117 116 115 111 107 104

Problema 1

Continua a iterare finché l'elenco Lcontiene almeno 7 elementi.

15 caratteri
while len(L)>6:
(Sì, ho potuto salvare 3 byte su questo, ma ho visto per errore la soluzione Sp3000, quindi non rivendicherò quei tre byte.)

Problema 2

Controlla se due galleggianti xe ysono entrambi positivi.

5 caratteri
x>0<y

Problema 3

Se Boolean bè true, rimuovere il primo elemento di L. Altrimenti, lascialo invariato.

7 caratteri
L=L[b:]

Problema 4

Controlla se tutti gli elementi di un elenco Ldi numeri non vuoto sono uguali. Per questo problema, è OK per modificare l'elenco.

13 caratteri
L[1:]==L[:-1]

Problema 5

Aggiungi un numero nalla fine di un elenco Lsolo se Lcontiene già quel numero.

15 caratteri
L+=[n]*(n in L)
o
L+=[n][:n in L]

Problema 6

Esprimi il segno di un float x: +1per positivo, 0per 0, -1per negativo.

8 caratteri, Python 2
cmp(x,0)
Secondo i documenti questo potrebbe restituire qualsiasi valore positivo / negativo, ma il consenso è che restituisce sempre -1, 0, 1.

Problema 7

Continua un ciclo fino a quando è il primo elemento di L, un elenco di booleani True. Fermati anche se Lè vuoto.

12 caratteri
while[1]<=L:

Problema 8

Continua un ciclo finché nè maggiore di 1. Il numero nè garantito per essere un numero intero positivo.

9 caratteri
while~-n:

Problema 9

Verifica se un numero intero rappresentato come stringa sè negativo (ovvero, inizia con '-').

5 caratteri
s<'.'

Problema 10

Converti un valore booleano bin "Win"/ "Lose", con True-> "Win"e False-> "Lose".

15 caratteri
"LWoisne"[b::2]

Totale: 106 104 102 caratteri

Problema 1

12 caratteri
while L[6:]:

Problema 2

5 caratteri
x>0<y
Huzzah per il concatenamento di confronto

Problema 3

7 caratteri
L=L[b:]
Buona vecchia conversione implicita

Problema 4

13
len(set(L))<2

In alternativa:
L[1:]==L[:-1]

Stupido modo per ottenere la negazione di ciò che vogliamo in Python 2:
","in`set(L)`

Non sono sicuro di quale sia la rilevanza di "Va bene modificare l'elenco", perché il migliore che mi viene in mente è di 14 caratteri (ed è effettivamente sbagliato):
L==[L.pop()]+L

Problema 5

13 caratteri
L+={n}&set(L)
Fare cose funky con i set

Problema 6

11 caratteri
(x>0)-(x<0)

Problema 7

12 caratteri
while[1]<=L:
Usa l'ordine lessicografico delle liste

Problema 8

9 caratteri
while~-n:

Problema 9

5 caratteri
s<"."
Utilizza l'ordinamento lessicografico delle stringhe

Problema 10

15 caratteri
"LWoisne"[b::2]

In alternativa:
b*"Win"or"Lose"

Totale: 99 byte

Problema 1

12 byte
while L[6:]:

Problema 2

5 byte
x>0<y

Problema 3

7 byte
L=L[b:]

Problema 4

13 byte
len(set(L))<2

14 byte alternative
min(L)==max(L)
set(L)=={L[0]}

Problema 5

13 byte
L+=set(L)&{n}

Problema 6

8 byte
cmp(x,0)

Problema 7

12 byte
while[1]<=L:

Problema 8

9 byte
while~-n:

Problema 9

5 byte
s<'.'

Problema 10

15 byte
b*"Win"or"Lose"
- oppure -
"LWoisne"[b::2]

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)o L+=[n][:n in L]
6: 11
Questo è l'unico per cui un'espressione idiomatica non mi è balenata immediatamente in mente, ma penso di aver trovato la risposta giusta. Modifica: No, è stato orribile.
(x>0)-(x<0)
7: 12
while[1]<=L:
O se il programma è completato dopo, while L[0]è carino.
8: 9
while~-n:
9: 5
Qui funzionano molte stringhe ma il "metodo ingenuo" è divertente.
s<'0'
10: 15
'LWoisne'[b::2]

Totale: 106

Dimensione totale: 123121 120 116

(12) while L[6:]:

(10) min(x,y)>0

(7) L=L[b:]

(13) len(set(L))<2 oppureL[1:]==L[:-1]

(15) L+=[n]*(n in L)

(14) x and abs(x)/x o (ispirato alla soluzione di Claudiu dopo aver rinunciato)x and(x>0)*2-1

(15) while[0]<L[:1]:

(9) while~-n:

(5) s<'.'

(15) b*"Win"or"Lose"

Totale: 121

Primi tentativi:

Problema 1

15 caratteri
while len(L)>6:

Problema 2

5 caratteri
x>0<y

Problema 3

7 caratteri
L=L[b:]

Problema 4

13 caratteri
len(set(L))<2

Problema 5

16 caratteri
if n in L:L+=[n]

Problema 6

16 caratteri
x and(1,-1)[x<0]

Problema 7

16 caratteri
while(L+[0])[0]:

Problema 8

10 caratteri
while n>1:

Problema 9

8 caratteri
s[0]<'0'

Problema 10

15 caratteri
"LWoisne"[b::2]