Question

I would like to print a database-table to STDOUT. If the table-width is greater than the screen-width I would like to cut the column each with the same percentage (unless a table-width has reached min_width) until the table fits in the screen. I’ve tried to solve this with the posted subroutine. Does somebody know a shorter and more elegant algorithm to solve this problem?

sub cal_size {
    my ( $maxcols, $ref ) = @_;         
    # $maxcols => screen width
    # $ref => ref to an AoA; holds the table
    my ( $max ) = cal_tab( $ref );
    # $max => ref to an array; holds the length of the longest string of each column
    # $tab = 2;
    if ( $max and @$max ) {
        my $sum = sum( @$max ) + $tab * @$max; 
        $sum -= $tab;
        my @max_tmp = @$max;
        my $percent = 0;
        while ( $sum > $maxcols ) {
            $percent += 0.5;
            if ( $percent > 99 ) {
                return;
            }
            my $count = 0;

            for my $i ( 0 .. $#max_tmp ) {
                # $min_width => columns width should not be less than $min_width if possible 
                next if $min_width >= $max_tmp[$i]; 
                # no need to cut if the column width id less than min_width
                next if $min_width >= minus_x_percent( $max_tmp[$i], $percent ); 
                # don't cut if column width become less than min_width 
                $max_tmp[$i] = minus_x_percent( $max_tmp[$i], $percent );
                $count++;
                last if $sum <= $maxcols;   
            }
            $min_width-- if $count == 0 and $min_width > 1; 
            # if no cuts but $sum > $maxcols reduce $min_width
            $sum = sum( @max_tmp ) + $tab * @max_tmp; 
            $sum -= $tab;
        }
        my $rest = $maxcols - $sum;
        while ( $rest > 0 ) { # distribute the rest
            my $count = 0;
            for my $i ( 0 .. $#max_tmp ) {
                if ( $max_tmp[$i] < $max->[$i] ) {
                    $max_tmp[$i]++;
                    $rest--;
                    $count++;
                    last if $rest < 1;
                }
            } 
            last if $count == 0;
            last if $rest < 1;
        }
        $max = [ @max_tmp ] if @max_tmp;
    }
    return $max;
}


sub minus_x_percent {
    my ( $value, $percent ) = @_;
    return int $value - ( $value * 1/100 * $percent );
}

Answer 1

This problem would be simple if it wasn’t for the lower limit for the field widths. Once a field cannot get any smaller only the larger ones are eligible for scaling, so the calculation varies depending on whether all, none, or some of the fields have been scaled down to their limit.

The scaling has several bands, one per unique field width. As the fields are scaled down in equal proportion the smallest of them will be the first to hit the minimum field size limit. After that only the columns bigger than the smallest size can be reduced any further until the second smallest also reaches the limit.

This continues until all columns have reached their minimum size, after which the available space is just divided equally between the columns.

This program implements the calculations for that algorithm, and I think does what you want.

Note that the returned field widths are floating-point values and you must round them as you see fit.

use strict;
use warnings;

use List::Util 'max';

my $min_col_width = 10;
my $tab = 2;

my $widths = recalc_widths(80, [ 10, 15, 20, 25, 30 ]);
print join '  ', map sprintf('%.3f', $_), @$widths;
print "\n";

sub recalc_widths {

  my ($target, $widths) = @_;
  $target -= (@$widths - 1) * $tab;

  my @sorted_widths = sort { $a <=> $b } @$widths;

  my $num_limited = 0;
  my $adjustable_total_width = 0;
  $adjustable_total_width += $_ for @sorted_widths;

  while (@sorted_widths) {

    my $boundary = $sorted_widths[0];

    my $scale = ($target - $num_limited * $min_col_width) / $adjustable_total_width;

    if ($boundary * $scale >= $min_col_width) {
      return [ map max($_ * $scale, $min_col_width), @$widths ];
    }

    while (@sorted_widths and $sorted_widths[0] == $boundary) {
      shift @sorted_widths;
      $adjustable_total_width -= $boundary;
      $num_limited++;
    }
  }

  return [ ($target / $num_limited) x $num_limited ];
}

output

10.000  10.333  13.778  17.222  20.667