Portál AbcLinuxu, 10. května 2025 16:40
/foo/bar/1/3/10 /foo/bar/1/3/11 /foo/bar/1/3/18 /foo/bar/1/3/2 /foo/bar/1/3/24 /foo/bar/1/3/25 /foo/bar/1/3/5 /foo/bar/1/3/6 /foo/bar/1/3/8 /foo/bar/1/3/9Tohle potřebuji
/foo/bar/1/3/2 /foo/bar/1/3/5 /foo/bar/1/3/6 /foo/bar/1/3/8 /foo/bar/1/3/9 /foo/bar/1/3/10 /foo/bar/1/3/11 /foo/bar/1/3/18 /foo/bar/1/3/24 /foo/bar/1/3/25Zkoušela jsem hledat, opravdu, nenašla jsem ale lautr nic :( Děkuji, V.
Řešení dotazu:
sort -n soubor
-k
, ale array? Buď používá pole v Bashi, nebo je to nějaký jiný jazyk a nevíme který… Pro ten jiný jazyk pak platí univerzální rada: pohledej, jak se jeho sortu předává vlastní komparační funkce.
Zkoušela jsem hledat, opravdu, nenašla jsem ale lautr nic :( Děkuji, V.
Domácí úkol nemáš hledat, máš ho vyřešit. Je to cvičení na obecné dovednosti kolem UNIXu a na základy programování, čtení manuálových stránek atd. Pokud bude někdo řešit úkoly za tebe, u zkoušky nebo zápočtového testu přijdou krušné chvíle.
Nespecifikuješ, jestli to musí být efektivní. Předpokládám, že ne. Tak prosím, tady je výstavní kvadratický hnus:
sort_by_number_after_last_slash() { local -i -r INT_MAX=9223372036854775807 # 2^63 - 1 local -n -r input_reference="$1" local -n output_reference="$2" local -a input=("${input_reference[@]}") local -i index sorting_key minimum minimum_index for index in "${!output_reference[@]}"; do unset output_reference[index] done while ((${#input[@]} > 0)); do minimum=INT_MAX for index in "${!input[@]}"; do sorting_key="${input[index]##*/}" if ((sorting_key < minimum)); then minimum=sorting_key minimum_index=index fi done output_reference+=("${input[minimum_index]}") unset input[minimum_index] done }
A tady je ukázka, jak se to používá (a drobný test, jestli to funguje, jak má):
declare -a unsorted_array=( '/foo/bar/1/3/10' '/foo/bar/1/3/11' '/foo/bar/1/3/18' '/foo/bar/1/3/2' '/foo/bar/1/3/24' '/foo/bar/1/3/25' '/foo/bar/1/3/5' '/foo/bar/1/3/6' '/foo/bar/1/3/8' '/foo/bar/1/3/9' ) declare -a sorted_array=('nonsense, should disappear') ########################################################### sort_by_number_after_last_slash unsorted_array sorted_array ########################################################### echo "Original array (must be unchanged):" for item in "${unsorted_array[@]}"; do echo "${item}" done echo "Sorted and unsorted array size (must be equal):" echo "${#sorted_array[@]}" "${#unsorted_array[@]}" echo "Sorted array (must be ... sorted):" for item in "${sorted_array[@]}"; do echo "${item}" done
Zapomněl jsem, že řídká pole se iterují v pořadí podle indexů. Takže i tohle by mohlo fungovat. Lepší řídká pole než řídká stolice. (Jenom to nesnese záporná čísla v těch názvech souborů, ale co už.)
sort_by_number_after_last_slash() { local -n -r input_reference="$1" local -n output_reference="$2" local -a input_map local item for item in "${input_reference[@]}"; do input_map["${item##*/}"]="${item}" done output_reference=() for item in "${input_map[@]}"; do output_reference+=("${item}") done }
Ještě bych dodal, jen tak z prdele, co s tím, kdyby to muselo být efektivní a kdyby to náhodou nesmělo využívat řídká pole v Bashi. #firstworldproblems
#becausewecan
Napřed si vyrobíme mergesort na integery:
mergesort() { local -n -r input_reference="$1" local -n output_reference="$2" local -r -i size="${#input_reference[@]}" local -a -i merge runs indices local -i index previous merged_idx \ run_a_idx run_a_stop \ run_b_idx run_b_stop output_reference=("${input_reference[@]}") if ((size == 0)); then return; fi previous=output_reference[0] runs=(0) for ((index = 0;;)) do for ((++index;; ++index)); do if ((index >= size)); then break 2; fi if ((output_reference[index] < previous)); then break; fi previous=output_reference[index] done previous=output_reference[index] runs+=(index) done runs+=(size) while (("${#runs[@]}" > 2)); do indices=("${!runs[@]}") merge=("${output_reference[@]}") for ((index = 0; index < "${#indices[@]}" - 2; index += 2)); do merged_idx=runs[indices[index]] run_a_idx=merged_idx previous=indices[$((index + 1))] run_a_stop=runs[previous] run_b_idx=runs[previous] run_b_stop=runs[indices[$((index + 2))]] unset runs[previous] while ((run_a_idx < run_a_stop && run_b_idx < run_b_stop)); do if ((merge[run_a_idx] < merge[run_b_idx])); then output_reference[merged_idx++]=merge[run_a_idx++] else output_reference[merged_idx++]=merge[run_b_idx++] fi done while ((run_a_idx < run_a_stop)); do output_reference[merged_idx++]=merge[run_a_idx++] done while ((run_b_idx < run_b_stop)); do output_reference[merged_idx++]=merge[run_b_idx++] done done done }A pak na to klidně napasujeme třídění těch cest k souborům. Míle a míle se táhnou těch cest. Tady už se ale řídká pole používají, ježto se mi to nechtělo řešit jinak, a v tom je ošklivost: Výraz
"${!input_map[@]}"
dá ty indexy už setříděné, takže následující mergesort
krok je úplně k hovnu. Ale to nevadí, když máme ten mergesort
tak úžasně efektivní, on se s tím moc párat nebude (1 běh a konec).
sort_by_number_after_last_slash() { local -n -r input_reference="$1" local -n output_reference="$2" local -a -i input output local -a input_map local item for item in "${input_reference[@]}"; do input_map["${item##*/}"]="${item}" done input=("${!input_map[@]}") mergesort input output # na hovno echo "${input[@]}" echo "${output[@]}" output_reference=() for item in "${output[@]}"; do output_reference+=("${input_map[item]}") done }Byť je tohle všechno na prd, jako zajímavá ukázka na hraní s Bashem to může být dobré (ten
mergesort
přinejmenším).
declare -a -i unsorted=(RANDOM RANDOM RANDOM RANDOM RANDOM) declare -a -i sorted mergesort unsorted sorted echo "${unsorted[@]}" echo "${sorted[@]}"
Tiskni
Sdílej:
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.