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>

=={{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:

=={{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}}

=={{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}}==

Fun with j. The verb tacit_loop implements the computation.

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

Now derive it from the python solution. The monadic verb loop fairly straightforwardly matches the python solution except that loop returns the vector of computed values rather than displays them.

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}}

This entry uses the jq implementation of is_prime as shown at

[[Erd%C5%91s-primes#jq]].

| while( .count <= 42;

.emit = null

else .

end )

{{out}}

<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}}

=={{header|Ksh}}==

#!/bin/ksh

(( i+=$i ))

fi

{{out}}<pre>

43 is prime, 1 primes found(so far)

=={{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

=={{header|R}}==

R cannot complete this task with a for loop. See https://stackoverflow.com/a/5913329/ . Instead, we must go down the same path as the Kotlin solution. Because it is sufficient for numbers this small, we will save ourselves some work and use the gmp library's isprime function for checking if a number is prime.

primeCount <- 0

while(primeCount < 42)

}

i <- i + 1

{{Out}}

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

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>

=={{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 ()) ;

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

=={{header|Vlang}}==

{{trans|go}}

if n % 2 == 0 {

return n == 2

}

}

{{out}}

{{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}}

=={{header|Yabasic}}==

counter = 0

while counter < 42

wend

return True

=={{header|zkl}}==

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">