Уменьшить, сложить или отсканировать (влево / вправо)?

Обычно метод REDUCE, FOLD, SCAN работает, накапливая данные по LEFT и продолжая изменять переменную RIGHT. Основное различие между ними: REDUCE, FOLD: -

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

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

• Метод LEFT_REDUCE работает аналогично методу REDUCE.

• RIGHT_REDUCE противоположно reduceLeft, т.е. он накапливает значения в RIGHT и продолжает изменять левую переменную.

• reduceLeftOption и reduceRightOption похожи на left_reduce и right_reduce, только разница заключается в том, что они возвращают результаты в объект OPTION.

Часть выхода для упомянутого ниже кода будет: -

используя операцию scan над списком чисел (используя seed значение 0) List(-2,-1,0,1,2)

• {0, -2} = > - 2 {-2, -1} = > - 3 {-3,0} = > - 3 {-3,1} = > - 2 {-2, 2} = > 0 Список сканирования (0, -2, -3, -3, -2, 0)

• {0, -2} = > - 2 {-2, -1} = > - 3 {-3,0} = > - 3 {-3,1} = > - 2 {-2, 2} = > 0 scanLeft (a + b) Список (0, -2, -3, -3, -2, 0)

• {0, -2} = > - 2 {-2, -1} = > - 3 {-3,0} = > - 3 {-3,1} = > - 2 {-2, 2} = > 0 scanLeft (b + a) Список (0, -2, -3, -3, -2, 0)

• {2,0} = > 2 {1,2} = > 3 {0,3} = > 3 {-1,3} = > 2 {-2,2} = > 0 scanRight ( a + b) Список (0, 2, 3, 3, 2, 0)

• {2,0} = > 2 {1,2} = > 3 {0,3} = > 3 {-1,3} = > 2 {-2,2} = > 0 scanRight ( b + a) Список (0, 2, 3, 3, 2, 0)

с помощью операций reduce, fold над списком строк List("A","B","C","D","E")

• {A, B} = > AB {AB, C} = > ABC {ABC, D} = > ABCD {ABCD, E} = > ABCDE уменьшить (a + b) ABCDE
• {A, B} = > AB {AB, C} = > ABC {ABC, D} = > ABCD {ABCD, E} = > ABCDE reduceLeft (a + b) ABCDE
• {A, B} = > BA {BA, C} = > CBA {CBA, D} = > DCBA {DCBA, E} = > EDCBA reduceLeft (b + a) EDCB
• {D, E} = > DE {C, DE} = > CDE {B, CDE} = > BCDE {A, BCDE} = > ABCDE reduceRight (a + b) ABCDE
• {D, E} = > ED {C, ED} = > EDC {B, EDC} = > EDCB {A, EDCB} = > EDCBA reduceRight (b + a) EDCBA

Код:

object ScanFoldReduce extends App {

    val list = List("A","B","C","D","E")
            println("reduce (a+b) "+list.reduce((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  ")
                a+b
            }))

            println("reduceLeft (a+b) "+list.reduceLeft((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  ")
                a+b
            }))

            println("reduceLeft (b+a) "+list.reduceLeft((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  " )
                b+a
            }))

            println("reduceRight (a+b) "+list.reduceRight((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))

            println("reduceRight (b+a) "+list.reduceRight((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  ")
                b+a
            }))

            println("scan            "+list.scan("[")((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))
            println("scanLeft (a+b)  "+list.scanLeft("[")((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))
            println("scanLeft (b+a)  "+list.scanLeft("[")((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  " )
                b+a
            }))
            println("scanRight (a+b) "+list.scanRight("[")((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))
            println("scanRight (b+a) "+list.scanRight("[")((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  " )
                b+a
            }))
//Using numbers
     val list1 = List(-2,-1,0,1,2)

            println("reduce (a+b) "+list1.reduce((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  ")
                a+b
            }))

            println("reduceLeft (a+b) "+list1.reduceLeft((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  ")
                a+b
            }))

            println("reduceLeft (b+a) "+list1.reduceLeft((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  " )
                b+a
            }))

            println("      reduceRight (a+b) "+list1.reduceRight((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))

            println("      reduceRight (b+a) "+list1.reduceRight((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  ")
                b+a
            }))

            println("scan            "+list1.scan(0)((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))

            println("scanLeft (a+b)  "+list1.scanLeft(0)((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b
            }))

            println("scanLeft (b+a)  "+list1.scanLeft(0)((a,b)=>{
                print("{"+a+","+b+"}=>"+ (b+a)+"  " )
                b+a
            }))

            println("scanRight (a+b)         "+list1.scanRight(0)((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                a+b}))

            println("scanRight (b+a)         "+list1.scanRight(0)((a,b)=>{
                print("{"+a+","+b+"}=>"+ (a+b)+"  " )
                b+a}))
}