SudokuSolverCara1::getAllVerticalValue() - Code Metrics - Inspection of "fixing issue travis config" - chipulaja/algo-backtrack-sudoku - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (785395)

by Syaiful

created 2021-01-01 22:50 UTC

SudokuSolverCara1::getAllVerticalValue() A

↳ Parent: SudokuSolverCara1

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	13
Ratio	100 %

Code Coverage

Tests	8
CRAP Score	4

Importance

Changes

Metric	Value
dl	13
loc	13
ccs	8
cts	8
cp	1
rs	9.8333
c	0
b	0
f	0
cc	4
nc	4
nop	2
crap	4

<?php

namespace Chipulaja\Algo\Backtrack\Sudoku;

class SudokuSolverCara1
{
    private $soal     = [];
    private $jawaban  = [];
    private $emptyLocation = [];

    public function tryToSolve(
        $data,
        $emptyLocation = [],
        $possibilitiesValue = [],
        $prevValue = null,
        $lastPosition = null,
        $tempSolusion = []
    ) {
        if (empty($emptyLocation)) {
            $emptyLocation = $this->getEmptyLocation($data);
            $this->soal = $data;
            $this->emptyLocation = $emptyLocation;
            foreach ($emptyLocation as $position => $location) {
                $possibilitiesValue[$position] = $this->getPossibilitiesValue(
                    $location,
                    $data
                );
            }
        }

        $newData = $data;
        if ($lastPosition === null) {
            $keysLocation = array_keys($emptyLocation);
            $lastPosition = (int)$keysLocation[0];
        }

        $record = false;
        foreach ($emptyLocation as $position => $location) {
            if (sizeof($tempSolusion) >= sizeof($emptyLocation)) {
                $this->jawaban = $tempSolusion;
                break;
            }

            if ($position == $lastPosition) {
                $record = true;
            }

            if ($record == false) {

                continue;
            }
            $lastPosition = $position;
            $value = $this->getNextValue($prevValue, $possibilitiesValue[$position]);
            if ($value === null) {
                $prevLocation = $this->getPrevLocation($lastPosition, $emptyLocation);
                $position = key($prevLocation);
                $lastPosition = $position;
                $x = $prevLocation[$position]["x"];
                $y = $prevLocation[$position]["y"];
                $prevValue = $tempSolusion[$lastPosition];
                $newData[$x][$y] = 0;
                array_pop($tempSolusion);

                $tempSolusion = $this->tryToSolve(
                    $newData,
                    $emptyLocation,
                    $possibilitiesValue,
                    $prevValue,
                    $position,
                    $tempSolusion
                );
            } else {
                $isValidValue = $this->isValidValue($location, $newData, $value);
                $x = $location["x"];
                $y = $location["y"];
                $newData[$x][$y] = $value;
                if ($isValidValue == true) {

                    $tempSolusion[$position] = $value;
                    $prevValue = null;
                } else {
                    $newData[$x][$y] = 0;
                    $tempSolusion = $this->tryToSolve(
                        $newData,
                        $emptyLocation,
                        $possibilitiesValue,
                        $value,
                        $position,
                        $tempSolusion
                    );
                    break;
                }
            }
        }

        return $tempSolusion;
    }

    public function getEmptyLocation($data)

    {
        $location = [];
        foreach ($data as $x => $cells) {
            foreach ($cells as $y => $value) {
                if (empty($value)) {
                    $position = (int)($x."".$y);
                    $location[$position] = [
                        'x' => $x,
                        'y' => $y
                    ];
                }
            }
        }

        return $location;
    }

    protected function getPossibilitiesValue($location, $data)
    {
        $allHorisontalValue = $this->getAllHorisontalValue($location, $data);
        $allVerticalValue = $this->getAllVerticalValue($location, $data);
        $allSquereValue = $this->getAllSquereValue($location, $data);
        $allValue = array_merge(
            $allHorisontalValue,
            $allVerticalValue,
            $allSquereValue
        );

        $possibilitiesValue = array_diff(range(1, 9), $allValue);
        $possibilitiesValue = array_values($possibilitiesValue);
        return $possibilitiesValue;
    }

    protected function getAllHorisontalValue($location, $data)

    {
        $horisontalValue = [];
        $x = $location['x'];
        for ($i=$x; $i<=$x; $i++) {
            for ($j=0; $j<9; $j++) {
                if (!empty($data[$i][$j])) {
                    $horisontalValue[] = $data[$i][$j];
                }
            }
        }
        return $horisontalValue;
    }

    protected function getAllVerticalValue($location, $data)

    {
        $verticalValue = [];
        $y = $location['y'];
        for ($i=0; $i<9; $i++) {
            for ($j=$y; $j<=$y; $j++) {
                if (!empty($data[$i][$j])) {
                    $verticalValue[] = $data[$i][$j];
                }
            }
        }
        return $verticalValue;
    }

    protected function getAllSquereValue($location, $data)
    {
        $squereValue = [];
        $x = $location['x'];
        $y = $location['y'];

        $iStart = 3 * floor($x/3);
        $iEnd   = $iStart + 2;
        $jStart = 3 * floor($y/3);
        $jEnd   = $jStart + 2;

        for ($i=$iStart; $i<=$iEnd; $i++) {

            for ($j=$jStart; $j<=$jEnd; $j++) {
                if (!empty($data[$i][$j])) {
                    $squereValue[] = $data[$i][$j];
                }
            }
        }
        return $squereValue;
    }

    protected function isValidValue($location, $data, $value)
    {
        $allHorisontalValue = $this->getAllHorisontalValue($location, $data);
        if (in_array($value, $allHorisontalValue)) {
            return false;
        }

        $allVerticalValue = $this->getAllVerticalValue($location, $data);
        if (in_array($value, $allVerticalValue)) {
            return false;
        }

        $allSquereValue = $this->getAllSquereValue($location, $data);
        if (in_array($value, $allSquereValue)) {
            return false;
        }

        return true;
    }

    protected function getPrevLocation($currentPosition, $emptyLocation)
    {
        while (key($emptyLocation) !== $currentPosition) {
            next($emptyLocation);
        }
        $location = prev($emptyLocation);
        $position = key($emptyLocation);

        return [$position => $location];
    }

    protected function getNextValue($value, $possibilitiesValue)
    {
        if (!is_numeric($value)) {
            return @$possibilitiesValue[0];
        }

        $key = array_search($value, $possibilitiesValue);

        return @$possibilitiesValue[$key+1];
    }

    public function getAnswerBoard()
    {
        $jawabanBoard = $this->soal;
        $emptyLocation = $this->emptyLocation;
        $jawaban = $this->jawaban;

        foreach ($emptyLocation as $position => $location) {
            $x = $location['x'];
            $y = $location['y'];
            $jawabanValue = $jawaban[$position];
            $jawabanBoard[$x][$y] = $jawabanValue;
        }
        return $jawabanBoard;
    }
}


1			<?php
2
3			namespace Chipulaja\Algo\Backtrack\Sudoku;
4
5			class SudokuSolverCara1
6			{
7			private $soal = [];
8			private $jawaban = [];
9			private $emptyLocation = [];
10
11	1		public function tryToSolve(
12			$data,
13			$emptyLocation = [],
14			$possibilitiesValue = [],
15			$prevValue = null,
16			$lastPosition = null,
17			$tempSolusion = []
18			) {
19	1		if (empty($emptyLocation)) {
20	1		$emptyLocation = $this->getEmptyLocation($data);
21	1		$this->soal = $data;
22	1		$this->emptyLocation = $emptyLocation;
23	1		foreach ($emptyLocation as $position => $location) {
24	1		$possibilitiesValue[$position] = $this->getPossibilitiesValue(
25	1		$location,
26	1		$data
27			);
28			}
29			}
30
31	1		$newData = $data;
32	1		if ($lastPosition === null) {
33	1		$keysLocation = array_keys($emptyLocation);
34	1		$lastPosition = (int)$keysLocation[0];
35			}
36
37	1		$record = false;
38	1		foreach ($emptyLocation as $position => $location) {
39	1		if (sizeof($tempSolusion) >= sizeof($emptyLocation)) {
40	1		$this->jawaban = $tempSolusion;
41	1		break;
42			}
43
44	1		if ($position == $lastPosition) {
45	1		$record = true;
46			}
47
48	1		if ($record == false) {
			0 ignored issues – show Coding Style Best Practice introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
49	1		continue;
50			}
51	1		$lastPosition = $position;
52	1		$value = $this->getNextValue($prevValue, $possibilitiesValue[$position]);
53	1		if ($value === null) {
54	1		$prevLocation = $this->getPrevLocation($lastPosition, $emptyLocation);
55	1		$position = key($prevLocation);
56	1		$lastPosition = $position;
57	1		$x = $prevLocation[$position]["x"];
58	1		$y = $prevLocation[$position]["y"];
59	1		$prevValue = $tempSolusion[$lastPosition];
60	1		$newData[$x][$y] = 0;
61	1		array_pop($tempSolusion);
62
63	1		$tempSolusion = $this->tryToSolve(
64	1		$newData,
65	1		$emptyLocation,
66	1		$possibilitiesValue,
67	1		$prevValue,
68	1		$position,
69	1		$tempSolusion
70			);
71			} else {
72	1		$isValidValue = $this->isValidValue($location, $newData, $value);
73	1		$x = $location["x"];
74	1		$y = $location["y"];
75	1		$newData[$x][$y] = $value;
76	1		if ($isValidValue == true) {
			0 ignored issues – show Coding Style Best Practice introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
77	1		$tempSolusion[$position] = $value;
78	1		$prevValue = null;
79			} else {
80	1		$newData[$x][$y] = 0;
81	1		$tempSolusion = $this->tryToSolve(
82	1		$newData,
83	1		$emptyLocation,
84	1		$possibilitiesValue,
85	1		$value,
86	1		$position,
87	1		$tempSolusion
88			);
89	1		break;
90			}
91			}
92			}
93
94	1		return $tempSolusion;
95			}
96
97	1	View Code Duplication	public function getEmptyLocation($data)
			1 ignored issue – show Duplication introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
98			{
99	1		$location = [];
100	1		foreach ($data as $x => $cells) {
101	1		foreach ($cells as $y => $value) {
102	1		if (empty($value)) {
103	1		$position = (int)($x."".$y);
104	1		$location[$position] = [
105	1		'x' => $x,
106	1		'y' => $y
107			];
108			}
109			}
110			}
111
112	1		return $location;
113			}
114
115	1		protected function getPossibilitiesValue($location, $data)
116			{
117	1		$allHorisontalValue = $this->getAllHorisontalValue($location, $data);
118	1		$allVerticalValue = $this->getAllVerticalValue($location, $data);
119	1		$allSquereValue = $this->getAllSquereValue($location, $data);
120	1		$allValue = array_merge(
121	1		$allHorisontalValue,
122	1		$allVerticalValue,
123	1		$allSquereValue
124			);
125
126	1		$possibilitiesValue = array_diff(range(1, 9), $allValue);
127	1		$possibilitiesValue = array_values($possibilitiesValue);
128	1		return $possibilitiesValue;
129			}
130
131	1	View Code Duplication	protected function getAllHorisontalValue($location, $data)
			0 ignored issues – show Duplication introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
132			{
133	1		$horisontalValue = [];
134	1		$x = $location['x'];
135	1		for ($i=$x; $i<=$x; $i++) {
136	1		for ($j=0; $j<9; $j++) {
137	1		if (!empty($data[$i][$j])) {
138	1		$horisontalValue[] = $data[$i][$j];
139			}
140			}
141			}
142	1		return $horisontalValue;
143			}
144
145	1	View Code Duplication	protected function getAllVerticalValue($location, $data)
			0 ignored issues – show Duplication introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
146			{
147	1		$verticalValue = [];
148	1		$y = $location['y'];
149	1		for ($i=0; $i<9; $i++) {
150	1		for ($j=$y; $j<=$y; $j++) {
151	1		if (!empty($data[$i][$j])) {
152	1		$verticalValue[] = $data[$i][$j];
153			}
154			}
155			}
156	1		return $verticalValue;
157			}
158
159	1		protected function getAllSquereValue($location, $data)
160			{
161	1		$squereValue = [];
162	1		$x = $location['x'];
163	1		$y = $location['y'];
164
165	1		$iStart = 3 * floor($x/3);
166	1		$iEnd = $iStart + 2;
167	1		$jStart = 3 * floor($y/3);
168	1		$jEnd = $jStart + 2;
169
170	1	View Code Duplication	for ($i=$iStart; $i<=$iEnd; $i++) {
			0 ignored issues – show Duplication introduced 2021-01-01 21:35 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
171	1		for ($j=$jStart; $j<=$jEnd; $j++) {
172	1		if (!empty($data[$i][$j])) {
173	1		$squereValue[] = $data[$i][$j];
174			}
175			}
176			}
177	1		return $squereValue;
178			}
179
180	1		protected function isValidValue($location, $data, $value)
181			{
182	1		$allHorisontalValue = $this->getAllHorisontalValue($location, $data);
183	1		if (in_array($value, $allHorisontalValue)) {
184	1		return false;
185			}
186
187	1		$allVerticalValue = $this->getAllVerticalValue($location, $data);
188	1		if (in_array($value, $allVerticalValue)) {
189	1		return false;
190			}
191
192	1		$allSquereValue = $this->getAllSquereValue($location, $data);
193	1		if (in_array($value, $allSquereValue)) {
194	1		return false;
195			}
196
197	1		return true;
198			}
199
200	1		protected function getPrevLocation($currentPosition, $emptyLocation)
201			{
202	1		while (key($emptyLocation) !== $currentPosition) {
203	1		next($emptyLocation);
204			}
205	1		$location = prev($emptyLocation);
206	1		$position = key($emptyLocation);
207
208	1		return [$position => $location];
209			}
210
211	1		protected function getNextValue($value, $possibilitiesValue)
212			{
213	1		if (!is_numeric($value)) {
214	1		return @$possibilitiesValue[0];
215			}
216
217	1		$key = array_search($value, $possibilitiesValue);
218
219	1		return @$possibilitiesValue[$key+1];
220			}
221
222	1		public function getAnswerBoard()
223			{
224	1		$jawabanBoard = $this->soal;
225	1		$emptyLocation = $this->emptyLocation;
226	1		$jawaban = $this->jawaban;
227
228	1		foreach ($emptyLocation as $position => $location) {
229	1		$x = $location['x'];
230	1		$y = $location['y'];
231	1		$jawabanValue = $jawaban[$position];
232	1		$jawabanBoard[$x][$y] = $jawabanValue;
233			}
234	1		return $jawabanBoard;
235			}
236			}
237

chipulaja / algo-backtrack-sudoku

Branch — master (785395)

SudokuSolverCara1::getAllVerticalValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like