Сконкатенировать список строк в фразу без запятой перед последней строкой и с “и”/”или” перед последней строкой.

Если у меня есть список строк, такой как {“A”, “B”, “C”, “D”}, какой код по динамической конкатенации будет самым чистым, чтобы объединить их в фразу без запятой перед последней строкой и с “и” или “или” перед последней строкой?

Например:
если у меня {“A”}, то должно быть “A”
если у меня {“A”,”B”}, то должно быть “A или B”
если у меня {“A”,”B”,”C”}, то должно быть “A, B или C”

Я бы разбил список на “последний элемент” и “все остальные”. Объединил бы “все остальные” с помощью string.Join и добавил “последний элемент” в конце. Крайние случаи – когда в списке только один или нет элементов.

string Concatenate(List<string> strings) {
    if (strings.Count < 2) {
        return strings.FirstOrDefault() ?? "";
    } else {
        return $"{string.Join(", ", strings[..^1])} или {strings[^1]}";
    }
}

Вот как я это сделал на C#, не уверен, что это самый чистый код, но проверено, что он работает для каждого из вышеуказанных сценариев:

var listOfStrings = new List<string>() { "A", "B", "C", "D" };
// замените на "и", если требуется
var concatenatorPhrase = "или";
var fullPhrase = new StringBuilder();
var firstString = listOfStrings.First();
listOfStrings.Remove(firstString);
fullPhrase.Append(firstString);
if (listOfStrings.Count > 0)
{
    var lastString = listOfStrings.Last();
    listOfStrings.Remove(lastString);

    if (listOfStrings.Count > 0)
    {
        fullPhrase.Append(", ");
        foreach (var str in listOfStrings)
        {
            fullPhrase.Append(str).Append(", ");
        }
    }

    fullPhrase.Append($"{concatenatorPhrase} ").Append(lastString);
}
fullPhrase.ToString()

Я рассмотрел как ваш вопрос, так и ответ. И я предоставил свой код соответственно. Вы модифицируете существующий список, удаляя элементы, что можно избежать. И ваш код не выглядит чистым.

var listOfStrings = new List<string> { "A", "B", "C", "D" };
var concatenatorPhrase = "или"; // Замените на "и", если требуется

string JoinStrings(List<string> strings, string separator)
{
    if (strings == null || strings.Count == 0) return string.Empty;
    if (strings.Count == 1) return strings[0];
    if (strings.Count == 2) return $"{strings[0]} {separator} {strings[1]}";

    var allButLast = strings.Take(strings.Count - 1);
    var lastString = strings.Last();
    return $"{string.Join(", ", allButLast)} {separator} {lastString}";
}

var fullPhrase = JoinStrings(listOfStrings, concatenatorPhrase);
Console.WriteLine(fullPhrase);

string[][] strings =
[
  ["A", "B", "C", "D"],
  ["A", "B", "C"],
  ["A", "B"],
  ["A"]
];
foreach (var arr in strings)
{
  string s = string.Join("", arr.Select((s, index) => s + arr.Count() switch
  {
    1 => "",
    _ => (index == arr.Count() - 1) ? "" : (index == arr.Count() - 2) ? " или " : ", "
  }));
  Console.WriteLine(s);
}

// Вывод:
// A, B, C или D
// A, B или C
// A или B
// A

Как насчёт этого:

    private static string CustomConcatenate(List<string> inputList)
    {
        var lengthOfList = inputList.Count;
        var listWithSeparators = inputList
            .Select((s, i) => ((i == 0) ? string.Empty : (i == lengthOfList - 1) ? " или " : ", ") + s);
        return string.Join("", listWithSeparators);
    }
    
// Тестовый случай XUnit просто чтобы проверить, дает ли функция ожидаемый результат или нет
    [Fact] 
    public void ConcatTest()
    {
        var givenLstWithMoreThan2Elmts = new List<string> { "A", "B", "C" };
        "A, B или C".Should().Be(CustomConcatenate(givenLstWithMoreThan2Elmts));
    
        // 2-й случай
        var givenLstWith2Elmts = new List<string> { "A", "B" };
        "A или B".Should().Be(CustomConcatenate(givenLstWith2Elmts));
    
        // 3-й случай
        var givenLst3 = new List<string> { "A" };
        "A".Should().Be(CustomConcatenate(givenLst3));
    }