Come posso stampare il numero più lungo in una stringa?

Sto cercando un metodo per stampare il numero più lungo in una stringa.

Ad esempio: se ho la stringa

212334123434test233

come posso stampare

212334123434

?

Nota: sto cercando la sequenza di numeri continua più lunga, non il valore numericamente più alto.

Modifica: grazie per le risposte, a tutti. La risposta a questa domanda è stata abbastanza travolgente. Ho contrassegnato il post di @ HaukeLaging come risposta accettata perché si adattava molto bene al mio caso specifico, ma vorrei sottolineare che tutte le risposte sono ugualmente valide. È sempre bello avere diverse opzioni per risolvere un problema.

echo 212334123434test233abc44 | 
awk '{gsub("[^0-9]+","\n"); print;}' | 
awk '{ if (length($0) > max) {max = length($0); maxline = $0} } 
  END { print maxline }'

212334123434

Credo che si può fare questo con un solo grep, sorte tailpure. Ecco alcune stringhe di esempio.

$ echo <str> | grep -oP "\d+" | sort -n | tail -1

Dov'è la <str>nostra stringa in questione.

Esempio

$ set -o posix; set | grep "str[0-9]"
str0=212334123434test233
str1=212334123434test233abc44
str2=233test212334123434
str3=a212334123434test233abc44
str4=a91234b212334123434abc

Ora, se eseguo questi tramite il mio grep ...comando a turno.

$ echo $str0 | grep -oP "\d+" | sort -n | tail -1
212334123434
$ echo $str1 | grep -oP "\d+" | sort -n | tail -1
212334123434
$ echo $str2 | grep -oP "\d+" | sort -n | tail -1
212334123434
$ echo $str3 | grep -oP "\d+" | sort -n | tail -1
212334123434
$ echo $str4 | grep -oP "\d+" | sort -n | tail -1
212334123434

Questo approccio funziona selezionando tutte le sottostringhe che sono sequenze di cifre. Ordiniamo quindi numericamente questo output sort -n, e quindi prendiamo l'ultimo valore nell'elenco, usando tail -1. Questa sarà la sottostringa più lunga.

Puoi vedere come funziona togliendo tail -1e rilanciando uno degli esempi:

$ echo $str4 | grep -oP "\d+" | sort -n
91234
212334123434

Stringhe che iniziano con zeri

L'approccio di cui sopra funziona per ogni situazione che potrei concepire tranne una. @terdon ha menzionato nella chat questo scenario che ostacola l'approccio sopra.

• 0000000000001
• 2

Quindi, per far fronte a questo, dovrai cambiare leggermente le tattiche. Il kernel dell'approccio sopra può ancora essere sfruttato, tuttavia è necessario iniettare anche il numero di caratteri nei risultati. Ciò consente di ordinare i risultati in base al numero di caratteri nelle stringhe e ai loro valori.

$ for i in $(echo $str0 | grep -oP "\d+");do a=$(echo "$i" | wc -c); \
    echo "$a $i"; done | sort -n | tail -1 | cut -d" " -f2

risultati:

$ echo $str0
0000000000001a2test

$ for i in $(echo $str0 | grep -oP "\d+");do a=$(echo "$i" | wc -c); \
    echo "$a $i"; done | sort -n | tail -1 | cut -d" " -f2
0000000000001

Puoi condensarlo un po 'sfruttando la capacità di Bash di determinare la lunghezza di una variabile usando ${#var}.

$ for i in $(echo $str0 | grep -oP "\d+");do echo "${#i} $i"; done | \
    sort -n | tail -1 | cut -d" " -f2
0000000000001

Usando `grep -P

Ho optato per l'uso grep -P ...sopra perché io, essendo uno sviluppatore Perl, mi piace la sintassi della classe di dire tutte le cifre in questo modo:, \d+invece di [[:digit:]]\+o [0-9]\+. Ma per questo particolare problema non è davvero necessario. Potresti scambiare facilmente l' grepho usato così:

$ .... grep -o "[0-9]\+" ....

Per esempio:

$ for i in $(echo $str0 | grep -o "[0-9]\+");do echo "${#i} $i"; done | \
    sort -n | tail -1 | cut -d" " -f2
0000000000001

Una soluzione in perl:

echo 212334123434test233abc44 |
perl -nle 'print ((
    map { $_->[0] }
    sort{ $a->[1] <=> $b->[1] }
    map { [$_,length] }
    split /\D+/, $_)[-1]
    )'
212334123434

Riferimenti

• Trasformazione di Schwartz

Utilizzando python con la stringa passata sulla riga di comando e supponendo che si desideri la prima sequenza di lunghezza massima:

import sys

longest = current = ""
for x in sys.argv[1]:
    if current and not x.isdigit():
        if len(current) > len(longest):
            longest = current
        current = ""
    else:
        current += x 
print(longest)

Ecco un altro approccio Perl che può gestire sia i decimali che i numeri interi:

echo "0.212334123434test233" | 
 perl -lne 'while(/([\d.]+)/g){$max=$1 if length($1) > length($max)} print $max'

Si noti che nessuna delle risposte finora pubblicate tratterà dei decimali e poiché si specifica che si desidera il numero più lungo e non il numero numericamente maggiore, suppongo che in realtà siano necessari decimali.

Spiegazione

• perl -lne: -nSignifica "leggi l'input riga per riga ed esegui lo script fornito da -eesso". Il -laggiunge un ritorno a capo ad ogni printchiamata (e altre cose che non interessano qui).
• while(/([\d.]+)/g): scorre tutti i numeri ( \dsignifica [0-9], quindi [\d.]corrisponderà alle cifre e .. Se vuoi anche trovare numeri negativi, aggiungi -. Le parentesi catturano la stringa corrispondente come quella $1usata nel passaggio successivo.
• $max=$1 if length($1) > length($max): Se la lunghezza della partita corrente è maggiore della più lunga finora ( $max), salva la partita come $max.
• print $max: stampa la stringa di numeri più lunga trovata. Questo verrà eseguito al termine del ciclo while, quindi dopo aver trovato tutti i numeri.

Dato

str="212334123434test233"

poi in bash

max=""
while read num; do 
  (( ${#num} > ${#max} )) && max=$num
done < <(grep -Eo '[0-9]+' <<< "$str")
echo $max
212334123434

Una soluzione bash forse più pura che utilizza un array costruito sostituendo i caratteri non numerici nella stringa con spazi bianchi, al posto del grep

max=""
declare -a nums="${str//[^[:digit:]]/ }"
for num in ${nums[@]}; do 
  (( ${#num} > ${#max} )) && max=$num
done
echo $max

Sulla base della risposta di @mikeserv, ecco un'altra alternativa. Estrae i numeri (secondo il metodo di Mikeserv), quindi li ordina in ordine numerico e prende l'ultimo. Escludendo gli zeri iniziali, questo ti darà il numero più grande (non tenendo conto del segno):

echo 1111askdlfm2234 |  printf %s\\n $(tr -sc 0-9 \ ) | sort -n | tail -1

bash e ordinamento GNU

IFS=$'\0' read -r l _ < <(tr -cs '[:digit:]' '[\0*]' <<<'11abcde1234556ghijk22'| sort -znr)
echo $l
1234556

Usa caratteri non numerici per dividere la stringa e trova la sequenza più lunga o il valore numerico più grande (per numeri di uguale lunghezza) con un operatore ternario.

$ echo "212334123434test233" | awk -F'[^0-9]+' '{for(i=1;i<=NF;i++){m=length($i)>=length(m)||$i>m?$i:m}};END{print m}'
212334123434

Puoi anche impostare il separatore di record ( RS) di awk come qualsiasi stringa di caratteri non numerica:

$ echo "212334123434test233" \
    | awk -v RS='[^0-9]+' '
        length(longest) < length($0) {longest = $0};
        END{print longest}'
212334123434