Bash скрипт для обработки текстового файла

#!/usr/bin/env python3

with open("test-input.txt") as input_file:
    input_data = input_file.readlines()

dict = {}

for line in input_data:
    dict_key, dict_val = line.split("/")
    dict_val_list = list(map(int, dict_val.replace("\n", "").split(",")))
    try:
        if dict[dict_key]:
            new_value = sorted(list(set(dict[dict_key] + dict_val_list)))
            dict[dict_key] = new_value
    except KeyError:
        dict[dict_key] = dict_val_list

with open("test-output.txt", "w") as output_file:
    for k, v in dict.items():
        output_file.write("{}/{}\n".format(k, ",".join(str(x) for x in v)))

#!/usr/bin/env python3

from sys import stdin, stdout
from typing import Set, Dict, Iterable, Generator, TextIO
from argparse import ArgumentParser, FileType

WORD_SEPARATOR = '/'
KEYS_SEPARATOR = ','

parser = ArgumentParser()
parser.add_argument('input', nargs='?', type=FileType('r'),
                    default=stdin, help='input file')
parser.add_argument('output', nargs='?', type=FileType('w'),
                    default=stdout, help='output file')


def get_parsed_data(data: Iterable[str]) -> Dict[str, Set[str]]:
    parsed_data = {}

    for line in data:
        if WORD_SEPARATOR in line:
            word, keys = line.split(WORD_SEPARATOR)[:2]
            keys = keys.strip().split(KEYS_SEPARATOR)
            parsed_data.setdefault(word, set()).update(keys)

    return parsed_data


def gen_output(data: Dict[str, Iterable[str]]) -> Generator[str, None, None]:
    for word, keys in data.items():
        keys = sorted(map(int, keys))
        keys = KEYS_SEPARATOR.join(map(str, keys))
        line = WORD_SEPARATOR.join((word, keys))

        yield line


def main(input_file: TextIO, output_file: TextIO):
    input_data = input_file.readlines()
    parsed_data = get_parsed_data(input_data)
    output_data = sorted(gen_output(parsed_data))
    output_file.write('\n'.join(output_data))


if __name__ == '__main__':
    args = parser.parse_args()
    main(args.input, args.output)

#!/usr/bin/env bash

input_file="d.txt"
output_file="out.txt"
declare -i -a fa2 fa
declare -i i j ni ni1 t vi
previous_word=

exec > "$output_file"

make_out() {
	local i l
	for i; do l+=${l:+,}$i; done
	echo "$previous_word/$l"
}

while IFS=/ read current_word flags; do
	if [[ $previous_word == "$current_word" ]]; then
		IFS=, read -a fa2 <<< "$flags"
		# add uniq flags
		for i in ${fa[*]}; do
			for j in "${!fa2[@]}"; do
				[[ i -eq fa2[j] ]] && fa2[j]=-1
			done
		done
		for j in ${fa2[*]}; do
			[[ j -ne -1 ]] && fa+=(j)
		done
	else
		if [[ $previous_word ]]; then
			# sort
			ni=${#fa[@]}
			ni1=ni-1
			for ((i=0; i<ni1; i++)); do
				vi=fa[i]
				for ((j=i+1; j<ni; j++)); do
					if [[ fa[j] -lt vi ]]; then
						t=fa[j]
						fa[j]=vi
						vi=t
					fi
				done
				fa[i]=vi
			done

			make_out "${fa[@]}"
		fi
		previous_word=$current_word
		IFS=, read -a fa <<< "$flags"
	fi
done < "$input_file"

[[ $previous_word ]] && make_out "${fa[@]}"

#!/usr/bin/env bash

input_file="d.txt"
output_file="out.txt"
declare -i -a fa
declare -i i j
declare pw word flags

exec > "$output_file"

make_out() {
	if [[ $pw ]]; then
		local l
		local -i n=${#fa[@]} vi t
		# sort
		for ((i=0; i<n; i++)); do
			vi=fa[i]
			for ((j=i+1; j<n; j++)); do
				if [[ fa[j] -lt vi ]]; then
					t=fa[j]
					fa[j]=vi
					vi=t
				fi
			done
			l+=${l:+,}$vi
		done
		echo "$pw/$l"
		fa=()
	fi
	pw=$1
}

while IFS=/ read word flags; do
	[[ $pw != "$word" ]] && make_out "$word"
	# add uniq flags
	while read -d ',' j; do
		for i in ${fa[*]}; do
			[[ i -eq j ]] && continue 2
		done
		fa+=(j)
	done <<< "$flags,"
done < "$input_file"

make_out

if dict_key in dict