¿Cómo mostrar una línea aleatoria de un archivo de texto?

Estoy tratando de escribir un script de shell. La idea es seleccionar una sola línea al azar del archivo de texto y mostrarla como una notificación de escritorio de Ubuntu.

Pero quiero que se seleccionen diferentes líneas cada vez que ejecuto el script. ¿Hay alguna solución para hacer esto? No quiero todo el guión. Solo esa cosa simple solamente.

Puede usar la shufutilidad para imprimir líneas aleatorias desde el archivo

$ shuf -n 1 filename

-n : número de líneas para imprimir

Ejemplos:

$ shuf -n 1 /etc/passwd

git:x:998:998:git daemon user:/:/bin/bash

$ shuf -n 2 /etc/passwd

avahi:x:84:84:avahi:/:/bin/false
daemon:x:2:2:daemon:/sbin:/bin/false

También puede usar el sortcomando para obtener una línea aleatoria del archivo.

sort -R filename | head -n1

Sólo por diversión, aquí hay una solución pura fiesta que no utiliza shuf, sort, wc, sed, head, tailu otras herramientas externas.

La única ventaja sobre la shufvariante es que es un poco más rápido, ya que es puro golpe. En mi máquina, para un archivo de 1000 líneas, la shufvariante tarda aproximadamente 0.1 segundos, mientras que el siguiente script tarda aproximadamente 0.01 segundos;) Entonces, si bien shufes la variante más fácil y más corta, esta es más rápida.

Honestamente, seguiría buscando la shufsolución, a menos que la alta eficiencia sea una preocupación importante.

#!/bin/bash

FILE=file.txt

# get line count for $FILE (simulate 'wc -l')
lc=0
while read -r line; do
 ((lc++))
done < $FILE

# get a random number between 1 and $lc
rnd=$RANDOM
let "rnd %= $lc"
((rnd++))

# traverse file and find line number $rnd
i=0
while read -r line; do
 ((i++))
 [ $i -eq $rnd ] && break
done < $FILE

# output random line
printf '%s\n' "$line"

Digamos que tienes archivo notifications.txt. Necesitamos contar el número total de líneas, para determinar el rango del generador aleatorio:

$ cat notifications.txt | wc -l

Vamos a escribir en la variable:

$ LINES=$(cat notifications.txt | wc -l)

Ahora para generar un número de 0a $LINEusaremos RANDOMvariable.

$ echo $[ $RANDOM % LINES]

Vamos a escribirlo en la variable:

$  R_LINE=$(($RANDOM % LINES))

Ahora solo necesitamos imprimir este número de línea:

$ sed -n "${R_LINE}p" notifications.txt

Acerca de ALEATORIO:

   RANDOM Each time this parameter is referenced, a random integer between
          0 and 32767 is generated.  The sequence of random numbers may be
          initialized by assigning a value to RANDOM.  If RANDOM is unset,
          it  loses  its  special  properties,  even if it is subsequently
          reset.

Asegúrese de que su archivo tenga menos de 32767 números de línea. Ver esto si necesita un generador aleatorio más grande que funcione de inmediato.

Ejemplo:

$ od -A n -t d -N 3 /dev/urandom | tr -d ' '

Aquí hay un script de Python que selecciona una línea aleatoria de los archivos de entrada o stdin:

#!/usr/bin/env python
"""Usage: select-random [<file>]..."""
import random

def select_random(iterable, default=None, random=random):
    """Select a random element from iterable.

    Return default if iterable is empty.
    If iterable is a sequence then random.choice() is used for efficiency instead.
    If iterable is an iterator; it is exhausted.
    O(n)-time, O(1)-space algorithm.
    """
    try:
        return random.choice(iterable) # O(1) time and space
    except IndexError: # empty sequence
        return default
    except TypeError: # not a sequence
        return select_random_it(iter(iterable), default, random.randrange)

def select_random_it(iterator, default=None, randrange=random.randrange):
    """Return a random element from iterator.

    Return default if iterator is empty.
    iterator is exhausted.
    O(n)-time, O(1)-space algorithm.
    """
    # from /programming//a/1456750/4279
    # select 1st item with probability 100% (if input is one item, return it)
    # select 2nd item with probability 50% (or 50% the selection stays the 1st)
    # select 3rd item with probability 33.(3)%
    # select nth item with probability 1/n
    selection = default
    for i, item in enumerate(iterator, start=1):
        if randrange(i) == 0: # random [0..i)
            selection = item
    return selection

if __name__ == "__main__":
    import fileinput
    import sys

    random_line = select_random_it(fileinput.input(), '\n')
    sys.stdout.write(random_line)
    if not random_line.endswith('\n'):
        sys.stdout.write('\n') # always append newline at the end

El algoritmo es O (n) -time, O (1) -space. Funciona para archivos de más de 32767 líneas. No carga archivos de entrada en la memoria. Lee cada línea de entrada exactamente una vez, es decir, puede canalizar contenido arbitrario de gran tamaño (pero finito). Aquí hay una explicación del algoritmo .

Estoy impresionado por el trabajo que hicieron Malte Skoruppa y otros, pero aquí hay una forma mucho más simple de hacerlo:

IFS=$'\012'
# set field separator to newline only
lines=( $(<test5) )
# slurp entire file into an array
numlines=${#lines[@]}
# count the array elements
num=$(( $RANDOM$RANDOM$RANDOM % numlines ))
# get a (more-or-less) random number within the correct range
line=${lines[$num]}
# select the element corresponding to the random number
echo $line
# display it

Como algunos han notado, $ RANDOM no es aleatorio. Sin embargo, el límite de tamaño de archivo de 32767 líneas se supera al unir $ RANDOM juntos según sea necesario.