Здравствуйте, Gaperton, Вы писали:

G>Ваши примеры с Linq — ужасны, и проигрывают компрехеншнсам. При этом, в них по своей сути нет ничего, что не могло бы быть сделано при помощи простых ФВП и циклов. Никакой принципиальной разницы, и преимущества нет. Только закрученный на ровном месте код, и все.

G>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.

Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

Здравствуйте, Lloyd, Вы писали:

G>>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.
L>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

Show me your code.

Здравствуйте, Геннадий Васильев, Вы писали:

G>>>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.
L>>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

ГВ>Show me your code.

Для начала посмотри код Gaperton-а. Есть подозрение, что он не без ошибок.

Здравствуйте, Lloyd, Вы писали:

G>>>>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.
L>>>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.
ГВ>>Show me your code.

L>Для начала посмотри код Gaperton-а. Есть подозрение, что он не без ошибок.

Кстати, да. Вместо "+ 1" в функции p должен быть "- 1". Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Здравствуйте, Lloyd, Вы писали:

G>>>>>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.
L>>>>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.
ГВ>>>Show me your code.

L>>Для начала посмотри код Gaperton-а. Есть подозрение, что он не без ошибок.

ГВ>Кстати, да. Вместо "+ 1" в функции p должен быть "- 1". Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.

Это не единственная ошибка, заложенная в функцию p. Еще там должно стоять i > 0, а не i > 1. То есть, правильное условие — это

i > 0 && x[ i — 1 ] == x[ i ] — 1

Здравствуйте, Геннадий Васильев, Вы писали:

L>>Для начала посмотри код Gaperton-а. Есть подозрение, что он не без ошибок.

ГВ>Кстати, да. Вместо "+ 1" в функции p должен быть "- 1". Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.

Не только, ищи дальше.

Здравствуйте, Геннадий Васильев, Вы писали:

L>>Для начала посмотри код Gaperton-а. Есть подозрение, что он не без ошибок.

ГВ>Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.

Ну это еще цветочки. Ты не видел какой мрак получается с бесконечными последовательностями.

Здравствуйте, Lloyd, Вы писали:

ГВ>>Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.
L>Ну это еще цветочки. Ты не видел какой мрак получается с бесконечными последовательностями.

Дык, я уже трепещу. Давай, свей мой разум в невозможную фигуру!

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>>>Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.
L>>Ну это еще цветочки. Ты не видел какой мрак получается с бесконечными последовательностями.

ГВ>Дык, я уже трепещу. Давай, свей мой разум в невозможную фигуру!

Ща, свой сперва раскукожу.

Здравствуйте, Gaperton, Вы писали:

G>Это не единственная ошибка, заложенная в функцию p. Еще там должно стоять i > 0, а не i > 1. То есть, правильное условие — это

G>i > 0 && x[ i — 1 ] == x[ i ] — 1

А на обработке канала слабо написать? А то мне сейчас до юниксов тянуться долго.

Здравствуйте, Lloyd, Вы писали:

G>>Ваши примеры с Linq — ужасны, и проигрывают компрехеншнсам. При этом, в них по своей сути нет ничего, что не могло бы быть сделано при помощи простых ФВП и циклов. Никакой принципиальной разницы, и преимущества нет. Только закрученный на ровном месте код, и все.

G>>Подозреваю, что и с вашим Linq эту задачу можно решить так же. В противном случае он бы вообще никуда не годился.

L>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

Код будет, или тебе и правда по существу возразить совсем нечего? Не ожидал как-то от тебя. Ты просил пример с циклом — вот тебе пример с циклом, и еще с эквивалентным comprehensions впридачу. Что теперь-то тебя удерживает от демонстрации немерянной крутизны линка вне контекста "реляционных" задач? Просим-просим. Что стесняться-то, все свои.

Здравствуйте, Геннадий Васильев, Вы писали:

G>>Это не единственная ошибка, заложенная в функцию p. Еще там должно стоять i > 0, а не i > 1. То есть, правильное условие — это

G>>i > 0 && x[ i — 1 ] == x[ i ] — 1

ГВ>А на обработке канала слабо написать? А то мне сейчас до юниксов тянуться долго.

Использовать канал в качестве итератора? Я думал об этом, но отмел этот вариант, так как почувствовал, что он будет сложнее. Давай попробую, почему нет.

Здравствуйте, Геннадий Васильев, Вы писали:

ГВ>Кстати, да. Вместо "+ 1" в функции p должен быть "- 1". Только сути это не меняет — всё равно пока решения на Linq либо до мрачности сложны, либо сильно похожи на обычный цикл.

Ну, по мелочи — двоеточие пропустил. Вот здесь.

for i, val := range x {

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

Здравствуйте, Gaperton, Вы писали:

L>>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

G>Код будет, или тебе и правда по существу возразить совсем нечего? Не ожидал как-то от тебя. Ты просил пример с циклом — вот тебе пример с циклом, и еще с эквивалентным comprehensions впридачу.

Я просил не пример с циклами, а пример, решающий задачу. Чувствуешь разницу?

G>Что теперь-то тебя удерживает от демонстрации немерянной крутизны линка вне контекста "реляционных" задач? Просим-просим. Что стесняться-то, все свои.

Буде

Здравствуйте, Gaperton, Вы писали:

G>Ну, по мелочи — двоеточие пропустил. Вот здесь.

G>for i, val := range x {

И это еще не конец. Эх, Gaperton, вроде и язык простой и задача простая, а столько ошибок на пустом месте.
Как же так?

Здравствуйте, Lloyd, Вы писали:

G>>Код будет, или тебе и правда по существу возразить совсем нечего? Не ожидал как-то от тебя. Ты просил пример с циклом — вот тебе пример с циклом, и еще с эквивалентным comprehensions впридачу.

L>Я просил не пример с циклами, а пример, решающий задачу. Чувствуешь разницу?

Не чувствую. Вот тебе код, где я поправил три опечатки. Длина не изменилась (замена двух символов, вставка третьего). Видишь ошибки в алгоритме — покажи их, и все. Зачем намеками-то говорить?

func ( x []int ) p( i int ) bool {
    return i > 0 && x[ i - 1 ] == x[ i ] - 1
}

func gena_1( x []int ) []int {
    res := vector.NewIntVector(0)
    
    for i, val := range x {
        if x.p( i ) && !x.p( i - 1 ) {
            res.Push( val )
        }
    }

    return res.Data()
}

G>>Что теперь-то тебя удерживает от демонстрации немерянной крутизны линка вне контекста "реляционных" задач? Просим-просим. Что стесняться-то, все свои.

L>Буде

Хорошо.

Здравствуйте, Gaperton, Вы писали:

L>>Я просил не пример с циклами, а пример, решающий задачу. Чувствуешь разницу?

G>Не чувствую. Вот тебе код, где я поправил три опечатки. Длина не изменилась (замена двух символов, вставка третьего). Видишь ошибки в алгоритме — покажи их, и все. Зачем намеками-то говорить?

Там два условия:
1) елемент на единицу больше предыдущего.
2)

при этом извлечённый элемент не должен принимать участия в последующем сравнении

Ты же заменил 2-е условие на другое:

при этом предшествующий элемент не должен удовлетворять первому условию

А такая замена некорректна.

Здравствуйте, Lloyd, Вы писали:

L>>>Толсто, Gaperton, очень толсто. От вас я ожидал более умного троллинга.

G>>Код будет, или тебе и правда по существу возразить совсем нечего? Не ожидал как-то от тебя. Ты просил пример с циклом — вот тебе пример с циклом, и еще с эквивалентным comprehensions впридачу.

L>Я просил не пример с циклами, а пример, решающий задачу. Чувствуешь разницу?

Второй пример. Беру твой код.

int lastNdx = int.MinValue;
var q1 = Enumerable.Range(1, arr.Length - 1).Where(i => {
    if (i == lastNdx + 1 || arr[i] != arr[i - 1] + 1) {
        return false;
    } else {
        lastNdx = i;
        return true;
    }
}).Select(i => arr[i]);

и, не трогая алгоритма и структуры кода, втупую вычищаю из него весь линк.

lastNdx := -1
res := vector.NewIntVector(0)

for i, val := range arr {
 if i == lastNdx + 1 || arr[i] != arr[i - 1] + 1 {
      continue
 } 
 lastNdx = i
 res.Push( val )
}

От чего твоему коду сильно легчает, и становится заметно, что это простейшая императивная реализация.

Вот тебе еще один пример с циклом, который проще чем твой вариант с линком.

Здравствуйте, Геннадий Васильев, Вы писали:

L>>Ну это еще цветочки. Ты не видел какой мрак получается с бесконечными последовательностями.

ГВ>Дык, я уже трепещу. Давай, свей мой разум в невозможную фигуру!

Кушать подано:

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    static void Main(string[] args) {
        var arr = new[] { 1, 2, 3, 7, 8, 9, 10 };
        var q = arr
            .Zip(arr.Skip(1), (prev, curr) => new { curr, prev })
            .Select((item, i) => new { item.curr, item.prev, i })
            .Where(item => item.curr == item.prev + 1)
            .AttachState(
                () => new { include = true, prev = -1 },
                (item, prevState) => new {
                    include = !prevState.include || (prevState.prev + 1 != item.i),
                    prev = item.i
                },
                (item, state) => new { item.curr, state.include }
            )
            .Where(item => item.include)
            .Select(item => item.curr);

        foreach (var item in q) {
            Console.WriteLine(item);
        }
    }
}

public static class StateEnumerableExtensions {
    public static IEnumerable<TResult> AttachState<T, TState, TResult>(
        this IEnumerable<T> source,
        Func<TState> getInitialState,
        Func<T, TState, TState> getNextState,
        Func<T, TState, TResult> selector
    ) {
        var state = getInitialState();
        foreach (var item in source) {
            yield return selector(item, state);
            state = getNextState(item, state);
        }
    }
}

Здравствуйте, Gaperton, Вы писали:

G>От чего твоему коду сильно легчает, и становится заметно, что это простейшая императивная реализация.

G>Вот тебе еще один пример с циклом, который проще чем твой вариант с линком.

Ну вот, превратил занятную головоломку для последующих supporter-ов в какое-то банальное унылое г**но.