How to Increment an Integer in Ruby

How to increment an integer in Ruby

Ruby doesn't have an ++ operator. You can do puts 1.next though. Note that for your second example this would not change the value of x, in that case you'd have to use x += 1.

Ruby how to increment a string number

You can convert that string to integer, call #next and then convert it back to string

'-3'.to_i.next.to_s

Increment variable in ruby

From the documentation,

Ruby has no pre/post increment/decrement operator. For instance, x++ or x-- will fail to parse

So, you can do

i += 1

which is equivalent of i = i + 1

Incrementing string by integer in ruby

There are several things to add in your code:

• Instead String.new, you can simply add your string within quotes.
• str.split("") can be str.chars.
• $j = $j + 1 can be $j += 1.
• If you're doing a comparison between $j and $n then << should be <.
• You don't need ; unless you're writing all in one line.
• begin; end while can be just while; end

I guess it could be like:

n = gets.to_i
s = 'abc'
s.split('').each do |i|
  j = 0
  x = i
  while j < n
    x = x.next
    j += 1
  end
  puts x
end

But you could use String#ord over each char in your string to return the ordinal of it, add the user input and then String#chr to get the ASCII character for that number:

# With n being the user's input as integer, in this case 3.
p 'abc'.chars.map { |char| (char.ord + n).chr }.join 
# "def"

Added n = gets.to_i as stated in the comments by @Ganesh.

If looking for a Caesar Cipher implementation:

def foo(string, n)
  lower = ('a'..'z').to_a.join
  upper = ('A'..'Z').to_a.join
  string.tr(lower + upper, lower[n..-1] + lower[0...n] + upper[n..-1] + upper[0...n])
end

p foo('XYZ', 1) # "YZA"
p foo('ABC', 1) # "BCD"
p foo('ABC', 3) # "DEF"

Slower, but...

Ruby: Idiom for create and increment

The question is clear:

• A variable is known to hold nil or an integer. If nil the variable is to be set equal to 1, else it is to be set equal to its value plus 1.
• What is the best way to implement this in Ruby?

First, two points.

• The question states, "If it is nil, it should be initialized with 1.". This contradicts the statement that the variable is known to be nil or an integer, meaning that it has already been initialized, or more accurately, defined. In the case of an instance variable, this distinction is irrelevant as Ruby initializes undefined instance variables to nil when they are referenced as rvalues. It's an important distinction for local variables, however, as an exception is raised when an undefined local variable is referenced as an rvalue.
• The comments largely address situations where the variable holds an object other than nil or an integer. They are therefore irrelevant. If the OP wishes to broaden the question to allow the variable to hold objects other than nil or an integer (an array or hash, for example), a separate question should be asked.

What criteria should be used in deciding what code is best? Of the various possibilities that have been mentioned, I do not see important differences in efficiency. Assuming that to be the case, or that relative efficiency is not important in the application, we are left with readability (and by extension, maintainability) as the sole criterion. If x equals nil or an integer, or is an undefined instance variable, perhaps the clearest code is the following:

x = 0 if x.nil?
x += 1

or

x = x.nil? ? 1 : x+1

Ever-so-slightly less readable:

x = (x || 0) + 1

and one step behind that:

x = x.to_i + 1

which requires the reader to know that nil.to_i #=> 0.

The OP may regard these solutions as "clumsy", but I think they are all beautiful.

Can an expression be written that references x but once? I can't think of a way and one has not been suggested in the comments, so if there is a way (doubtful, I believe) it probably would not meet the test for readability.

Consider now the case where the local variable x may not have been defined. In that case we might write:

x = (defined?(x) ? (x || 0) : 0) + 1

defined? is a Ruby keyword.

How to increment the number in a string while keeping the appropriate trailing/leading zeros

You can use next like so:

("%03d" % 1).next #=> '002'

How to add(increment) integer value like we do in other languages using ++(increment) operator in Ruby on Rails

'no implicit conversion of Integer into Array'

It's because .pluck() and .map() return an array.

• @user_id + 1 => is trying to add an array(@user_id) and an integer(1).
• Since 1 is an integer which should be cast to an array to get added to an array and ruby doesn't want to do it implicitly.
• Hence the error.

Why not this?

User.limit(1).order('created_at desc') will return last active record. If created_at is not tempered you can achieve the same simply by

@user_id = User.last.user_id + 1

---

Related Topics