# Filling an array excepted first and last position

ldom = 30 # variable (last day of a month…)

# array init to 0

@obk = []
1.step(ldom, 1) do |i|
@obk[i] = 0
end

## I am filling an array as follows (part of a larger filling scheme) :

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this

loop…
obdays.each do |bd|
@obk[bd] = 1
end

ldom = 30 # variable (last day of a month…)

# array init to 0

@obk = []
1.step(ldom, 1) do |i|
@obk[i] = 0
end

Why not:

@obk = Array.new(ldom,0)

## I am filling an array as follows (part of a larger filling scheme) :

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this loop…

``````obdays.each do |bd|
@obk[bd] = 1
end
``````

<…>

Not sure what are you trying to do here, but maybe something like this
may suit you?

@obk.fill(1,ldom-1){|i| obdays[i]}

Regards,
Rimantas

On 20.10.2006 09:59, Josselin wrote:

ldom = 30 # variable (last day of a month…)

# array init to 0

@obk = []
1.step(ldom, 1) do |i|
@obk[i] = 0
end

@obk = Array.new(ldom, 0)

@obk[obdays.first] += -1
@obk[obdays.last] += -2

I am not exactly sure what problem you have with this approach. Here is
a different one

obdays.each_with_index do |bd, idx|
case idx
when 0
# ignore, @obk[bd] is 0 already
when obdays.length - 1
# set to 1 + (-2) = -1
@obk[bd] = -1
else
@obk[bd] = 1
end
end

Does that help?

``robert``

Josselin wrote:

ldom = 30 # variable (last day of a month…)

# array init to 0

@obk = []
1.step(ldom, 1) do |i|
@obk[i] = 0
end

You could do also
@obk = Array.new(ldom) { 0 }

## I am filling an array as follows (part of a larger filling scheme) :

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this

loop…
obdays.each do |bd|
@obk[bd] = 1
end

hmm… there are maybe better ways for this, but I would try:

([email protected]).each {|i| puts @obk[i] }

HTH,
Peter
http://www.rubyrailways.com

On 2006-10-20 09:59:58 +0200, Josselin [email protected] said:

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this loop…

``````obdays.each do |bd|
@obk[bd] = 1
end
``````

# ajusting first and last position (in the larger scheme)

``````@obk[obdays.first] += -1
@obk[obdays.last] += -2
``````

thanks to all of you, i’ll try all your clues…
Ruby is incredible… you can writing as in any C, C++, java multi
lines routine… then shrink it to a minimal line… that’s why newbie
ask for well-trained support at first then may require guru help !!

On 10/20/06, Josselin [email protected] wrote:

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this loop…

``````obdays.each do |bd|
@obk[bd] = 1
end
``````

@obk = Array.new(ldom, 0)
obdays[1…-2].to_a.each{|bd| @obk[bd] = 1}

to_a just in case obdays is empty, in which case obdays[1…-2] return
nil.
I don’t know why Array#[] with a range cannot just always return [].

And don’t worry about creating a new object,
obdays and obdays[1…-2] actually share storage.

On 2006-10-20 10:26:50 +0200, “Rimantas L.” [email protected]
said:

@obk = Array.new(ldom,0)
yes , it’s better … avoiding @obk[0] = nil in my writing…

Not sure what are you trying to do here, but maybe something like this
may suit you?

@obk.fill(1,ldom-1){|i| obdays[i]}
obdays are all days in a given period in a month (ex : 2 to 6
november)
I need to fill @obk[3] = 1 … @obk[5] = 1 # booked
but @obk[2] += -1 (in value) @obk[6] += -2 (out value)

because on november 6, I can also have late another booking period
starting

so I will get
@obk[6] += 1 (in value)… in which case @obk[6] will be -3

finally I got my array for november from 1 to 30
Day 1 2 3 4 5 6 7 8 9 …
value 0 -1 1 1 1 -3 1 1 1 …
these values are used in a javascript calendar to fix the CSS class for
display
0 no booking color
-1 half day starting
1 booked day
-3 half day ending / half day starting

-2 half day ending

that’s it…

On 2006-10-20 10:32:18 +0200, Robert K. [email protected]
said:

On 20.10.2006 09:59, Josselin wrote:

ldom = 30 # variable (last day of a month…)

# array init to 0

@obk = []
1.step(ldom, 1) do |i|
@obk[i] = 0
end

@obk = Array.new(ldom, 0)
better , avoiding @obk[0] = nil …

@obk[obdays.first] += -1
# set to 1 + (-2) = -1
@obk[bd] = -1
else
@obk[bd] = 1
end
end

Does that help?

robert

yes and no, I cannot test @obk[bd] == 0 as it may change… as
indicated in one of my response post

On 2006-10-20 10:54:24 +0200, “Tomasz W.”
[email protected] said:

#fiiling the array upon another array content

# but I’d like to AVOID filling the first and last position in this loop…

``````obdays.each do |bd|
@obk[bd] = 1
end
``````

@obk = Array.new(ldom, 0)
obdays[1…-2].to_a.each{|bd| @obk[bd] = 1}

interesting but when I enter this command obdays is already a range :

obdays = > 2…6
so I want to do someting like that :
obdays[3…5].to_a.each{|bd| @obk[bd] = 1}
starting the position after the first in the range and ending with the
position before the last
like obdays[start+1…end-1].to_a.each{|bd| @obk[bd] = 1}
?

On 2006-10-20 13:40:44 +0200, Robert K. [email protected]
said:

end
end
when 0

robert

Thanks Robert, I solved the problem creating a sub-range without the
first and last position of the the initial range

``````  other_booking_days = (bk.start_at.day..bk.end_at.day)

@obk[other_booking_days.first] += -1
obd = (bk.start_at.day+1..bk.end_at.day-1)
obd.each {|bd| @obk[bd] = 1 }
@obk[other_booking_days.last] += -2
``````

all range is initialized to 0
first and last position in the range act like incremental counters…
in between just get a value

On 20.10.2006 13:35, Josselin wrote:

end
@obk[bd] = 1
case idx
Does that help?

``````robert
``````

yes and no, I cannot test @obk[bd] == 0 as it may change… as
indicated in one of my response post

??? There is no test for @obk[bd] == 0 in the code above. It’s a bit
difficult to guess what you really want with the information I have
seen.

Cheers

``robert``

Josselin wrote:

all range is initialized to 0
first and last position in the range act like incremental counters…
in between just get a value

This sounds as if the design is at least questionable. If you have
separate counters then why not make them separate? Do they have
anything in common with all the other values in the array?

Regards

``robert``