Reset author name to chosen name ✨
This commit is contained in:
@@ -0,0 +1,179 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>Lab3DArraysSort_ChloeFontenot.java</title>
|
||||
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
|
||||
<style type="text/css">
|
||||
<!--
|
||||
body {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
|
||||
pre {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
|
||||
table {color: #888888; background-color: #313335; font-family: monospace; font-weight: bold}
|
||||
.literal {color: #cc7832}
|
||||
.ST3 {font-family: monospace; font-weight: bold; font-style: italic}
|
||||
.ST0 {color: #287bde}
|
||||
.number {color: #6897bb}
|
||||
.string {color: #6a8759}
|
||||
.ST2 {color: #9876aa}
|
||||
.ST5 {color: #8a653b}
|
||||
.comment {color: #808080}
|
||||
.whitespace {color: #505050}
|
||||
.ST1 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
|
||||
.ST4 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
|
||||
-->
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP1_ChloeFontenot/src/main/java/com/chloefontenot/mp1_chloefontenot/Lab3DArraysSort_ChloeFontenot.java</td></tr></table>
|
||||
<pre>
|
||||
<span class="comment">/*</span>
|
||||
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt</span><span class="comment"> to change this license</span>
|
||||
<span class="comment"> */</span>
|
||||
<span class="literal">package</span> com.chloefontenot.mp1_chloefontenot;
|
||||
|
||||
<span class="comment">/**</span>
|
||||
<span class="comment"> *</span>
|
||||
<span class="comment"> * </span><span class="comment">@author</span> <span class="comment">chloe</span>
|
||||
<span class="comment">*/</span>
|
||||
<span class="literal">public</span> <span class="literal">class</span> Lab3DArraysSort_ChloeFontenot {
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">int</span> <span class="ST1">maxNumberOfColumnsInJagged2dArray</span>(<span class="literal">char</span>[][] ar) {
|
||||
<span class="literal">int</span> maxNumberOfColumns = <span class="number">0</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> row = <span class="number">0</span>; row < ar.<span class="ST2">length</span>; ++row) {
|
||||
<span class="literal">if</span> (ar[row].<span class="ST2">length</span> > maxNumberOfColumns) {
|
||||
maxNumberOfColumns = ar[row].<span class="ST2">length</span>;
|
||||
}
|
||||
}
|
||||
|
||||
<span class="literal">return</span> maxNumberOfColumns;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">printColumnMajorOrder</span>(<span class="literal">char</span>[][] ar) {
|
||||
<span class="literal">int</span> row = <span class="number">0</span>;
|
||||
<span class="literal">int</span> column = <span class="number">0</span>;
|
||||
<span class="literal">int</span> max = <span class="ST3">maxNumberOfColumnsInJagged2dArray</span>(ar);
|
||||
<span class="literal">for</span> (column = <span class="number">0</span>; column < max; ++column) {
|
||||
<span class="literal">for</span> (row = <span class="number">0</span>; row < ar.<span class="ST2">length</span>; ++row) {
|
||||
<span class="literal">if</span> (column < ar[row].<span class="ST2">length</span>) {
|
||||
System.<span class="ST4">out</span>.print(ar[row][column] + <span class="string">"</span> <span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
System.<span class="ST4">out</span>.println(<span class="string">"</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
|
||||
<span class="comment">/**</span>
|
||||
<span class="comment"> * </span><span class="comment">Prints</span> <span class="comment">row</span> <span class="comment">by</span> <span class="comment">row</span>
|
||||
<span class="comment"> *</span>
|
||||
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST5">ar</span>
|
||||
<span class="comment">*/</span>
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">printRowMajorOrder</span>(<span class="literal">char</span>[][][] array) {
|
||||
<span class="literal">for</span> (<span class="literal">char</span>[][] i: array) {
|
||||
System.<span class="ST4">out</span>.println(<span class="string">"</span><span class="string">---------------------------------</span><span class="string">"</span>);
|
||||
<span class="ST3">printRowMajorOrder</span>(i);
|
||||
}
|
||||
}
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">printRowMajorOrder</span>(<span class="literal">char</span>[][] ar)<span class="comment">//normal</span>
|
||||
{
|
||||
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x < ar.<span class="ST2">length</span>; ++x) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> y = <span class="number">0</span>; y < ar[x].<span class="ST2">length</span>; ++y) {
|
||||
System.<span class="ST4">out</span>.print(ar[x][y] + <span class="string">""</span>);
|
||||
}
|
||||
System.<span class="ST4">out</span>.println();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> String <span class="ST1">returnRowMajorOrder</span>(<span class="literal">char</span>[] ar)<span class="comment">//normal</span>
|
||||
{
|
||||
String returnString = <span class="string">""</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x < ar.<span class="ST2">length</span>; ++x) {
|
||||
returnString += ar[x];
|
||||
}
|
||||
<span class="literal">return</span> returnString;
|
||||
}
|
||||
|
||||
<span class="comment">/**</span>
|
||||
<span class="comment"> * </span><span class="comment">Sorts</span> <span class="comment">the</span> <span class="comment">methods</span> <span class="comment">in</span> <span class="comment">ascending</span> <span class="comment">order</span> <span class="comment">using</span> <span class="comment">Selection</span> <span class="comment">Sort</span>
|
||||
<span class="comment"> *</span>
|
||||
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST5">names</span> <span class="comment">the</span> <span class="comment">names</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">sorted</span>
|
||||
<span class="comment">*/</span>
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">sortNames</span>(<span class="literal">char</span>[][][] names) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> array = <span class="number">0</span>; array < names.<span class="ST2">length</span>; ++array) {
|
||||
System.<span class="ST4">out</span>.println(<span class="string">"</span><span class="string">times looped: </span><span class="string">"</span> + array);
|
||||
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i < names[array].<span class="ST2">length</span> - <span class="number">1</span>; ++i) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> j = i + <span class="number">1</span>; j < names[array].<span class="ST2">length</span>; ++j) {
|
||||
<span class="literal">char</span> compChar1 = names[array][i][<span class="number">0</span>], compChar2 = names[array][j][<span class="number">0</span>];
|
||||
<span class="comment">// Reoder entire row</span>
|
||||
<span class="literal">for</span> (<span class="literal">int</span> rowIterate = <span class="number">1</span>; rowIterate < <span class="ST3">maxNumberOfColumnsInJagged2dArray</span>(names[array]); ++rowIterate) {
|
||||
<span class="literal">if</span> (Character.<span class="ST3">toLowerCase</span>(compChar1) == Character.<span class="ST3">toLowerCase</span>(compChar2)) {
|
||||
<span class="literal">try</span> {
|
||||
compChar1 = names[array][i][rowIterate];
|
||||
compChar2 = names[array][j][rowIterate];
|
||||
} <span class="literal">catch</span> (Exception ex) {
|
||||
<span class="comment">// If it's failed, the index has gone out of range.</span>
|
||||
<span class="comment">// Check the length of the arrays and swap the larger one with the smaller one.</span>
|
||||
<span class="literal">if</span> (names[array][i].<span class="ST2">length</span> > names[array][j].<span class="ST2">length</span>) {
|
||||
System.<span class="ST4">out</span>.println(names[array][i].<span class="ST2">length</span> + <span class="string">"</span> <span class="string">"</span> + names[array][j].<span class="ST2">length</span>);
|
||||
System.<span class="ST4">out</span>.println(<span class="string">"</span><span class="string">Swapping </span><span class="string">"</span> + <span class="ST3">returnRowMajorOrder</span>(names[array][i]) + <span class="string">"</span><span class="string"> with </span><span class="string">"</span> + <span class="ST3">returnRowMajorOrder</span>(names[array][j]));
|
||||
<span class="literal">char</span>[] temp = names[array][i];
|
||||
names[array][i] = names[array][j];
|
||||
names[array][j] = temp;
|
||||
}
|
||||
<span class="literal">break</span>;
|
||||
}
|
||||
|
||||
}
|
||||
<span class="literal">if</span> (Character.<span class="ST3">toLowerCase</span>(compChar1) > Character.<span class="ST3">toLowerCase</span>(compChar2)) {
|
||||
System.<span class="ST4">out</span>.println(<span class="string">"</span><span class="string">Swapping </span><span class="string">"</span> + <span class="ST3">returnRowMajorOrder</span>(names[array][i]) + <span class="string">"</span><span class="string"> with </span><span class="string">"</span> + <span class="ST3">returnRowMajorOrder</span>(names[array][j]));
|
||||
<span class="literal">char</span>[] temp = names[array][i];
|
||||
names[array][i] = names[array][j];
|
||||
names[array][j] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">main</span>(String[] args) {
|
||||
<span class="comment">/*</span>
|
||||
<span class="comment">char[][] names = {</span>
|
||||
<span class="comment"> {'j', 'o', 'h', 'n'},</span>
|
||||
<span class="comment"> {'a', 'n'},</span>
|
||||
<span class="comment"> {'b', 'y', 'r', 'o', 'n'},};</span>
|
||||
<span class="comment"> */</span>
|
||||
<span class="comment">///*</span>
|
||||
<span class="literal">char</span>[][][] names = {
|
||||
{
|
||||
{<span class="string">'</span><span class="string">j</span><span class="string">'</span>, <span class="string">'</span><span class="string">o</span><span class="string">'</span>, <span class="string">'</span><span class="string">h</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">y</span><span class="string">'</span>, <span class="string">'</span><span class="string">r</span><span class="string">'</span>, <span class="string">'</span><span class="string">o</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">y</span><span class="string">'</span>, <span class="string">'</span><span class="string">r</span><span class="string">'</span>, <span class="string">'</span><span class="string">o</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>, <span class="string">'</span><span class="string">i</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">o</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">c</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>}
|
||||
},
|
||||
{
|
||||
{<span class="string">'</span><span class="string">L</span><span class="string">'</span>, <span class="string">'</span><span class="string">i</span><span class="string">'</span>, <span class="string">'</span><span class="string">s</span><span class="string">'</span>, <span class="string">'</span><span class="string">s</span><span class="string">'</span>, <span class="string">'</span><span class="string">e</span><span class="string">'</span>, <span class="string">'</span><span class="string">t</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">E</span><span class="string">'</span>, <span class="string">'</span><span class="string">t</span><span class="string">'</span>, <span class="string">'</span><span class="string">h</span><span class="string">'</span>, <span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">C</span><span class="string">'</span>, <span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">l</span><span class="string">'</span>, <span class="string">'</span><span class="string">e</span><span class="string">'</span>, <span class="string">'</span><span class="string">b</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">L</span><span class="string">'</span>, <span class="string">'</span><span class="string">u</span><span class="string">'</span>, <span class="string">'</span><span class="string">l</span><span class="string">'</span>, <span class="string">'</span><span class="string">y</span><span class="string">'</span>},
|
||||
{<span class="string">'</span><span class="string">C</span><span class="string">'</span>, <span class="string">'</span><span class="string">h</span><span class="string">'</span>, <span class="string">'</span><span class="string">a</span><span class="string">'</span>, <span class="string">'</span><span class="string">n</span><span class="string">'</span>, <span class="string">'</span><span class="string">c</span><span class="string">'</span>, <span class="string">'</span><span class="string">e</span><span class="string">'</span>}
|
||||
}
|
||||
};
|
||||
<span class="comment">//*/</span>
|
||||
<span class="comment">//printColumnMajorOrder(names);</span>
|
||||
<span class="ST3">printRowMajorOrder</span>(names);
|
||||
System.<span class="ST4">out</span>.println();
|
||||
<span class="ST3">sortNames</span>(names);
|
||||
System.<span class="ST4">out</span>.println();
|
||||
<span class="ST3">printRowMajorOrder</span>(names);
|
||||
<span class="comment">//printColumnMajorOrder(names);</span>
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
</pre></body>
|
||||
</html>
|
||||
296
Semester 2/Assignments/MP1_ChloeFontenot/MP1_CalebFontenot.html
Normal file
296
Semester 2/Assignments/MP1_ChloeFontenot/MP1_CalebFontenot.html
Normal file
@@ -0,0 +1,296 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>MP1_ChloeFontenot.java</title>
|
||||
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
|
||||
<style type="text/css">
|
||||
<!--
|
||||
body {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
|
||||
pre {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
|
||||
table {color: #888888; background-color: #313335; font-family: monospace; font-weight: bold}
|
||||
.literal {color: #cc7832}
|
||||
.ST4 {font-family: monospace; font-weight: bold; font-style: italic}
|
||||
.ST0 {color: #287bde}
|
||||
.string {color: #6a8759}
|
||||
.number {color: #6897bb}
|
||||
.ST3 {color: #9876aa}
|
||||
.comment {color: #808080}
|
||||
.whitespace {color: #505050}
|
||||
.ST1 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
|
||||
.ST2 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
|
||||
-->
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP1_ChloeFontenot/src/main/java/com/chloefontenot/mp1_chloefontenot/MP1_ChloeFontenot.java</td></tr></table>
|
||||
<pre>
|
||||
<span class="comment">/*</span>
|
||||
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt</span><span class="comment"> to change this license</span>
|
||||
<span class="comment"> */</span>
|
||||
<span class="literal">package</span> com.chloefontenot.mp1_chloefontenot;
|
||||
|
||||
<span class="literal">import</span> java.util.Scanner;
|
||||
|
||||
<span class="comment">/**</span>
|
||||
<span class="comment"> *</span>
|
||||
<span class="comment"> * </span><span class="comment">@author</span> <span class="comment">chloe</span>
|
||||
<span class="comment">*/</span>
|
||||
<span class="literal">public</span> <span class="literal">class</span> MP1_ChloeFontenot {
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">int</span>[][] <span class="ST1">inputArray</span>() {
|
||||
<span class="literal">int</span> m, n, i, j;
|
||||
<span class="comment">// Create scanner</span>
|
||||
Scanner input = <span class="literal">new</span> Scanner(System.<span class="ST2">in</span>);
|
||||
System.<span class="ST2">out</span>.print(<span class="string">"</span><span class="string">Enter the number of rows: </span><span class="string">"</span>);
|
||||
<span class="comment">//taking row as input </span>
|
||||
m = input.nextInt();
|
||||
System.<span class="ST2">out</span>.print(<span class="string">"</span><span class="string">Enter the number of columns: </span><span class="string">"</span>);
|
||||
<span class="comment">//taking column as input </span>
|
||||
n = input.nextInt();
|
||||
<span class="comment">// Declaring the two-dimensional matrix </span>
|
||||
<span class="literal">int</span> returnArray[][] = <span class="literal">new</span> <span class="literal">int</span>[m][n];
|
||||
<span class="comment">// Read the matrix values </span>
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Enter the elements of the array: </span><span class="string">"</span>);
|
||||
<span class="comment">//loop for row </span>
|
||||
<span class="literal">for</span> (i = <span class="number">0</span>; i < m; i++) <span class="comment">//inner for loop for column </span>
|
||||
{
|
||||
<span class="literal">for</span> (j = <span class="number">0</span>; j < n; j++) {
|
||||
returnArray[i][j] = input.nextInt();
|
||||
}
|
||||
}
|
||||
<span class="comment">//accessing array elements </span>
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Elements of the array are: </span><span class="string">"</span>);
|
||||
<span class="literal">for</span> (i = <span class="number">0</span>; i < m; i++) {
|
||||
<span class="literal">for</span> (j = <span class="number">0</span>; j < n; j++) {
|
||||
<span class="literal">return</span> returnArray;
|
||||
}
|
||||
}
|
||||
<span class="literal">return</span> <span class="literal">null</span>;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">boolean</span> <span class="ST1">isConsecutiveFour</span>(<span class="literal">int</span>[] values) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i < values.<span class="ST3">length</span> - <span class="number">4</span>; ++i) {
|
||||
<span class="literal">if</span> (values[i] == values[i + <span class="number">1</span>]
|
||||
&& values[i + <span class="number">1</span>] == values[i + <span class="number">2</span>]
|
||||
&& values[i + <span class="number">2</span>] == values[i + <span class="number">3</span>]) {
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
} <span class="literal">else</span> {
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
}
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">main</span>(String[] args) { <span class="comment">//2965</span>
|
||||
<span class="literal">int</span>[][] horizontalTestArray = { <span class="comment">// Horizontal</span>
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">1</span>},
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">8</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">1</span>},
|
||||
{<span class="number">5</span>, <span class="number">6</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">9</span>},
|
||||
{<span class="number">6</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">9</span>, <span class="number">1</span>},
|
||||
{<span class="number">1</span>, <span class="number">3</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>},
|
||||
{<span class="number">3</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>}
|
||||
};
|
||||
|
||||
<span class="literal">int</span>[][] verticalTestArray = { <span class="comment">// Vertical</span>
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">1</span>},
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">8</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">1</span>},
|
||||
{<span class="number">5</span>, <span class="number">5</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">9</span>},
|
||||
{<span class="number">6</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">9</span>, <span class="number">1</span>},
|
||||
{<span class="number">1</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>},
|
||||
{<span class="number">3</span>, <span class="number">5</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>}
|
||||
};
|
||||
<span class="literal">int</span>[][] diagonalTestArray1 = { <span class="comment">// Diagonal 1</span>
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">1</span>},
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">8</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">1</span>},
|
||||
{<span class="number">9</span>, <span class="number">6</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">9</span>},
|
||||
{<span class="number">6</span>, <span class="number">9</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">9</span>, <span class="number">1</span>},
|
||||
{<span class="number">1</span>, <span class="number">3</span>, <span class="number">9</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>},
|
||||
{<span class="number">3</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">9</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>}
|
||||
};
|
||||
<span class="literal">int</span>[][] diagonalTestArray2 = { <span class="comment">// Diagonal 2</span>
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">1</span>},
|
||||
{<span class="number">0</span>, <span class="number">1</span>, <span class="number">6</span>, <span class="number">8</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">1</span>},
|
||||
{<span class="number">9</span>, <span class="number">6</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>, <span class="number">9</span>},
|
||||
{<span class="number">6</span>, <span class="number">9</span>, <span class="number">6</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">9</span>, <span class="number">1</span>},
|
||||
{<span class="number">1</span>, <span class="number">3</span>, <span class="number">9</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>},
|
||||
{<span class="number">3</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">9</span>, <span class="number">4</span>, <span class="number">0</span>, <span class="number">7</span>}
|
||||
};
|
||||
|
||||
<span class="comment">// Create scanner</span>
|
||||
Scanner input = <span class="literal">new</span> Scanner(System.<span class="ST2">in</span>);
|
||||
<span class="literal">int</span> userInput;
|
||||
<span class="literal">do</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Do you want to enter an array, or use a predefined one?</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">1. Use predefined array.</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">2. Enter a new array.</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">-1. quit and exit program</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.print(<span class="string">"</span><span class="string">Input: </span><span class="string">"</span>);
|
||||
userInput = input.nextInt();
|
||||
<span class="literal">if</span> (userInput == <span class="number">1</span>) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Selected </span><span class="literal">\"</span><span class="string">Use predefined array</span><span class="literal">\"</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Printing arrays...</span><span class="string">"</span>);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">1. horizontalTestArray</span><span class="string">"</span>);
|
||||
<span class="ST4">printArray</span>(horizontalTestArray);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">2. verticalTestArray</span><span class="string">"</span>);
|
||||
<span class="ST4">printArray</span>(verticalTestArray);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">3. diagonalTestArray1</span><span class="string">"</span>);
|
||||
<span class="ST4">printArray</span>(diagonalTestArray1);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">4. diagonalTestArray2</span><span class="string">"</span>);
|
||||
<span class="ST4">printArray</span>(diagonalTestArray2);
|
||||
System.<span class="ST2">out</span>.print(<span class="string">"</span><span class="string">Input: </span><span class="string">"</span>);
|
||||
userInput = input.nextInt();
|
||||
<span class="literal">if</span> (userInput == <span class="number">1</span>) {
|
||||
<span class="literal">if</span> (<span class="ST4">isConsecutiveFour</span>(horizontalTestArray)) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns true</span><span class="string">"</span>);
|
||||
} <span class="literal">else</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns false</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
<span class="literal">if</span> (userInput == <span class="number">2</span>) {
|
||||
<span class="literal">if</span> (<span class="ST4">isConsecutiveFour</span>(verticalTestArray)) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns true</span><span class="string">"</span>);
|
||||
} <span class="literal">else</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns false</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
<span class="literal">if</span> (userInput == <span class="number">3</span>) {
|
||||
<span class="literal">if</span> (<span class="ST4">isConsecutiveFour</span>(diagonalTestArray1)) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns true</span><span class="string">"</span>);
|
||||
} <span class="literal">else</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns false</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
<span class="literal">if</span> (userInput == <span class="number">4</span>) {
|
||||
<span class="literal">if</span> (<span class="ST4">isConsecutiveFour</span>(diagonalTestArray2)) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns true</span><span class="string">"</span>);
|
||||
} <span class="literal">else</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns false</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
userInput = <span class="number">0</span>;
|
||||
}
|
||||
<span class="literal">if</span> (userInput == <span class="number">2</span>) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Selected </span><span class="literal">\"</span><span class="string">Enter new array</span><span class="literal">\"</span><span class="string">"</span>);
|
||||
<span class="literal">int</span>[][] newArray = <span class="ST4">inputArray</span>();
|
||||
<span class="literal">if</span> (<span class="ST4">isConsecutiveFour</span>(newArray)) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns true</span><span class="string">"</span>);
|
||||
} <span class="literal">else</span> {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Testing method returns false</span><span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
} <span class="literal">while</span> (userInput != -<span class="number">1</span>);
|
||||
System.<span class="ST4">exit</span>(<span class="number">0</span>);
|
||||
<span class="comment">//printArray(intArray1);</span>
|
||||
<span class="comment">//System.out.println(isConsecutiveFour(intArray1));</span>
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">printArray</span>(<span class="literal">int</span>[][] array) {
|
||||
<span class="literal">int</span> rowCounter = <span class="number">0</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x < array.<span class="ST3">length</span>; x++) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> y = <span class="number">0</span>; y < array[x].<span class="ST3">length</span>; y++) {
|
||||
System.<span class="ST2">out</span>.print(array[x][y] + <span class="string">"</span> <span class="string">"</span>);
|
||||
rowCounter++;
|
||||
<span class="literal">if</span> (rowCounter % (array.<span class="ST3">length</span> + <span class="number">1</span>) == <span class="number">0</span>) {
|
||||
System.<span class="ST2">out</span>.println();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST1">printArray</span>(<span class="literal">int</span>[] array) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> i : array) {
|
||||
System.<span class="ST2">out</span>.print(i + <span class="string">"</span> <span class="string">"</span>);
|
||||
}
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">boolean</span> <span class="ST1">isConsecutiveFour</span>(<span class="literal">int</span>[][] values) {
|
||||
<span class="comment">// Horizontal Checking</span>
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Checking for Horizontal matches...</span><span class="string">"</span>);
|
||||
<span class="literal">boolean</span> horizontalTest = <span class="ST4">horizontalMatch</span>(values);
|
||||
<span class="comment">// Vertical Checking</span>
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Checking for Vertical matches...</span><span class="string">"</span>);
|
||||
<span class="literal">boolean</span> verticalTest = <span class="ST4">verticalMatch</span>(values);
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Checking for Diagonal matches...</span><span class="string">"</span>);
|
||||
<span class="literal">boolean</span> diagonalTest = <span class="ST4">diagonalMatch</span>(values);
|
||||
<span class="literal">if</span> (horizontalTest || verticalTest || diagonalTest) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Match found!</span><span class="string">"</span>);
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
}
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">No match found.</span><span class="string">"</span>);
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">boolean</span> <span class="ST1">diagonalMatch</span>(<span class="literal">int</span>[][] array) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> row = <span class="number">0</span>; row < array.<span class="ST3">length</span> - <span class="number">3</span>; row++) {
|
||||
<span class="literal">for</span> (<span class="literal">int</span> col = <span class="number">0</span>; col < array[row].<span class="ST3">length</span> - <span class="number">3</span>; col++) {
|
||||
<span class="comment">// Check for four consecutive numbers diagonally from top-left to bottom-right</span>
|
||||
<span class="literal">if</span> (array[row][col] == array[row + <span class="number">1</span>][col + <span class="number">1</span>] && array[row + <span class="number">1</span>][col + <span class="number">1</span>] == array[row + <span class="number">2</span>][col + <span class="number">2</span>]
|
||||
&& array[row + <span class="number">2</span>][col + <span class="number">2</span>] == array[row + <span class="number">3</span>][col + <span class="number">3</span>]) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Found four consecutive numbers diagonally at: </span><span class="string">"</span> + row + <span class="string">"</span><span class="string">,</span><span class="string">"</span> + col);
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
}
|
||||
<span class="comment">// Check for four consecutive numbers diagonally from top-right to bottom-left</span>
|
||||
<span class="literal">if</span> (array[row][col + <span class="number">3</span>] == array[row + <span class="number">1</span>][col + <span class="number">2</span>] && array[row + <span class="number">1</span>][col + <span class="number">2</span>] == array[row + <span class="number">2</span>][col + <span class="number">1</span>]
|
||||
&& array[row + <span class="number">2</span>][col + <span class="number">1</span>] == array[row + <span class="number">3</span>][col]) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Found four consecutive numbers diagonally at: </span><span class="string">"</span> + row + <span class="string">"</span><span class="string">,</span><span class="string">"</span> + (col + <span class="number">3</span>));
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
}
|
||||
}
|
||||
}
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">boolean</span> <span class="ST1">verticalMatch</span>(<span class="literal">int</span>[][] values) {
|
||||
<span class="literal">int</span> intCounter = <span class="number">0</span>, y = <span class="number">0</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> rowIterate = <span class="number">0</span>; rowIterate < values.<span class="ST3">length</span>; ++rowIterate) {
|
||||
y = <span class="number">0</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x < values.<span class="ST3">length</span> - <span class="number">1</span>; ++x) {
|
||||
++y;
|
||||
<span class="literal">if</span> (values[x][rowIterate] == values[y][rowIterate]) {
|
||||
intCounter++;
|
||||
System.<span class="ST2">out</span>.println(values[x][rowIterate] + <span class="string">"</span> <span class="string">"</span> + values[y][rowIterate] + <span class="string">"</span><span class="string">, intCounter: </span><span class="string">"</span> + intCounter);
|
||||
} <span class="literal">else</span> {
|
||||
intCounter = <span class="number">0</span>;
|
||||
System.<span class="ST2">out</span>.println(values[x][rowIterate] + <span class="string">"</span> <span class="string">"</span> + values[y][rowIterate] + <span class="string">"</span><span class="string">, intCounter: </span><span class="string">"</span> + intCounter);
|
||||
}
|
||||
<span class="literal">if</span> (intCounter == <span class="number">3</span>) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Vertical match!</span><span class="string">"</span>);
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
}
|
||||
}
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Checking next line...</span><span class="string">"</span>);
|
||||
}
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
|
||||
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">boolean</span> <span class="ST1">horizontalMatch</span>(<span class="literal">int</span>[][] values) {
|
||||
<span class="literal">int</span> intCounter = <span class="number">0</span>, y = <span class="number">0</span>;
|
||||
<span class="comment">// Horizontal checking</span>
|
||||
<span class="comment">// If the same value has been observed 4 times, return true</span>
|
||||
<span class="comment">//System.out.println("values[0].length: " + values[0].length);</span>
|
||||
<span class="comment">//System.out.println("values.length: " + values.length);</span>
|
||||
|
||||
<span class="literal">for</span> (<span class="literal">int</span> rowIterate = <span class="number">0</span>; rowIterate < values.<span class="ST3">length</span>; ++rowIterate) {
|
||||
y = <span class="number">0</span>;
|
||||
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x < values[<span class="number">0</span>].<span class="ST3">length</span> - <span class="number">1</span>; ++x) {
|
||||
++y;
|
||||
<span class="literal">if</span> (values[rowIterate][x] == values[rowIterate][y]) {
|
||||
intCounter++;
|
||||
System.<span class="ST2">out</span>.println(values[rowIterate][x] + <span class="string">"</span> <span class="string">"</span> + values[rowIterate][y] + <span class="string">"</span><span class="string">, intCounter: </span><span class="string">"</span> + intCounter);
|
||||
} <span class="literal">else</span> {
|
||||
intCounter = <span class="number">0</span>;
|
||||
System.<span class="ST2">out</span>.println(values[rowIterate][x] + <span class="string">"</span> <span class="string">"</span> + values[rowIterate][y] + <span class="string">"</span><span class="string">, intCounter: </span><span class="string">"</span> + intCounter);
|
||||
}
|
||||
<span class="literal">if</span> (intCounter == <span class="number">3</span>) {
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Horizontal match!</span><span class="string">"</span>);
|
||||
<span class="literal">return</span> <span class="literal">true</span>;
|
||||
}
|
||||
}
|
||||
System.<span class="ST2">out</span>.println(<span class="string">"</span><span class="string">Checking next line...</span><span class="string">"</span>);
|
||||
}
|
||||
<span class="literal">return</span> <span class="literal">false</span>;
|
||||
}
|
||||
}
|
||||
|
||||
</pre></body>
|
||||
</html>
|
||||
BIN
Semester 2/Assignments/MP1_ChloeFontenot/mp1-s23-1.docx
Normal file
BIN
Semester 2/Assignments/MP1_ChloeFontenot/mp1-s23-1.docx
Normal file
Binary file not shown.
14
Semester 2/Assignments/MP1_ChloeFontenot/pom.xml
Normal file
14
Semester 2/Assignments/MP1_ChloeFontenot/pom.xml
Normal file
@@ -0,0 +1,14 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>com.chloefontenot</groupId>
|
||||
<artifactId>MP1_ChloeFontenot</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
<packaging>jar</packaging>
|
||||
<properties>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<maven.compiler.source>17</maven.compiler.source>
|
||||
<maven.compiler.target>17</maven.compiler.target>
|
||||
<exec.mainClass>com.chloefontenot.mp1_chloefontenot.MP1_ChloeFontenot</exec.mainClass>
|
||||
</properties>
|
||||
</project>
|
||||
@@ -0,0 +1,149 @@
|
||||
/*
|
||||
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
|
||||
*/
|
||||
package com.chloefontenot.mp1_chloefontenot;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author chloe
|
||||
*/
|
||||
public class Lab3DArraysSort_ChloeFontenot {
|
||||
|
||||
public static int maxNumberOfColumnsInJagged2dArray(char[][] ar) {
|
||||
int maxNumberOfColumns = 0;
|
||||
for (int row = 0; row < ar.length; ++row) {
|
||||
if (ar[row].length > maxNumberOfColumns) {
|
||||
maxNumberOfColumns = ar[row].length;
|
||||
}
|
||||
}
|
||||
|
||||
return maxNumberOfColumns;
|
||||
}
|
||||
|
||||
public static void printColumnMajorOrder(char[][] ar) {
|
||||
int row = 0;
|
||||
int column = 0;
|
||||
int max = maxNumberOfColumnsInJagged2dArray(ar);
|
||||
for (column = 0; column < max; ++column) {
|
||||
for (row = 0; row < ar.length; ++row) {
|
||||
if (column < ar[row].length) {
|
||||
System.out.print(ar[row][column] + " ");
|
||||
}
|
||||
}
|
||||
System.out.println("");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints row by row
|
||||
*
|
||||
* @param ar
|
||||
*/
|
||||
public static void printRowMajorOrder(char[][][] array) {
|
||||
for (char[][] i: array) {
|
||||
System.out.println("---------------------------------");
|
||||
printRowMajorOrder(i);
|
||||
}
|
||||
}
|
||||
public static void printRowMajorOrder(char[][] ar)//normal
|
||||
{
|
||||
for (int x = 0; x < ar.length; ++x) {
|
||||
for (int y = 0; y < ar[x].length; ++y) {
|
||||
System.out.print(ar[x][y] + "");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static String returnRowMajorOrder(char[] ar)//normal
|
||||
{
|
||||
String returnString = "";
|
||||
for (int x = 0; x < ar.length; ++x) {
|
||||
returnString += ar[x];
|
||||
}
|
||||
return returnString;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sorts the methods in ascending order using Selection Sort
|
||||
*
|
||||
* @param names the names to be sorted
|
||||
*/
|
||||
public static void sortNames(char[][][] names) {
|
||||
for (int array = 0; array < names.length; ++array) {
|
||||
System.out.println("times looped: " + array);
|
||||
for (int i = 0; i < names[array].length - 1; ++i) {
|
||||
for (int j = i + 1; j < names[array].length; ++j) {
|
||||
char compChar1 = names[array][i][0], compChar2 = names[array][j][0];
|
||||
// Reoder entire row
|
||||
for (int rowIterate = 1; rowIterate < maxNumberOfColumnsInJagged2dArray(names[array]); ++rowIterate) {
|
||||
if (Character.toLowerCase(compChar1) == Character.toLowerCase(compChar2)) {
|
||||
try {
|
||||
compChar1 = names[array][i][rowIterate];
|
||||
compChar2 = names[array][j][rowIterate];
|
||||
} catch (Exception ex) {
|
||||
// If it's failed, the index has gone out of range.
|
||||
// Check the length of the arrays and swap the larger one with the smaller one.
|
||||
if (names[array][i].length > names[array][j].length) {
|
||||
System.out.println(names[array][i].length + " " + names[array][j].length);
|
||||
System.out.println("Swapping " + returnRowMajorOrder(names[array][i]) + " with " + returnRowMajorOrder(names[array][j]));
|
||||
char[] temp = names[array][i];
|
||||
names[array][i] = names[array][j];
|
||||
names[array][j] = temp;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
if (Character.toLowerCase(compChar1) > Character.toLowerCase(compChar2)) {
|
||||
System.out.println("Swapping " + returnRowMajorOrder(names[array][i]) + " with " + returnRowMajorOrder(names[array][j]));
|
||||
char[] temp = names[array][i];
|
||||
names[array][i] = names[array][j];
|
||||
names[array][j] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/*
|
||||
char[][] names = {
|
||||
{'j', 'o', 'h', 'n'},
|
||||
{'a', 'n'},
|
||||
{'b', 'y', 'r', 'o', 'n'},};
|
||||
*/
|
||||
///*
|
||||
char[][][] names = {
|
||||
{
|
||||
{'j', 'o', 'h', 'n'},
|
||||
{'a', 'n'},
|
||||
{'b', 'y', 'r', 'o', 'n'},
|
||||
{'b', 'y', 'r', 'o', 'n', 'i'},
|
||||
{'a', 'a', 'o', 'n'},
|
||||
{'b', 'b', 'b', 'b'},
|
||||
{'b', 'b', 'b', 'c'},
|
||||
{'b', 'b', 'b'}
|
||||
},
|
||||
{
|
||||
{'L', 'i', 's', 's', 'e', 't'},
|
||||
{'E', 't', 'h', 'a', 'n'},
|
||||
{'C', 'a', 'l', 'e', 'b'},
|
||||
{'L', 'u', 'l', 'y'},
|
||||
{'C', 'h', 'a', 'n', 'c', 'e'}
|
||||
}
|
||||
};
|
||||
//*/
|
||||
//printColumnMajorOrder(names);
|
||||
printRowMajorOrder(names);
|
||||
System.out.println();
|
||||
sortNames(names);
|
||||
System.out.println();
|
||||
printRowMajorOrder(names);
|
||||
//printColumnMajorOrder(names);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
/*
|
||||
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
|
||||
*/
|
||||
package com.chloefontenot.mp1_chloefontenot;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author chloe
|
||||
*/
|
||||
public class MP1_ChloeFontenot {
|
||||
|
||||
public static int[][] inputArray() {
|
||||
int m, n, i, j;
|
||||
// Create scanner
|
||||
Scanner input = new Scanner(System.in);
|
||||
System.out.print("Enter the number of rows: ");
|
||||
//taking row as input
|
||||
m = input.nextInt();
|
||||
System.out.print("Enter the number of columns: ");
|
||||
//taking column as input
|
||||
n = input.nextInt();
|
||||
// Declaring the two-dimensional matrix
|
||||
int returnArray[][] = new int[m][n];
|
||||
// Read the matrix values
|
||||
System.out.println("Enter the elements of the array: ");
|
||||
//loop for row
|
||||
for (i = 0; i < m; i++) //inner for loop for column
|
||||
{
|
||||
for (j = 0; j < n; j++) {
|
||||
returnArray[i][j] = input.nextInt();
|
||||
}
|
||||
}
|
||||
//accessing array elements
|
||||
System.out.println("Elements of the array are: ");
|
||||
for (i = 0; i < m; i++) {
|
||||
for (j = 0; j < n; j++) {
|
||||
return returnArray;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static boolean isConsecutiveFour(int[] values) {
|
||||
for (int i = 0; i < values.length - 4; ++i) {
|
||||
if (values[i] == values[i + 1]
|
||||
&& values[i + 1] == values[i + 2]
|
||||
&& values[i + 2] == values[i + 3]) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static void main(String[] args) { //2965
|
||||
int[][] horizontalTestArray = { // Horizontal
|
||||
{0, 1, 0, 3, 1, 6, 1},
|
||||
{0, 1, 6, 8, 6, 0, 1},
|
||||
{5, 6, 2, 1, 8, 2, 9},
|
||||
{6, 5, 6, 1, 1, 9, 1},
|
||||
{1, 3, 6, 1, 4, 0, 7},
|
||||
{3, 3, 3, 3, 4, 0, 7}
|
||||
};
|
||||
|
||||
int[][] verticalTestArray = { // Vertical
|
||||
{0, 1, 0, 3, 1, 6, 1},
|
||||
{0, 1, 6, 8, 6, 0, 1},
|
||||
{5, 5, 2, 1, 8, 2, 9},
|
||||
{6, 5, 6, 1, 1, 9, 1},
|
||||
{1, 5, 6, 1, 4, 0, 7},
|
||||
{3, 5, 3, 3, 4, 0, 7}
|
||||
};
|
||||
int[][] diagonalTestArray1 = { // Diagonal 1
|
||||
{0, 1, 0, 3, 1, 6, 1},
|
||||
{0, 1, 6, 8, 6, 0, 1},
|
||||
{9, 6, 2, 1, 8, 2, 9},
|
||||
{6, 9, 6, 1, 1, 9, 1},
|
||||
{1, 3, 9, 1, 4, 0, 7},
|
||||
{3, 3, 3, 9, 4, 0, 7}
|
||||
};
|
||||
int[][] diagonalTestArray2 = { // Diagonal 2
|
||||
{0, 1, 0, 3, 1, 6, 1},
|
||||
{0, 1, 6, 8, 6, 0, 1},
|
||||
{9, 6, 2, 1, 8, 2, 9},
|
||||
{6, 9, 6, 1, 1, 9, 1},
|
||||
{1, 3, 9, 1, 4, 0, 7},
|
||||
{3, 3, 3, 9, 4, 0, 7}
|
||||
};
|
||||
|
||||
// Create scanner
|
||||
Scanner input = new Scanner(System.in);
|
||||
int userInput;
|
||||
do {
|
||||
System.out.println("Do you want to enter an array, or use a predefined one?");
|
||||
System.out.println("1. Use predefined array.");
|
||||
System.out.println("2. Enter a new array.");
|
||||
System.out.println("-1. quit and exit program");
|
||||
System.out.print("Input: ");
|
||||
userInput = input.nextInt();
|
||||
if (userInput == 1) {
|
||||
System.out.println("Selected \"Use predefined array\"");
|
||||
System.out.println("Printing arrays...");
|
||||
System.out.println("1. horizontalTestArray");
|
||||
printArray(horizontalTestArray);
|
||||
System.out.println("2. verticalTestArray");
|
||||
printArray(verticalTestArray);
|
||||
System.out.println("3. diagonalTestArray1");
|
||||
printArray(diagonalTestArray1);
|
||||
System.out.println("4. diagonalTestArray2");
|
||||
printArray(diagonalTestArray2);
|
||||
System.out.print("Input: ");
|
||||
userInput = input.nextInt();
|
||||
if (userInput == 1) {
|
||||
if (isConsecutiveFour(horizontalTestArray)) {
|
||||
System.out.println("Testing method returns true");
|
||||
} else {
|
||||
System.out.println("Testing method returns false");
|
||||
}
|
||||
}
|
||||
if (userInput == 2) {
|
||||
if (isConsecutiveFour(verticalTestArray)) {
|
||||
System.out.println("Testing method returns true");
|
||||
} else {
|
||||
System.out.println("Testing method returns false");
|
||||
}
|
||||
}
|
||||
if (userInput == 3) {
|
||||
if (isConsecutiveFour(diagonalTestArray1)) {
|
||||
System.out.println("Testing method returns true");
|
||||
} else {
|
||||
System.out.println("Testing method returns false");
|
||||
}
|
||||
}
|
||||
if (userInput == 4) {
|
||||
if (isConsecutiveFour(diagonalTestArray2)) {
|
||||
System.out.println("Testing method returns true");
|
||||
} else {
|
||||
System.out.println("Testing method returns false");
|
||||
}
|
||||
}
|
||||
userInput = 0;
|
||||
}
|
||||
if (userInput == 2) {
|
||||
System.out.println("Selected \"Enter new array\"");
|
||||
int[][] newArray = inputArray();
|
||||
if (isConsecutiveFour(newArray)) {
|
||||
System.out.println("Testing method returns true");
|
||||
} else {
|
||||
System.out.println("Testing method returns false");
|
||||
}
|
||||
}
|
||||
} while (userInput != -1);
|
||||
System.exit(0);
|
||||
//printArray(intArray1);
|
||||
//System.out.println(isConsecutiveFour(intArray1));
|
||||
}
|
||||
|
||||
public static void printArray(int[][] array) {
|
||||
int rowCounter = 0;
|
||||
for (int x = 0; x < array.length; x++) {
|
||||
for (int y = 0; y < array[x].length; y++) {
|
||||
System.out.print(array[x][y] + " ");
|
||||
rowCounter++;
|
||||
if (rowCounter % (array.length + 1) == 0) {
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void printArray(int[] array) {
|
||||
for (int i : array) {
|
||||
System.out.print(i + " ");
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean isConsecutiveFour(int[][] values) {
|
||||
// Horizontal Checking
|
||||
System.out.println("Checking for Horizontal matches...");
|
||||
boolean horizontalTest = horizontalMatch(values);
|
||||
// Vertical Checking
|
||||
System.out.println("Checking for Vertical matches...");
|
||||
boolean verticalTest = verticalMatch(values);
|
||||
System.out.println("Checking for Diagonal matches...");
|
||||
boolean diagonalTest = diagonalMatch(values);
|
||||
if (horizontalTest || verticalTest || diagonalTest) {
|
||||
System.out.println("Match found!");
|
||||
return true;
|
||||
}
|
||||
System.out.println("No match found.");
|
||||
return false;
|
||||
}
|
||||
|
||||
public static boolean diagonalMatch(int[][] array) {
|
||||
for (int row = 0; row < array.length - 3; row++) {
|
||||
for (int col = 0; col < array[row].length - 3; col++) {
|
||||
// Check for four consecutive numbers diagonally from top-left to bottom-right
|
||||
if (array[row][col] == array[row + 1][col + 1] && array[row + 1][col + 1] == array[row + 2][col + 2]
|
||||
&& array[row + 2][col + 2] == array[row + 3][col + 3]) {
|
||||
System.out.println("Found four consecutive numbers diagonally at: " + row + "," + col);
|
||||
return true;
|
||||
}
|
||||
// Check for four consecutive numbers diagonally from top-right to bottom-left
|
||||
if (array[row][col + 3] == array[row + 1][col + 2] && array[row + 1][col + 2] == array[row + 2][col + 1]
|
||||
&& array[row + 2][col + 1] == array[row + 3][col]) {
|
||||
System.out.println("Found four consecutive numbers diagonally at: " + row + "," + (col + 3));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static boolean verticalMatch(int[][] values) {
|
||||
int intCounter = 0, y = 0;
|
||||
for (int rowIterate = 0; rowIterate < values.length; ++rowIterate) {
|
||||
y = 0;
|
||||
for (int x = 0; x < values.length - 1; ++x) {
|
||||
++y;
|
||||
if (values[x][rowIterate] == values[y][rowIterate]) {
|
||||
intCounter++;
|
||||
System.out.println(values[x][rowIterate] + " " + values[y][rowIterate] + ", intCounter: " + intCounter);
|
||||
} else {
|
||||
intCounter = 0;
|
||||
System.out.println(values[x][rowIterate] + " " + values[y][rowIterate] + ", intCounter: " + intCounter);
|
||||
}
|
||||
if (intCounter == 3) {
|
||||
System.out.println("Vertical match!");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
System.out.println("Checking next line...");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static boolean horizontalMatch(int[][] values) {
|
||||
int intCounter = 0, y = 0;
|
||||
// Horizontal checking
|
||||
// If the same value has been observed 4 times, return true
|
||||
//System.out.println("values[0].length: " + values[0].length);
|
||||
//System.out.println("values.length: " + values.length);
|
||||
|
||||
for (int rowIterate = 0; rowIterate < values.length; ++rowIterate) {
|
||||
y = 0;
|
||||
for (int x = 0; x < values[0].length - 1; ++x) {
|
||||
++y;
|
||||
if (values[rowIterate][x] == values[rowIterate][y]) {
|
||||
intCounter++;
|
||||
System.out.println(values[rowIterate][x] + " " + values[rowIterate][y] + ", intCounter: " + intCounter);
|
||||
} else {
|
||||
intCounter = 0;
|
||||
System.out.println(values[rowIterate][x] + " " + values[rowIterate][y] + ", intCounter: " + intCounter);
|
||||
}
|
||||
if (intCounter == 3) {
|
||||
System.out.println("Horizontal match!");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
System.out.println("Checking next line...");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
/*
|
||||
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
|
||||
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
|
||||
*/
|
||||
package com.chloefontenot.mp1_chloefontenot;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author chloe
|
||||
*/
|
||||
public class MarkouCode {
|
||||
|
||||
/**
|
||||
* Traverses the parm array diagonally from top left towards the top and prints the (i,j) indexes of the traversal.
|
||||
*
|
||||
* @param ar 2D array
|
||||
*/
|
||||
public static boolean topLeftTriangleDiagonalNothwest(int[][] ar) {
|
||||
System.out.println("diagonal indexes top-triangle of array ");
|
||||
int rowCount = 0;
|
||||
for (int columnCounter = 0; columnCounter < ar[0].length; ++columnCounter) {
|
||||
int i = 0;
|
||||
int j = columnCounter;
|
||||
int[] diagonalArray = new int[rowCount + 1];
|
||||
for (int diagonalCounter = 0; diagonalCounter <= rowCount; ++diagonalCounter) {
|
||||
diagonalArray[diagonalCounter] = ar[i][j];
|
||||
if (isConsecutiveFour(diagonalArray)) {
|
||||
return true;
|
||||
}
|
||||
System.out.print(i + "," + j + " ");
|
||||
++i;
|
||||
j--;
|
||||
if (i == ar.length | j == ar[0].length) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
rowCount++;
|
||||
|
||||
System.out.println("");
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*Traverses the parm array diagonally from bottom right towrads the to
|
||||
//and prints the (i,j) indexes of the traversal.
|
||||
|
||||
*
|
||||
* @param ar
|
||||
*/
|
||||
public static boolean bottomRightTriangleDiagonalNothwest(int[][] ar) {
|
||||
System.out.println("diagonal indexes bottom-triangle of array ");
|
||||
|
||||
int rowCount = 0;
|
||||
int numColumns = 0;
|
||||
int[] diagonalArray = new int[rowCount + 1];
|
||||
if (ar[0].length == ar.length)//square table
|
||||
{
|
||||
numColumns = ar[0].length - 1;
|
||||
} else if (ar[0].length > ar.length)//wide table
|
||||
{
|
||||
numColumns = ar.length - 1;
|
||||
} else //narrow-width rectangle array
|
||||
{
|
||||
numColumns = ar[0].length;
|
||||
}
|
||||
|
||||
for (int columnCounter = 0; columnCounter < numColumns; ++columnCounter) {
|
||||
int i = ar.length - 1;
|
||||
int j = ar[0].length - 1 - columnCounter;
|
||||
for (int diagonalCounter = 0; diagonalCounter <= rowCount; ++diagonalCounter) {
|
||||
|
||||
System.out.print(i + "," + j + " ");
|
||||
diagonalArray[diagonalCounter] = ar[i][j];
|
||||
if (isConsecutiveFour(diagonalArray)) {
|
||||
return true;
|
||||
}
|
||||
--i;
|
||||
j++;
|
||||
}
|
||||
rowCount++;
|
||||
System.out.println("");
|
||||
return false;
|
||||
}
|
||||
//middle chunk of narrow array
|
||||
|
||||
System.out.println("-----------------------");
|
||||
if (ar.length > ar[0].length) {
|
||||
System.out.println("diagonal indexes middle part of array when the array "
|
||||
+ "is narrow ");
|
||||
|
||||
for (int i = 1; i < ar.length - ar[0].length; ++i) {
|
||||
int rowIndex = i;
|
||||
int columnIndex = ar[0].length - 1;
|
||||
for (int j = 0; j < ar[0].length; ++j) {
|
||||
|
||||
System.out.print(rowIndex + "," + columnIndex + " ");
|
||||
diagonalArray[diagonalCounter] = ar[i][j];
|
||||
if (isConsecutiveFour(diagonalArray)) {
|
||||
return true;
|
||||
}
|
||||
rowIndex++;
|
||||
columnIndex--;
|
||||
|
||||
}
|
||||
|
||||
System.out.println("");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static boolean isConsecutiveFour(int[][] values) {
|
||||
return true;
|
||||
}
|
||||
|
||||
public static boolean isConsecutiveFour(int[] values) {
|
||||
for (int i = 0; i < values.length - 4; ++i) {
|
||||
if (values[i] == values[i + 1]
|
||||
&& values[i + 1] == values[i + 2]
|
||||
&& values[i + 2] == values[i + 3]) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void printIndexesDiagonally(int ar[][]) {
|
||||
topLeftTriangleDiagonalNothwest(ar);
|
||||
System.out.println("------------------------");
|
||||
bottomRightTriangleDiagonalNothwest(ar);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
int[][] ar1
|
||||
= {
|
||||
{
|
||||
1, 1, 1, 1, 8
|
||||
},
|
||||
{
|
||||
1, 1, 1, 8, 9
|
||||
},
|
||||
{
|
||||
1, 1, 8, 1, 9
|
||||
},
|
||||
{
|
||||
1, 8, 1, 3, 2
|
||||
},};
|
||||
|
||||
int[][] ar2
|
||||
= {
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1
|
||||
},};
|
||||
|
||||
int[][] ar3
|
||||
= {
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},
|
||||
{
|
||||
1, 1, 1
|
||||
},};
|
||||
System.out.println(topLeftTriangleDiagonalNothwest(ar1));
|
||||
/*
|
||||
System.out.println("SQUARE array of size 4x4");
|
||||
printIndexesDiagonally(ar1);
|
||||
|
||||
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
||||
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
||||
System.out.println("\nWIDE array of size 8x5");
|
||||
printIndexesDiagonally(ar2);
|
||||
|
||||
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
||||
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
||||
System.out.println("\nNARROW array of size 10x3");
|
||||
printIndexesDiagonally(ar3);
|
||||
*/
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user