Jak wyświetlić losową linię z pliku tekstowego?

Próbuję napisać skrypt powłoki. Chodzi o to, aby wybrać losowo pojedynczą linię z pliku tekstowego i wyświetlić ją jako powiadomienie na pulpicie Ubuntu.

Ale chcę, aby przy każdym uruchomieniu skryptu były wybierane różne wiersze. Czy jest na to jakieś rozwiązanie? Nie chcę całego skryptu. Tylko ta prosta rzecz.

Możesz użyć shufnarzędzia do drukowania losowych linii z pliku

$ shuf -n 1 filename

-n : liczba linii do wydrukowania

Przykłady:

$ 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

Możesz także użyć sortpolecenia, aby uzyskać losową linię z pliku.

sort -R filename | head -n1

Tak dla zabawy, tutaj jest czystą rozwiązanie bash , który nie korzysta shuf, sort, wc, sed, head, taillub jakiekolwiek inne narzędzia zewnętrzne.

Jedyna przewaga nad shuf wariantem jest to, że jest nieco szybszy, ponieważ jest czystym uderzeniem. Na moim komputerze, dla pliku 1000 linii shufwariant zajmuje około 0,1 sekundy, podczas gdy poniższy skrypt zajmuje około 0,01 sekundy;) Tak więc, chociaż shufjest to najłatwiejszy i najkrótszy wariant, jest on szybszy.

Szczerze mówiąc nadal wybrałbym shufrozwiązanie, chyba że wysoka wydajność jest ważnym problemem.

#!/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"

Powiedz, że masz plik notifications.txt. Musimy policzyć całkowitą liczbę linii, aby określić zakres generatora losowego:

$ cat notifications.txt | wc -l

Napiszmy do zmiennej:

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

Teraz do wygenerowania liczby od 0do $LINEużyjemy RANDOMzmiennej.

$ echo $[ $RANDOM % LINES]

Napiszmy do zmiennej:

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

Teraz musimy tylko wydrukować ten numer wiersza:

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

O firmie RANDOM:

   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.

Upewnij się, że plik ma mniej niż 32767 numerów linii. Zobacz to, jeśli potrzebujesz większego generatora losowego, który działa od razu po wyjęciu z pudełka.

Przykład:

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

Oto skrypt w języku Python, który wybiera losową linię z plików wejściowych lub standardowego wejścia:

#!/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

Algorytm to czas O (n), przestrzeń O (1). Działa dla plików większych niż 32767 linii. Nie ładuje plików wejściowych do pamięci. Czyta każdą linię wejściową dokładnie raz, tzn. Można do niej wstawić dowolną dużą (ale skończoną) treść. Oto wyjaśnienie algorytmu .

Jestem pod wrażeniem pracy, którą wykonała Malte Skoruppa i inni, ale tutaj jest o wiele prostszy sposób „czystej bash”:

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

Jak niektórzy zauważyli, $ RANDOM nie jest przypadkowy. Jednak limit rozmiaru pliku wynoszący 32767 wierszy zostaje pokonany przez połączenie łańcuchów $ RANDOM w razie potrzeby.