Range combo

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::open($save_path, $name) should either be compatible with SessionHandlerInterface::open(string $path, string $name): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 129

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::close() should either be compatible with SessionHandlerInterface::close(): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 280

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::read($session_id) should either be compatible with SessionHandlerInterface::read(string $id): string|false, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 151

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::write($session_id, $session_data) should either be compatible with SessionHandlerInterface::write(string $id, string $data): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 208

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::destroy($session_id) should either be compatible with SessionHandlerInterface::destroy(string $id): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 297

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: Return type of CI_Session_database_driver::gc($maxlifetime) should either be compatible with SessionHandlerInterface::gc(int $max_lifetime): int|false, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Filename: drivers/Session_database_driver.php

Line Number: 335

Backtrace:

File: /home/paste/public_html/application/controllers/Main.php
Line: 63
Function: library

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

A PHP Error was encountered

Severity: 8192

Message: filter_var(): Passing null to parameter #3 ($options) of type array|int is deprecated

Filename: core/Input.php

Line Number: 572

Backtrace:

File: /home/paste/public_html/application/models/Pastes.php
Line: 522
Function: ip_address

File: /home/paste/public_html/application/controllers/Main.php
Line: 592
Function: getPaste

File: /home/paste/public_html/index.php
Line: 284
Function: require_once

From Asbjørn, 8 Years ago, written in Delphi (Object Pascal).

URL https://paste.ie/view/7698f058

Embed

Download Paste or View Raw

program RangeCombo;

{$APPTYPE CONSOLE}

{$R *.res}

uses

System.SysUtils, System.Math, Generics.Defaults, Generics.Collections;

type

Func<TResult> = reference to function(): TResult;

Func<T, TResult> = reference to function(const Arg1: T): TResult;

Func<T1, T2, TResult> = reference to function(const Arg1: T1; const Arg2: T2): TResult;

// various algorithms

Alg = record

class function Aggregate<T, TAccumulate>(const Input: TArray<T>; const F: Func<TAccumulate, T, TAccumulate>): TAccumulate; overload; static;

class function Aggregate<T, TAccumulate>(const Input: TArray<T>; const InitialValue: TAccumulate; const F: Func<TAccumulate, T, TAccumulate>): TAccumulate; overload; static;

class function Sort<T>(const Input: TArray<T>): TArray<T>; overload; static;

end;

{ Alg }

class function Alg.Aggregate<T, TAccumulate>(const Input: TArray<T>;

const F: Func<TAccumulate, T, TAccumulate>): TAccumulate;

begin

result := Aggregate<T, TAccumulate>(Input, Default(TAccumulate), F);

end;

class function Alg.Aggregate<T, TAccumulate>(const Input: TArray<T>;

const InitialValue: TAccumulate;

const F: Func<TAccumulate, T, TAccumulate>): TAccumulate;

var

elm: T;

begin

result := InitialValue;

for elm in Input do

begin

result := F(result, elm);

end;

end;

class function Alg.Sort<T>(const Input: TArray<T>): TArray<T>;

begin

result := Copy(Input);

TArray.Sort<T>(result, TComparer<T>.Default);

end;

type

Range = record

First: integer;

Last: integer;

class operator Implicit(const Value: integer): Range;

end;

function IsSingularRange(const R: Range): boolean;

begin

result := (R.First = R.Last);

end;

{ Range }

class operator Range.Implicit(const Value: integer): Range;

begin

result.First := Value;

result.Last := Value;

end;

function CombineRanges(const Input: TArray<integer>): TArray<Range>;

var

sortedInput: TArray<integer>;

begin

sortedInput := Alg.Sort<integer>(Input);

result := Alg.Aggregate<integer, TArray<Range>>(sortedInput,

function(const Accumulator: TArray<Range>; const Value: integer): TArray<Range>

var

r: Range;

begin

if (Length(Accumulator) = 0) then

begin

result := [Value];

exit;

end;

r := Accumulator[High(Accumulator)];

if (Value > (r.Last + 1)) then

begin

// need a new range

result := Accumulator + [Value];

end

else

begin

// extend last range

result := Accumulator;

result[High(result)].Last := System.Math.Max(r.Last, Value);

end

end

);

end;

function ExpandRanges(const Input: TArray<Range>): TArray<integer>;

begin

result := Alg.Aggregate<Range, TArray<integer>>(Input,

function(const Accumulator: TArray<integer>; const Value: Range): TArray<integer>

var

i: integer;

begin

result := Accumulator;

for i := Value.First to Value.Last do

begin

result := result + [i];

end;

end

);

end;

var

input: TArray<integer>;

ranges: TArray<Range>;

r: Range;

values: TArray<integer>;

i: integer;

begin

input := [1,2,3,4,6,7,8,13,14];

try

ranges := CombineRanges(input);

for r in ranges do

begin

if (IsSingularRange(r)) then

WriteLn(r.First)

else

WriteLn(r.First, '-', r.Last);

end;

WriteLn;

WriteLn;

values := ExpandRanges(ranges);

for i in values do

begin

WriteLn(i);

end;

except

on E: Exception do

Writeln(E.ClassName, ': ', E.Message);

end;

WriteLn('done');

ReadLn;

end.

Author

Title

Language

Your paste - Paste your paste here

program RangeCombo;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils, System.Math, Generics.Defaults, Generics.Collections;

type
  Func<TResult> = reference to function(): TResult;
  Func<T, TResult> = reference to function(const Arg1: T): TResult;
  Func<T1, T2, TResult> = reference to function(const Arg1: T1; const Arg2: T2): TResult;

// various algorithms
  Alg = record
    class function Aggregate<T, TAccumulate>(const Input: TArray<T>; const F: Func<TAccumulate, T, TAccumulate>): TAccumulate; overload; static;
    class function Aggregate<T, TAccumulate>(const Input: TArray<T>; const InitialValue: TAccumulate; const F: Func<TAccumulate, T, TAccumulate>): TAccumulate; overload; static;
    class function Sort<T>(const Input: TArray<T>): TArray<T>; overload; static;
  end;

{ Alg }

class function Alg.Aggregate<T, TAccumulate>(const Input: TArray<T>;
  const F: Func<TAccumulate, T, TAccumulate>): TAccumulate;
begin
  result := Aggregate<T, TAccumulate>(Input, Default(TAccumulate), F);
end;

class function Alg.Aggregate<T, TAccumulate>(const Input: TArray<T>;
  const InitialValue: TAccumulate;
  const F: Func<TAccumulate, T, TAccumulate>): TAccumulate;
var
  elm: T;
begin
  result := InitialValue;
  for elm in Input do
  begin
    result := F(result, elm);
  end;
end;

class function Alg.Sort<T>(const Input: TArray<T>): TArray<T>;
begin
  result := Copy(Input);
  TArray.Sort<T>(result, TComparer<T>.Default);
end;

type
  Range = record
    First: integer;
    Last: integer;

class operator Implicit(const Value: integer): Range;
  end;

function IsSingularRange(const R: Range): boolean;
begin
  result := (R.First = R.Last);
end;

{ Range }

class operator Range.Implicit(const Value: integer): Range;
begin
  result.First := Value;
  result.Last := Value;
end;

function CombineRanges(const Input: TArray<integer>): TArray<Range>;
var
  sortedInput: TArray<integer>;
begin
  sortedInput := Alg.Sort<integer>(Input);

result := Alg.Aggregate<integer, TArray<Range>>(sortedInput,
    function(const Accumulator: TArray<Range>; const Value: integer): TArray<Range>
    var
      r: Range;
    begin
      if (Length(Accumulator) = 0) then
      begin
        result := [Value];
        exit;
      end;

r := Accumulator[High(Accumulator)];

if (Value > (r.Last + 1)) then
      begin
        // need a new range
        result := Accumulator + [Value];
      end
      else
      begin
        // extend last range
        result := Accumulator;
        result[High(result)].Last := System.Math.Max(r.Last, Value);
      end
    end
  );
end;

function ExpandRanges(const Input: TArray<Range>): TArray<integer>;
begin
  result := Alg.Aggregate<Range, TArray<integer>>(Input,
    function(const Accumulator: TArray<integer>; const Value: Range): TArray<integer>
    var
      i: integer;
    begin
      result := Accumulator;
      for i := Value.First to Value.Last do
      begin
        result := result + [i];
      end;
    end
  );
end;

var
  input: TArray<integer>;
  ranges: TArray<Range>;
  r: Range;
  values: TArray<integer>;
  i: integer;
begin
  input := [1,2,3,4,6,7,8,13,14];

try
    ranges := CombineRanges(input);

for r in ranges do
    begin
      if (IsSingularRange(r)) then
        WriteLn(r.First)
      else
        WriteLn(r.First, '-', r.Last);
    end;

WriteLn;
    WriteLn;

values := ExpandRanges(ranges);

for i in values do
    begin
      WriteLn(i);
    end;

except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  WriteLn('done');
  ReadLn;
end.

Create Shorturl - Create a shorter url that redirects to your paste?

Private - Private paste aren't shown in recent listings.

Delete After - When should we delete your paste?

Spam protection - Type in the letters

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

A PHP Error was encountered

Reply to "Range combo"