python - vérification de pair/impair nombre et évolution des sorties sur le nombre de la taille

Vous donner la réponse complète aurait pas de point du tout, car c'est les devoirs, alors voici quelques conseils :

Pair ou Impair:

number % 2 == 0

est certainement un très bon moyen de trouver si votre numéro est le même.

Dans le cas où vous ne savez pas %, cela ne modulo qui est, ici, le reste de la division de number par 2. http://en.wikipedia.org/wiki/Modulo_operation

L'impression de la pyramide:

Premier conseil: pour imprimer *****, vous pouvez le faire print "*" * 5.

Deuxième conseil: pour centre les astérisques, vous avez besoin de savoir combien d'espaces à écrire avant de les astérisques. Ensuite, vous pouvez imprimer un tas d'espaces et d'astérisques avec print " "*1 + "*"*3

Simple mais encore rapide:

>>> def is_odd(a):
...     return bool(a - ((a>>1)<<1))
...
>>> print(is_odd(13))
True
>>> print(is_odd(12))
False
>>>

Ou encore plus simple:

>>> def is_odd(a):
...   return bool(a & 1)

if number%2==0

vous dire que c'est la même. Si un nombre impair serait l'instruction else là. Le "%" est le mod signe qui renvoie le reste de la division. Donc, nous sommes en train de dire si le nombre est divisible par deux, nous pouvons présumer qu'il est même. Sinon c'est bizarre (c'est une corrélation parfaite!)

Comme pour l'astérisque placer vous souhaitez ajouter les astérisques avec le nombre de places corrélée à la ligne, c'est sur. Dans votre exemple

***** line 0
***   line 1
*     line 2

Nous voulons de l'espace en conséquence

0*****
01***
012*

Je suppose que la méthode la plus simple et la plus fondamentale est cette

import math

number = int (input ('Enter number: '))

if number % 2 == 0 and number != 0:
    print ('Even number')
elif number == 0:
    print ('Zero is neither even, nor odd.')
else:
    print ('Odd number')

Juste et conditions de base en mathématiques. Il a également esprits zéro, qui n'est ni le même, ni impair et vous donner n'importe quel numéro que vous souhaitez en entrée, donc c'est très variable.

il y a beaucoup de façons de vérifier si un entier est pair ou impair.
Je vais vous montrer les deux principaux moyens:

number = 5

def best_way(number):
    if number%2==0:
        print "even"
    else:
        print "odd"

def binary_way(number):
    if str(bin(number))[len(bin(number))-1]=='0':
        print "even"
    else:
        print "odd"
best_way(number)
binary_way(number)

espère que cela aide

Voici ma solution:

def is_even(n):
    r=n/2.0
    return True if r==int(r) else False

Quelques solutions ici référence au temps nécessaire pour que les divers "est même", principalement n % 2 vs n & 1, sans vérifier systématiquement la façon dont cela varie avec la taille de n, qui s'avère être un facteur prédictif de la vitesse.

La réponse courte est que si vous utilisez des nombres de taille raisonnable, normalement < 1e9, il n'a pas beaucoup de différence. Si vous êtes en utilisant un plus grand nombre, alors vous voudrez probablement à l'aide de l'opérateur au niveau du bit.

Voici un complot visant à démontrer ce qu'il se passe (avec Python 3.7.3, sous Linux 5.1.2):

Fondamentalement que vous cliquez sur "précision arbitraire" aspire à ce que les choses deviennent progressivement plus lente pour le module, tout en restant constant pour la bit-à-bit, op. Notez également la 10**-7 multiplicateur sur ce, c'est à dire que je peux faire ~30 millions de dollars (petit entier) vérifie par seconde.

Ici est le même tracé pour Python 2.7.16:

qui montre l'optimisation qui s'est passé dans les nouvelles versions de Python.

Je n'ai que ces versions de Python sur ma machine, mais pourrait repris pour d'autres versions d'il y a un intérêt. Il y a 51 ns entre 1 et 1e100 (uniformément espacés sur une échelle logarithmique), pour chaque point, je ne l'équivalent de:

timeit('n % 2', f'n={n}', number=niter) 

où niter est calculé à faire timeit prendre de ~0,1 secondes, et cela est répété 5 fois. Le peu maladroite de la manipulation de n est de s'assurer que nous ne sommes pas aussi l'analyse comparative de la variable globale de recherche, qui est plus lent que les variables locales. La moyenne de ces valeurs sont utilisées pour tracer la ligne, et les valeurs individuelles sont dessinés comme des points.

Ma solution fondamentalement, nous avons deux chaînes de caractères et le & nous obtenons le droit de l'indice:

res = ["Even", "Odd"]
print(res[x & 1])

Veuillez noter qu'il semble plus lent que les autres alternatives:

#!/usr/bin/env python3
import math
import random
from timeit import timeit

res = ["Even", "Odd"]

def foo(x):
    return res[x & 1]

def bar(x):
    if x & 1:
        return "Odd"
    return "Even"

la = lambda x : "Even" if not x % 2 else "Odd"

iter = 10000000

time = timeit('bar(random.randint(1, 1000))', "from __main__ import bar, random", number=iter)
print(time)
time = timeit('la(random.randint(1, 1000))', "from __main__ import la, random", number=iter)
print(time)
time = timeit('foo(random.randint(1, 1000))', "from __main__ import foo, random", number=iter)
print(time)

de sortie:

8.05739480999182

8.170479692984372

8.892275177990086