Largest five adjacent number: Difference between revisions

From Rosetta Code
Content added Content deleted
(Added BASIC256, Chipmunk Basic, Gambas,PureBasic, QBasic, True BASIC and Yabasic)
(Added Easylang)
 
(One intermediate revision by one other user not shown)
Line 500: Line 500:
<pre>
<pre>
Largest 5 adjacent digits are 99914
Largest 5 adjacent digits are 99914
</pre>

=={{header|EasyLang}}==
<syntaxhighlight>
for i to 1000
n$ &= random 10 - 1
.
min = 99999
for i = 1 to 995
n = number substr n$ i 5
min = lower min n
max = higher max n
.
print min & " " & max
</syntaxhighlight>
{{out}}
<pre>
21 99768
</pre>
</pre>


Line 983: Line 1,001:
{{libheader|Wren-fmt}}
{{libheader|Wren-fmt}}
Very simple approach as there's little need for speed here.
Very simple approach as there's little need for speed here.
<syntaxhighlight lang="ecmascript">import "random" for Random
<syntaxhighlight lang="wren">import "random" for Random
import "/fmt" for Fmt
import "./fmt" for Fmt


var rand = Random.new()
var rand = Random.new()

Latest revision as of 21:15, 20 April 2024

Largest five adjacent number is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task


Generate random 1000-digit number.
Find the five adjacent digits in the 1000-digit number that form the largest 5-digit number.

Extra credit

Find the five adjacent digits in the 1000-digit number that form the smallest 5-digit number.


11l

Translation of: Python
V largeNum = [random:(1..9)] [+] (0.<999).map(i -> random:(0..9))

V (maxNum, minNum) = (0, 99999)

L(i) 996
   V num = Int(largeNum[i.+5].join(‘’))
   I num > maxNum
      maxNum = num
   E I num < minNum
      minNum = num

print(‘Largest 5-digit number extracted from random 1000-digit number: ’maxNum)
print(‘Smallest 5-digit number extracted from random 1000-digit number: #05’.format(minNum))
Output:
Largest 5-digit number extracted from random 1000-digit number: 99902
Smallest 5-digit number extracted from random 1000-digit number: 00043

Ada

with Ada.Text_Io;
with Ada.Numerics.Discrete_Random;

procedure Adjacent_Numbers is

   Adjacent_Length : constant := 5;

   subtype Digit is Character range '0' .. '9';
   package Random_Digits
   is new Ada.Numerics.Discrete_Random (Digit);

   Gen   : Random_Digits.Generator;
   Line  : String (1 .. 1000);
   Large : Natural := Natural'First;
   Small : Natural := Natural'Last;
begin
   Random_Digits.Reset (Gen);
   Line := (others => Random_Digits.Random (Gen));

   for I in Line'First .. Line'Last - Adjacent_Length + 1 loop
      declare
         Window : String renames Line (I .. I + Adjacent_Length - 1);
      begin
         Large := Natural'Max (Large, Natural'Value (Window));
         Small := Natural'Min (Small, Natural'Value (Window));
      end;
   end loop;
   Ada.Text_Io.Put_Line ("The largest number : " & Natural'Image (Large));
   Ada.Text_Io.Put_Line ("The smallest number: " & Natural'Image (Small));
end Adjacent_Numbers;
Output:
The largest number :  99625
The smallest number:  102

ALGOL 68

Adding the minimum number for good measure... 

BEGIN # generate 1000 random digits and find the largest/smallest numbers formed from 5 consecutive digits #
    [ 1 : 1000 ]CHAR digits;
    FOR i TO UPB digits DO digits[ i ] := REPR ( ENTIER ( next random * 10 ) + ABS "0" ) OD;
    STRING max number := digits[ 1 : 5 ];
    STRING min number := digits[ 1 : 5 ];
    FOR i FROM 2 TO UPB digits - 4 DO
        STRING next number = digits[ i : i + 4 ];
        IF next number > max number
        THEN
            # found a new higher number #
            max number := next number
        FI;
        IF next number < min number
        THEN
            # found a new lower number #
            min number := next number
        FI
    OD;
    print( ( "Largest  5 consecutive digits from 1000 random digits: ", max number, newline ) );
    print( ( "Smallest 5 consecutive digits from 1000 random digits: ", min number, newline ) )
END
Output:
Largest  5 consecutive digits from 1000 random digits: 99987
Smallest 5 consecutive digits from 1000 random digits: 00119

APL

Works with: Dyalog APL
⌈/((⊣+10×⊢)/(⌽↓))⌺5⊢(-⎕IO)+?1000/10
Output:

(example) 

99994

Arturo

N: join to [:string] map 1..100 'x -> random 1000000000 9999999999

i: 0
maxNum: 0
minNum: ∞
while [i < (size N)-5][
    num: to :integer join @[N\[i] N\[i+1] N\[i+2] N\[i+3] N\[i+4]]
    if num > maxNum -> maxNum: num
    if num < minNum -> minNum: num
    i: i + 1
]

print "Our random 1000-digit number is:"
print N

print ""

print ["Max 5-adjacent number found:" maxNum]
print ["Min 5-adjacent number found:" (repeat "0" 5-(size to :string minNum)) ++ (to :string minNum)]
Output:
Our random 1000-digit number is:
2540956677308157418624519953263471599696918276171651168484519407031160813613006352660058588944602704848634276542837184618726044674117357036813240557325769932073351534364289297094415941273117151277729576200542643185699525405079189015204192029912043004161916366921458912887890652627268028071729897387395041640352395354106991129061548748712499227024213135531365974620993813773921850969630855401781344832397898392812417729744785629765286216304456806870691502938136795922685099816652448188701308354551593078486609811394420601431484916913833634669083737749230355341380266781803894385432741405633278873213701238310761908151961510643290964548205746238459266137202173265468217401777681775761126374654289733873900330799576500024068191362342162163615972164105625935627483920193464168192083262176697432155066174175594837721476581087940310642712981291006889657297350894628612724944063786324456854104801432247483498384207351647946918119868105898645178074174003550762101547842674605061792172905254724197215648686667

Max 5-adjacent number found: 99816 
Min 5-adjacent number found: 00024

AutoHotkey

maxNum := 0, str := ""
loop, 1000
{
    Random, rnd, 0, 9
    str .= rnd
    output .= rnd . (Mod(A_Index, 148) ? "" : "`n")
    if A_Index < 5
        continue
    num := SubStr(str, A_Index-4, 5)    
    maxNum := maxNum > num ? maxNum : num
    minNum := A_Index = 5 ? num : minNum < num ? minNum : num
}
MsgBox % result := output "`n`nLargest five adjacent digits = " maxNum 
                    .  "`n`nSmallest five adjacent digits = " minNum
Output:
3893212622395522104846091986776081862634026945871752892124324578621089065097043281907406149009719673003318226562809101957181871693776164191416491334
2509291361707848297387923254298547833186351133036771338719578505791529263806019240009497155124458943732581184022226943392528107498748575424217651885
3083736872582691290721469942482918430078673685947447234032602113276631102983248999047362916320523840282929255314468323644427797630259187509914424396
1523615571637081320270791095221484894567420630155741441396012393172769867922862248399483054652921274863786220527596050784952102267710198517665662903
6335615800351254988779849447078262460051794249274045128158246939351902901862546960248213286880570086476859341012102414828750098051948784732121573660
9618754338433412518619240496583375235634416473003920360759949694724646721954909867058588446320222792637823988375313876167705092153587245148819122980
2777308429997046827297505483667631338885207838402941712216614732232703459440770039141898763110002290662921501156

Largest five adjacent digits = 99970

Smallest five adjacent digits = 00022

AWK

# syntax: GAWK -f LARGEST_FIVE_ADJACENT_NUMBER.AWK
BEGIN {
    limit = 1000
    width = 5
    max_n = 0
    for (i=1; i<=width; i++) {
      min_n = min_n "9"
    }
    srand()
    for (i=1; i<=limit; i++) {
      digits = digits int(rand() * 10)
    }
    for (i=1; i<=limit-width+1; i++) {
      n = substr(digits,i,width)
      if (n > max_n) {
        max_n = n
        max_pos = i
      }
      if (n < min_n) {
        min_n = n
        min_pos = i
      }
    }
    printf("look for %d digit number using %d digits\n",width,limit)
    printf("largest  %0*d in positions %d-%d\n",width,max_n,max_pos,max_pos+width-1)
    printf("smallest %0*d in positions %d-%d\n",width,min_n,min_pos,min_pos+width-1)
    exit(0)
}
Output:
look for 5 digit number using 1000 digits
largest  99873 in positions 300-304
smallest 00099 in positions 697-701

BASIC

BASIC256

Translation of: FreeBASIC
dim number(1000)
highest = 0
lowest = 100000
for i = 0 to 999
	number[i] = int(rand*10)
	if i >= 4 then
		tmp = number[i] + 10*number[i-1] + 100*number[i-2] + 1000*number[i-3] + 10000*number[i-4]
		if tmp < lowest then lowest = tmp
		if tmp > highest then highest = tmp
	end if
next i
print highest, lowest

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
Translation of: FreeBASIC
100 randomize timer
110 dim number(999)
120 highest = 0
130 lowest = 100000
140 for i = 0 to 999
150   number(i) = int(rnd(10))
160   if i >= 4 then
170     tmp = number(i)+10*number(i-1)+100*number(i-2)+1000*number(i-3)+10000*number(i-4)
180     if tmp < lowest then lowest = tmp
190     if tmp > highest then highest = tmp
200   endif
210 next i
220 print highest,lowest
230 end

Gambas

Translation of: FreeBASIC
Public number[1000] As Byte

Public Sub Main() 
  
  Randomize
  Dim tmp As Integer, highest As Integer = 0, lowest As Integer = 100000 
  For i As Integer = 0 To 999 
    number[i] = Int(Rnd(10))
    If i >= 4 Then 
      tmp = number[i] + 10 * number[i - 1] + 100 * number[i - 2] + 1000 * number[i - 3] + 10000 * number[i - 4] 
      If tmp < lowest Then lowest = tmp 
      If tmp > highest Then highest = tmp 
    End If 
  Next 
  Print highest, lowest
  
End

PureBasic

Translation of: FreeBASIC
OpenConsole()
Dim number.i(999)
highest.i = 0
lowest.i = 100000
For i.i = 0 To 999
  number(i) = Random(10)
  If i >= 4:
    tmp = number(i) + 10*number(i-1) + 100*number(i-2) + 1000*number(i-3) + 10000*number(i-4)
    If tmp < lowest: lowest = tmp: EndIf
    If tmp > highest: highest = tmp: EndIf
  EndIf
Next i 
PrintN(Str(highest) + #TAB$ + Str(lowest))

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Translation of: FreeBASIC
RANDOMIZE TIMER
DIM number(0 TO 999)
highest = 0
lowest = 100000
FOR i = 0 TO 999
    number(i) = INT(RND * 10)
    IF i >= 4 THEN
        tmp = number(i) + 10 * number(i - 1) + 100 * number(i - 2) + 1000 * number(i - 3) + 10000 * number(i - 4)
        IF tmp < lowest THEN lowest = tmp
        IF tmp > highest THEN highest = tmp
    END IF
NEXT i
PRINT highest, lowest
END

True BASIC

Translation of: QBasic
RANDOMIZE
DIM number(0 TO 999)
LET highest = 0
LET lowest = 100000
FOR i = 0 TO 999
    LET number(i) = INT(RND*10)
    IF i >= 4 THEN
       LET tmp = number(i)+10*number(i-1)+100*number(i-2)+1000*number(i-3)+10000*number(i-4)
       IF tmp < lowest THEN LET lowest = tmp
       IF tmp > highest THEN LET highest = tmp
    END IF
NEXT i
PRINT highest, lowest
END

Yabasic

Translation of: FreeBASIC
dim number(999)
highest = 0
lowest = 100000
for i = 0 to 999
    number(i) = int(ran(10))
    if i >= 4 then
        tmp = number(i) + 10*number(i-1) + 100*number(i-2) + 1000*number(i-3) + 10000*number(i-4)
        if tmp < lowest  lowest = tmp
        if tmp > highest  highest = tmp
    fi
next i 
print highest, lowest

BQN

⌈´(⊣+10×⊢)˝⌽⍉5↕1000 •rand.Range 10
Output:

(example) 

99991

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>

#define DIGITS 1000
#define NUMSIZE 5

uint8_t randomDigit() {
    uint8_t d;
    do {d = rand() & 0xF;} while (d >= 10);
    return d;
}

int numberAt(uint8_t *d, int size) {
    int acc = 0;
    while (size--) acc = 10*acc + *d++;
    return acc;
}

int main() {
    uint8_t digits[DIGITS];
    int i, largest = 0;
    
    srand(time(NULL));
    
    for (i=0; i<DIGITS; i++) digits[i] = randomDigit();
    for (i=0; i<DIGITS-NUMSIZE; i++) {
        int here = numberAt(&digits[i], NUMSIZE);
        if (here > largest) largest = here;
    }

    printf("%d\n", largest);
    return 0;
}
Output:

(example) 

99931

CLU

% Generate a number of N random digits
random_digits = proc (n: int) returns (sequence[int])
    digits: array[int] := array[int]$predict(1,n)
    
    % A number never starts with a zero
    array[int]$addh(digits, 1+random$next(9))
    for i: int in int$from_to(1,n-1) do
        array[int]$addh(digits, random$next(10))
    end
    return(sequence[int]$a2s(digits))
end random_digits

% Find the largest and smallest N-adjacent number in the digits 
find_min_max = proc (n: int, digits: sequence[int]) returns (int,int)
    min: int := 10**n  % Guaranteed to be bigger than any N-adjacent number
    max: int := 0
    
    for i: int in int$from_to(1, sequence[int]$size(digits)-n) do
        cur: int := 0
        for j: int in int$from_to(0, n-1) do
            cur := 10*cur + digits[i+j]
        end
        if cur<min then min:=cur end
        if cur>max then max:=cur end
    end
    return(min, max)
end find_min_max

start_up = proc ()
    % Seed the RNG with the current time
    d: date := now()
    random$seed(d.second + 60*(d.minute + 60*d.hour))
    
    % Find the minimum and maximum 5-adjacent numbers in a 1000-digit number
    min, max: int := find_min_max(5, random_digits(1000)) 
    
    po: stream := stream$primary_output()
    stream$putl(po, "Smallest: " || int$unparse(min))
    stream$putl(po, "Largest: " || int$unparse(max))
end start_up
Output:
Smallest: 144
Largest: 99951

Delphi

Works with: Delphi version 6.0
Library: SysUtils,StdCtrls


function Get5DigitNumber(S: string; Off: integer): integer;
{Extract 5 digit number from string at Off}
var I: integer;
var NS: string;
begin
NS:=Copy(S,Off,5);
Result:=StrToIntDef(NS,-1);
end;



function BreakupString(S: string): string;
{Breakup thousand digit number for easy display}
var I: integer;
begin
for I:=1 to Length(S) do
 	begin
 	Result:=Result+S[I];
 	if (I mod 55)=0 then Result:=Result+#$0D#$0A;
 	end;
end;

procedure FiveDigitNumber(Memo: TMemo);
{Find the largest and small 5 digit sequence}
{in 1000 digit number}
var S: string;
var N,I: integer;
var Largest,Smallest: integer;
begin
Smallest:=High(Integer);
Largest:=0;
for I:=1 to 1000 do
 S:=S+Char(Random(10)+$30);
for I:=1 to Length(S)-5 do
	begin
	N:=Get5DigitNumber(S,I);
	if N>Largest then Largest:=N;
	if N<Smallest then Smallest:=N;
	end;
Memo.Lines.Add(BreakupString(S));
Memo.Lines.Add('Largest: '+IntToStr(Largest));;
Memo.Lines.Add('Smallest: '+IntToStr(Smallest));;
end;
Output:
0082263134040802937368731342824182794880115050767752659
6926207485596307977119758620628125911215421677000178364
7438810001625238336693427757455861441056098692774612931
9301856160395349334087194184285169534216966507128749101
0333045468523586265833674268791722749102838792380205401
7335212073765802860114410575280403628540910018912794058
9569778977033072890894634763659190635686944921467068416
0978402580498879216810854417805724457730620420683349740
8203884243646784563247619038458645194136841413688117232
0960606571886477139587251334596793042923055521495533796
5592094928040937883628134090110628164451939278452734493
5741344340195488542852682604882967292438604245256357719
4755578568409079269700382959730067457921191314413220282
3502307407547002586284406642530858066838890257743184196
5040611036453640792847940715686736822030381083124941163
3588177613294220880152655471721880286144478485085399563
1095924640071825166992021998152653370680394470682198029
3879102724160697653653330275506532525946257246355415772
4978409544
Largest: 99815
Smallest: 16


F#

// Largest five adjacent number. Nigel Galloway: September 28th., 2021
let n()=let n()=System.Random().Next(10) in Seq.unfold(fun g->Some(g,(g%10000)*10+n()))(n()*10000+n()*1000+n()*100+n()*10+n())
printfn $"Largest 5 adjacent digits are %d{(n()|>Seq.take 995|>Seq.max)}"
Output:
Largest 5 adjacent digits are 99914

EasyLang

for i to 1000
   n$ &= random 10 - 1
.
min = 99999
for i = 1 to 995
   n = number substr n$ i 5
   min = lower min n
   max = higher max n
.
print min & " " & max
Output:
21 99768

Factor

Works with: Factor version 0.99 2021-06-02
USING: grouping io math.functions prettyprint random sequences ;

1000 10^ random unparse 5 <clumps> supremum print
Output:
99987

FreeBASIC

Generate the number digit by digit, and test as we go. If the task didn't specifically ask to generate the whole 1,000 digit number I wouldn't bother storing more than five of its digits at a time. 

randomize timer
dim as ubyte number(0 to 999)
dim as uinteger seg, highest = 0, lowest = 100000
for i as uinteger = 0 to 999
    number(i) = int(rnd*10)
    if i >= 4 then
        seg = number(i) + 10*number(i-1) + 100*number(i-2) +_
              1000*number(i-3) + 10000*number(i-4)
        if seg < lowest then lowest = seg
        if seg > highest then highest = seg
    end if
next i 
print highest, lowest
Output:
99748         31

Go

Translation of: Wren
Library: Go-rcu
package main

import (
    "fmt"
    "math/rand"
    "rcu"
    "strings"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    var sb strings.Builder
    for i := 0; i < 1000; i++ {
        sb.WriteByte(byte(rand.Intn(10) + 48))
    }
    number := sb.String()
    for i := 99999; i >= 0; i-- {
        quintet := fmt.Sprintf("%05d", i)
        if strings.Contains(number, quintet) {
            ci := rcu.Commatize(i)
            fmt.Printf("The largest  number formed from 5 adjacent digits (%s) is: %6s\n", quintet, ci)
            break
        }
    }
    for i := 0; i <= 99999; i++ {
        quintet := fmt.Sprintf("%05d", i)
        if strings.Contains(number, quintet) {
            ci := rcu.Commatize(i)
            fmt.Printf("The smallest number formed from 5 adjacent digits (%s) is: %6s\n", quintet, ci)
            return
        }
    }
}
Output:

Sample run: 

The largest  number formed from 5 adjacent digits (99928) is: 99,928
The smallest number formed from 5 adjacent digits (00120) is:    120

J

>./5([+10*])/@|:\?1000#10
Output:

(example) 

99929

jq

Works with: jq

Also works with gojq, the Go implementation of jq.

First, a direct solution using only jq's standard library and a line for generating the PRN: 

< /dev/random tr -cd '0-9' | head -c 1000 | jq -R '
  length as $n
  | . as $s
  | ($s[0:5] | tonumber) as $m
  | reduce range(1; $n - 5) as $i ( {min: $m, max: $m};
      ($s[$i: $i+5] | tonumber) as $x
      | if   $x < .min then .min = $x 
        elif $x > .max then .max = $x 
        else . end)
'
Output:
{
  "min": 224,
  "max": 99772
}

Next, a "one-line solution" apart from generic helper functions and the line for generating the PRN: 

< /dev/random tr -cd '0-9' | head -c 1000 | jq -R '
  # Input: an array
  # Output: a stream of the width-long subarrays
  def windows(width):
    range(0; 1 + length - width)  as $i | .[$i:$i+width];

  def minmax(s):
    reduce s as $x ( {};
      if .min == null then {min: $x, max: $x}
      elif $x < .min then .min = $x
      elif $x > .max then .max = $x else . end);

  explode | minmax(windows(5) | implode | tonumber)

Julia

dig = rand(0:9, 1000)
@show maximum(evalpoly(10, dig[i:i+4]) for i in 1:length(dig)-4)
Output:
maximum((evalpoly(10, dig[i:i + 4]) for i = 1:length(dig) - 4)) = 99993

Or, using strings, and see Nigel's comment in the discussion: 

julia> setprecision(3324)
3324

julia> s = string(BigFloat(pi))[3:end]
"141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365" ⋯ 180 bytes ⋯ "66940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019898"

julia> m, pos = maximum((s[i:i+4], i) for i in 1:length(s)-4)
("99999", 763)

julia> println("Maximum is $m at position $pos.")
Maximum is 99999 at position 763.

Mathematica / Wolfram Language

MinMax[FromDigits /@ Partition[RandomInteger[{0, 9}, 1000], 5, 1]]
Output:
{104,99984}

Nim

import random, strutils

randomize()

const N = 1000
type Digit = 0..9

# Build a 1000-digit number.
var number: array[1..N, Digit]
number[1] = rand(1..9)  # Make sure the first digit is not 0.
for i in 1..N: number[i] = rand(9)

func `>`(s1, s2: seq[Digit]): bool =
  ## Compare two digit sequences.
  ## Defining `<` rather than `>` would work too.
  assert s1.len == s2.len
  for i in 0..s1.high:
    let comp = cmp(s1[i], s2[i])
    if comp != 0: return comp == 1
  result = false

var max = @[Digit 0, 0, 0, 0, 0]
for i in 5..N:
  let n = number[i-4..i]
  if n > max: max = n

echo "Largest 5-digit number extracted from random 1000-digit number: ", max.join()
Output:
Largest 5-digit number extracted from random 1000-digit number: 99855

Pascal

Works with: Free Pascal

inspired by Wren
Assumes that there at least is a "1" 4 digits before end of all digits.Else I have to include sysutils and s := Format('%.5d',[i]); for leading zeros. 

var
  digits,
  s : AnsiString;
  i : LongInt;
begin
  randomize;
  setlength(digits,1000);
  for i := 1 to 1000 do
    digits[i] := chr(random(10)+ord('0'));
  for i := 99999 downto 0 do
  begin
    str(i:5,s);
    if Pos(s,digits) > 0 then
      break;
  end;
  writeln(s, ' found as largest 5 digit number ')
end.
Output:
99889 found as largest 5 digit number

Perl

#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Largest_five_adjacent_number
use warnings;

$_ = join '', map int rand 10, 1 .. 1e3;
my @n;
@n[ /(?=(\d{5}))/g ] = ();
print "$#n\n";
Output:
99899

Phix

with javascript_semantics
procedure shlong(string s)
    string hi5 = s[1..5], lo5 = hi5
    for i=2 to length(s)-4 do
        string s5 = s[i..i+4]
        hi5 = max(hi5,s5)
        lo5 = min(lo5,s5)
    end for
    printf(1,"String %s: hi5:%s, lo5:%s\n",{shorten(s),hi5,lo5})
end procedure

string s = repeat(' ',1000)
for i=1 to length(s) do
    s[i] = rand(10)-1+'0'
end for
shlong(s)

include mpfr.e
mpfr pi = mpfr_init(0,-1001) -- (set precision to 1,000 dp, plus the "3.")
mpfr_const_pi(pi)
s = mpfr_get_fixed(pi,1000)
s = s[3..$]
shlong(s)
Output:
String 35369847249221789712...55814915156742014134 (1,000 digits): hi5:99969, lo5:00013
String 14159265358979323846...66111959092164201989 (1,000 digits): hi5:99999, lo5:00031

Python

Seeding the random number generator directly with the datetime stamp produces a warning that it will be deprecated in Python 3.9, hence the "hack" of creating a string out of the timestamp and then seeding with it. 

#Aamrun, 5th October 2021

from random import seed,randint
from datetime import datetime

seed(str(datetime.now()))

largeNum = [randint(1,9)]

for i in range(1,1000):
    largeNum.append(randint(0,9))

maxNum,minNum = 0,99999

for i in range(0,994):
    num = int("".join(map(str,largeNum[i:i+5])))
    if num > maxNum:
        maxNum = num
    elif num < minNum:
        minNum = num

print("Largest 5-adjacent number found ", maxNum)
print("Smallest 5-adjacent number found ", minNum)

Results from multiple runs :

Output:


Largest 5-adjacent number found  99743
Smallest 5-adjacent number found  102


Largest 5-adjacent number found  99965
Smallest 5-adjacent number found  84


Largest 5-adjacent number found  99808
Smallest 5-adjacent number found  58


Largest 5-adjacent number found  99938
Smallest 5-adjacent number found  10


Largest 5-adjacent number found  99957
Smallest 5-adjacent number found  35

Quackery

  9 random 1+
  999 times [ 10 * 10 random + ]
  dup 10 995 ** / swap
  say "1000 digit number"
  cr cr
  dup echo
  cr cr
  [] swap 1000 times
     [ 10 /mod
         rot join swap ]
  drop dup
  0 0 rot witheach
    [ swap 10 *
      100000 mod +
      tuck max swap ]
  drop
  say "largest 5 adjacent digits " echo
  cr cr
  5 split nip
  dip dup witheach
    [ swap 10 *
      100000 mod +
      tuck min swap ]
  drop
  say "smallest 5 adjacent digits "
  number$
  char 0 over size 5 swap - of
  swap join echo$
Output:
1000 digit number

6840907174710710253578773992410923828010161316527489025709598588564725782830158923520744533291356763925463645174705745049218864529135157750600471363289558510223445011025163844199130052941524405130793922050669143532883592357897096269697903780509770222546659289832999639637730759831717125055857319129937934353617386529810429642261048827016148476352187592939822910964334104828550764225596939965675519243696921514153715258715961987394884393797714002723369560598384723111928648279375269590756880538160907807290640466592734345970439851284217252141914792365031610947925633607292897379320456985054219371373707477609843617810620097343420379245258762479642377134776965386535533204636182773979582543243782455626021964121509778973939346873293400502531060571761381532229278485105166678017234489439222625767334040651185482277484204647473910364297105035077787620562600454016296114868335345408156093266755340971022669397814048919735693462065796634326535292979494128432997646841467835174156471055078228524511787150409

largest 5 adjacent digits 99963

smallest 5 adjacent digits 00272

Raku

Show minimum too because... why not?

Use some Tamil Unicode numbers for brevity, and for amusement purposes. 

   ௰ - Tamil number ten
   ௲ - Tamil number one thousand

Do it 5 times for variety, it's random after all. 

(^௰).roll(௲).rotor(5 => -4)».join.minmax.bounds.put xx 5
Sample output:
00371 99975
00012 99982
00008 99995
00012 99945
00127 99972

Ring

digit = ""
max = 0
min = 99999
limit = 1000

for n = 1 to limit
    rand = random(9)
    randStr = string(rand)
    digit += randStr
next

for n = 1 to len(digit)-5
    res = substr(digit,n,5)
    resNum = number(res)
    if resNum > max 
       max = resNum
    ok
    if resNum < min
       min = res
    ok
next

see "The largest number is:" + nl
see max + nl
see "The smallest number is:" + nl
see min + nl
Output:
The largest number is:
99638
The smallest number is:
00118

RPL

RPL can not handle 1000-digit numbers, so we use a 1000-digit string. 

≪ "" 
   1 1000 START RAND 9 * 0 RND →STR + NEXT
   { -99999 0 } 
   1 3 PICK SIZE 4 - FOR j
      OVER j DUP 4 + SUB 
      STR→ NEG LASTARG 2 →LIST MAX 
   NEXT ABS
≫ 'TASK' STO
Output:
2: "46725324552811522…
1: { 198 99886 }

Ruby

digits = %w(0 1 2 3 4 5 6 7 8 9)
arr = Array.new(1000){ digits.sample }
puts "minimum sequence %s, maximum sequence %s." % arr.each_cons(5).minmax_by{|slice| slice.join.to_i}.map(&:join)
Output:
minimum sequence 00096, maximum sequence 99508.

Sidef

var k = 5
var n = 1e1000.irand

say "length(n) = #{n.len}"

var c = n.digits.cons(k)

say ("Min #{k}-digit sub-number: ", c.min_by { .digits2num }.flip.join)
say ("Max #{k}-digit sub-number: ", c.max_by { .digits2num }.flip.join)
Output:
length(n) = 1000
Min 5-digit sub-number: 00072
Max 5-digit sub-number: 99861

V (Vlang)

Translation of: go
import rand
import rand.seed
import strings

fn main() {
    rand.seed(seed.time_seed_array(2))
    mut sb := strings.new_builder(128)
    for _ in 0..1000 {
        sb.write_byte(u8(rand.intn(10) or {0} + 48))
    }
    number := sb.str()
    println('>> $number')
    for i := 99999; i >= 0; i-- {
        quintet := "${i:05}"
        if number.contains(quintet) {
            println("The largest  number formed from 5 adjacent digits ($quintet) is: ${i:6}")
            break
        }
    }
    for i := 0; i <= 99999; i++ {
        quintet := "${i:05}"
        if number.contains(quintet) {
            println("The smallest number formed from 5 adjacent digits ($quintet) is: ${i:6}")
            return
        }
    }
}
Output:
The largest  number formed from 5 adjacent digits (99928) is: 99,928
The smallest number formed from 5 adjacent digits (00120) is:    120

Wren

Library: Wren-fmt

Very simple approach as there's little need for speed here. 

import "random" for Random
import "./fmt" for Fmt

var rand = Random.new()
var digits = List.filled(1000, 0)
for (i in 0...999) digits[i] = rand.int(10)
var number = digits.join()
for (r in [99999..0, 0..99999]) {
    var target = (r.from == 0) ? "smallest" : "largest "
    for (i in r) {
        var quintet = Fmt.swrite("$05d", i)
        if (number.contains(quintet)) {
            Fmt.print("The $s number formed from 5 adjacent digits ($s) is: $,6d", target, quintet, i)
            break
        }
    }
}
Output:

Sample output: 

The largest  number formed from 5 adjacent digits (99830) is: 99,830
The smallest number formed from 5 adjacent digits (00154) is:    154

XPL0

char    Number(1000);
int     Num, Max, I, J;
[for I:= 0 to 1000-1 do         \generate 1000-digit number
        Number(I):= Ran(10);
Max:= 0;                        \find its largest 5-digit number
for I:= 0 to 1000-5 do
        [Num:= 0;
        for J:= 0 to 5-1 do
                Num:= Num*10 + Number(I+J);
        if Num > Max then
                Max:= Num;
        ];
IntOut(0, Max);
]
Output:
99930
Retrieved from "https://rosettacode.org/wiki/Largest_five_adjacent_number?oldid=363842"