I've got a question.
1.0X + 1.0Y + -7.0 = 0
How can I print an equation better?
For example, instead of +- 7.0 I'd like to print -7.0; or in a case with zero coefficients.
Thanks
Prints an equation with full control of formating
a = b = 1
c = -7
puts "%0.1fX + %0.1fY %s %0.1f = %d"%[ a, b, c < 0 ? '-' : '+', c.abs, 0 ]
output:
1.0X + 1.0Y - 7.0 = 0
Documentation: Ruby's % string operator / sprintf
With a few substitutions, you could achieve a much cleaner equation :
equation = "1.0X + 1.0Y - -0.0Z + -7.0 = 0"
new_equation = equation.gsub('+ -', '- ')
.gsub('- -', '+ ')
.gsub(/^\s*\+/, '') # Remove leading +
.gsub(/(?<=\d)\.0+(?=\D)/, '') # Remove trailing zeroes
.gsub(/\b1(?=[a-z])/i, '') # Remove 1 in 1X
.gsub(/[+-]? ?0[a-z] ?/i, '') # Remove 0Z
p new_equation
# "X + Y - 7 = 0"
By the way, as much as I love Ruby, I must say that Sympy is an awesome project. This library alone makes it worthwhile to learn the basic Python syntax.
Related
What I am trying to do is to change number that comes after $ sign into 0 in a string. I could do simple "find $ sign then change next thing after it into 0", but the problem is that number may have different number of digits. Another problem is that number might be non-integer like "2.5" so it has to tolerate comma, or negative numbers like "-2"
For example:
I have an equation which is string type: x^(-2) + 4x + 123 + 42.2 + 1
I write it as follows: x^($-2) + $4x + $123 + $42.2 + 1
Output that I am trying to get should be: x^(0) + 0x + 0 + 1
Do you have an idea how to do that?
For now I have came up with idea, but I don't know if such method exist in ruby.
x=0
while index('$',x+1) do
x = index('$',x+1)
#function that does translating
end
In the loop, there could be a function that trims every digit until it find non-numeric character (with exception of starting - and . imitating negative or floating point number) and then puts in that place "0".
r = /
\$ # match '$'
(?: # begin a non-capture group
-(?>\d) # match a hyphen followed by a digit in a positive lookahead
| # or
[\d,.]+ # match one of the characters one or more times
) # end the non-capture group
/x # free-spacing regex definition mode
which is conventionally written as follows.
r = /\$(?:-(?>\d)|[\d,.]+)/
"x^($-2) + $4,000x + $123 + $42.2 + 1".gsub(r, '0')
#=> "x^(0) + 0x + 0 + 0 + 1"
"x^($-2) + $4x + $-123- $42.2 + 1".gsub(r, '0')
#=> "x^(0) + 0x + 023- 0 + 1"
You could use regex with String#gsub like follows:
"x^($-2) + $4,000x + $123 + $42.2 + 1".gsub(/\$-?\d+(\,\d+)*(\.\d+)?/,'0')
#=> "x^(0) + 0x + 0 + 0 + 1"
Below I've posted the code to a non-working "divide and conquer" multiplication method in ruby(with debug prints). I cannot tell if its broken code, or a quirk in Ruby like how the L-shift(<<) operator doesn't push bits into the bit-bucket; this is unexpected compared to similar operations in C++.
Is it broken code (doesn't match the original algorithm) or unexpected behavior?
Pseudo code for original algorithm
def multiply(x,y,n, level)
#print "Level #{level}\n"
if n == 1
#print "\tx[#{x.to_s(2)}][#{y.to_s(2)}]\n\n"
return x*y
end
mask = 2**n - 2**(n/2)
xl = x >> (n / 2)
xr = x & ~mask
yl = y >> (n / 2)
yr = y & ~mask
print " #{n} | x = #{x.to_s(2)} = L[#{xl.to_s(2)}][#{xr.to_s(2)}]R \n"
print " #{n} | y = #{y.to_s(2)} = L[#{yl.to_s(2)}][#{yr.to_s(2)}]R \n"
#print "\t[#{xl.to_s(2)}][#{yr.to_s(2)}]\n"
#print "\t[#{xr.to_s(2)}][#{yr.to_s(2)}]\n"
#print "\t([#{xl.to_s(2)}]+[#{xr.to_s(2)}])([#{yl.to_s(2)}]+[#{yr.to_s(2)}])\n\n"
p1 = multiply( xl, yl, n/2, level+1)
p2 = multiply( xr, yr, n/2, level+1)
p3 = multiply( xl+xr, yl+yr, n/2, level+1)
return p1 * 2**n + (p3 - p1 - p2) * 2**(n/2) + p2
end
x = 21
y = 22
print "x = #{x} = #{x.to_s(2)}\n"
print "y = #{y} = #{y.to_s(2)}\n"
print "\nDC_multiply\t#{x}*#{y} = #{multiply(x,y,8, 1)} \nregular\t#{x}*#{y} = #{x*y}\n\n "
I am not familiar with the divide and conquer algorithm but i don't think it contains parts you can't do in Ruby.
Here is a quick attempt:
def multiplb(a,b)
#Break recursion when a or b has one digit
if a < 10 || b < 10
a * b
else
#Max number of digits of a and b
n = [a.to_s.length, b.to_s.length].max
# Steps to split numbers to high and low digits sub-numbers
# (1) to_s.split('') => Converting digits to string then arrays to ease splitting numbers digits
# (2) each_slice => Splitting both numbers to high(left) and low(right) digits groups
# (3) to_a , map, join, to_i => Simply returning digits to numbers
al, ar = a.to_s.split('').each_slice(n/2).to_a.map(&:join).map(&:to_i)
bl, br = b.to_s.split('').each_slice(n/2).to_a.map(&:join).map(&:to_i)
#Recursion
p1 = multiplb(al, bl)
p2 = multiplb(al + ar, bl + br)
p3 = multiplb(ar, br)
p1 * (10**n) + (p2 - p1 - p3) * (10**(n/2)) + p3
end
end
#Test
puts multiplb(1980, 2315)
# => 4583700 yeah that's correct :)
Here are some references to further explain part of the code:
Finding max of numbers => How do you find a min / max with Ruby?
Spliting an array to half => Splitting an array into equal parts in ruby
Turning a fixnum into array => Turning long fixed number to array Ruby
Hope it hepls !
I have the following method for doing a check digit on a tracking number, but it just feels lengthy/sloppy. Can it be refactored and just generally cleaned up?
I'm running Ruby 1.8.7.
def is_fedex(number)
n = number.reverse[0..14]
check_digit = n.first.to_i
even_numbers = n[1..1].to_i + n[3..3].to_i + n[5..5].to_i + n[7..7].to_i + n[9..9].to_i + n[11..11].to_i + n[13..13].to_i
even_numbers = even_numbers * 3
odd_numbers = n[2..2].to_i + n[4..4].to_i + n[6..6].to_i + n[8..8].to_i + n[10..10].to_i + n[12..12].to_i + n[14..14].to_i
total = even_numbers + odd_numbers
multiple_of_ten = total + 10 - (total % 10)
remainder = multiple_of_ten - total
if remainder == check_digit
true
else
false
end
end
EDIT: Here are valid and invalid numbers.
Valid: 9612019950078574025848
Invalid: 9612019950078574025847
def is_fedex(number)
total = (7..20).inject(0) {|sum, i| sum + number[i..i].to_i * ( i.odd? ? 1 : 3 ) }
number[-1].to_i == (total / 10.0).ceil * 10 - total
end
I believe you should keep your code. While it's not idiomatic or clever, it's the one you will have the least trouble to understand a few months from now.
I'm not a ruby programmer, so if any of the syntax is off, I apologize but you should get the general idea. A few things I see: First, you don't need to slice the array, a single index should be sufficient. Second, Instead of splitting even and odd, you could do something like this:
total = 0
for i in (1..14)
total += n[i].to_i * ( i % 2 == 1 ? 1 : 3 )
end
Third, remainder could be simplified to 10 - (total % 10).
I realize you're running 1.8.7, but here's my attempt using each_slice and inject in conjunction, a 1.9.2 feature:
def is_fedex(number)
total = number.reverse[1..14].split(//).map(&:to_i).each_slice(2).inject(0) do |t, (e,o)|
t += e*3 + o
end
10 - (total % 10) == number[-1].to_i
end
It passes both tests
Give this a try:
#assuming number comes in as a string
def is_fedex(number)
n = number.reverse[0..14].scan(/./)
check_digit = n[0].to_i
total = 0
n[1..14].each_with_index {|d,i| total += d.to_i * (i.even? ? 3 : 1) }
check_digit == 10 - (total % 10)
end
> is_fedex("12345678901231") => true
edit incorporating simplified remainder logic as Kevin suggested
Something like this?
def is_fedex(number)
even_arr, odd_arr = number.to_s[1..13].split(//).map(&:to_i).partition.with_index { |n, i| i.even? }
total = even_arr.inject(:+) * 3 + odd_arr.inject(:+)
number.to_s.reverse[0..0].to_i == (total + 10 - (total % 10)) - total
end
If you can give me a valid and invalid number I can test if it works and maybe tweak it further :)
This function should to:
def is_fedex(number)
# sanity check
return false unless number.length == 15
data = number[0..13].reverse
check_digit = number[14..14].to_i
total = (0..data.length-1).inject(0) do |total, i|
total += data[i..i].to_i * 3**((i+1)%2)
end
(10 - total % 10) == check_digit
end
The arithmetic expression 3**((i+1)%2) might look a bit complex, but is essentially the same as (i.odd? ? 1 : 3). Both variants are correct, which you use is up to you (and might affect speed...)
Also note, that if you use Ruby 1.9, you can use data[i] instead of data[i..i] which is required for for Ruby 1.8.
This loop does not terminate after I type x. I'm really new to Ruby, and so far, it is so much different than what I learned before - quite interesting,
total = 0
i = 0
while ((number = gets) != "x")
total += number.to_i
i += 1
end
puts "\nAverage: " + (total / i).to_s
Any help is greatly appreciated.
Because gets gives you the newline as well. You need to chomp it.
Try:
while ((number = gets.chomp) != "x")
and you'll see it starts working:
pax> ruby testprog.rb
1
5
33
x
Average: 13
s is a string, This seems very long-winded - how can i simplify this? :
if x === 2
z = s
elsif x === 3
z = s+s
elsif x === 4
z = s+s+s
elsif x === 5
z = s+s+s+s
elsif x === 6
z = s+s+s+s+s
Thanks
Something like this is the simplest and works (as seen on ideone.com):
puts 'Hello' * 3 # HelloHelloHello
s = 'Go'
x = 4
z = s * (x - 1)
puts z # GoGoGo
API links
ruby-doc.org - String: str * integer => new_str
Copy—Returns a new String containing integer copies of the receiver.
"Ho! " * 3 #=> "Ho! Ho! Ho! "
z=''
(x-1).times do
z+=s
end
Pseudo code (not ruby)
if 1 < int(x) < 7 then
z = (x-1)*s
For example for a rating system up to 5 stars you can use something like this:
def rating_to_star(rating)
'star' * rating.to_i + 'empty_star' * (5 - rating.to_i)
end