Largest five adjacent number

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

Task

Extra credit

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

11l

Translation of: Python

<lang 11l>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))</lang>

Output:

Largest 5-digit number extracted from random 1000-digit number: 99902
Smallest 5-digit number extracted from random 1000-digit number: 00043

Ada

<lang 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;</lang>

Output:

The largest number :  99625
The smallest number:  102

ALGOL 68

Adding the minimum number for good measure... <lang algol68>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</lang>

Output:

Largest  5 consecutive digits from 1000 random digits: 99987
Smallest 5 consecutive digits from 1000 random digits: 00119

APL

Works with: Dyalog APL

Output:

(example)

AutoHotkey

<lang 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</lang>

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)

} </lang>

Output:

look for 5 digit number using 1000 digits
largest  99873 in positions 300-304
smallest 00099 in positions 697-701

BQN

<lang bqn>⌈´(⊣+10×⊢)˝⌽⍉5↕1000 •rand.Range 10</lang>

Output:

(example)

CLU

<lang 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</lang>

Output:

Smallest: 144
Largest: 99951

<lang fsharp> // 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)}" </lang>

Output:

Largest 5 adjacent digits are 99914

Factor

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: grouping io math.functions prettyprint random sequences ;

1000 10^ random unparse 5 <clumps> supremum print</lang>

Output:

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. <lang freebasic> 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 </lang>

Output:

99748         31

Go

Translation of: Wren

Library: Go-rcu

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

}</lang>

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

Output:

(example)

Julia

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

</lang>

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

<lang Mathematica>Max[FromDigits /@ Partition[RandomInteger[{0, 9}, 1000], 5, 1]]</lang>

Output:

Nim

<lang 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()</lang>

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.

<lang pascal> 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.</lang>

Output:

99889 found as largest 5 digit number

Perl

<lang 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";</lang>

Output:

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. <lang Python>

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) </lang> 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

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.

<lang perl6>(^௰).roll(௲).rotor(5 => -4)».join.minmax.bounds.put xx 5</lang>

Sample output:

00371 99975
00012 99982
00008 99995
00012 99945
00127 99972

Ring

<lang ring> digit = "" max = 0 min = 99999 limit = 1000

for n = 1 to limit

   rand = random(9)
   randStr = string(rand)
   digit += randStr

   res = substr(digit,n,5)
   resNum = number(res)
   if resNum > max 
      max = resNum
   ok
   if resNum < min
      min = res
   ok

Output:

The largest number is:
99638
The smallest number is:
00118

Ruby

<lang 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) </lang>

Output:

minimum sequence 00096, maximum sequence 99508.

Wren

Library: Wren-fmt

Very simple approach as there's little need for speed here. <lang ecmascript>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
       }
   }

}</lang>

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

<lang 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); ]</lang>

Output:

Largest five adjacent number

Contents

11l

Ada

ALGOL 68

APL

AutoHotkey

AWK

BQN

C

CLU

F#

Factor

FreeBASIC

Go

J

Julia

Mathematica / Wolfram Language

Nim

Pascal

Perl

Phix

Python

Raku

Ring

Ruby

Wren

XPL0