We Keep Coding

Creating this number pattern in Java

I am trying to create a pattern in java by using a for-loop and nested for-loop based on the user input of a positive integer.
Here is an example:
User input = 5
Output:
5 5 5 5 5 5 5 5 5
5 4 4 4 4 4 4 4 5
5 4 3 3 3 3 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 2 1 2 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 3 3 3 3 4 5
5 4 4 4 4 4 4 4 5
5 5 5 5 5 5 5 5 5
This is what I have so far. I am getting a list of integers, but I cannot find out where to go from here to get a pattern such as the one above. All I am getting is "5 5 5 5 5 4 4 4 4 3 3 3 2 2 1 "
System.out.print("Enter the value of n: ");
int n = scan.nextInt();
for (int row = 1; row <= n; row++) { //rows
for (int col = 1; col <= n; col++) { //columns
if (n - col + 1 <= n - row + 1 && row <= n && col <= n) { //what to print
System.out.print(n - row + 1 + " ");
} else if (n - col + 1 <= n - row + 1 && row <= n && col <= n) {
System.out.print(n - row + 1 + " ");
}
}
}

In this code I'm mirroring the column's and after that mirroring the rows. From mirroring I mean first creating mirror of the data.
First writing data to columns(left side) and then mirroring the column hence I get the right side of the column.
After writing data to the upper rows then mirroring the upper row I get bottom row.
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
public class Pattern {
static final PrintStream out = System.out;
public static void displayPattern(int n) {
final int arr[][] = new int[n * 2 - 1][];
for (int i = 0; i < arr.length; i++)
arr[i] = new int[n * 2 - 1];
final List<Integer> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
int current = n - i;
list.add(current);
for (int j = 0; j < list.size(); j++) {
arr[i][j] = list.get(j);
}
int remainings = n - list.size();
for (int j = list.size(), count = 0; count < remainings; j++, count++) {
arr[i][j] = current;
}
//writing data to right side of the columns(mirroring columns)
for (int j = n, count = 1; j < arr[i].length; j++, count++)
arr[i][j] = arr[i][j - count * 2];
}
//writing data to bottom half of the rows(mirroring rows)
for (int i = n, count = 1; i < n * 2 - 1; i++, count++) {
for (int j = 0; j < n * 2 - 1; j++)
arr[i][j] = arr[i - count * 2][j];
}
for (int a[] : arr) {
for (int b : a)
out.print(b + " ");
out.println();
}
}
public static void main(final String... $) {
displayPattern(5);
}
}
Output:
5 5 5 5 5 5 5 5 5
5 4 4 4 4 4 4 4 5
5 4 3 3 3 3 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 2 1 2 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 3 3 3 3 4 5
5 4 4 4 4 4 4 4 5
5 5 5 5 5 5 5 5 5

How do i fix the angle of my mathematical triangle of squares?

I need to fix my output as shown at the bottom, i have code that outputs the correct math values
but it does not output the correct angle that is expected of the example output that i have provided below. ( I know this is pretty simple for most of you stack users but im a beginner in java and this is something that confuses me ). I have not come up with any ideas on what i can do to fix this issue and put in the correct angle.
Instructions:
-Write a program using a Scanner that asks the user for a number
n between 1 and 9 (inclusive).
-The program prints a triangle with n rows.
-The first row contains only the square of 1, and it is right-justified.
-The second row contains the square of 2 followed by the square of 1,
and is right justified.
-Subsequent rows include the squares of 3, 2, and 1, and then 4, 3, 2
and 1, and so forth until n rows are printed.
Assuming the user enters 4, the program prints the following triangle to the console
1
4 1
9 4 1
16 9 4 1
Code:
import java.util.Scanner;
public class Triangle {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Please enter a number between 1 and 9 inclusive:");
int n = scan.nextInt();
for (int i = 1 ; i <=n; i++) {
for (int j = n-i; j >=1; j--) {
System.out.print("");
}
for (int k = i; k <= n; k++ ) {
System.out.print(" " + i * i);
}
System.out.println(" ");
}
scan.close();
}
}
My output:
Please enter a number between 1 and 9 inclusive: 4
1 1 1 1
4 4 4
9 9
16

Here is a short and simple variant.
for (int row = 1; row <= n; row ++) {
for (int col = n; col >= 1; col--) {
if (col <= row) {
System.out.print(String.format("%2d ", col * col));
} else {
System.out.print(" ");
}
}
System.out.println();
}
Here is the output generated for input 9:
1
4 1
9 4 1
16 9 4 1
25 16 9 4 1
36 25 16 9 4 1
49 36 25 16 9 4 1
64 49 36 25 16 9 4 1
81 64 49 36 25 16 9 4 1

TL;DR; Use a pen and paper for annoying logic problems.
The easiest way to do a problem like this is to write out the locations you're printing in terms of the variables you are iterating through. An extra variable, col helps us keep track of the current column opposite of the direction we are iterating from.
We can notice that the number just corresponds to the column position, squared, if we were counting columns from right to left.
We can also notice that the number of blank spaces is equal to n - one less than the current row iteration (since that starts at 0).
1
4 1
9 4 1
16 9 4 1
All of that nonsense aside, we can use String.format() to make the output even for double digit numbers.
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Please enter a number between 1 and 9 inclusive:");
int n = scan.nextInt();
for (int i = n; i > 0; i--) {
int col = 4;
// Print spaces
for (int j = 0; j < (i-1); j++) {
System.out.print(" ");
col--;
}
// Print numbers
for (int j = (i-1); j < n; j++) {
System.out.print(String.format("%2d", col*col) + " ");
col--;
}
System.out.println();
}
scan.close();
}

I have used the code you guys provided and it had some logical issues when inputting a number past 4 it would not square the triangle correctly and would only create the shape. I have solved the issue by adding a while loop and editing the for loops and not it outputs correctly.
Incorrect output:
Please enter a number between 1 and 9 inclusive: 8
9
4 9
1 4 9
0 1 4 9
1 0 1 4 9
4 1 0 1 4 9
9 4 1 0 1 4 9
16 9 4 1 0 1 4 9
Correct Code Given:
import java.util.Scanner;
public class AverageGrades {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Please enter a number between 1 and 9 inclusive:");
int n = scan.nextInt();
for (int row = 1; row <= n; row ++) {
for (int col = n; col >= 1; col--) {
if (col <= row) {
System.out.print(String.format("%2d ", col * col));
} else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
My Code:
import java.util.Scanner;
public class TriangleTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("Enter Number between 1 and 9 : ");
int n = scan.nextInt();
while(n < 0 || n > 9)
{
System.out.print("Please enter a valid value between 1 and 9 :");
n = scan.nextInt();
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j <= n*2-(i + i); j++)
{
System.out.print(" ");
}
for(int l = i + 1; l > 0; l--)
{
int r = l*l;
System.out.print(r + " ");
}
System.out.println("\n");
}
scan.close();
}
}
Correct Output:
Enter Number between 1 and 9 : 10
Please enter a valid value between 1 and 9 :9
1
4 1
9 4 1
16 9 4 1
25 16 9 4 1
36 25 16 9 4 1
49 36 25 16 9 4 1
64 49 36 25 16 9 4 1
81 64 49 36 25 16 9 4 1

Permutation using ArrayList<Integer> to print by size of 10 in a console

I wrote simple code on random permutation between 1 to 10 using ArrayList. How can I make ArrayList in my file SmartPermutationGenerator to print the result by size of 10 in a console to get output as below:
I don't want this output:
Random arrays using Smart Force:
8 4 8 1 8 4 10 8 4 1 7 8 4 1 10 5 8 4 1 10 7 2 8 4 1 10 7 5 9 8 4 1 10 7 5 2 6 8 4 1 10 7 5 2 9 3 8 4 1 10 7 5 2 9 6
I want this output instead:
Random arrays using Smart Force:
8 4 8 1 8 4 10 8 4 1
7 8 4 1 10 5 8 4 1 10
7 2 8 4 1 10 7 5 9 8
4 1 10 7 5 2 6 8 4 1
10 7 5 2 9 3 8 4 1 10
7 5 2 9 6
Should limit the solution using arraylist only, don't want to use recursion.
This is my file SmartPermutationGenerator
import java.util.ArrayList;
import java.util.Random;
public class SmartPermutationGenerator
{
private int size;
private Random rand = new Random();
public SmartPermutationGenerator()
{
this.size = 10;
}
public ArrayList nextPermutation()
{
ArrayList<Integer> unused = new ArrayList<Integer>();
for (int i = 0; i < size; i++) // loop for element in array
{
unused.add(i + 1);
}
ArrayList<Integer> perm = new ArrayList<Integer>();
for (int k = 0; k < size; k++) //loop for random number between 1 to 10
{
int pos = rand.nextInt(unused.size());
perm.add(unused.get(pos));
unused.remove(pos);
System.out.print(perm.get(k) + " ");
for (int j = 0; j < k; j++)
{
System.out.print(perm.get(j) + " "); //loop for permutation 10 times
//System.out.println();
}
}
return perm;
}
}
This is my file BrutePermutationGenerator
import java.util.Random;
public class BrutePermutationGenerator
{
private int[] num = new int[10];
public int[] nextPermutation()
{
Random rand = new Random();
for (int j = 0; j < 10; j++)//loop for permutation 10 times
{
for (int i = 0; i < 10; i++)//loop for random number between 1 to 10
{
int low = 1;
int high = 10;
int range = high - low + 1;
int r = rand.nextInt(range);
num[i] = num[r];
num[r] = i;
}
for (int i = 0; i < 10; i++)// loop for element in array
{
System.out.print(num[i] + 1 + " ");
}
System.out.println();
}
return num;
}
}
This is my main file PermutationGeneratorViewer
public class PermutationGeneratorViewer
{
public static void main(String[] args)
{
BrutePermutationGenerator brute = new BrutePermutationGenerator();
SmartPermutationGenerator smart = new SmartPermutationGenerator();
System.out.println("\n" + "Random arrays using Brute Force: ");
brute.nextPermutation();
System.out.println("\n" + "Random arrays using Smart Force: ");
smart.nextPermutation();
}
}

You can use the modulus operator (%) in the printing loops to see if the index is a multiple of ten. If it is, print a newline.
Something like this would work:
for(...){
System.out.print(...);
if(count%10==0 && count!=0){ // if the index of the number is a multiple of 10 but not the first number
System.out.println(); // print a newline to separate rows
}
}
This will add a newline after the 10th, 20th, 30th, etc. numbers.

Another excellent solution is to create function for permutation to be repeated in file SmartPermutationGenerator as below:
public ArrayList<Integer> getRandomPermutation()
{
ArrayList<Integer> unused = new ArrayList<>();
.
.
.
}
public void nextPermutation()
{
for(int i = 0; i < size; i++) //loop for permutation 10 times
{
for(Integer item : getRandomPermutation())
{
System.out.print(item + " ");
}
System.out.println();
}
}
Solution credited to Mr.Soleh Abd Wahab.

Pyramid Pattern in Java

It was so hard to ask such a newbie question on this advanced site. But after so much tries and even loosing my hope i was forced to bring my self here. I am not been able to print the following pattern:
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
But with my tiresome efforts i reached the following:
public static void main(String[] args) {
int num = 1;
for (int i = 0; i < 15; i++) {
for (int j = 0; j < 15 - i; j++) {
System.out.print(" ");
}
for (int k = 0; k <= i; k++) {
System.out.print(num + " ");
}
System.out.println();
}
}
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 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

Here ya go
public static void main(String[] args) {
int max = 6;
int padLength = (int) Math.ceil(Math.log10(Math.pow(2, max) + 1)) + 2;
for (int i = 0; i < max; i++) {
for (int j = 1; j < max - i; j++) {
System.out.print(pad(" ", padLength));
}
for (int k = 0; k <= i; k++) {
System.out.print(pad(Math.pow(2, k), padLength));
}
for (int k = i - 1; k >= 0; k--) {
System.out.print(pad(Math.pow(2, k), padLength));
}
System.out.println();
}
}
public static String pad(double d, int l) {
Integer i = (int) d;
return pad(i.toString(), l);
}
public static String pad(String s, int l) {
return String.format("%-" + l + "s", s);
}
Explanation
int padLength = (int) Math.ceil(Math.log10(Math.pow(2, max) + 1)) + 2;
Math.pow(2,max) - Gives me maximal number I will have to display
Math.ceil(Math.log10(number + 1)) - I use this to determine length of string representation of specific number. Please refer to wikipedia to check what logarithm is. I add 1 to skip edge case when number is exact power of 10 e.g. log10(10)->1 (this will never occur in task specified in question, it's just for purity of solution). Ceil just rounds number up.
+2 - minimum gap between two numbers is specified example was 2 spaces long so I just add this
You could use here Integer.toString(((int)Math.pow(2, max))).length()+2 but it's not as pretty :)
return String.format("%-" + l + "s", s);
First I build format string that looks like e.g. %-3s, which means print String with minimum length of 3, padding on the right. Second argument is the String I want to print. Refer to documentation
Running example

I find the other answer very overwhelming and dramatic. You don't need much maths and complexity to solve this problem. This might not be the best code but I think it is easy to understand. Not even an explanation is needed, it is a row by row approach, It's good to keep things simple.
public static void main(String[] args) {
// Init
int row = 0;
int maxRows = 6;
int num = 1;
int indent = maxRows - 1;
// Printing loop
while (row < maxRows) {
// Indent
for (int i = 0; i < indent; ++i)
System.out.print(" ");
// Print nums
for (int i = 0; i < num; ++i)
System.out.printf("%4d", (int) Math.pow(2.0, i));
for (int i = num - 2; i >= 0; --i)
System.out.printf("%4d", (int) Math.pow(2.0, i));
// New line
System.out.println("");
// Adjustments
++row;
--indent;
++num;
}
Output:
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1

How do I write a program to output a triangle of numbers in Java?

I need help. My assignment is to write a Java program using nested loops to print out the following output pattern:
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
1 2 4 8 16 32 64 32 16 8 4 2 1
1 2 4 8 16 32 64 128 64 32 16 8 4 2 1
//pattern1
for(int outer=1;outer<=6;outer++) // outer loop controls number of rows
{
for(int inner=1;inner<=outer; inner++) // another loop to control number of numbers in each row.
{
System.out.print(inner);
}
System.out.println(); // move the cursor from the end of the current line to the beggiing to the next line
}
//pattern 2
for(int outer =1; outer<=6 ; outer++) //outer loop controls number of rows
{
//3-1 create spaces before numbers.
for(int space=1; space<=6-outer; space++ ) //group controls number of spaces
{
System.out.print(" ");
}
//3-2 print out real numbers.
for(int inner=1;inner<=outer; inner++) // another loop to control number of numbers in each row.
{
System.out.print(inner);
}
System.out.println();
}
Those two codes are back to back, but I do not understand how I would make the numbers 2 4 8 16 etc show up, and put them back to back.
What's wrong with my code? Is there a better way of doing this in Java?

A simple version with bit shifting and static column size / padding - could be improved by using Math.getExponent() for dynamically repeating spaces and format %3d ...
public static void f(int n) {
for (int i = 0; i < n; i++) {
for (int l = n - i; l > 0; l--) { // padding for symmetry
System.out.print(" ");
}
for (int j = 0; j <= i; j++) { // "left side" of pyramid
System.out.printf("%3d ", 1 << j);
}
for (int k = i - 1; k >= 0; k--) { // "right side" of pyramid
System.out.printf("%3d ", 1 << k);
}
System.out.println();
}
}
Output:
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
1 2 4 8 16 32 64 32 16 8 4 2 1
1 2 4 8 16 32 64 128 64 32 16 8 4 2 1

You're going to use a nested loop with an if statement controlling the output.
This code should help you with your formatting. You'll have to figure out how to add the || so that it flips the triangle and how to format your print statements so it looks like that.
int totalWidth = 8;
for (int row = 1; row <= totalWidth; row++) {
for (int col = 1; col <= totalWidth; col++) {
if (col <= totalWidth - row) {
System.out.print(" ");
}else {
System.out.print("*");
}
}
System.out.println();
}
It will output
*
**
***
****
*****
******
*******
********

public class pyramid
public static void f(int n) {
for (int i = 0; i < n; i++) {
for (int l = n - i; l > 0; l--) { // padding for symmetry
System.out.print(" ");
}
for (int j = 0; j <= i; j++) { // "left side" of pyramid
System.out.printf("%3d ", 1 << j);
}
for (int k = i - 1; k >= 0; k--) { // "right side" of pyramid
System.out.printf("%3d ", 1 << k);
}
System.out.println();
}
}