Numbers with equal rises and falls: Difference between revisions

 

 

 

;See also:

 

 

 

 

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

 

putch: equ 2

org 100h

num: db '0 $'

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

 

{{out}}

=={{header|8086 Assembly}}==

 

cpu 8086

bits 16

;;; Current number, stored as ASCII

db 0,0,0,0,0,0,0,0

 

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

=={{header|Forth}}==

 

0 swap \ height

10 /mod \ digit and rest of number

." The first 200 numbers are: " two-hundred cr cr

." The 10,000,000th number is: " ten-million . cr

 

{{out}}

=={{header|Fortran}}==

 

INTEGER IDX, NUM, I

* Index and number start out at zero

IN SEQ = HEIGHT.EQ.0

RETURN

 

{{out}}

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

 

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

=={{header|MAD}}==

 

VECTOR VALUES FMT = $I8,1H:,I9*$

PRINT FORMAT FMT, I, J

 

{{out}}

200: 404

10000000: 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;

 

put "Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): ",

$upto.map({rf(+$base, Any, &infix:«<»)[.exp(10) - 1].&to-base($base)}).join: ', '

{{out}}

<pre>Rise = Fall:

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>