Factory and task leetcode

pkg/leetcode/numbers/README.md

@@ -0,0 +1,11 @@
+# Add Two Numbers
+
+ou are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+Example:
+
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+Explanation: 342 + 465 = 807.

pkg/leetcode/numbers/add_two_numbers.go

@@ -0,0 +1,69 @@
+package addtwonumbers
+
+// Calculater ...
+type Calculater interface {
+	AddTwoNumbers(l1 Lister, l2 Lister) Lister
+	addList(val int, head Lister) Lister
+}
+
+type addition struct {
+}
+
+// AddTwoNumbers ...
+func (a *addition) AddTwoNumbers(l1 Lister, l2 Lister) Lister {
+	var (
+		newList Lister
+		sum     int
+	)
+	for {
+		sum += l1.GetVal() + l2.GetVal()
+		if sum >= 10 {
+			newList = a.addList(sum-10, newList)
+			sum = 1
+		} else {
+			newList = a.addList(sum, newList)
+			sum = 0
+		}
+		if l1.GetNext() == nil && l2.GetNext() == nil && sum == 0 {
+			break
+		}
+		if l1.GetNext() == nil && l2.GetNext() == nil && sum == 1 {
+			newList = a.addList(sum, newList)
+			break
+		}
+		if l1.GetNext() != nil {
+			l1 = l1.GetNext()
+		} else {
+			l1.SetVal(0)
+		}
+		if l2.GetNext() != nil {
+			l2 = l2.GetNext()
+		} else {
+			l2.SetVal(0)
+		}
+	}
+	return newList
+}
+
+func (a *addition) addList(val int, head Lister) Lister {
+	next := head
+	if head == nil {
+		list := NewLister()
+		list.SetVal(val)
+		return list
+	}
+	for {
+		if next.GetNext() == nil {
+			list := NewLister()
+			list.SetVal(val)
+			next.SetList(list)
+			return head
+		}
+		next = next.GetNext()
+	}
+}
+
+// NewCalculater ...
+func NewCalculater() Calculater {
+	return &addition{}
+}

pkg/leetcode/numbers/creater.go

@@ -0,0 +1,52 @@
+package addtwonumbers
+
+// Lister ...
+type Lister interface {
+	SetVal(num int)
+	SetList(newList Lister)
+	GetArray(head Lister) []int
+	GetNext() Lister
+	GetVal() int
+}
+
+type listNode struct {
+	val  int
+	next Lister
+}
+
+// SetList ...
+func (l *listNode) SetList(newList Lister) {
+	l.next = newList
+}
+
+// SetVal ...
+func (l *listNode) SetVal(num int) {
+	l.val = num
+}
+
+// GetArray func to convert a list to an array
+func (l *listNode) GetArray(head Lister) []int {
+	var array []int
+	for {
+		if head == nil {
+			return array
+		}
+		array = append(array, head.GetVal())
+		head = head.GetNext()
+	}
+}
+
+// GetNext ...
+func (l *listNode) GetNext() Lister {
+	return l.next
+}
+
+// GetVal ...
+func (l *listNode) GetVal() int {
+	return l.val
+}
+
+// NewLister ...
+func NewLister() Lister {
+	return &listNode{}
+}

pkg/leetcode/numbers/numbers_test.go

@@ -0,0 +1,40 @@
+package addtwonumbers
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	testOneSuccess = "test one successfully"
+	testTwoSuccess = "test two fail"
+)
+
+func TestAddTwoNumbers(t *testing.T) {
+	obj := NewCalculater()
+	t.Run(testOneSuccess, func(t *testing.T) {
+		a := NewLister()
+		a.SetVal(1)
+		b := NewLister()
+		b.SetVal(9)
+		b.SetList(NewLister())
+		b.GetNext().SetVal(9)
+
+		got := obj.AddTwoNumbers(a, b)
+		want := &listNode{val: 0, next: &listNode{val: 0, next: &listNode{val: 1}}}
+		if !assert.EqualValues(t, want, got) {
+			t.Errorf("error func addTwoNumbers want %v got %v", want, got)
+		}
+	})
+	t.Run(testTwoSuccess, func(t *testing.T) {
+		a := &listNode{val: 1, next: &listNode{val: 9, next: &listNode{val: 1}}}
+		b := &listNode{val: 9, next: &listNode{val: 9}}
+		got := obj.AddTwoNumbers(a, b)
+		want := &listNode{val: 0, next: &listNode{val: 9, next: &listNode{val: 2}}}
+		if !assert.EqualValues(t, want, got) {
+			t.Errorf("error func addTwoNumbers want %v got %v", want, got)
+		}
+	})
+
+}

pkg/patterns/factory/README.md

@@ -0,0 +1,4 @@
+# Абстрактная фабрика (Abstract Factory)
+Паттерн Abstract Factory относится к порождающим паттернам уровня объекта.
+
+Паттерн Abstract Factory предоставляет общий интерфейс для создания семейства взаимосвязанных объектов. Это позволяет отделить функциональность системы от внутренней реализации каждого класса, а обращение к этим классам становится возможным через абстрактные интерфейсы.

pkg/patterns/factory/abstractFactory.go

@@ -0,0 +1,14 @@
+package factory
+
+type concreteProductA struct {
+}
+
+// DoSomething ...
+func (c *concreteProductA) DoSomething() string {
+	return "I am a PRODUCT A"
+}
+
+// NewEnterprise ...
+func NewEnterprise() Enterprise {
+	return &concreteFactoryA{}
+}

pkg/patterns/factory/abstractFactory_test.go

@@ -0,0 +1,23 @@
+package factory
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	testAbstractFactory = "Testing pattern abstract factory"
+)
+
+func TestAbstractFactory(t *testing.T) {
+	t.Run(testAbstractFactory, func(t *testing.T) {
+		x := NewEnterprise()
+		w := x.CreateProduct()
+		got := w.DoSomething()
+		want := "I am a PRODUCT A"
+		if !assert.EqualValues(t, want, got) {
+			t.Errorf("error test want %v got %v", want, got)
+		}
+	})
+}

pkg/patterns/factory/concrete_factory.go

@@ -0,0 +1,9 @@
+package factory
+
+type concreteFactoryA struct {
+}
+
+// CreateProduct ...
+func (c *concreteFactoryA) CreateProduct() Producer {
+	return &concreteProductA{}
+}

pkg/patterns/factory/factory.go

@@ -0,0 +1,6 @@
+package factory
+
+// Enterprise ...
+type Enterprise interface {
+	CreateProduct() Producer
+}

pkg/patterns/factory/producter.go

@@ -0,0 +1,6 @@
+package factory
+
+// Producer ...
+type Producer interface {
+	DoSomething() string
+}