travailler avec des nombres négatifs en python

Je suis un étudiant dans un des concepts de la programmation de la classe. Le laboratoire est dirigé par un TA et aujourd'hui dans le laboratoire, il nous a donné une réelle simple petit programme pour la construire. C'était celui où il serait de multiplier par plus. De toute façon, il nous avait utiliser absolue pour éviter de casser le prog avec les négatifs. J'ai fouetté jusqu'réel rapide et alors discuté avec lui pendant 10 minutes qu'il était mauvais en mathématiques. C'était, 4 * -5 n'est pas égale à 20, elle est égale à -20. Il a dit qu'il a vraiment doesnt de soins à ce sujet et qu'il serait trop difficile de faire de la prog gérer les aspects négatifs de toute façon. Donc ma question est comment puis-je aller à ce sujet.

voici la prog j'ai tourné dans:

#get user input of numbers as variables

numa, numb = input("please give 2 numbers to multiply seperated with a comma:")

#standing variables
total = 0
count = 0

#output the total
while (count< abs(numb)):
    total = total + numa
    count = count + 1

#testing statements
if (numa, numb <= 0):
    print abs(total)
else:
    print total

Je veux le faire sans absolus, mais chaque fois que je la saisie de nombres négatifs, je reçois un gros goosegg. Je sais qu'il y est une certaine façon simple de le faire, je ne peux pas le trouver.

Préférez toujours raw_input à input, qui ne devrait pas être dans la langue (et est éliminé en Python 3.)
Et juste pour confondre les choses, input en Python 3 est le même que raw_input en Python 2, et autant que je me souvienne, Python 3 n'a pas de raw_input. @_@
C'est vrai, raw_input est renommé input en Python 3.

OriginalL'auteur dman762000 | 2010-03-16

negative-number python

Peut-être vous accomplir cela avec quelque chose à l'effet de

text = raw_input("please give 2 numbers to multiply separated with a comma:")
split_text = text.split(',')
a = int(split_text[0])
b = int(split_text[1])
# The last three lines could be written: a, b = map(int, text.split(','))
# but you may find the code I used a bit easier to understand for now.

if b > 0:
    num_times = b
else:
    num_times = -b

total = 0
# While loops with counters basically should not be used, so I replaced the loop 
# with a for loop. Using a while loop at all is rare.
for i in xrange(num_times):
    total += a 
    # We do this a times, giving us total == a * abs(b)

if b < 0:
    # If b is negative, adjust the total to reflect this.
    total = -total

print total

ou peut-être

a * b

RTQ: multiplication par plus

OriginalL'auteur Mike Graham

3

Trop dur? Votre TA est... eh bien, la phrase serait probablement m'interdit. De toute façon, vérifier pour voir si numb est négatif. Si c'est pour multiplier numa par -1 et ne numb = abs(numb). Puis faire la boucle.

Ummm l'ensemble du projet est à propos de la multiplication; devrait-il mettre en oeuvre une multiplication par -1 par récurrence? Peut-être la récursivité et les piles sont trop dur pour la TA 🙂
Nah. Juste soustraire à partir de 0.

OriginalL'auteur Ignacio Vazquez-Abrams
3

De l'abs() dans la condition du while est nécessaire, car, ainsi, il contrôle le nombre d'itérations (comment définiriez-vous un nombre négatif d'itérations?). Vous pouvez le corriger en inversant le signe du résultat, si numb est négatif.

C'est donc la version modifiée de votre code. Remarque, j'ai remplacé la boucle while avec un nettoyant pour la boucle.
```
#get user input of numbers as variables
numa, numb = input("please give 2 numbers to multiply seperated with a comma:")

#standing variables
total = 0

#output the total
for count in range(abs(numb)):
    total += numa

if numb < 0:
    total = -total

print total
```
OriginalL'auteur slacker
1

Essayez ceci sur votre TA:
```
# Simulate multiplying two N-bit two's-complement numbers
# into a 2N-bit accumulator
# Use shift-add so that it's O(base_2_log(N)) not O(N)

for numa, numb in ((3, 5), (-3, 5), (3, -5), (-3, -5), (-127, -127)):
    print numa, numb,
    accum = 0
    negate = False
    if numa < 0:
        negate = True
        numa = -numa
    while numa:
        if numa & 1:
            accum += numb
        numa >>= 1
        numb <<= 1
    if negate:
        accum = -accum
    print accum
```
de sortie:
```
3 5 15
-3 5 -15
3 -5 -15
-3 -5 15
-127 -127 16129
```
Techniquement, le signe des inversions (accum = -accum et autres) ainsi que les changements de l'exploitation (numb <<= 1) sont des multiplications, mais +1 n'en est pas moins une excellente idée, et les concepts qui probablement s'insèrent dans les choses typiques que l'OP a ou va bientôt couvrir dans la classe.
On l'appelle la négation, pas d'inversion du signe ... si la zone objet de la simulation n'a pas un NEG de l'instruction, de le faire par la soustraction à partir de zéro. À l'aide de votre raisonnement, la abs() éparpillées à travers certains autres réponses, c'est aussi la multiplication!! Si le déplacement est de multiplication, alors il en est d'ailleurs par exemple numa += numa !!! Le déplacement est un très primitif le fonctionnement matériel et est utilisé dans la mise en œuvre de la multiplication.
Vous avez raison, sur tous les plans. Et, en effet, une fois que vous regardez au niveau de la CPU, cet exercice devient vraiment inconfortable pour le dire poliment. Content que l'on pourrait aider l'OP, je déteste quand les instructeurs semblent décourager les étudiants à aller le mile supplémentaire...

OriginalL'auteur John Machin
0

Comment au sujet de quelque chose comme ça? (N'utilise pas de l'abs (), ni mulitiplication)

Notes:
- de l'abs() la fonction est uniquement utilisée pour l'optimisation de la tour. Cet extrait peut être supprimé ou recodé.
- la logique est moins efficace car nous sommes en train de tester le signe de a et b à chaque itération (le prix à payer pour éviter à la fois l'abs() et l'opérateur de multiplication)
```
def multiply_by_addition(a, b):
""" School exercise: multiplies integers a and b, by successive additions.
"""
   if abs(a) > abs(b):
      a, b = b, a     # optimize by reducing number of iterations
   total = 0
   while a != 0:
      if a > 0:
         a -= 1
         total += b
      else:
         a += 1
         total -= b
   return total

multiply_by_addition(2,3)
6
multiply_by_addition(4,3)
12
multiply_by_addition(-4,3)
-12
multiply_by_addition(4,-3)
-12
multiply_by_addition(-4,-3)
12
```
Vous devez mettre le while boucle à l'intérieur de la if déclaration, puisque le if déclaration évalue chaque fois la même chose. Ou définir une variable da à 1 ou -1, et dt à total ou -total, avant la boucle while.
Les fonctions en Python doit commencer par une lettre minuscule. Si quelqu'un voit FooBar (en dehors d'une bibliothèque externe avec une convention de nommage), ils vont penser que c'est une classe.
oui! Vous avez raison, ce serait généralement préférable. Dans le cadre de ce artificiel affectation, j'ai opté pour un seul tout en approche, parce qu'il le reflet de l'algorithme original et rend le calcul plus autonome. Bien que faisant tout notre "signe de test" à l'avance et avoir 2 (ou 3 ou 4), tandis que les boucles au lieu de cela serait équivalent, l'unique, tout en se lit plus comme un seul algorithme (psychologique, sans doute).
merci pour cette remarque. En fait PEP8 appels pour un nom comme mul_by_add() ou mieux encore multiply_by_addition(). My bad, j'ai garder la commutation de langues et rigoureuse et stupide convention de nommage au travail n'aide pas 🙁

OriginalL'auteur mjv
0

Merci à tous, vous tous m'ont permis d'apprendre beaucoup de choses. C'est ce que je suis venu avec l'aide de certains de vos suggestions
```
#this is apparently a better way of getting multiple inputs at the same time than the 
#way I was doing it
text = raw_input("please give 2 numbers to multiply separated with a comma:")
split_text = text.split(',')
numa = int(split_text[0])
numb = int(split_text[1])

#standing variables
total = 0

if numb > 0:
    repeat = numb
else:
    repeat = -numb

#for loops work better than while loops and are cheaper
#output the total
for count in range(repeat):
    total += numa


#check to make sure the output is accurate
if numb < 0:
    total = -total


print total
```
Merci pour toute l'aide tout le monde.

Quel est le point de l'ensemble de la si-clause else, si tout ce qu'il fait est un simple repeat = abs(numb) ?
Aussi, si votre problème est résolu, veuillez accepter l'une des réponses (peut-être même votre propre).
sans la si la clause else les chiffres de retour avec la valeur absolue, et non pas la vraie valeur, de sorte que, sans elle, l'prog retourne encore 4*-5 20 au lieu de -20
En fait, sans le si-sinon la clause 4*-5 retourne 0, range() avec un argument négatif retourne une liste vide. Je ne parlais pas de cette logique étant inutile. je parlais de réinventer la roue, comme ces 4 lignes pourraient être remplacées par une seule ligne qui lit repeat = abs(numb). Ce qui serait non seulement plus courte, mais aussi plus claire.
Oh, je vois maintenant ce que vous dites. Ok, désolé pour ce que je suis juste à l'apprentissage. Vous êtes de droite qui ne fonctionne pas mieux et c'est plus propre et plus clair.

OriginalL'auteur dman762000

-1

import time

print ('Two Digit Multiplication Calculator')
print ('===================================')
print ()
print ('Give me two numbers.')

x = int ( input (':'))

y = int ( input (':'))

z = 0

print ()


while x > 0:
    print (':',z)
    x = x - 1
    z = y + z
    time.sleep (.2)
    if x == 0:
        print ('Final answer: ',z)

while x < 0:
    print (':',-(z))
    x = x + 1
    z = y + z
    time.sleep (.2)
    if x == 0:
        print ('Final answer: ',-(z))

print ()

code seulement des réponses n'est généralement pas bien, pouvez-vous expliquer?

OriginalL'auteur Kitiyo

Vous devez vous connecter pour publier un commentaire.