1. C# / Говнокод #3529

    +118

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    public static IEnumerable<Tuple<A1, A2, A3, A4>> 
			CrossProduct<A1, A2, A3, A4>
			(IEnumerable<A1> arg1, IEnumerable<A2> arg2,
			IEnumerable<A3> arg3, IEnumerable<A4> arg4)
		{
			foreach (var a1 in arg1)
				foreach (var a2 in arg2)
					foreach (var a3 in arg3)
						foreach (var a4 in arg4)
							yield return Make.Tuple(a1, a2, a3, a4);
		}

    Интересно, а что этот человек будет делать, когда нужно будет n ступенек? :-)

    Запостил: tinynick, 21 Июня 2010

    Комментарии (14) RSS

    • ava Webkill 21.06.2010 16:43 # −8

      показать все, что скрытопохож ена результат работы F# или чего подобного. точно человек писал?
      Ответить

    • ava Инкрезон 22.06.2010 02:06 # −2

      А почему вы смеетесь? Если у человека правда четыре элемента?
      А если будет 5 -- то скопировать код ведь всегда легко!
      И что такое "n ступенек"? n -- это же не число!

      Я конечно завтра спрошу у Дениса Попова (он у нас в классе -- голова!), но скорее всего тут опечатка, потому что про n я не понял.
      Ответить

      • ava Webkill 22.06.2010 03:28 # −1

        > он у нас в классе -- голова

        <pretrosyan>А ты, стало быть, жопа?</pretrosyan>
        Ответить

      • ava tinynick 22.06.2010 10:54 # −1

        Я к тому, что количество ступенек может быть заранее неизвестным числом.

        Юмор в том, что можно просто взять SelectMany и сделать сколько угодно раз.
        Ответить

    • ava ReallyBugMeNot 22.06.2010 13:37 # +2

      Хотелось бы узнать "авторский ответ", а именно более простой способ получение идентичной функциональности, включая возвращаемый тип?
      Ответить

      • ava tinynick 23.06.2010 08:49 # 0

        Идентичной функциональности?
        IEnumerable<TR> Cross<T1, T2, TR>(IEnumerable<T1> xs, 
	IEnumerable<T2> ys, Func<T1, T2, TR> f)
{
	return xs.SelectMany(e => ys.Select(y => f(e, y)));
}

        соответственно
        var xs0 = new[] {"a", "b"};
var x1 = new[] {true, false};
var x2 = new[] {"x", "y", "z"};
var x3 = new[] {1, 2, 3};

var xs1 = Cross(xs0, x1, (t, x) => Make.Tuple(t, x));
var xs2 = Cross(xs1, x2, (t, x) => Make.Tuple(t._1, t._2, x));
var xs3 = Cross(xs2, x3, (t, x) => Make.Tuple(t._1, t._2, t._3, x));
Console.WriteLine(xs3.Count());

        Если же тип одинаковый, и у нас есть операция t (*) x, скажем конкатенация, то можно и для любого n. Да-да.
        Ответить

        • ava tinynick 23.06.2010 09:15 # 0

          Чтобы не быть голословным:
          var x1 = new[] { "a", "b" };
var x2 = new[] {"x", "y", "z"};
var x3 = new[] {"A", "B"};
var xxx = new IEnumerable<string>[] { x1, x2, x3 };

var yyy = xxx.Aggregate(
	(xs, ys) => Cross(xs, ys, (x, y) => x + y));
yyy.ForEach(Console.WriteLine);

          последняя строчка выведет:
          axA
          axB
          ayA
          ayB
          azA
          azB
          bxA
          bxB
          byA
          byB
          bzA
          bzB

          Естественно, количество элементов в xxx может быть любым ;-)
          Ответить

    Добавить комментарий