aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Numbers-with-equal-rises-and-falls/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Numbers_with_equal_rises_and_falls

27
Task/Numbers-with-equal-rises-and-falls/00-TASK.txt Normal file
View file

@ -0,0 +1,27 @@
When a number is written in base 10,   adjacent digits may "rise" or "fall" as the number is read   (usually from left to right).
;Definition:
Given the decimal digits of the number are written as a series &nbsp; <big>d</big>:
:* &nbsp; A &nbsp; ''rise'' &nbsp; is an index &nbsp; <big>i</big> &nbsp; such that &nbsp; <big> d(i) &nbsp;&lt;&nbsp; d(i+1)</big>
:* &nbsp; A &nbsp; ''fall''&nbsp; &nbsp; is an index &nbsp; <big>i</big> &nbsp; such that &nbsp; <big> d(i) &nbsp;&gt;&nbsp; d(i+1)</big>
;Examples:
:* &nbsp; The number &nbsp; '''726,169''' &nbsp; has &nbsp; '''3''' &nbsp; rises and &nbsp; '''2''' &nbsp; falls, &nbsp; so it <u>isn't</u> in the sequence.
:* &nbsp; The number &nbsp; &nbsp; '''83,548''' &nbsp; has &nbsp; '''2''' &nbsp; rises and &nbsp; '''2''' &nbsp; falls, &nbsp; so it &nbsp; <u>is</u> &nbsp; in the sequence.
;Task:
:* &nbsp; Print the first &nbsp; '''200''' &nbsp; numbers in the sequence
:* &nbsp; Show that the &nbsp; '''10 millionth''' &nbsp; (10,000,000<sup>th</sup>) &nbsp; number in the sequence is &nbsp; '''41,909,002'''
;See also:
* &nbsp; OEIS Sequence &nbsp;[[OEIS:A296712|A296712]] &nbsp; describes numbers whose digit sequence in base 10 have equal "rises" and "falls".
;Related tasks:
* &nbsp; [[Esthetic_numbers|Esthetic numbers]]
<br><br>

28
Task/Numbers-with-equal-rises-and-falls/11l/numbers-with-equal-rises-and-falls.11l Normal file
View file

@ -0,0 +1,28 @@
F riseEqFall(=num)
‘Check whether a number belongs to sequence A296712.’
V height = 0
V d1 = num % 10
num I/= 10
L num != 0
V d2 = num % 10
height += (d1 < d2) - (d1 > d2)
d1 = d2
num I/= 10
R height == 0
V num = 0
F nextNum()
L
:num++
I riseEqFall(:num)
L.break
R :num
print(‘The first 200 numbers are:’)
L 200
print(nextNum(), end' ‘ ’)
print()
L 0 .< 10'000'000 - 200 - 1
nextNum()
print(‘The 10,000,000th number is: ’nextNum())

85
Task/Numbers-with-equal-rises-and-falls/8080-Assembly/numbers-with-equal-rises-and-falls.8080 Normal file
View file

@ -0,0 +1,85 @@
puts: equ 9 ; CP/M calls
putch: equ 2
org 100h
;;; Print first 200 numbers
lxi d,first
mvi c,puts
call 5
mvi b,200 ; 200 numbers
f200: push b
call next ; Get next number
call pnum ; Print the number
pop b ; Restore counter
dcr b ; Are we there yet?
jnz f200 ; If not, next number
;;; Find 10,000,000th number
lxi d,tenmil
mvi c,puts
call 5
f1e7: call next ; Keep generating numbers until ten million reached
jnz f1e7 ; Then print the number
;;; Print the current number
pnum: lxi d,num
pscan: dcx d ; Scan for zero
ldax d
ana a
jnz pscan
mvi c,puts ; Once found, print string
jmp 5
;;; Increment number until rises and falls are equal
next: lxi h,num
incdgt: mov a,m ; Get digit
ana a ; If 0, then initialize
jz grow
inr a ; Otherwise, increment
mov m,a ; Store back
cpi '9'+1 ; Rollover?
jnz idone ; If not, we're done
mvi m,'0' ; If so, set digit to 0
dcx h ; And increment previous digit
jmp incdgt
grow: mvi m,'1'
idone: lxi h,num ; Find rises and falls
mvi b,0 ; B = rises - falls
mov c,m ; C = right digit in comparison
pair: dcx h
mov a,m ; A = left digit in comparison
ana a ; When zero, done
jz check
cmp c ; Compare left digit to right digit
jc fall ; A<C = fall
jnz rise ; A>C = rise
nxdgt: mov c,a ; C is now left digit
jmp pair ; Check next pair
fall: dcr b ; Fall: decrement B
jmp nxdgt
rise: inr b ; Rise: increment B
jmp nxdgt
check: mov a,b ; If B=0 then rises and falls are equal
ana a
jnz next ; Otherwise, increment number and try again
lxi h,ctr ; But if so, decrement the counter to 10 million
mov a,m ; First byte
sui 1
mov m,a
inx h ; Second byte
mov a,m
sbb b ; B=0 here
mov m,a
inx h ; Third byte
mov a,m
sbb b
mov m,a
dcx h ; OR them together to see if the number is zero
ora m
dcx h
ora m
ret
;;; Strings
first: db 'The first 200 numbers are:',13,10,'$'
tenmil: db 13,10,10,'The 10,000,000th number is: $'
;;; Current number (stored as ASCII)
db 0,0,0,0,0,0,0,0
num: db '0 $'
;;; 24-bit counter to keep track of ten million
ctr: db 80h,96h,98h ; 1e7 = 989680h

78
Task/Numbers-with-equal-rises-and-falls/8086-Assembly/numbers-with-equal-rises-and-falls.8086 Normal file
View file

@ -0,0 +1,78 @@
puts: equ 9 ; MS-DOS print string
cpu 8086
bits 16
org 100h
section .text
mov bp,98h ; BP:DI = 989680h = ten million
mov di,9680h
;;; Print first 200 numbers
mov dx,first ; Print message
mov ah,puts
int 21h
n200: call next ; Get next number
call pnum ; Print the number
cmp di,95B8h ; Have we had 200 yet?
ja n200 ; If not, print next number
;;; Print the 10 millionth number
mov dx,tenmil ; Print message
mov ah,puts
int 21h
n1e7: call next ; Get next number
jnz n1e7 ; Until we have the 10 millionth
;;; Print the current number
pnum: std ; Read backwards
xchg si,di ; Keep DI safe
mov di,num
mov cx,9
xor al,al ; Find the first zero
repnz scasb
inc di ; Go to first digit
inc di
xchg si,di ; Put DI back
mov dx,si ; Call DOS to print the number
mov ah,puts
int 21h
ret
;;; Increment number until rises and falls are equal
next: std ; Read number backwards
.inc: mov bx,num
.iloop: mov al,[bx] ; Get digit
test al,al ; If uninitialized, write a 1
jz .grow
inc ax ; Otherwise, increment
mov [bx],al ; Write it back
cmp al,'9'+1 ; Rollover?
jnz .idone ; If not, the increment is done
mov [bx],byte '0' ; But if so, this digit should be 0,
dec bx ; and the next digit incremented.
jmp .iloop
.grow: mov [bx],byte '1' ; The number gains an extra digit
.idone: xor bl,bl ; BL = rise and fall counter
mov si,num
lodsb ; Read first digit to compare to
.pair: xchg ah,al ; Previous digit to compare
lodsb ; Read next digit
test al,al ; Done yet?
jz .done
cmp al,ah ; If not, compare the digits
ja .fall ; If they are different,
jb .rise ; there is a fall or a rise
jmp .pair ; Otherwise, try next pair
.fall: dec bl ; Fall: decrement BL
jmp .pair
.rise: inc bl ; Rise: increment BL
jmp .pair
.done: test bl,bl ; At the end, check if BL is zero
jnz .inc ; If not, try next number
sub di,1 ; Decrement the million counter in BP:DI
sbb bp,0
mov ax,di ; Test if BP:DI is zero
or ax,bp
ret
section .data
;;; Strings
first: db 'The first 200 numbers are:',13,10,'$'
tenmil: db 13,10,10,'The 10,000,000th number is: $'
;;; Current number, stored as ASCII
db 0,0,0,0,0,0,0,0
num: db '0 $'

37
Task/Numbers-with-equal-rises-and-falls/ALGOL-68/numbers-with-equal-rises-and-falls.alg Normal file
View file

@ -0,0 +1,37 @@
BEGIN
# 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) #
# FALSE otherwise #
PROC rises equals falls = ( INT n )BOOL:
BEGIN
INT rf := 0;
INT prev := n MOD 10;
INT v := n OVER 10;
WHILE v > 0 DO
INT d = v MOD 10;
IF d < prev THEN
rf +:= 1 # rise #
ELIF d > prev THEN
rf -:= 1 # fall #
FI;
prev := d;
v OVERAB 10
OD;
rf = 0
END; # rises equals falls #
# task tests #
print( ( "The first 200 numbers in the sequence are:", newline ) );
INT count := 0;
INT max count = 10 000 000;
FOR n WHILE count < max count DO
IF rises equals falls( n ) THEN
count +:= 1;
IF count <= 200 THEN
print( ( whole( n, -4 ) ) );
IF count MOD 20 = 0 THEN print( ( newline ) ) FI
ELIF count = max count THEN
print( ( newline, "The 10 millionth number in the sequence is ", whole( n, -8 ), ".", newline ) )
FI
FI
OD
END

16
Task/Numbers-with-equal-rises-and-falls/APL/numbers-with-equal-rises-and-falls.apl Normal file
View file

@ -0,0 +1,16 @@
risefall←{
⍝ Determine if a number is in the sequence
inSeq←0=(+/2(<->)/10(⊥⍣¯1)⊢)
⍝ First 200 numbers
⎕←'The first 200 numbers are:'
⎕←(⊢(/⍨)inSeq¨)⍳404
⍝ 10,000,000th number
⍝ You can't just make a list that big and filter
⍝ it, because that will just get you a WS FULL.
⍝ Instead it's necessary to loop over them the old-
⍝ fashioned way
⍞←'The 10,000,000th number is: '
⎕←1e7{⍺=0:⍵-1 ⋄ (⍺-inSeq ⍵)∇ ⍵+1}1
}

40
Task/Numbers-with-equal-rises-and-falls/AWK/numbers-with-equal-rises-and-falls.awk Normal file
View file

@ -0,0 +1,40 @@
# syntax: GAWK -f NUMBERS_WITH_EQUAL_RISES_AND_FALLS.AWK
# converted from Go
BEGIN {
print("1-200:")
while (1) {
if (rises_equals_falls(++n)) {
if (++count <= 200) {
printf("%4d",n)
if (count % 20 == 0) {
printf("\n")
}
}
if (count == 1E7) {
printf("\n%d: %d",count,n)
break
}
}
}
exit(0)
}
function rises_equals_falls(n, d,falls,prev,rises) {
if (n < 10) {
return(1)
}
prev = -1
while (n > 0) {
d = n % 10
if (prev >= 0) {
if (d < prev) {
rises++
}
else if (d > prev) {
falls++
}
}
prev = d
n = int(n / 10)
}
return(rises == falls)
}

44
Task/Numbers-with-equal-rises-and-falls/Ada/numbers-with-equal-rises-and-falls.ada Normal file
View file

@ -0,0 +1,44 @@
with Ada.Text_Io;
with Ada.Integer_Text_Io;
procedure Equal_Rise_Fall is
use Ada.Text_Io;
function Has_Equal_Rise_Fall (Value : Natural) return Boolean is
Rises : Natural := 0;
Falls : Natural := 0;
Image : constant String := Natural'Image (Value);
Last : Character := Image (Image'First + 1);
begin
for Pos in Image'First + 2 .. Image'Last loop
if Image (Pos) > Last then
Rises := Rises + 1;
elsif Image (Pos) < Last then
Falls := Falls + 1;
end if;
Last := Image (Pos);
end loop;
return Rises = Falls;
end Has_Equal_Rise_Fall;
Value : Natural := 1;
Count : Natural := 0;
begin
loop
if Has_Equal_Rise_Fall (Value) then
Count := Count + 1;
if Count <= 200 then
Ada.Integer_Text_Io.Put (Value, Width => 5);
if Count mod 20 = 0 then
New_Line;
end if;
end if;
if Count = 10_000_000 then
New_Line;
Put_Line ("The 10_000_000th: " & Natural'Image (Value));
exit;
end if;
end if;
Value := Value + 1;
end loop;
end Equal_Rise_Fall;

36
Task/Numbers-with-equal-rises-and-falls/AutoHotkey/numbers-with-equal-rises-and-falls.ahk Normal file
View file

@ -0,0 +1,36 @@
limit1 := 200, limit2 := 10000000
count := 0, result1 := result1 := ""
loop{
num := A_Index
if !Rise_Fall(num)
continue
count++
if (count <= limit1)
result1 .= num . (Mod(count, 20) ? "`t" : "`n")
if (count = limit2){
result2 := num
break
}
if !mod(count, 10000)
ToolTip % count
}
ToolTip
MsgBox % "The first " limit1 " numbers in the sequence:`n" result1 "`nThe " limit2 " number in the sequence is: " result2
return
Rise_Fall(num){
rise := fall := 0
for i, n in StrSplit(num){
if (i=1)
prev := n
else if (n > prev)
rise++
else if (n < prev)
fall++
if (rise > (StrLen(num)-1) /2) || (fall > (StrLen(num)-1) /2)
return 0
prev := n
}
if (fall = rise)
return 1
}

26
Task/Numbers-with-equal-rises-and-falls/BASIC256/numbers-with-equal-rises-and-falls.basic Normal file
View file

@ -0,0 +1,26 @@
c = 0
i = 1
while c < 10000001
if eqrf(i) then
c += 1
if c <= 200 then print i;" ";
if c = 10000000 then print : print i
end if
i += 1
end while
end
function eqrf(n)
sn$ = string(n)
q = 0
for i = 2 to length(sn$)
if asc(mid(sn$,i,1)) > asc(mid(sn$,i-1,1)) then
q += 1
else
if asc(mid(sn$,i,1)) < asc(mid(sn$,i-1,1)) then
q -= 1
end if
end if
next i
if q = 0 then return true else return false
end function

30
Task/Numbers-with-equal-rises-and-falls/C++/numbers-with-equal-rises-and-falls.cpp Normal file
View file

@ -0,0 +1,30 @@
#include <iomanip>
#include <iostream>
bool equal_rises_and_falls(int n) {
int total = 0;
for (int previous_digit = -1; n > 0; n /= 10) {
int digit = n % 10;
if (previous_digit > digit)
++total;
else if (previous_digit >= 0 && previous_digit < digit)
--total;
previous_digit = digit;
}
return total == 0;
}
int main() {
const int limit1 = 200;
const int limit2 = 10000000;
int n = 0;
std::cout << "The first " << limit1 << " numbers in the sequence are:\n";
for (int count = 0; count < limit2; ) {
if (equal_rises_and_falls(++n)) {
++count;
if (count <= limit1)
std::cout << std::setw(3) << n << (count % 20 == 0 ? '\n' : ' ');
}
}
std::cout << "\nThe " << limit2 << "th number in the sequence is " << n << ".\n";
}

39
Task/Numbers-with-equal-rises-and-falls/C/numbers-with-equal-rises-and-falls.c Normal file
View file

@ -0,0 +1,39 @@
#include <stdio.h>
/* Check whether a number has an equal amount of rises
* and falls
*/
int riseEqFall(int num) {
int rdigit = num % 10;
int netHeight = 0;
while (num /= 10) {
netHeight += ((num % 10) > rdigit) - ((num % 10) < rdigit);
rdigit = num % 10;
}
return netHeight == 0;
}
/* Get the next member of the sequence, in order,
* starting at 1
*/
int nextNum() {
static int num = 0;
do {num++;} while (!riseEqFall(num));
return num;
}
int main(void) {
int total, num;
/* Generate first 200 numbers */
printf("The first 200 numbers are: \n");
for (total = 0; total < 200; total++)
printf("%d ", nextNum());
/* Generate 10,000,000th number */
printf("\n\nThe 10,000,000th number is: ");
for (; total < 10000000; total++) num = nextNum();
printf("%d\n", num);
return 0;
}

44
Task/Numbers-with-equal-rises-and-falls/CLU/numbers-with-equal-rises-and-falls.clu Normal file
View file

@ -0,0 +1,44 @@
% Find how many rises and falls a number has
rises_falls = proc (n: int) returns (int,int)
rises: int := 0
falls: int := 0
while n >= 10 do
dl: int := n//10
n := n / 10
dh: int := n//10
if dh < dl then rises := rises + 1
elseif dl < dh then falls := falls + 1
end
end
return (rises, falls)
end rises_falls
% Generate all numbers with equal rises and falls
equal_rises_falls = iter () yields (int)
n: int := 1
rises, falls: int
while true do
rises, falls := rises_falls(n)
if rises = falls then yield (n) end
n := n + 1
end
end equal_rises_falls
% Show the first 200 and the 10,000,000th
start_up = proc ()
po: stream := stream$primary_output()
count: int := 0
for n: int in equal_rises_falls() do
count := count + 1
if count <= 200 then
stream$putright(po, int$unparse(n), 5)
if count//10 = 0 then stream$putc(po, '\n') end
elseif count = 10000000 then
stream$putl(po, "\nThe 10,000,000th number is: "
|| int$unparse(n))
break
end
end
end start_up

49
Task/Numbers-with-equal-rises-and-falls/Cowgol/numbers-with-equal-rises-and-falls.cowgol Normal file
View file

@ -0,0 +1,49 @@
include "cowgol.coh";
# return the change in height of a number
sub height(n: uint32): (h: int8) is
h := 0;
var dgt := (n % 10) as uint8;
var prev: uint8;
n := n / 10;
while n > 0 loop
prev := dgt;
dgt := (n % 10) as uint8;
n := n / 10;
if prev < dgt then
h := h + 1;
elseif prev > dgt then
h := h - 1;
end if;
end loop;
end sub;
var number: uint32 := 0;
var seen: uint32 := 0;
var col: uint8 := 10;
print("The first 200 numbers are:");
print_nl();
while seen < 10000000 loop
loop
number := number + 1;
if height(number) == 0 then break; end if;
end loop;
seen := seen + 1;
if seen <= 200 then
print_i32(number);
col := col - 1;
if col != 0 then
print_char('\t');
else
print_char('\n');
col := 10;
end if;
end if;
end loop;
print_nl();
print("The 10,000,000th number is: ");
print_i32(number);
print_nl();

59
Task/Numbers-with-equal-rises-and-falls/Delphi/numbers-with-equal-rises-and-falls.delphi Normal file
View file

@ -0,0 +1,59 @@
procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
var T: integer;
begin
SetLength(IA,0);
repeat
begin
T:=N mod 10;
N:=N div 10;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=T;
end
until N<1;
end;
function HasEqualRiseFall(N: integer): boolean;
{Count rises and falls in numbers left to Right}
var I: integer;
var IA: TIntegerDynArray;
var Rise,Fall: integer;
begin
Rise:=0; Fall:=0;
GetDigits(N,IA);
for I:=High(IA) downto 1 do
if IA[I-1]>IA[I] then Inc(Rise)
else if IA[I-1]<IA[I] then Inc(Fall);
Result:=Rise=Fall;
end;
procedure ShowEqualRiseFall(Memo: TMemo);
var I,Cnt: integer;
var S: string;
begin
Cnt:=0;
S:='';
for I:=1 to High(integer) do
if HasEqualRiseFall(I) then
begin
Inc(Cnt);
S:=S+Format('%4.0d', [I]);
if (Cnt mod 20)=0 then S:=S+CRLF;
if Cnt=200 then break;
end;
Memo.Text:=S;
Memo.Lines.Add('Count = '+IntToStr(Cnt));
for I:=1 to High(integer) do
if HasEqualRiseFall(I) then
begin
Inc(Cnt);
if Cnt>=10000000 then
begin
Memo.Lines.Add('10-Million: '+IntToStr(I));
break;
end;
end;
end;

5
Task/Numbers-with-equal-rises-and-falls/F-Sharp/numbers-with-equal-rises-and-falls.fs Normal file
View file

@ -0,0 +1,5 @@
// 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)
let A296712=seq{1..2147483647}|>Seq.filter fN
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))

16
Task/Numbers-with-equal-rises-and-falls/Factor/numbers-with-equal-rises-and-falls.factor Normal file
View file

@ -0,0 +1,16 @@
USING: grouping io kernel lists lists.lazy math math.extras
prettyprint tools.memory.private ;
: rises-and-falls-equal? ( n -- ? )
0 swap 10 /mod swap
[ 10 /mod rot over - sgn rotd + spin ] until-zero drop 0 = ;
: OEIS:A296712 ( -- list )
1 lfrom [ rises-and-falls-equal? ] lfilter ;
! Task
"The first 200 numbers in OEIS:A296712 are:" print
200 OEIS:A296712 ltake list>array 20 group simple-table. nl
"The 10 millionth number in OEIS:A296712 is " write
9,999,999 OEIS:A296712 lnth commas print

36
Task/Numbers-with-equal-rises-and-falls/Forth/numbers-with-equal-rises-and-falls.fth Normal file
View file

@ -0,0 +1,36 @@
: in-seq? ( n -- is N in the sequence? )
0 swap \ height
10 /mod \ digit and rest of number
begin dup while \ as long as the number isn't zero...
10 /mod \ get next digit and quotient
-rot swap \ retrieve previous digit
over - sgn \ see if higher, lower or equal (-1, 0, 1)
>r rot r> + \ add to height
-rot swap \ quotient on top of stack
repeat
drop drop \ drop number and last digit
0= \ is height equal to zero?
;
: next-val ( n -- n: retrieve first element of sequence higher than N )
begin 1+ dup in-seq? until
;
: two-hundred
begin over 200 < while
next-val dup .
swap 1+ swap
repeat
;
: ten-million
begin over 10000000 < while
next-val
swap 1+ swap
repeat
;
0 0 \ top of stack: current index and number
." The first 200 numbers are: " two-hundred cr cr
." The 10,000,000th number is: " ten-million . cr
bye

52
Task/Numbers-with-equal-rises-and-falls/Fortran/numbers-with-equal-rises-and-falls.f Normal file
View file

@ -0,0 +1,52 @@
PROGRAM A296712
INTEGER IDX, NUM, I
* Index and number start out at zero
IDX = 0
NUM = 0
* Find and write the first 200 numbers
WRITE (*,'(A)') 'The first 200 numbers are: '
DO 100 I = 1, 200
CALL NEXT NUM(IDX, NUM)
WRITE (*,'(I4)',ADVANCE='NO') NUM
IF (MOD(I,20).EQ.0) WRITE (*,*)
100 CONTINUE
* Find the 10,000,000th number
WRITE (*,*)
WRITE (*,'(A)',ADVANCE='NO') 'The 10,000,000th number is: '
200 CALL NEXT NUM(IDX, NUM)
IF (IDX.NE.10000000) GOTO 200
WRITE (*,'(I8)') NUM
STOP
END
* Given index and current number, retrieve the next number
* in the sequence.
SUBROUTINE NEXT NUM(IDX, NUM)
INTEGER IDX, NUM
LOGICAL IN SEQ
100 NUM = NUM + 1
IF (.NOT. IN SEQ(NUM)) GOTO 100
IDX = IDX + 1
END
* See whether N is in the sequence
LOGICAL FUNCTION IN SEQ(N)
INTEGER N, DL, DR, VAL, HEIGHT
* Get first digit and divide value by 10
DL = MOD(N, 10)
VAL = N / 10
HEIGHT = 0
100 IF (VAL.NE.0) THEN
* Retrieve digits by modulo and division
DR = DL
DL = MOD(VAL, 10)
VAL = VAL / 10
* Record rise or fall
IF (DL.LT.DR) HEIGHT = HEIGHT + 1
IF (DL.GT.DR) HEIGHT = HEIGHT - 1
GOTO 100
END IF
* N is in the sequence if the final height is 0
IN SEQ = HEIGHT.EQ.0
RETURN
END

22
Task/Numbers-with-equal-rises-and-falls/FreeBASIC/numbers-with-equal-rises-and-falls.basic Normal file
View file

@ -0,0 +1,22 @@
function eqrf( n as uinteger ) as boolean
dim as string sn = str(n)
dim as integer q = 0
for i as uinteger = 2 to len(sn)
if asc(mid(sn,i,1)) > asc(mid(sn,i-1,1)) then
q += 1
elseif asc(mid(sn,i,1)) < asc(mid(sn,i-1,1)) then
q -= 1
end if
next i
if q = 0 then return true else return false
end function
dim as uinteger c = 0, i = 1
while c < 10000001
if eqrf(i) then
c += 1
if c <= 200 then print i;" ";
if c = 10000000 then print : print i
end if
i += 1
wend

29
Task/Numbers-with-equal-rises-and-falls/Gambas/numbers-with-equal-rises-and-falls.gambas Normal file
View file

@ -0,0 +1,29 @@
Public Sub Main()
Dim c As Integer = 0, i As Integer = 1
While c < 10000001
If eqrf(i) Then
c += 1
If c <= 200 Then Print " "; i;
If c = 10000000 Then Print Chr(10); i
End If
i += 1
Wend
End
Function eqrf(n As Integer) As Boolean
Dim sn As String = Str(n)
Dim q As Integer = 0, i As Integer
For i = 2 To Len(sn)
If Asc(Mid(sn, i, 1)) > Asc(Mid(sn, i - 1, 1)) Then
q += 1
Else If Asc(Mid(sn, i, 1)) < Asc(Mid(sn, i - 1, 1)) Then
q -= 1
End If
Next
If q = 0 Then Return True Else Return False
End Function

47
Task/Numbers-with-equal-rises-and-falls/Go/numbers-with-equal-rises-and-falls.go Normal file
View file

@ -0,0 +1,47 @@
package main
import "fmt"
func risesEqualsFalls(n int) bool {
if n < 10 {
return true
}
rises := 0
falls := 0
prev := -1
for n > 0 {
d := n % 10
if prev >= 0 {
if d < prev {
rises = rises + 1
} else if d > prev {
falls = falls + 1
}
}
prev = d
n /= 10
}
return rises == falls
}
func main() {
fmt.Println("The first 200 numbers in the sequence are:")
count := 0
n := 1
for {
if risesEqualsFalls(n) {
count++
if count <= 200 {
fmt.Printf("%3d ", n)
if count%20 == 0 {
fmt.Println()
}
}
if count == 1e7 {
fmt.Println("\nThe 10 millionth number in the sequence is ", n)
break
}
}
n++
}
}

21
Task/Numbers-with-equal-rises-and-falls/Haskell/numbers-with-equal-rises-and-falls.hs Normal file
View file

@ -0,0 +1,21 @@
import Data.Char
pairs :: [a] -> [(a,a)]
pairs (a:b:as) = (a,b):pairs (b:as)
pairs _ = []
riseEqFall :: Int -> Bool
riseEqFall n = rel (>) digitPairs == rel (<) digitPairs
where rel r = sum . map (fromEnum . uncurry r)
digitPairs = pairs $ map digitToInt $ show n
a296712 :: [Int]
a296712 = [n | n <- [1..], riseEqFall n]
main :: IO ()
main = do
putStrLn "The first 200 numbers are: "
putStrLn $ unwords $ map show $ take 200 a296712
putStrLn ""
putStr "The 10,000,000th number is: "
putStrLn $ show $ a296712 !! 9999999

28
Task/Numbers-with-equal-rises-and-falls/J/numbers-with-equal-rises-and-falls.j Normal file
View file

@ -0,0 +1,28 @@
NB. This would have been shorter but memory constraints forced me to test candidates
NB. in batches rather than all at once (iPads are amazing but not supercomputers...)
gennumberblocks =: 3 : 0
NB. y Block index. Each block is at most 100000 numbers
NB. Return one or more boxed blocks of numbers, segregated by digit count
(<. 10 ^. n) </. n =. (y * 100000) + >: i.100000
)
testblock =: 3 : 0
NB. y A block of numbers all with the same digit count
NB. Return those that pass the test
y #~ ((+/"1) 2 </\"1 f) = (+/"1) 2 >/\"1 "."1"0 ": ,. y
)
pow =: 3 : 0
NB. Generate and test one or more blocks of numbers and add the results to the
NB. running list of answers
'nextblockindex answers' =. y
(>: nextblockindex) ; answers , ; testblock &. > gennumberblocks nextblockindex
)
go =: 3 : 0
result =: pow ^: ((1e7&>)@#@(1&{::)) ^:_ (0 ; '')
'The first 200 numbers are:' (1!:2) 2
(10 20 $ 200 {. 1 {:: result) (1!:2) 2
'The 10,000,000th number is: ' , ": 9999999 { 1 {:: result
)

29
Task/Numbers-with-equal-rises-and-falls/Java/numbers-with-equal-rises-and-falls.java Normal file
View file

@ -0,0 +1,29 @@
public class EqualRisesFalls {
public static void main(String[] args) {
final int limit1 = 200;
final int limit2 = 10000000;
System.out.printf("The first %d numbers in the sequence are:\n", limit1);
int n = 0;
for (int count = 0; count < limit2; ) {
if (equalRisesAndFalls(++n)) {
++count;
if (count <= limit1)
System.out.printf("%3d%c", n, count % 20 == 0 ? '\n' : ' ');
}
}
System.out.printf("\nThe %dth number in the sequence is %d.\n", limit2, n);
}
private static boolean equalRisesAndFalls(int n) {
int total = 0;
for (int previousDigit = -1; n > 0; n /= 10) {
int digit = n % 10;
if (previousDigit > digit)
++total;
else if (previousDigit >= 0 && previousDigit < digit)
--total;
previousDigit = digit;
}
return total == 0;
}
}

34
Task/Numbers-with-equal-rises-and-falls/Jq/numbers-with-equal-rises-and-falls.jq Normal file
View file

@ -0,0 +1,34 @@
def risesEqualsFalls:
. as $n
| if . < 10 then true
else {rises: 0, falls: 0, prev: -1, n: $n}
| until (.n <= 0;
(.n % 10 ) as $d
| if .prev >= 0
then if $d < .prev then .rises += 1
elif $d > .prev then .falls += 1
else .
end
else .
end
| .prev = $d
| .n = ((.n/10)|floor) )
| .rises == .falls
end ;
def A296712: range(1; infinite) | select(risesEqualsFalls);
# Override jq's incorrect definition of nth/2
# Emit the $n-th value of the stream, counting from 0; or emit nothing
def nth($n; s):
if $n < 0 then error("nth/2 doesn't support negative indices")
else label $out
| foreach s as $x (-1; .+1; select(. >= $n) | $x, break $out)
end;
# The tasks
"First 200:",
[limit(200; A296712)],
"\nThe 10 millionth number in the sequence is \(
nth(1e7 - 1; A296712))"

35
Task/Numbers-with-equal-rises-and-falls/Julia/numbers-with-equal-rises-and-falls.julia Normal file
View file

@ -0,0 +1,35 @@
using Lazy
function rises_and_falls(n)
if n < 10
return 0, 0
end
lastr, rises, falls = n % 10, 0, 0
while n != 0
n, r = divrem(n, 10)
if r > lastr
falls += 1
elseif r < lastr
rises += 1
end
lastr = r
end
return rises, falls
end
isA296712(x) = ((a, b) = rises_and_falls(x); return a == b)
function genA296712(N, M)
A296712 = filter(isA296712, Lazy.range(1));
j = 0
for i in take(200, A296712)
j += 1
print(lpad(i, 4), j % 20 == 0 ? "\n" : "")
end
for i in take(M, A296712)
j = i
end
println("\nThe $M-th number in sequence A296712 is $j.")
end
genA296712(200, 10_000_000)

28
Task/Numbers-with-equal-rises-and-falls/MAD/numbers-with-equal-rises-and-falls.mad Normal file
View file

@ -0,0 +1,28 @@
NORMAL MODE IS INTEGER
VECTOR VALUES FMT = $I8,1H:,I9*$
INTERNAL FUNCTION(NUM)
ENTRY TO RISFAL.
N=NUM
DEPTH = 0
DIGA = N-(N/10)*10
N = N/10
LOOP WHENEVER N.E.0, FUNCTION RETURN DEPTH.E.0
DIGB = DIGA
DIGA = N-(N/10)*10
N = N/10
WHENEVER DIGA.L.DIGB, DEPTH=DEPTH-1
WHENEVER DIGA.G.DIGB, DEPTH=DEPTH+1
TRANSFER TO LOOP
END OF FUNCTION
I=0
J=0
LOOP J=J+1
WHENEVER .NOT.RISFAL.(J), TRANSFER TO LOOP
I=I+1
WHENEVER I.LE.200, PRINT FORMAT FMT, I, J
WHENEVER I.L.10000000, TRANSFER TO LOOP
PRINT FORMAT FMT, I, J
END OF PROGRAM

13
Task/Numbers-with-equal-rises-and-falls/Mathematica/numbers-with-equal-rises-and-falls.math Normal file
View file

@ -0,0 +1,13 @@
ClearAll[EqualRisesAndFallsQ]
EqualRisesAndFallsQ[n_Integer] := Total[Sign[Differences[IntegerDigits[n]]]] == 0
Take[Select[Range[1000], EqualRisesAndFallsQ], 200]
valid = 0;
Dynamic[{i, valid}]
Do[
If[EqualRisesAndFallsQ[i],
valid += 1;
If[valid == 10^7, Print[i]; Break[]]
]
,
{i, 50 10^6}
]

33
Task/Numbers-with-equal-rises-and-falls/Nim/numbers-with-equal-rises-and-falls.nim Normal file
View file

@ -0,0 +1,33 @@
import strutils
func insequence(n: Positive): bool =
## Return true if "n" is in the sequence.
if n < 10: return true
var diff = 0
var prev = n mod 10
var n = n div 10
while n != 0:
let digit = n mod 10
if digit < prev: inc diff
elif digit > prev: dec diff
prev = digit
n = n div 10
result = diff == 0
iterator a297712(): (int, int) =
## Yield the positions and the numbers of the sequence.
var n = 1
var pos = 0
while true:
if n.insequence:
inc pos
yield (pos, n)
inc n
echo "First 200 numbers in the sequence:"
for (pos, n) in a297712():
if pos <= 200:
stdout.write ($n).align(3), if pos mod 20 == 0: '\n' else: ' '
elif pos == 10_000_000:
echo "\nTen millionth number in the sequence: ", n
break

29
Task/Numbers-with-equal-rises-and-falls/Perl/numbers-with-equal-rises-and-falls.pl Normal file
View file

@ -0,0 +1,29 @@
#!/usr/bin/perl
use strict;
use warnings;
sub rf
{
local $_ = shift;
my $sum = 0;
$sum += $1 <=> $2 while /(.)(?=(.))/g;
$sum
}
my $count = 0;
my $n = 0;
my @numbers;
while( $count < 200 )
{
rf(++$n) or $count++, push @numbers, $n;
}
print "first 200: @numbers\n" =~ s/.{1,70}\K\s/\n/gr;
$count = 0;
$n = 0;
while( $count < 10e6 )
{
rf(++$n) or $count++;
}
print "\n10,000,000th number: $n\n";

36
Task/Numbers-with-equal-rises-and-falls/Phix/numbers-with-equal-rises-and-falls.phix Normal file
View file

@ -0,0 +1,36 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The first 200 numbers are:\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">rmf</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">r</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">rmf</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">compare</span><span style="color: #0000FF;">(</span><span style="color: #000000;">l</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span>
<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">rmf</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">200</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%3d "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">==</span> <span style="color: #000000;">1e7</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nThe %,dth number is %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()></span><span style="color: #000000;">t1</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%,d:%,d\r"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<!--

39
Task/Numbers-with-equal-rises-and-falls/PureBasic/numbers-with-equal-rises-and-falls.basic Normal file
View file

@ -0,0 +1,39 @@
Procedure.b eqrf(n.i)
sn.s = Str(n)
q.i = 0
For i.i = 2 To Len(sn)
If Asc(Mid(sn, i, 1)) > Asc(Mid(sn, i - 1, 1)):
q + 1
Else
If Asc(Mid(sn, i, 1)) < Asc(Mid(sn, i - 1, 1)):
q - 1
EndIf
EndIf
Next
If q = 0:
ProcedureReturn #True
Else
ProcedureReturn #False
EndIf
EndProcedure
OpenConsole()
c.i = 0
i.i = 1
While c < 10000001
If eqrf(i):
c + 1
If c <= 200:
Print(" " + Str(i))
EndIf
If c = 10000000:
PrintN(#CRLF$ + Str(i))
EndIf
EndIf
i + 1
Wend
Input()
CloseConsole()

33
Task/Numbers-with-equal-rises-and-falls/Python/numbers-with-equal-rises-and-falls.py Normal file
View file

@ -0,0 +1,33 @@
import itertools
def riseEqFall(num):
"""Check whether a number belongs to sequence A296712."""
height = 0
d1 = num % 10
num //= 10
while num:
d2 = num % 10
height += (d1<d2) - (d1>d2)
d1 = d2
num //= 10
return height == 0
def sequence(start, fn):
"""Generate a sequence defined by a function"""
num=start-1
while True:
num += 1
while not fn(num): num += 1
yield num
a296712 = sequence(1, riseEqFall)
# Generate the first 200 numbers
print("The first 200 numbers are:")
print(*itertools.islice(a296712, 200))
# Generate the 10,000,000th number
print("The 10,000,000th number is:")
print(*itertools.islice(a296712, 10000000-200-1, 10000000-200))
# It is necessary to subtract 200 from the index, because 200 numbers
# have already been consumed.

35
Task/Numbers-with-equal-rises-and-falls/REXX/numbers-with-equal-rises-and-falls.rexx Normal file
View file

@ -0,0 +1,35 @@
/*REXX pgm finds and displays N numbers that have an equal number of rises and falls,*/
parse arg n . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 200 /*Not specified? Then use the default.*/
append= n>0 /*a flag that is used to append numbers*/
n= abs(n) /*use the absolute value of N. */
call init /*initialize the rise/fall database. */
do j=1 until #==n /*test integers until we have N of them*/
s= 0 /*initialize the sum of rises/falls. */
do k=1 for length(j)-1 /*obtain a set of two digs from number.*/
t= substr(j, k, 2) /*obtain a set of two digs from number.*/
s= s + @.t /*sum the rises and falls in the number*/
end /*k*/
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.*/
else say 'the ' commas(n)th(n) " number is: " commas(j) /*show Nth #.*/
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do c=length(_)-3 to 1 by -3; _=insert(',', _, c); end; return _
th: parse arg th; return word('th st nd rd',1+(th//10)*(th//100%10\==1)*(th//10<4))
/*──────────────────────────────────────────────────────────────────────────────────────*/
init: @.= 0; do i=1 for 9; _= i' '; @._= 1; _= '0'i; @._= +1; end /*i*/
do i=10 to 99; parse var i a 2 b; if a>b then @.i= -1
else if a<b then @.i= +1
end /*i*/; #= 0; $=; return
/*──────────────────────────────────────────────────────────────────────────────────────*/
show: say 'the first ' commas(#) " numbers are:"; say; w= length( word($, #) )
_=; do o=1 for n; _= _ right( word($, o), w); if o//20\==0 then iterate
say substr(_, 2); _= /*display a line; nullify a new line. */
end /*o*/ /* [↑] display 20 numbers to a line.*/
if _\=='' then say substr(_, 2); return /*handle any residual numbers in list. */

56
Task/Numbers-with-equal-rises-and-falls/Raku/numbers-with-equal-rises-and-falls.raku Normal file
View file

@ -0,0 +1,56 @@
use Lingua::EN::Numbers;
use Base::Any;
sub rf (int $base = 10, $batch = Any, &op = &infix:<==>) {
my %batch = batch => $batch if $batch;
flat (1 .. ∞).hyper(|%batch).map: {
my int ($this, $last) = $_, $_ % $base;
my int ($rise, $fall) = 0, 0;
while $this {
my int $rem = $this % $base;
$this = $this div $base;
if $rem > $last { $fall = $fall + 1 }
elsif $rem < $last { $rise = $rise + 1 }
$last = $rem
}
next unless &op($rise, $fall);
$_
}
}
# The task
my $upto = 200;
put "Rise = Fall:\nFirst {$upto.&cardinal} (base 10):";
.put for rf[^$upto]».fmt("%3d").batch(20);
$upto = 10_000_000;
put "\nThe {$upto.&ordinal} (base 10): ", comma rf(10, 65536)[$upto - 1];
# Other bases and comparisons
put "\n\nGeneralized for other bases and other comparisons:";
$upto = ^5;
my $which = "{tc $upto.map({.exp(10).&ordinal}).join: ', '}, values in some other bases:";
put "\nRise = Fall: $which";
for <3 296691 4 296694 5 296697 6 296700 7 296703 8 296706 9 296709 10 296712
11 296744 12 296747 13 296750 14 296753 15 296756 16 296759 20 296762 60 296765>
-> $base, $oeis {
put "Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): ",
$upto.map({rf(+$base, Any)[.exp(10) - 1].&to-base($base)}).join: ', '
}
put "\nRise > Fall: $which";
for <3 296692 4 296695 5 296698 6 296701 7 296704 8 296707 9 296710 10 296713
11 296745 12 296748 13 296751 14 296754 15 296757 16 296760 20 296763 60 296766>
-> $base, $oeis {
put "Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): ",
$upto.map({rf(+$base, Any, &infix:«>»)[.exp(10) - 1].&to-base($base)}).join: ', '
}
put "\nRise < Fall: $which";
for <3 296693 4 296696 5 296699 6 296702 7 296705 8 296708 9 296711 10 296714
11 296746 12 296749 13 296752 14 296755 15 296758 16 296761 20 296764 60 296767>
-> $base, $oeis {
put "Base {$base.fmt(<%2d>)} (https://oeis.org/A$oeis): ",
$upto.map({rf(+$base, Any, &infix:«<»)[.exp(10) - 1].&to-base($base)}).join: ', '
}

9
Task/Numbers-with-equal-rises-and-falls/Ruby/numbers-with-equal-rises-and-falls.rb Normal file
View file

@ -0,0 +1,9 @@
class Integer
def eq_rise_fall? = digits.each_cons(2).sum{|a,b| a <=> b} == 0
end
puts (1..).lazy.select(&:eq_rise_fall?).take(200).force.join(" ")
n = 10_000_000
res = (1..).lazy.select(&:eq_rise_fall?).take(n).drop(n-1).first
puts "The #{n}th number in the sequence is #{res}."

18
Task/Numbers-with-equal-rises-and-falls/Sidef/numbers-with-equal-rises-and-falls.sidef Normal file
View file

@ -0,0 +1,18 @@
func isok(arr) {
var diffs = arr.map_cons(2, {|a,b| a - b })
diffs.count { .is_pos } == diffs.count { .is_neg }
}
var base = 10
with (200) {|n|
say "First #{n} terms (base #{base}):"
n.by { isok(.digits(base)) && .is_pos }.each_slice(20, {|*a|
say a.map { '%3s' % _ }.join(' ')
})
}
with (1e7) {|n| # takes a very long time
say "\nThe #{n.commify}-th term (base #{base}): #{
n.th { isok(.digits(base)) && .is_pos }.commify}"
}

34
Task/Numbers-with-equal-rises-and-falls/Swift/numbers-with-equal-rises-and-falls.swift Normal file
View file

@ -0,0 +1,34 @@
import Foundation
func equalRisesAndFalls(_ n: Int) -> Bool {
var total = 0
var previousDigit = -1
var m = n
while m > 0 {
let digit = m % 10
m /= 10
if previousDigit > digit {
total += 1
} else if previousDigit >= 0 && previousDigit < digit {
total -= 1
}
previousDigit = digit
}
return total == 0
}
var count = 0
var n = 0
let limit1 = 200
let limit2 = 10000000
print("The first \(limit1) numbers in the sequence are:")
while count < limit2 {
n += 1
if equalRisesAndFalls(n) {
count += 1
if count <= limit1 {
print(String(format: "%3d", n), terminator: count % 20 == 0 ? "\n" : " ")
}
}
}
print("\nThe \(limit2)th number in the sequence is \(n).")

39
Task/Numbers-with-equal-rises-and-falls/Wren/numbers-with-equal-rises-and-falls.wren Normal file
View file

@ -0,0 +1,39 @@
import "/fmt" for Fmt
var risesEqualsFalls = Fn.new { |n|
if (n < 10) return true
var rises = 0
var falls = 0
var prev = -1
while (n > 0) {
var d = n%10
if (prev >= 0) {
if (d < prev) {
rises = rises + 1
} else if (d > prev) {
falls = falls + 1
}
}
prev = d
n = (n/10).floor
}
return rises == falls
}
System.print("The first 200 numbers in the sequence are:")
var count = 0
var n = 1
while (true) {
if (risesEqualsFalls.call(n)) {
count = count + 1
if (count <= 200) {
Fmt.write("$3d ", n)
if (count % 20 == 0) System.print()
}
if (count == 1e7) {
Fmt.print("\nThe 10 millionth number in the sequence is $,d.", n)
break
}
}
n = n + 1
}

34
Task/Numbers-with-equal-rises-and-falls/XPL0/numbers-with-equal-rises-and-falls.xpl0 Normal file
View file

@ -0,0 +1,34 @@
func RiseFall(N); \Return 'true' if N has equal rises and falls
int N, R, F, D, D0;
[R:= 0; F:= 0;
N:= N/10;
D0:= rem(0);
while N do
[N:= N/10;
D:= rem(0);
if D > D0 then R:= R+1;
if D < D0 then F:= F+1;
D0:= D;
];
return R = F;
];
int N, Cnt;
[N:= 1;
Cnt:= 0;
loop [if RiseFall(N) then
[Cnt:= Cnt+1;
if Cnt <= 200 then
[IntOut(0, N);
if rem (Cnt/10) = 0 then CrLf(0)
else ChOut(0, 9\tab\);
];
if Cnt = 10_000_000 then
[Text(0, "10 millionth number is ");
IntOut(0, N); CrLf(0);
quit;
];
];
N:= N+1;
];
]