Loops/Wrong ranges: Difference between revisions

*   [[Loops/Wrong ranges]]

<br><br>

 

=={{header|ALGOL W}}==

Using the Algol W for loop and limiting the sequence to 10 values. The Algol W for loop considers the sign of the increment value when deciding whether to terminate when the loop counter exceeds the stop value (positive increment) or is smaller than the stop value (negative increment).

% sets the first n elements of s to the sequences of values specified by start, stop and increment %

% s( 0 ) is set to the number of elements of s that have been set, in case the sequence ends before n %

testSequence( 2, 2, 0, "Start equal stop: zero increment" );

testSequence( 0, 0, 0, "Start equal stop equal zero: zero increment" )

{{out}}

<pre>

Start equal stop equal zero: zero increment : 0 0 0 0 0 0 0 0 0 0

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f LOOPS_WRONG_RANGES.AWK

BEGIN {

exit(0)

}

{{out}}

-2, 2, 1,Normal : -2 -1 0 1 2

-2, 2, 0,Zero increment : -2 -2 -2 -2 -2 -2 -2 -2 -2 -2

2, 2,-1,Start equal stop: negative increment : 2 1 0 -1 -2 -3 -4 -5 -6 -7

2, 2, 0,Start equal stop: zero increment : 2 2 2 2 2 2 2 2 2 2

 

=={{header|C}}==

C's 'for' statement appears to fit the bill here and so we use it directly to generate the required ranges of numbers though, as some of the ranges will be infinite, we limit the output to a maximum of 10 numbers.

 

#define TRUE 1

}

return 0;

 

{{out}}

{{trans|Visual Basic .NET}}

Behavior for naïve translation is different from VB.NET (and identical to C), as it does not handle an "overshot" iteration variable when the increment is negative.

using System.Collections.Generic;

 

Console.WriteLine();

}

 

{{out|note=identical to C}}

{{trans|C|version=287385}}

Just for fun; some strictly unnecessary changes made to be closer to idiomatic C#.

 

static class Program {

return 0;

}

 

{{out}}

Same as original C.

 

=={{header|Common Lisp}}==

(dolist (lst '((-2 2 1 "Normal") ; Iterate the parameters list `start' `stop' `increment' and `comment'

(-2 2 0 "Zero increment")

(reverse result))) ; The in(de)creased numbers into result

(push i result))) ; Add the number to result

 

{{out}}

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program Wrong_ranges;

 

Example(0, 0, 0, 'Start equal stop equal zero: zero increment');

Readln;

{{out}}

<pre>Normal ------------------------------------------- -2 -1 0 1 2

Version with TEnumerate:

{{libheader| System.SysUtils}}

program Wrong_rangesEnumerator;

 

Example(0, 0, 0, 'Start equal stop equal zero: zero increment');

Readln;

{{out}}

<pre>Normal ------------------------------------------- -2 -1 0 1 2

 

=={{header|Eiffel}}==

example

-- Loops/Wrong ranges

end

 

{{out}}

In this example, we are using the "symbolic form" of the Eiffel across loop, such as: ⟳ ¦ ⟲

=={{header|Factor}}==

<code><range></code> divides by the step value, so a step of 0 causes a divide by zero exception. For the purpose of getting through all the examples, the exceptions are dropped and execution continues, which in general should be avoided.

prettyprint sequences ;

 

[ "%2d %2d %2d <range> => " printf ]

[ try-range ] 3bi

{{out}}

<pre>

0 0 0 <range> => Exception: divide by zero.

</pre>

 

=={{header|Forth}}==

Forth, being a language that assumes a smart programmer, has absolutely no qualms with integer overflow or zero increments; it simply does what you told it to, not what you meant. This is, of course, dangerous code, so another looping construct is provided that ''does'' check whether the bounds and increment are valid.

===DO===

cr rot dup ." start: " 2 .r

rot dup ." stop: " 2 .r

2 2 -1 test-seq

2 2 0 test-seq

{{out}}

Some of these loop infinitely, and some under/overflow, so for the sake of brevity long outputs will be truncated by <code>...</code>.

===?DO===

This is almost exactly the same as the above DO, but the bounds are checked for validity first.

cr rot dup ." start: " 2 .r

rot dup ." stop: " 2 .r

2 2 -1 test-seq

2 2 0 test-seq

{{out}}

Some of these loop infinitely, and some under/overflow, so for the sake of brevity long outputs will be truncated by <code>...</code>. If there is no output beyond the <code>|</code> symbol, then the loop was not entered.

start: 0 stop: 0 inc: 0 |

</pre>

 

=={{header|Go}}==

 

It appears that either #1 or #4 fits the requirements of this task so I've written a function which generates the appropriate sequence using #1 (limited to a maximum of 10 elements as some sequences will be infinite). I've then applied #4 to the resulting sequence. All sequences include the stop value if it's actually reached.

 

import "fmt"

fmt.Println()

}

 

{{out}}

 

=={{header|Haskell}}==

 

main = putStrLn $ showTable True '|' '-' '+' table

top = replicate (length hr) hor

bss = map (\ps -> map (flip replicate ' ') $ zipWith (-) ms ps) $ vss

{{out}}

<pre>+-----+----+---------+-------------------------------------------+---------------------+---------------------------------+

Instantiation of an a priori invalid range is a fatal error.

 

 

class Example {

);

}

 

{{out}}

 

</pre>

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.List;

 

}

{{out}}

<pre>

Start equal stop: zero increment [2, 2, 2, 2, 2, 2, 2, 2, 2, 2] (loops forever)

Start equal stop equal zero: zero increment [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] (loops forever)

</pre>

 

=={{header|Julia}}==

Julia has a start:increment:stop iterator syntax, which allows negative increments, but not zero increments.

collect(-2:1:2) # → [-2, -1, 0, 1, 2]

collect(-2:0:2) # fails

collect(2:0:2) # fails

collect(0:0:0) # fails

 

=={{header|Kotlin}}==

Although Kotlin's 'for' statement can deal with a range of integers, the increment must be positive and so it cannot be used for this task. We therefore use instead a 'while' statement to generate the same sequence as a C language 'for' statement would (limited to a maximum of 10 elements as some sequences will be infinite) and wrap it in a function.

 

class Example(val start: Int, val stop: Int, val incr: Int, val comment: String)

println()

}

 

{{output}}

 

=={{header|langur}}==

 

{{trans|Python}}

start stop increment comment

-2 2 1 Normal

 

var .table = submatches(RE/([^ ]+) +([^ ]+) +([^ ]+) +(.+)\n?/, .data)

for .i in 2..len(.table) {

.table[.i] = map [.f, .f, .f, _], .table[.i]

val .start, .stop, .inc, .comment = .test

{

catch {

} else {

}

}

 

{{out}}

result: []

</pre>

 

=={{header|Maple}}==

seq(-2..2, 1);

 

# Start equal stop equal zero: zero increment

seq(0..0, 0);

{{out}}

<pre>

0

</pre>

 

=={{header|Nim}}==

The following program display the values yielded by “countup” our “countdown” for the given ranges:

 

 

proc displayRange(first, last, step: int) =

(-2, 2, 10), (2, -2, 1), (2, 2, 1),

(2, 2, -1), (2, 2, 0), (0, 0, 0)]:

 

{{out}}

=={{header|Perl}}==

None of these sequences are 'errors', though some are of infinite length, and #5 has a length of zero.

[ -2, 2, 1], #1 Normal

[ -2, 2, 0], #2 Zero increment

return $term > $stop ? '' : $term;

}

{{out}}

<pre>start: -2 stop: 2 incr: 1 | -2 -1 0 1 2

 

=={{header|Phix}}==

The following shows the behaviour of both for and while loops, and the latter has a couple of

additional commented out termination checks that might be appropriate in some cases.

 

{{out}}

<pre>

Start equal stop equal zero: zero increment: {0,0,0,0,0,0,0,0,0,0}

</pre>

=={{header|PL/I}}==

declare i fixed binary;

 

put skip list (' 0 to 0 by 0: infinite loop, prints 0');

 

Output:

<pre>

=={{header|Python}}==

Python has the [https://docs.python.org/3/library/functions.html#func-range range] function.

from itertools import islice # To limit execution if it would generate huge values

# list(islice('ABCDEFG', 2)) --> ['A', 'B']

else:

print(' =', str(values[:22])[:-1], '...')

 

{{out}}

=={{header|R}}==

Aside from the second case, this behaviour is explained by two sentences of seq's documentation: "''generates '''from''', '''from'''+'''by''', ..., up to the sequence value less than or equal to '''to'''. Specifying '''to''' - '''from''' and '''by''' of opposite signs is an error.''" As we can see, '''from''' is always included whenever an error is not thrown and '''to''' will be missed if it cannot be reached.

seq(from = -2, to = 2, by = 0)#Fails: "invalid '(to - from)/by'"

seq(from = -2, to = 2, by = -1)#Fails: As in the notes above - "Specifying to - from and by of opposite signs is an error."

seq(from = 2, to = 2, by = -1)#Output: 2

seq(from = 2, to = 2, by = 0)#Output: 2

 

=={{header|Racket}}==

 

 

(require racket/sandbox)

(with-handlers ([exn:fail:resource? (thunk* 'timeout)])

(with-limits 1 #f

 

{{out}}

Also note: The iterator function for the sequence is literally a function. It is any expression that produces a value. These sequences all use simple arithmatic increments but that is not a limitation of the sequence operator.

 

# start stop inc. Comment

for -2, 2, 1, # Normal

 

# Iterate strings backwards.

{{out}}

<pre>Start: -2, Stop: 2, Increment: 1 | -2 -1 0 1 2

 

The REXX language will cause the '''do''' loop index to be checked at the "head" of the '''do''' loop to see if the index falls within the specified iteration range &nbsp; (if there is one).

@.=; @.1= ' -2 2 1 ' /*"normal". */

@.2= ' -2 2 0 ' /*"normal", zero increment.*/

say center(' end of performing DO loop number ' k " with range: " x y z, 79, '─')

say

{{out|output|:}}

<pre>

─────────── end of performing DO loop number 9 with range: 0 0 0───────────

</pre>

 

=={{header|Ruby}}==

A Range with a step (without a block) results in an ArthmeticSequence (an object). A step size of zero is perfectly valid.

To illustrate, a representation of the ArithmicSequence and it's size are shown.

[ -2, 2, 1],

[ -2, 2, 0],

puts "#{as.inspect} size: #{as.size}"

end

{{out}}<pre>((-2..2).step(1)) size: 5

((-2..2).step(0)) size: Infinity

 

=={{header|Seed7}}==

 

const proc: testLoop (in integer: start, in integer: stop, in integer: incr, in string: comment) is func

testLoop( 2, 2, 0, "Start equal stop: zero increment");

testLoop( 0, 0, 0, "Start equal stop equal zero: zero increment");

 

{{out}}

 

=={{header|Smalltalk}}==

The rest in the code is sugar for a nice output and a breakout if running endless.

 

#(

(-2 2 1 'Normal')

] valueWithExit.

Transcript cr.

{{out}}

<pre>Normal............................................ -2 -1 0 1 2

=={{header|Vala}}==

{{trans|C#}}

const int MAX_ITER = 9;

int iteration = 0;

example(2, 2, 0, "Start equals stop: zero increment");

example(0, 0, 0, "Start equals stop equal zero: zero increment");

 

{{out}}

 

=={{header|VBA}}==

Call Example(-2, 2, 1, "Normal")

Call Example(-2, 2, 0, "Zero increment")

Debug.Print comment & vbCrLf

End Sub

Normal

 

Start equal stop equal zero: zero increment</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var loop = Fn.new { |start, stop, inc|

[-2, 2, 1], [-2, 2, 0], [-2, 2, -1], [-2, 2, 10], [2, -2, 1], [2, 2, 1], [2, 2, -1], [2, 2, 0], [0, 0, 0]

]

 

{{out}}

</pre>

 

 

{{out}}

<pre>

Normal

 

Zero increment

 

Increments away from stop value

 

First increment is beyond stop value

 

Start more than stop: positive increment

 

Start equal stop: positive increment

 

Start equal stop: negative increment

 

Start equal stop: zero increment

 

Start equal stop equal zero: zero increment

</pre>

 

 

=={{header|zkl}}==

// if stop is "*", the loop is has no end (ie infinite)

// stop is included unless step steps skips it

T( 2,2,1),T( 2,2,-1),T( 2,2,0),T( 0,0,0),

T(0.0, (0.0).pi, 0.7853981633974483), T("a","e",1), T("e","a",1) )

{{out}}

<pre>