python - vérification des nombres pairs/impairs et modification des sorties en fonction de la taille des nombres
J'ai quelques problèmes à résoudre pour une tâche et je suis un peu coincé .. La question est d'écrire un programme qui permet à l'utilisateur d'entrer un nombre impair (vérifiez que c'est impair), puis d'imprimer une pyramide à l'envers de étoiles en fonction de la taille de l'entrée.
Par exemple, si vous entrez 5, il apparaît avec
*****
***
*
Mon problème est donc double.
1) Comment puis-je vérifier si c'est pair ou impair? J'ai essayé if number/2 == int dans l'espoir que cela puisse faire quelque chose, et Internet me dit de faire if number%2==0, mais cela ne fonctionne pas.
2) Comment changer les astérisques au milieu de chaque ligne?
Toute aide concernant l'un ou l'autre problème est grandement appréciée.
Il ne servirait à rien de vous donner une réponse complète puisqu'il s'agit d'un devoir, alors voici quelques indications:
Pair ou impair:
number % 2 == 0
est certainement un très bon moyen de savoir si votre nombre est pair.
Si vous ne connaissez pas %, ceci modulo, qui est ici le reste de la division de number par 2. http://en.wikipedia.org/wiki/Modulo_operation
Impression de la pyramide:
Premier conseil: pour imprimer *****, vous pouvez faire print "*" * 5.
Deuxième conseil: pour centrer les astérisques, vous devez connaître le nombre d'espaces à écrire avant les astérisques. Ensuite, vous pouvez imprimer un tas d'espaces et d'astérisques avec print " "*1 + "*"*3
Les solutions modulo 2 avec% 2 sont bonnes, mais cela nécessite une division et une soustraction. Étant donné que les ordinateurs utilisent l’arithmétique binaire, une solution beaucoup plus efficace consiste à:
# This first solution does not produce a Boolean value.
is_odd_if_zero = value & 1
# or
is_odd = (value & 1) == 1
# or
is_even = (value & 1) == 0
Simple mais 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)
1) Comment puis-je vérifier si c'est pair ou impair? J'ai essayé "if number/2 == int" dans l'espoir que cela puisse faire quelque chose et Internet me dit de faire "if number% 2 == 0", mais cela ne fonctionne pas.
def isEven(number):
return number % 2 == 0
if number%2==0
vous dira que c'est même. Donc, les nombres impairs seraient la déclaration else ici. Le "%" est le signe mod qui retourne le reste après la division. Nous disons donc essentiellement que si le nombre est divisible par deux, nous pouvons supposer qu'il est pair. Sinon c'est étrange (c'est une corrélation parfaite!)
En ce qui concerne le positionnement de l'astérisque, vous souhaitez ajouter des astérisques au nombre d'espaces corrélés à la ligne sur laquelle il est placé. Dans votre exemple
***** line 0
*** line 1
* line 2
Nous voudrons espacer en conséquence
0*****
01***
012*
la = lambda x : "even" if not x % 2 else "odd"
Je suppose que le moyen le plus simple et le plus simple est-ce
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 conditions de base et mathématiques. Il a également à l'esprit zéro, ce qui n'est ni pair ni impair et vous donnez le nombre que vous voulez par entrée, donc c'est très variable.
il y a beaucoup de façons de vérifier si une valeur int est impair ou pair . Je vais vous montrer les deux manières principales:
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)
j'espère que ça aide
En ce qui concerne l’impression, voici comment je procéderais à l’aide du Mini spécification de format (section: Alignement du texte et spécification d’une largeur):
Une fois que vous avez votre longueur, dites length = 11:
rowstring = '{{: ^{length:d}}}'.format(length = length) # center aligned, space-padded format string of length <length>
for i in xrange(length, 0, -2): # iterate from top to bottom with step size 2
print rowstring.format( '*' * i )
Exemple d'instruction Étant donné un entier, n, effectuant les actions conditionnelles suivantes:
- Si n est impair, imprimez Bizarre
- Si n est pair et compris entre 2 et 5, imprimez Pas étrange
- Si n est pair et compris entre 6 et 20, imprimez Weird
Si n est pair et supérieur à 20, imprimez Pas étrange
import math n = int (input ())
si n% 2 == 1: print ("Bizarre") Elif n% 2 == 0 et n dans la plage (2,6): print ("pas bizarre") Elif n% 2 == 0 et n dans la plage (6,21): print ("Bizarre") Elif n% 2 == 0 et n> 20 : print ("pas bizarre")
C'est un code simple. Vous pouvez l'essayer et saisir facilement les connaissances.
n = int(input('Enter integer : '))
if n % 2 == 3`8huhubuiiujji`:
print('digit entered is ODD')
Elif n % 2 == 0 and 2 < n < 5:
print('EVEN AND in between [2,5]')
Elif n % 2 == 0 and 6 < n < 20:
print('EVEN and in between [6,20]')
Elif n % 2 == 0 and n > 20:
print('Even and greater than 20')
etc...
Quelques-unes des solutions citées ici font référence au temps pris pour diverses opérations "is even", notamment n % 2 vs n & 1, sans vérifier systématiquement comment cela varie avec la taille de n, ce qui s'avère prédictif de la vitesse.
La réponse courte est que si vous utilisez des nombres de taille raisonnable, normalement <1e9 , cela ne fait pas grande différence. Si vous utilisez des nombres plus grands, vous voudrez probablement utiliser l'opérateur bit à bit.
Voici un graphique montrant ce qui se passe (avec Python 3.7.3, sous Linux 5.1.2):
En gros, lorsque vous atteignez la "précision arbitraire", les choses deviennent de plus en plus lentes pour le module, tout en restant constantes pour l’opération au niveau du bit. Notez également le multiplicateur 10**-7, c’est-à-dire que je peux effectuer environ 30 millions de vérifications (petit nombre entier) par seconde.
Voici le même complot pour Python 2.7.16:
qui montre l'optimisation qui est allé dans les nouvelles versions de Python.
Je n'ai que ces versions de Python sur ma machine, mais je pourrais le relancer pour d'autres versions de cet intérêt. Il y a 51 ns compris entre 1 et 1e100 (régulièrement répartis sur une échelle logarithmique), pour chaque point, je fais l'équivalent de:
timeit('n % 2', f'n={n}', number=niter)
où niter est calculé pour rendre timeit prendre environ 0,1 seconde, et cela est répété 5 fois. La manipulation légèrement maladroite de n consiste à s'assurer que nous ne comparons pas non plus la recherche de variable globale, qui est plus lente que les variables locales. La moyenne de ces valeurs est utilisée pour tracer la ligne et les valeurs individuelles sont dessinées sous forme de points.
def main():
n = float(input('odd:'))
while n % 2 == 0:
if n % 2 == 1:
break
n = float(input('odd:'))
for i in range(int((n+1)/2)):
print(' '*i+'*'*int((n-2*i))+' '*i)
main()
#1st part ensures that it is an odd number that was entered.2nd part does the printing of triangular
Voici ma solution:
def is_even(n):
r=n/2.0
if r==int(r):
return True
else:
return False
Ma solution consiste essentiellement en deux chaînes et avec le & nous obtenons le bon index:
res = ["Even", "Odd"]
print(res[x & 1])
Veuillez noter que cela semble plus lent que d'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)
sortie:
8.05739480999182
8.170479692984372
8.892275177990086