Numbers with equal rises and falls: Difference between revisions

{{trans|Python}}

 

‘Check whether a number belongs to sequence A296712.’

V height = 0

L 0 .< 10'000'000 - 200 - 1

nextNum()

 

{{out}}

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

 

=={{header|Ada}}==

with Ada.Integer_Text_Io;

 

Value := Value + 1;

end loop;

{{out}}

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

 

=={{header|AutoHotkey}}==

count := 0, result1 := result1 := ""

loop{

if (fall = rise)

return 1

{{out}}

<pre>The first 200 numbers in the sequence:

 

=={{header|AWK}}==

# syntax: GAWK -f NUMBERS_WITH_EQUAL_RISES_AND_FALLS.AWK

# converted from Go

return(rises == falls)

}

{{out}}

<pre>

</pre>

 

 

 

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

return 0;

 

{{out}}

 

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

#include <iostream>

 

}

std::cout << "\nThe " << limit2 << "th number in the sequence is " << n << ".\n";

 

{{out}}

 

=={{header|CLU}}==

rises_falls = proc (n: int) returns (int,int)

rises: int := 0

end

end

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 11

 

=={{header|Cowgol}}==

 

# return the change in height of a number

print("The 10,000,000th number is: ");

print_i32(number);

 

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

The 10,000,000th number is: 41909002

</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|Java}}==

public static void main(String[] args) {

final int limit1 = 200;

return total == 0;

}

 

{{out}}

(*) gojq requires a very large amount of memory for computing the 10 millionth number in the sequence.

 

. as $n

| if . < 10 then true

 

"\nThe 10 millionth number in the sequence is \(

{{out}}

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

 

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

EqualRisesAndFallsQ[n_Integer] := Total[Sign[Differences[IntegerDigits[n]]]] == 0

Take[Select[Range[1000], EqualRisesAndFallsQ], 200]

,

{i, 50 10^6}

{{out}}

<pre>{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,153,154,160,161,162,163,164,165,170,171,172,173,174,175,176,180,181,182,183,184,185,186,187,190,191,192,193,194,195,196,197,198,201,202,203,204,205,206,207,208,209,212,213,214,215,216,217,218,219,222,230,231,232,240,241,242,243,250,251,252,253,254,260,261,262,263,264,265,270,271,272,273,274,275,276,280,281,282,283,284,285,286,287,290,291,292,293,294,295,296,297,298,301,302,303,304,305,306,307,308,309,312,313,314,315,316,317,318,319,323,324,325,326,327,328,329,333,340,341,342,343,350,351,352,353,354,360,361,362,363,364,365,370,371,372,373,374,375,376,380,381,382,383,384,385,386,387,390,391,392,393,394,395,396,397,398,401,402,403,404}

 

=={{header|Nim}}==

 

func insequence(n: Positive): bool =

elif pos == 10_000_000:

echo "\nTen millionth number in the sequence: ", n

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

rf(++$n) or $count++;

}

{{out}}

<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.*/

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

 

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

<pre>

</pre>

 

=={{header|Sidef}}==

var diffs = arr.map_cons(2, {|a,b| a - b })

diffs.count { .is_pos } == diffs.count { .is_neg }

say "\nThe #{n.commify}-th term (base #{base}): #{

n.th { isok(.digits(base)) && .is_pos }.commify}"

{{out}}

<pre>

 

=={{header|Swift}}==

 

func equalRisesAndFalls(_ n: Int) -> Bool {

}

}

 

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var risesEqualsFalls = Fn.new { |n|

}

n = n + 1

 

{{out}}

 

=={{header|XPL0}}==

int N, R, F, D, D0;

[R:= 0; F:= 0;

N:= N+1;

];

 

{{out}}