Como posso imprimir a sequência mais longa de linhas com números menores que um limite?

Perl uma linha:

perl -ne '$n = (split)[1]; if ($n > 2) {if ($i > $max) {$longest=$cur; $cur=""; $max=$i}; $i=0} else {$cur .= $n . "\n"; $i++} END {print $i > $max ? $cur : $longest}' < file.txt

Multilinha para melhor legibilidade:

perl -ne '
  $n = (split)[1];
  if ($n > 2) {
    if ($i > $max) {
      $longest=$cur;
      $cur="";
      $max=$i;
     }
     $i=0
  } else {
    $cur.= $n . "\n";
    $i++
  } 
  END {
    print $i > $max ? $cur : $longest
  }' < file.txt

Um forro com awk:

awk '$2 > 2 { if (i > max) {res=cur; cur=""; max=i} i=0} $2 < 2 {cur = cur $2 "\n"; i++} END {if (i > max) res=cur; printf res}' file.txt

Multilinha:

awk '
  $2 > 2 { 
    if (i > max) {
      res=cur
      cur=""
      max=i
    }
    i=0
  } 
  $2 < 2 {
    cur = cur $2 "\n"
    i++
  }
  END {
    if (i > max) res=cur
    printf res
  }' file.txt

Esta não é uma tarefa tão trivial. Também há debate se fornecer um programa finalizado é útil para outros aprenderem a resolver um problema em uma linguagem de programação, mas acredito que tem seus méritos, então proponho o seguinte programa (vamos chamá-lo de findlongestsequence.pl:

#!/usr/bin/perl
use strict;
use Getopt::Long;

my $limit; my $infile;
GetOptions( 'limit=f' => \$limit, 'infile=s' => \$infile );

my $lineno=0; my $groupstart;
my $currlength=0; my $maxlength=0; my $ingroup=0;
my @columns; my @groupbuf; my @longestgroup;

if (! open(fileinput, '<', "$infile" )) {exit 1;};
while (<fileinput>)
{
    $lineno++;
    @columns = split(/\s+/,$_);

    if ( $ingroup == 0 && $columns[1]<$limit )
    {
        $ingroup=1;
        $groupstart=$lineno;
        @groupbuf=();
    }

    if ( $ingroup == 1 )
    {
        if ($columns[1]>=$limit )
        {
            $ingroup=0;
            $currlength=$lineno-$groupstart;
    
            if ( $currlength>$maxlength )
            {
                $maxlength=$currlength;
                @longestgroup=@groupbuf;
            }
        }
        else
        {
            push(@groupbuf,$columns[1]);
        }
    }
}
close(fileinput);

if ( $ingroup == 1 )
{
    $currlength=$groupstart-$lineno;
    if ( $currlength>$maxlength )
    {
        $maxlength=$currlength;
        @longestgroup=@groupbuf;
    }
}

print join("\n",@longestgroup),"\n";
exit 0;

Você pode chamar o programa como

./findlongestsequence.pl --infile input.txt --limit 2.0

Isso primeiro interpretará os parâmetros da linha de comando usando Getopt::Long.

Em seguida, ele abrirá o arquivo e o lerá em linha, mantendo um contador de linha em $lineno. Cada linha será dividida em colunas no espaço em branco.

• Se o programa não estiver dentro de um grupo de linhas com valores < $limit( $ingroupé zero), mas encontrar uma linha adequada, ele registrará que agora está em tal grupo ( $ingroupdefinido como um), armazenará o início do grupo $groupstarte começará a armazenar em buffer o valores da coluna 2 em uma matriz @groupbuf.
• Se o programa estiver dentro de tal grupo, mas o valor atual for maior que $limit, ele reconhecerá o final do grupo e calculará seu comprimento. Se for maior que o grupo mais longo registrado anteriormente, o conteúdo ( @groupbuf) e o comprimento ( $currlength) do novo grupo mais longo serão copiados para @longestgroupe $maxlength, respectivamente.

Como é possível que um grupo seja encerrado no final do arquivo em vez de uma linha com valor > $limit, execute esta verificação também se $ingroupfor verdadeiro no final do arquivo.

No final, o conteúdo de @longestgroupé impresso \ncomo separador de token.

Usando qualquer awk:

$ cat tst.awk
$2 >= 2 {
    max = getMax(cur,max)
    cur = ""
    next
}
{ cur = cur $2 ORS }
END {
    printf "%s", getMax(cur,max)
}
function getMax(a,b) {
    return ( gsub(ORS,"&",a) > gsub(ORS,"&",b) ? a : b )
}

$ awk -f tst.awk file
1.19819
1.1113829
1.0953443
1.9458343
1.345645
1.3847385794
1.3534344

Talvez algo como:

<input perl -snle '
  if ($_ < $limit) {
    $n++;
  } else {
    $max = $n if $n > $max;
    $n = 0;
  }
  END {
    print ($n > $max ? $n : $max);
  }' -- -limit=2 -max=0

Ou se, em vez do número de linhas nesse maior grupo de linhas, você quiser ver essas linhas de acordo com as edições mais recentes da sua pergunta:

<input perl -snle '
  if ($_ < $limit) {
    push @lines, $_;
  } else {
    @max = @lines if @lines > @max;
    @lines = ();
  }
  END {
    print for @lines > @max ? @lines : @max;
  }' -- -limit=2

Se, como alguém editou na sua pergunta, os números das linhas fazem parte dos dados, adicione a -aopção (modo awk onde os registros são divididos no @Farray) e substitua $_(o registro inteiro) por $F[1](o segundo campo, $F[0]sendo o primeiro).

Solução idiomática utilizando <>para leitura a entrada e o operador flipflop.

#!/usr/bin/env perl
use strict;
use warnings;
# https://unix.stackexchange.com/questions/766081/how-to-print-the-longest-sequence-of-lines-featuring-numbers-smaller-than-a-thre
my $threshold = 2.00;
my ($section, $maxsection, $len, $maxlen);
my $flipflop;
while (<>) {
    # Remove leading line number
    s/^(\d+)\s+//;
    # Flip flop operator
    # https://www.effectiveperlprogramming.com/2010/11/make-exclusive-flip-flop-operators/
    if ($flipflop = $_ <= $threshold .. $_ > $threshold) {
        if ($flipflop =~ /E0$/) {
            # End of section
            if (!defined($maxlen) || $len > $maxlen) {
                $maxsection = $section;
                $maxlen = $len;
            }
            $len = 0;
            $section = "";
        } else {
            $len++;
            $section .= $_;
        }
    }
}
# One last possible end of section
if ($flipflop && $len > $maxlen) {
    $maxsection = $section;
}
print $maxsection;

Usando Raku (anteriormente conhecido como Perl_6)

~$ raku -ne 'BEGIN my (@max,@tmp);  $_ .= words;  \
             if .[1]  < 2 { @tmp.push: .[1] };    \
             if .[1] !< 2 { @max = @tmp if @tmp.elems > @max.elems; @tmp = Empty };  \
             END @max.elems >= @tmp.elems ?? (.put for @max) !! (.put for @tmp);'  file

OU:

~$ raku -ne 'BEGIN my (@max,@tmp);  $_ .= words;  \
             when .[1]  < 2 { @tmp.push: .[1] };  \
             default { @max = @tmp if @tmp.elems > @max.elems; @tmp = Empty };  \
             END @max.elems >= @tmp.elems ?? (.put for @max) !! (.put for @tmp);'  file

Aqui estão as respostas escritas em Raku, um membro da família Perl de linguagens de programação. Raku apresenta números racionais , caso você precise manter a precisão ao realizar operações matemáticas simples (por exemplo say 0.1 + 0.2 - 0.3;).

• A primeira resposta lê linhas $_usando -nesinalizadores linewise sem impressão automática. Tanto a @maxquanto @tmparray são declarados. A linha é quebrada em espaços em branco wordse .=salva novamente em $_. Se ( ifinstrução) a .[1]segunda coluna satisfizer os critérios, os valores serão pushinseridos na @tmpmatriz. Caso contrário, o @tmparray substitui o @maxarray se tiver mais elems(elementos). Independentemente disso, a @tmpmatriz está Empty(esvaziada). Para ENDgarantir que uma sequência contígua final seja/não a mais longa, o operador ternário Test ?? True !! False de Raku é usado para determinar puta matriz mais longa.

• A segunda resposta é semelhante à primeira, exceto que whensão usadas declarações. No Raku, uma vez whensatisfeita uma condicional, seu bloco associado é executado e o controle reverte para o bloco externo, ignorando quaisquer instruções whenor subsequentes default. Veja a referência abaixo.

Entrada de amostra:

1 16.3346384
2 11.43483
3 1.19819
4 1.1113829
5 1.0953443
6 1.9458343
7 1.345645
8 1.3847385794
9 1.3534344
10 2.1117454
11 1.17465
12 1.4587485

Saída de amostra:

1.19819
1.1113829
1.0953443
1.9458343
1.345645
1.3847385794
1.3534344

NOTA: O código acima produzirá a primeira sequência contígua mais longa no caso de empate.

https://docs.raku.org/syntax/when
https://docs.raku.org/
https://raku.org

Se você não quiser engenharia excessiva, tente esta linha de comando de linha única:

awk '{print $2}' yourfile.txt | sort -g > youroutput.txt

2. O primeiro comando escolherá a segunda coluna do seu arquivo
3. O segundo comando classificará a coluna selecionada com base na classificação numérica geral e gravará no arquivo de saída. Para mais detalhes e ajustes, verifique as páginas de manual de awke sort.