open System

let digitSum (n: int) : int =
    let rec sumDigits acc num =
        if num = 0 then acc
        else sumDigits (acc + (num % 10)) (num / 10)
    sumDigits 0 (abs n)

let countDivisors (n: int) : int =
    let absN = abs n
    if absN = 0 then 0
    elif absN = 1 then 1
    else
        [1..absN]
        |> List.filter (fun x -> absN % x = 0)
        |> List.length

let sortByDescending (lst: int list) : int list =
    lst |> List.sortByDescending id

let sortByDigitSumAscending (lst: int list) : int list =
    lst 
    |> List.sortBy (fun x -> (digitSum x, -(abs x)))

let sortByDivisorCountDescending (lst: int list) : int list =
    lst 
    |> List.sortBy (fun x -> (-(countDivisors x), -(abs x)))

let createTupleList (listA: int list) (listB: int list) (listC: int list) : (int * int * int) list =
    let sortedA = sortByDescending listA
    let sortedB = sortByDigitSumAscending listB
    let sortedC = sortByDivisorCountDescending listC
    
    let minLength = [List.length sortedA; List.length sortedB; List.length sortedC] |> List.min
    
    [0..minLength-1]
    |> List.map (fun i -> (sortedA.[i], sortedB.[i], sortedC.[i]))

let analyzeList (lst: int list) (name: string) : unit =
    printfn "Анализ списка %s: %A" name lst
    printfn "  Суммы цифр: %A" (lst |> List.map digitSum)
    printfn "  Количество делителей: %A" (lst |> List.map countDivisors)
    printfn "  По убыванию: %A" (sortByDescending lst)
    printfn "  По возрастанию суммы цифр: %A" (sortByDigitSumAscending lst)
    printfn "  По убыванию количества делителей: %A" (sortByDivisorCountDescending lst)
    printfn ""

let validateUniqueness (lst: int list) (name: string) : bool =
    let unique = lst |> List.distinct
    let isUnique = List.length lst = List.length unique
    if not isUnique then
        printfn "Предупреждение: список %s содержит повторяющиеся элементы!" name
    isUnique

let createTupleListSafe (listA: int list) (listB: int list) (listC: int list) : (int * int * int) list =
    let _ = validateUniqueness listA "A"
    let _ = validateUniqueness listB "B"
    let _ = validateUniqueness listC "C"
    createTupleList listA listB listC

let demonstrateSorting (lst: int list) (name: string) : unit =
    printfn "Демонстрация сортировки для списка %s: %A" name lst
    
    let withDigitSum = lst |> List.map (fun x -> (x, digitSum x))
    let withDivisors = lst |> List.map (fun x -> (x, countDivisors x))
    
    printfn "  Элементы с суммой цифр: %A" withDigitSum
    printfn "  Элементы с количеством делителей: %A" withDivisors
    
    printfn "  Сортировка по возрастанию суммы цифр:"
    withDigitSum 
    |> List.sortBy (fun (x, sum) -> (sum, -(abs x)))
    |> List.iter (fun (x, sum) -> printfn "    %d (сумма цифр: %d)" x sum)
    
    printfn "  Сортировка по убыванию количества делителей:"
    withDivisors 
    |> List.sortBy (fun (x, count) -> (-count, -(abs x)))
    |> List.iter (fun (x, count) -> printfn "    %d (делителей: %d)" x count)
    
    printfn ""

let getElementAtPosition (lst: 'a list) (position: int) (listName: string) : 'a option =
    if position >= 0 && position < List.length lst then
        Some lst.[position]
    else
        printfn "Позиция %d выходит за границы списка %s (длина: %d)" position listName (List.length lst)
        None

let createTupleListWithValidation (listA: int list) (listB: int list) (listC: int list) : (int * int * int) list =
    printfn "Создание списка кортежей из трех списков:"
    printfn "Список A: %A" listA
    printfn "Список B: %A" listB
    printfn "Список C: %A" listC
    printfn ""
    
    let sortedA = sortByDescending listA
    let sortedB = sortByDigitSumAscending listB
    let sortedC = sortByDivisorCountDescending listC
    
    printfn "После сортировки:"
    printfn "A (по убыванию): %A" sortedA
    printfn "B (по возрастанию суммы цифр): %A" sortedB
    printfn "C (по убыванию количества делителей): %A" sortedC
    printfn ""
    
    let minLength = [List.length sortedA; List.length sortedB; List.length sortedC] |> List.min
    printfn "Минимальная длина списков: %d" minLength
    printfn ""
    
    let result = [0..minLength-1] |> List.map (fun i -> (sortedA.[i], sortedB.[i], sortedC.[i]))
    
    printfn "Результирующие кортежи:"
    result |> List.iteri (fun i (a, b, c) -> printfn "  %d: (%d, %d, %d)" (i+1) a b c)
    printfn ""
    
    result

[<EntryPoint>]
let main argv =
    printfn "=== Задание 9: Составление списка кортежей из трех списков ==="
    printfn ""
    
    let testA1 = [10; 5; 20; 15; 8]
    let testB1 = [123; 45; 678; 12; 99]
    let testC1 = [12; 18; 24; 30; 6]
    
    printfn "Тест 1:"
    let result1 = createTupleListWithValidation testA1 testB1 testC1
    
    printfn "=== Детальный анализ списков ==="
    analyzeList testA1 "A1"
    analyzeList testB1 "B1"
    analyzeList testC1 "C1"
    
    let testA2 = [100; 50; 25; 75]
    let testB2 = [111; 222; 333; 444]
    let testC2 = [16; 20; 24; 28]
    
    printfn "Тест 2:"
    let result2 = createTupleListWithValidation testA2 testB2 testC2
    
    let testA3 = [7; 14; 21; 28; 35]
    let testB3 = [19; 28; 37; 46]
    let testC3 = [15; 21; 35; 45]
    
    printfn "Тест 3 (разные длины списков):"
    let result3 = createTupleListWithValidation testA3 testB3 testC3
    
    printfn "=== Демонстрация сортировки ==="
    demonstrateSorting testB1 "B1"
    demonstrateSorting testC1 "C1"
    
    printfn "=== Тест с повторяющимися элементами ==="
    let testA4 = [10; 20; 10; 30]
    let testB4 = [123; 123; 456]
    let testC4 = [12; 18; 12]
    
    printfn "Тест 4 (с повторяющимися элементами):"
    let result4 = createTupleListSafe testA4 testB4 testC4
    
    printfn "=== Тест граничных случаев ==="
    
    printfn "Тест 5 (пустые списки):"
    let result5 = createTupleList [] [] []
    printfn "Результат для пустых списков: %A" result5
    printfn ""
    
    printfn "Тест 6 (однозначные числа):"
    let testA6 = [9; 8; 7; 6; 5]
    let testB6 = [1; 2; 3; 4; 5]
    let testC6 = [6; 4; 3; 2; 1]
    let result6 = createTupleListWithValidation testA6 testB6 testC6
    
    printfn "=== Тест с отрицательными числами ==="
    let testA7 = [-10; -5; 15; 20]
    let testB7 = [-123; 45; -67; 89]
    let testC7 = [-12; 18; -24; 30]
    
    printfn "Тест 7 (с отрицательными числами):"
    let result7 = createTupleListWithValidation testA7 testB7 testC7
    
    0