Loops/Increment loop index within loop body: Difference between revisions

{{trans|Python}}

 

L(x) (2, 3)

I n % x == 0

print(‘n = #2 #16’.format(n, i))

i += i - 1

 

{{out}}

This task is a good example of the use of ED instruction to format a number.

For macro use (IF,DO,...), see [[360_Assembly_macros#360_Assembly_Structured_Macros|Structured Macros]].

LOOPILWB PROLOG

SR R6,R6 i=0

ZN DS CL20

REGEQU

{{out}}

<pre style="height:40ex">

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopinc64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

=={{header|Ada}}==

Ada does not allow the loop counter of a FOR loop to be modified in the loop. This example uses a simple Ada loop. The example also uses an Ada fixed decimal type to provide the comma insertion for the output.

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

with Ada.Text_IO.Editing; use Ada.Text_IO.Editing;

end loop;

end Main;

{{output}}

<pre>

=={{header|ALGOL 68}}==

In Algol 68, the FOR loop counter cannot be modified in the loop. This uses a WHILE loop testing at the top but is otherwise largely a translation of the Kotlin entry.

# returns TRUE if n is prime, FALSE otherwise #

PROC is prime = ( LONG INT n )BOOL:

i +:= 1

OD

{{out}}

<pre>

n = 41 49752014150467

n = 42 99504028301131

</pre>

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program loopinc96.s */

pop {r4,r5,lr} @ restaur registers

bx lr @ return

{{out}}

<Pre>

=={{header|Arturo}}==

{{trans|Python}}

n: 0

 

i: i + 1

]

{{out}}

<pre>n = 1 43

 

=={{header|AutoHotkey}}==

while (n<43){

if isPrime(i)

}

return true

{{out}}

<pre>1: 43

 

=={{header|AWK}}==

# syntax: GAWK -f LOOPS_INCREMENT_LOOP_INDEX_WITHIN_LOOP_BODY.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

 

=={{header|BASIC256}}==

if (number % 2 = 0) or (number % 3 = 0) then return false

lim = sqr(number)

i += 1

end while

 

 

 

The 'thousands separator' aspect (using the ' flag in printf and setting the locale appropriately) works fine when compiled with gcc on Ubuntu 14.04 but may not work on some other systems as this is not a standard flag.

#include <locale.h>

 

}

return 0;

 

{{out}}

 

=={{header|C sharp|C#}}==

using System;

using System.Globalization;

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include "stdafx.h"

#include <iostream>

}

return 0;

 

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

(defun primep (n) ; https://stackoverflow.com/questions/15817350/

(cond ((= 2 n) t) ; Hard-code "2 is a prime"

(format t "~&~5<~d~;->~>~20<~:d~>" c i) ; Display count of primes found and the prime

(incf i (decf i))))) ; Increment index to previous index plus the prime

{{out}}

<pre>

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Increment_loop_index_within_loop_body;

 

end;

readln;

{{out}}

Same of [[#C#]].

=={{header|Dyalect}}==

 

if number <= 1 {

return false

}

i += 1

 

Output:

n = 41 49752014150467

n = 42 99504028301131</pre>

 

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Well I don't do loops. Nigel Galloway: March 17th., 2019. Let me try to explain where the loopy variables are, for the imperatively constrained.

// cUL allows me to claim the rather trivial extra credit (commas in the numbers)

// unfold is sort of a loop with fG as an internal loop incremented by the exit value of the internal loop in this case.

Seq.unfold(fun n->let n=fG n in Some(n,n+n)) 42UL|>Seq.take 42|>Seq.iteri(fun n g->printfn "%2d -> %s" (n+1) (cUL g))

{{out}}

<pre>

Explicit loop indices are non-idiomatic, but Factor is certainly capable of using them. Factor has a for loop near-equivalent, <code><range> [ ] each</code>, but since it doesn't mesh well with mutation, a while loop is used.

=== Using two numbers on the data stack ===

tools.memory.private ;

IN: rosetta-code.loops-inc-body

[ 1 + ] dip

] while

=== Using lexical variables ===

Factor provides lexical variables for situations where they improve readability.

tools.memory.private ;

IN: rosetta-code.loops-inc-body

i 1 + i!

] while

{{out}}

<pre>

=={{header|Fortran}}==

Fortran does not allow to modify the index inside the loop.

write(*,*) i

i=i+1

<pre>

Error - I is currently being used as a DO or implied DO control variable

 

===Fortran 95===

integer*8 n

imax=42

return

EndIf

{{out}}

<pre style="height:60ex">

===Fortran IV===

The limit is set to 25 due to the size of integer in Fortran IV.

IMAX=25

I=0

50 ISPRIME=1

RETURN

{{out}}

<pre style="height:60ex">

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre style="height:40ex">n = 1 43

 

The 'thousands separator' aspect is dealt with by a couple of external packages (in the 'import' declarations) which can be installed using 'go get'.

 

import(

}

}

 

{{out}}

Same as Kotlin entry

</pre>

=={{header|Haskell}}==

No index mutations or loops. Recursion is used.

import Control.Monad (guard)

 

display (i, p) = show i ++ " " ++ digitGroup p

 

{{out}}

<pre>

And for minor variation, we could import isPrime from Data.Numbers.Primes, and define the comma-grouping of large integers in terms of chunksof:

 

import Data.List (intercalate)

import Data.List.Split (chunksOf)

 

main :: IO ()

 

=={{header|Haxe}}==

Haxe's for-loop does allow the index to be modified in the body of the loop, so a while-loop is used instead.

import haxe.Int64;

 

}

}

 

{{out}}

 

=={{header|J}}==

isPrime =: 1&p:

assert 1 1 0 -: isPrime 2 3 4 NB. test and example

n

)

Store the vector of indexes using its tail as the current index, removing the `n' variable. In doing so the last item of `i' is not part of the solution, hence change less than to less or equal, and discard the tail value. Also extract the conversion to extended precision x: .

loop =: verb define@:x:

i =. y

}: i

)

 

Replace the "if" statement with a computation. This one works by appending onto the solution vector isPrime copies of the proposed new index.

loop =: verb define@:x:

i =. y

}: i

)

Names are an issue brought forth in the j forums. Names have most meaning to the person who wrote them, so there's a bit of J philosophy that says "show the code". J doesn't enforce "code only", and definitions can encapsulate useful chunks of code. If the names I've chosen don't work in your experience or language you could replace them with `a' and `b'.

save_if_prime =: , (isPrime # _1 2&p.)@:{:

increment_tail =: _1&(>:@:{`[`]})

}: i

)

Why make two assignments when j can increment at save?

loop =: verb define@:x:

i =. y

}: i

)

Next replace the while loop with double application of J's generalized power conjunction.

While =: conjunction def 'u^:(0~:v)^:_'

 

}: increment_tail@:save_if_prime While(y >: #) i

)

By inspection the variable `i' doesn't contribute anything useful whatsoever. The verb's argument, y, remains.

Finally, implemented as an hook [http://www.jsoftware.com/help/dictionary/dictf.htm verb trains] with 'y' and `i' as left ([) and right (]) arguments the complete definitions for tacit_loop are

isPrime =: 1&p:

save_if_prime =: , (isPrime # _1 2&p.)@:{:

While =: conjunction def 'u^:(0~:v)^:_'

tacit_loop =: [: }: (increment_tail@:save_if_prime@:]While(>: #) x:)

Include the index numbers with demonstration:

9!:37 ] 0 2048 0 222 NB. output control permit lines of 2^11 columns

 

[: }: (_1&(>:@:{`[`]})@:(, (1&p: # _1 2&p.)@:{:)@:]^:(0 ~: (>: #))^:_ x:)

If the loop must require the output side effect, this save_if_prime definition does the trick. Without the output hook it is probably more efficient than the copying version because it evaluates the hook <pre>(, _1 2&p.@:{:)</pre> only when isPrime is true.

extra_credit =: ([: }. ,@(',' ,.~ _3 [\ ])&.|.@:":)&>

show =: [ ([: echo@:deb@:({. , ' ' , {:)@:extra_credit # , {:)

41 49,752,014,150,467

42 99,504,028,301,131

 

=={{header|Java}}==

The following uses a 'for' rather than a 'do/while' loop but otherwise is similar to the Kotlin

entry.

 

static final int LIMIT = 42;

}

}

 

{{out}}

Same as Kotlin entry

</pre>

 

=={{header|Julia}}==

Julia's <code>for</code> loop iterator is an iterator type which cannot be incremented as a simple variable would to change looping.

 

function doublemyindex(n=42)

 

doublemyindex()

The index is 1 and 43 is prime.

The index is 2 and 89 is prime.

 

So instead we use a do/while loop here which has no such restrictions.

 

fun isPrime(n: Long): Boolean {

}

while (n < 42)

{{out}}

<pre style="height:35ex">n = 1 43

The following version uses a tail recursive function rather than a while loop to achieve the same effect:

 

 

fun isPrime(n: Long): Boolean {

fun main(args: Array<String>) {

loop(42, 0)

 

{{out}}

Same as 'while' loop version.

</pre>

 

=={{header|Lua}}==

function isPrime (x)

if x < 2 then return false end

end

i = i + 1

{{out}}

<pre>n = 1 43

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Function IsPrime (x) {

}

CheckIt

 

{{out}}

=={{header|Maple}}==

A translation of Kotlin entry

count := 0:

while(count < 42) do

i := 2*i -1:

end if:

{{Out|Output}}

<pre>n=1 43

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

While[n < 42,

If[PrimeQ[i],

];

i++;

{{out}}

<pre>n=0 43

=={{header|Microsoft Small Basic}}==

Small Basic allows to modify the index inside the loop.

imax=42

i=0

nn=Text.GetSubText(space,1,Text.GetLength(space)-Text.GetLength(nn))+nn

ret_format_n=nn

{{out}}

<pre style="height:60ex">

=={{header|Nanoquery}}==

{{trans|Java}}

 

def isPrime(n)

i += i - 1

end

 

{{out}}

 

=={{header|NewLISP}}==

#! /usr/local/bin/newlisp

 

 

(exit)

 

<pre>

=={{header|Nim}}==

In Nim, loop index is read-only, so we have to use a normal variable and increment it as needed.

import strformat

from strutils import insertSep

 

main()

{{out}}

<pre style="height:50ex">

{{trans|Kotlin}}

{{libheader|ntheory}}

 

$i = 42;

$s =~ s/,$//;

$s = reverse $s;

{{out}}

<pre style="height:30ex"> 1 43

=={{header|Phix}}==

Phix does not allow for loop variables to be modified, so we must use a while loop and manual increment for this sort of thing.

<span style="color: #004080;">atom</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">42</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span>

<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">42</span> <span style="color: #008080;">do</span>

<span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

{{out}}

<pre>

=={{header|Python}}==

===Procedural===

for x in 2, 3:

if not n % x:

print('n = {:2} {:20,}'.format(n, i))

i += i - 1

{{out}}

<pre>n = 1 43

This task is defined in terms of procedural 'loops', which can generally be understood in functional terms as implementations of folds or maps. An analogous functional construction here might be a non-finite generator, or the iterative application of a function (over a tuple of values) to a seed value, for example:

 

 

from itertools import islice, takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> 1 -> 43

41 -> 49,752,014,150,467

42 -> 99,504,028,301,131</pre>

=={{header|R}}==

{

{

}

{{Out}}

<pre>Prime count: 1; The prime just found was: 43

Prime count: 41; The prime just found was: 49,752,014,150,467

Prime count: 42; The prime just found was: 99,504,028,301,131</pre>

=={{header|Racket}}==

 

Racket's <code>for</code> doesn't allow modification of index on the fly. The usual idiom for writing this kind of loop is to use named let, as shown here.

 

 

(require math/number-theory)

[(prime? x) (printf "~a: ~a\n" (add1 cnt) (comma x))

(loop (* 2 x) (add1 cnt))]

 

{{out}}

The ''best'' way is probably to not use an explicit loop. Just calculate the sequence directly.

 

my @seq = grep *.is-prime, (42, { .is-prime ?? $_+<1 !! $_+1 } … *);

 

# display code

{{out}}

<pre>1 43

 

=={{header|REXX}}==

numeric digits 20; d=digits() /*ensure enough decimal digits for Z. */

parse arg limit . /*obtain optional arguments from the CL*/

do j=5 by 6 until j*j>#; if # // j==0 | # // (J+2)==0 then return 0

end /*j*/ /* ___ */

{{out|output}}

<pre>

 

=={{header|Ring}}==

# Project : Loops/Increment loop index within loop body

 

i = i + 1

end

Output:

<pre>

n = 41 49,752,014,150,467

n = 42 99,504,028,301,131</pre>

 

=={{header|Ruby}}==

require 'prime'

end

end

Output :

<pre>

So instead we use tail recursion here which, with the use of immutable variables and no side effects, has no such restrictions, and we are save.

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/4HJPkBM/1 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/yzqldLOuRriR6ojqLKaYPQ Scastie (remote JVM)].

 

object LoopIncrementWithinBody extends App {

 

loop(limit, offset)

 

=={{header|Seed7}}==

const func boolean: isPrime (in integer: number) is func

end if;

end for;

 

{{out}}

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

idx := 42.

[:exit |

numFound == 42 ifTrue:exit

].

Note: above code uses a public domain printf goodie which is part of many Smalltalk's base libraries; if not present in a particular dialect, use regular print/display/transcribe or whatever is available.

{{out}}

 

=={{header|Standard ML}}==

fun until done change dolast x =

if done x

 

val printp = fn clist:(int*IntInf.int) list =>

call <pre>

printp (loop ()) ;

41 : 49752014150467

42 : 99504028301131</pre>

=={{header|Tcl}}==

Inspired by Java and Kotlin variants.

 

Tcl allows modifying the loop variable. Everything can be implemented straightforward.

if {[expr $n % 2] == 0} {

return [expr $n == 2]

incr i [expr $i -1]

}

{{Out}}

<pre>n=1, i=43

{{trans|Visual Basic .NET}}

{{works with|VBA|VBA Excel 2013}}

'Loops Increment loop index within loop body - 17/07/2018

Dim imax, i As Integer

Function RightX(c, n)

RightX = Right(Space(n) & c, n)

{{out}}

<pre style="height:60ex">

{{trans|Visual Basic}}

{{works with|Visual Basic .NET|2013}}

 

Sub Main()

End Function

 

{{out}}

<pre style="height:60ex">i= 1 : 43

i=41 : 49,752,014,150,467

i=42 : 99,504,028,301,131</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

Although it might appear as though one can change the index variable within a ''for'' loop, it does in fact change a local copy of the variable and the iteration is not affected at all. Consequently, the only way to complete this task in Wren is to use a ''while'' loop.

 

var isPrime = Fn.new { |n|

}

i = i + 1

 

{{out}}

41: 49,752,014,150,467

42: 99,504,028,301,131

</pre>

 

Uses libGMP (GNU MP Bignum Library) for easy prime detection

rather than write that bit of code and pollute this solution.

n,p := 1,BN(42);

do{

if(p.probablyPrime()){ println("n = %2d %,20d".fmt(n,p)); p.add(p); n+=1; }

p.add(1);

zkl loop variables are iterators that don't allow direct manipulation of

their underlying source. The compiler names these iterators __<index>Walker.

However, by using the look ahead stack, we can keep the iterator from

advancing through the source.

foreach n in ([1..42]){

if(p.probablyPrime()){ println("n = %2d %,20d".fmt(n,p)); p.add(p); }

else{ p.add(1); __nWalker.push(n); } // p not prime, don't advance n

{{out}}

<pre style="height:35ex">