Numbers with equal rises and falls: Difference between revisions

 

 

 

 

=={{header|8080 Assembly}}==

 

putch: equ 2

org 100h

num: db '0 $'

;;; 24-bit counter to keep track of ten million

 

{{out}}

The 10,000,000th number is: 41909002 </pre>

 

 

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

{{trans|Wren}}... with a single counter for rises and falls.

# returns TRUE if the number of digits in n followed by a higher digit (rises) #

# equals the number of digits followed by a lower digit (falls) #

OD

END

{{out}}

<pre>

{{works with|Dyalog APL}}

 

⍝ Determine if a number is in the sequence

inSeq←0=(+/2(<->)/10(⊥⍣¯1)⊢)

⍞←'The 10,000,000th number is: '

⎕←1e7{⍺=0:⍵-1 ⋄ (⍺-inSeq ⍵)∇ ⍵+1}1

 

{{out}}

41909002</pre>

 

 

 

/* Check whether a number has an equal amount of rises

return 0;

 

{{out}}

 

The 10,000,000th number is: 41909002</pre>

 

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

// A296712. Nigel Galloway: October 9th., 2020

let fN g=let rec fN Ψ n g=match n,Ψ with (0,0)->true |(0,_)->false |_->let i=n%10 in fN (Ψ + (compare i g)) (n/10) i in fN 0 g (g%10)

A296712|>Seq.take 200|>Seq.iter(printf "%d "); printfn"\n"

[999999;9999999;99999999]|>List.iter(fun n->printfn "The %dth element is %d" (n+1) (Seq.item n A296712))

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-08-14}}

prettyprint tools.memory.private ;

 

 

"The 10 millionth number in OEIS:A296712 is " write

{{out}}

<pre>

 

The 10 millionth number in OEIS:A296712 is 41,909,002

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

n++

}

 

{{out}}

=={{header|Haskell}}==

 

 

pairs :: [a] -> [(a,a)]

putStr "The 10,000,000th number is: "

putStrLn $ show $ a296712 !! 9999999

 

{{out}}

The 10,000,000th number is: 41909002

</pre>

 

=={{header|Julia}}==

 

function rises_and_falls(n)

function genA296712(N, M)

A296712 = filter(isA296712, Lazy.range(1));

j = 0

for i in take(200, A296712)

 

genA296712(200, 10_000_000)

<pre>

1 2 3 4 5 6 7 8 9 11 22 33 44 55 66 77 88 99 101 102

The 10000000-th number in sequence A296712 is 41909002.

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Python}}==

 

 

def riseEqFall(num):

# It is necessary to subtract 200 from the index, because 200 numbers

# have already been consumed.

 

{{out}}

</pre>

 

 

=={{header|Raku}}==

{{works with|Rakudo|2020.09}}

 

use Base::Any;

 

my %batch = batch => $batch if $batch;

my int ($this, $last) = $_, $_ % $base;

my int ($rise, $fall) = 0, 0;

$last = $rem

}

$_

}

}

 

my $upto = 200;

.put for rf[^$upto]».fmt("%3d").batch(20);

 

$upto = 10_000_000;

 

-> $base, $oeis {

{{out}}

1 2 3 4 5 6 7 8 9 11 22 33 44 55 66 77 88 99 101 102

103 104 105 106 107 108 109 111 120 121 130 131 132 140 141 142 143 150 151 152

381 382 383 384 385 386 387 390 391 392 393 394 395 396 397 398 401 402 403 404

 

 

 

=={{header|REXX}}==

To do the heavy lifting, &nbsp; this REXX program constructs a table of every two-digit sequence which indicates a

<br>'''rise''' &nbsp; (+1), &nbsp; &nbsp; '''fall''' &nbsp; (-1), &nbsp; &nbsp; or &nbsp; '''neither''' &nbsp; (0).

parse arg n . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 200 /*Not specified? Then use the default.*/

n= abs(n) /*use the absolute value of N. */

call init /*initialize the rise/fall database. */

s= 0 /*initialize the sum of rises/falls. */

if s\==0 then iterate /*Equal # of rises & falls? Then add it*/

#= # + 1 /*bump the count of numbers found. */

if append then $= $ j /*append to the list of numbers found. */

end /*j*/

 

if append then call show /*display a list of N numbers──►term.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

init: @.= 0; do i=1 for 9; _= i' '; @._= 1; _= '0'i; @._= +1; end /*i*/

end /*o*/ /* [↑] display 20 numbers to a line.*/

 

{{out|output|text=&nbsp; when using the default input:}}

<pre>

<pre>

the 10,000,000th number is: 41,909,002

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var risesEqualsFalls = Fn.new { |n|

}

n = n + 1

 

{{out}}

 

The 10 millionth number in the sequence is 41,909,002.

</pre>