首页 > 试题广场 >

打印回形数

[编程题]打印回形数
  • 热度指数:1512 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 64M,其他语言128M
  • 算法知识视频讲解
回形数是一个矩阵输出,从矩阵的左上角往右开始打印数字0,遇到矩阵边界时,顺时针90方向继续打印,并数字增长1,如此类推直到把矩阵填满,输入一个整形宽和高单位,每输出一个数字,占用1单位宽高空间,根据入参打印出对应的回形数

输入描述:
矩阵的宽高


输出描述:
回字形的矩阵
示例1

输入

8 3

输出

00000000
34444441
22222221

说明

顺时针从0开始
import java.util.Scanner;

/**
 * 欢聚时代2018校招笔试题-Android B卷 打印回形数
 * 回形数是一个矩阵输出,从矩阵的左上角往右开始打印数字0,遇到矩阵边界时,顺时针90方向
 * 继续打印,并数字增长1,如此类推直到把矩阵填满,输入一个整形宽和高单位,每输出一个数
 * 字,占用1单位宽高空间,根据入参打印出对应的回形数
 * 输入描述:
 * 矩阵的宽高
 * 输出描述:
 * 回字形的矩阵
 * 输入例子1:
 * 8 3
 * 输出例子1:
 * 00000000
 * 34444441
 * 22222221
 */
public class PrintBackMatrix {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int col = sc.nextInt();
        int row = sc.nextInt();
        printMatrix(col, row);
    }


    public static void printMatrix(int columns, int rows) {
        int[][] matrix = new int[rows][columns];
        int start = 0;
        while (columns > start * 2 && rows > start * 2) {
            printMatrixInCircle(matrix, columns, rows, start);
            start++;
        }

        int m = matrix.length;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                System.out.print(matrix[i][j]);
            }
            System.out.println();
        }
    }

    public static void printMatrixInCircle(int[][] matrix, int columns, int rows,
                                           int start) {
        int endX = columns - 1 - start;
        int endY = rows - 1 - start;

        int num = 0;

        //第一步:从左到右打印一行
        for (int i = start; i <= endX; i++) {
            matrix[start][i] = start * 4 + num;
        }

        num++;
        //第二步:从上到下打印一列
        if (start < endY) {
            for (int i = start + 1; i <= endY; i++) {
                matrix[i][endX] = start * 4 + num;
            }
        }
        num++;
        //第三步:从右到左打印一行
        if (start < endX && start < endY) {
            for (int i = endX - 1; i >= start; i--) {
                matrix[endY][i] = start * 4 + num;
            }
        }
        num++;
        //第四步:从下到上打印一列
        if (start < endX && start < endY - 1) {
            for (int i = endY - 1; i >= start + 1; i--) {
                matrix[i][start] = start * 4 + num;
            }
        }
        num = 0;
    }
}
发表于 2018-07-09 21:20:36 回复(0)
入门题。。
import java.util.*;

public class Main {
    private static int MAX = (int) 10e5+5;
    private static int INT_MAX = 0x3f3f3f3f;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(), n = sc.nextInt();
        int count = 0;
        int[][] map = new int[n][m];
        for (int i=0; i!=n; i++) {
            for (int j=0; j!=m; j++) {
                map[i][j] = -1;
            }
        }
        int i = 0, j = -1; int now = 0;
        while (count < m * n) {
            while (j+1<m && map[i][j+1]==-1 && count < m*n) { map[i][++j] = now; count++; } now++;
            while (i+1<n && map[i+1][j]==-1 && count < m*n) { map[++i][j] = now; count++; } now++;
            while (j-1>=0 && map[i][j-1]==-1 && count < m*n) { map[i][--j] = now; count++; } now++;
            while (i-1>=0 && map[i-1][j]==-1 && count < m*n) { map[--i][j] = now; count++; } now++;
        }
        StringBuilder sb = new StringBuilder();
        for (i=0; i!=n; i++) {
            for (j=0; j!=m; j++) {
                sb.append(map[i][j]);
            }
            sb.append("\n");
        }
        System.out.print(sb.toString());
        return;
    }
} 
编辑于 2019-02-11 01:34:05 回复(0)
直接上模拟边界法
import java.lang.String;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while((line = br.readLine()) != null) {
            String[] strWH = line.split(" ");
            int h = Integer.parseInt(strWH[1]), w = Integer.parseInt(strWH[0]);
            solve(h, w);
        }
    }
    
    private static void solve(int m, int n) {
        int[][] arr = new int[m][n];
        int idx = 0, start = 0;
        int left = 0, right = n - 1, top = 0, bottom = m - 1;
        while(idx <= m * n){
            for(int i = left; i <= right; i++){
                arr[top][i] = start;
                idx ++;
            }
            top ++;
            if(top > bottom) break;
            start ++;
            for(int i = top; i <= bottom; i++){
                arr[i][right] = start;
                idx ++;
            }
            right --;
            if(left > right) break;
            start ++;
            for(int i = right; i >= left; i--){
                arr[bottom][i] = start;
                idx ++;
            }
            bottom --;
            if(top > bottom) break;
            start ++;
            for(int i = bottom; i >= top; i--){
                arr[i][left] = start;
                idx ++;
            }
            left ++;
            if(left > right) break;
            start ++;
        }
        StringBuilder sb;
        for(int i = 0; i < m; i++){
            sb = new StringBuilder();
            for(int j = 0; j < n; j++)
                sb.append(arr[i][j]);
            System.out.println(sb.toString());
        }
    }
}



编辑于 2020-11-30 17:08:01 回复(0)
左程云老师的书P331页,转圈打印矩阵,类似的题目
发表于 2019-02-19 13:08:02 回复(0)
public class Main { //一个时间复杂度O(width*height),空间复杂度O(1)的算法
  public static void main(String[] args) {
    java.util.Scanner sc = new java.util.Scanner(System.in);
    int width = sc.nextInt(), height = sc.nextInt(), i, j, minDis, prt;
    for (i = 1; i <= height; ++i) {
      for (j = 1; j <= width; ++j) {//本循环内只有判断结构和顺序结构,
        minDis = i - 1;             //所以循环内花费的时间是常数,
        prt = 4 * minDis;           //总的时间花费是常数*width*height,
        if (width - j < minDis) {   //略去常数,复杂度为O(width*height)。
          minDis = width - j;       //显然因为要打印width*height个字符,
          prt = 1 + 4 * minDis;     //所以不考虑常数的时间复杂度已最佳。
        }                           //而因为没有使用一个矩阵存储,
        if (height - i < minDis) {  //空间复杂度只为常数,即O(1)
          minDis = height - i;
          prt = 2 + 4 * minDis;
        }
        if (j - 1 < minDis)
          prt = 3 + 4 * (j - 1);
        System.out.print(prt);
      }
      System.out.println("");
    }
  }
}

编辑于 2018-07-10 00:21:45 回复(1)
[cols,rows]=list(map(int,input().strip().split()))
res=[[0 for i in range(cols)]for i in range(rows)]
left=0
right=cols-1
up=0
down=rows-1
val=0
while left<=right and up<=down:
    for j in range(left,right+1):
        res[up][j]=val
    val+=1
    for i in range(up+1,down+1):
        res[i][right]=val
    if up<down:
        val+=1
        for i in range(right-1,left-1,-1):
            res[down][i]=val
    if left<right:#注意
        val+=1
        for j in range(down-1,up,-1):
            res[j][left]=val
    val+=1
    left+=1
    right-=1
    up+=1
    down-=1
for i in res:
    print(''.join(list(map(str,i))))
注意倒着走的两个单排防止回流的判断
发表于 2020-03-27 14:00:16 回复(0)
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{
    int N,M;
    cin>>N>>M;
    vector<vector<int>> rec(M);
    vector<int> temp(N,-1);
    for(int i=0;i<M;i++)
    {
         rec[i]=temp;   
    }
    int x=0,y=0;
    int value=0;
    int pM=M,pN=N;
    while(pM!=0&&pN!=0)
    {
        for(int i=0;i<pN;i++)
        {
            rec[x][y++]=value;
        }
		y--;
        pM--;value++;
        if(pM==0) break;
        for(int i=0;i<pM;i++)
        {
            rec[++x][y]=value;
        }
        pN--;value++;
        if(pN==0) break;
        for(int i=0;i<pN;i++)
        {
            rec[x][--y]=value;
        }
        pM--;value++;
        if(pM==0) break;
        for(int i=0;i<pM;i++)
        {
            rec[--x][y]=value;
        }
        pN--;value++;
        y++;
    }
    for(auto r:rec)
    {
        for(auto s:r)
            cout<<s;
        cout<<endl;
    }
}

发表于 2019-09-10 15:12:12 回复(0)
#include<bits/stdc++.h>
// 剑指offer顺时针打印矩阵类似题目
using namespace std;
void printMatrixInCircle(vector<vector<int>> &res, int start, int width, int length){
    int endy = length - start -1; //终止列号
    int endx = width - start - 1; //终止行号

    for(int i = start; i <= endy; i++)
        res[start][i] = start*4; 

    
    if(endx > start){ //终止行号大于起始行号
        for(int i = start+1; i <= endx; i++){
            res[i][endy] = start*4 +1;
        }
    }
    
    if(endx > start && endy > start){//终止行号大于起始行号 and 终止列号也大于起始列号
        for(int i = endy-1; i >= start ; i--){
            res[endx][i] = start*4 +2;
        }
    }
    
    if(endx > start+1 && endy > start){//终止行号比起始行号大2或者以上 and 终止列号也大于起始列号
        for(int i = endx-1; i > start ; i--){
            res[i][start] = start*4 +3;
        }
    }
}
int main(){
    int length,width;
    cin>>length>>width;
    if(length <= 0 || width <= 0)
        return 0;
    int start = 0;
    vector<vector<int>> res(width, vector<int>(length, -1));

    while(length > start*2 && width > start*2){
        printMatrixInCircle(res, start++, width, length);
    }
    for(int i = 0; i < width; i++){
        for(int j = 0; j< length; j++)
            cout<<res[i][j];
        cout<<endl;
    }
    return 0;
}

发表于 2019-09-05 09:24:03 回复(0)
只做越界判断,越界就走下一个方向
#include<bits/stdc++.h>
using namespace std;

int main(){
    int m=0, n=0;
    scanf("%d%d", &n, &m);
    vector<vector<int>> mat(m, vector<int>(n, -1));
    int direct[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
    int cnt=0, flag=0, x=0, y=0, cur=0;
    while(cnt < n*m){
        //如果没越界,一直走
        while(0<=x&&x<m && 0<=y&&y<n && mat[x][y]==-1){
            ++cnt;
            mat[x][y] = cur;
            x += direct[flag][0];
            y += direct[flag][1];
        }
        //越界了,往回走一步
        x -= direct[flag][0];
        y -= direct[flag][1];
        //走下一个方向
        cur += 1;
        flag = (flag+1)%4;
        x += direct[flag][0];
        y += direct[flag][1];
    }
    for(int i=0; i<m; ++i){
        for(const auto&x: mat[i]){
            cout<< x;
        }cout<< endl;
    }
    return 0;
}


发表于 2019-08-13 21:54:36 回复(0)
#include <bits/stdc++.h>
using namespace std;
void A (int rows,int columns,vector<vector<int>> matrix,int value, int start){
    int endX=columns-1-start;
    int endY=rows-1-start;
    for(int i=start;i<=endX;i++){
        matrix[start][i]=value;
        value++;
    }
    if(start<endY){
        for(int i=start+1;i<=endY;i++){
             matrix[i][endX]=value;
        value++; 
        }
    }
    if(start<endX&&start<endY){
          for(int i=endX;i>=start;i--){
             matrix[endY][i]=value;
        value++; 
        }
    }
    if(start<endX&&start<endY-1){
          for(int i=endY-1;i>=start+1;i--){
             matrix[i][start]=value;
                value++; 
        }
    }
}
int main (){
    int n,m;
      vector <vector<int>> M;
    while(cin>>n>>m){
        int val=0;
        int sta=0;
  while (n > sta * 2 && m > sta * 2) {
               A ( n,m,M[n][m], val,  sta);
                sta++;
            }
    }
for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                   cout<<M[i][j];
                }
              cout<<endl;
            }
        }
为啥数组越界~
编辑于 2019-07-10 19:38:48 回复(0)
# -*- coding: utf-8 -*-
"""
Created on Sun May 12 10:34:14 2019

@author: i
"""
def mawari(a,h1,h2,w1,w2,start):
    if h2-h1 == 0:
        for j in range(w1,w2+1):
            a[h1][j] = start
        return
    if w2-w1 == 0:
        a[h1][w1] = start
        for i in range(h1+1,h2+1):
            a[i][w1] = start+1
        return
    if h2-h1 == 1:
        for j in range(w1,w2+1):
            a[h1][j] = start
        a[h2][w2] = start+1
        for j in range(w1,w2):
            a[h2][j] = start+2
        return
    if w2-w1 == 1:
        for j in range(w1,w2+1):
            a[h1][j] = start
        for i in range(h1+1,h2+1):
            a[i][w2] = start+1
        a[h2][w1] = start+2
        for i in range(h1+1,h2):
            a[i][w1] = start+3
        return
    
    for j in range(w1,w2+1):
        a[h1][j] = start
    for i in range(h1+1,h2+1):
        a[i][w2] = start+1
    for j in range(w1,w2):
        a[h2][j] = start+2
    for i in range(h1+1,h2):
        a[i][w1] = start+3
    mawari(a,h1+1,h2-1,w1+1,w2-1,start+4)

if __name__ == "__main__":
    line = raw_input()
    lines = line.split()
    W,H = int(lines[0]),int(lines[1])
    a = [[0 for j in range(W)] for i in range(H)]
    mawari(a,0,H-1,0,W-1,0)
    for i in range(H):
        result = [str(item) for item in a[i]]
        print "".join(result)
     

发表于 2019-05-12 20:01:34 回复(0)
import java.util.Scanner;

/**
 * 详见《剑指offer》 顺时针打印矩阵
 * https://blog.csdn.net/qq_32767041/article/details/83831330#421__1344
 *
 * @author wylu
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int cols = scanner.nextInt(), rows = scanner.nextInt();
            int[][] matrix = new int[rows][cols];
            int value = 0, start = 0;

            while (cols > start * 2 && rows > start * 2) {
                value = calMatrixInCircle(matrix, rows, cols, start++, value);
            }

            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < cols; j++) {
                    System.out.print(matrix[i][j]);
                }
                System.out.println();
            }
        }
    }

    private static int calMatrixInCircle(int[][] matrix,
                                         int rows, int cols,
                                         int start, int value) {
        int endX = cols - start - 1, endY = rows - start - 1;

        for (int i = start; i <= endX; i++) matrix[start][i] = value;
        value++;

        if (endY > start) {
            for (int i = start + 1; i <= endY; i++) matrix[i][endX] = value;
            value++;
        }

        if (endY > start && endX > start) {
            for (int i = endX - 1; i >= start; i--) matrix[endY][i] = value;
            value++;
        }

        if (endX > start && endY - start > 1) {
            for (int i = endY - 1; i > start; i--) matrix[i][start] = value;
            value++;
        }

        return value;
    }
}

发表于 2019-01-10 17:30:18 回复(0)