java程序设计基础训练一（6-10）

小雷不爱编程

已于 2024-06-15 14:48:23 修改

阅读量55

点赞数

分类专栏： HNU面向对象程序设计(java) 文章标签： java 算法开发语言

于 2023-10-29 14:52:12 首次发布

本文链接：https://blog.csdn.net/lzylzzy/article/details/134102794

版权

HNU面向对象程序设计(java) 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

【问题描述】

骰子是个立方体每个面一个数字，初始为左1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态。放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。

【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复

【输出形式】输出经过一系列操作后的序列注：按左右前后上下顺序输出

【样例输入】LB

【样例输出】5 6 1 2 3 4

import java.util.Scanner;
public class Main {
    //我写的
    public static int[] Achange(int[] arr){
        int temp = arr[0];
        arr[0] = arr[3];
        arr[3] = arr[1];
        arr[1] = arr[2];
        arr[2] = temp;
        return arr;
    };

    public static int[] Cchange(int[] arr){
        int temp = arr[0];
        arr[0]=arr[2];
        arr[2]=arr[1];
        arr[1]=arr[3];
        arr[3]=temp;
        return arr;
    };

    public static int[] Fchange(int[] arr){
        int temp=arr[2];
        arr[2]=arr[4];
        arr[4]=arr[3];
        arr[3]=arr[5];
        arr[5]=temp;
        return arr;
    };

    public static int[] Bchange(int[] arr){
        int temp=arr[2];
        arr[2]=arr[5];
        arr[5]=arr[3];
        arr[3]=arr[4];
        arr[4]=temp;
        return arr;
    };

    public static int[] Lchange(int[] arr){
        int temp=arr[0];
        arr[0]=arr[4];
        arr[4]=arr[1];
        arr[1]=arr[5];
        arr[5]=temp;
        return arr;
    };

    public static int[] Rchange(int[] arr){
        int temp=arr[0];
        arr[0]=arr[5];
        arr[5]=arr[1];
        arr[1]=arr[4];
        arr[4]=temp;
        return arr;
    };
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int[] arr1={1,2,3,4,5,6};
        String cz=in.nextLine();
        int len=cz.length();
        for(int i=0;i<len;i++){
            if(cz.charAt(i)=='L'){
                arr1=Lchange(arr1);
            }
            if(cz.charAt(i)=='R'){
                arr1=Rchange(arr1);
            }
            if(cz.charAt(i)=='F'){
                arr1=Fchange(arr1);
            }
            if(cz.charAt(i)=='B'){
                arr1=Bchange(arr1);
            }
            if(cz.charAt(i)=='A'){
                arr1=Achange(arr1);
            }
            if(cz.charAt(i)=='C'){
                arr1=Cchange(arr1);
            }
        }
        for(int i=0;i<6;i++){
            System.out.print(arr1[i]+" ");
        }


    }
}

【问题描述】

有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，每个供应商的供应能力有上限，每个商店都有自己的商品需求量（need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。

【输入形式】

输入说明：第一行包含两个整数N，M

接下来N行包含三个整数，第一个数表示供应商编号，第二数表示供应能力上限，表示该供应商的供应量不能超过这个上限，第三个数表示运送单位商品到商店的运费。

接下来M行包含两个整数，第一个数表示商店编号，第二个数表示某种商品的需求量。
【输出形式】

输出说明：若可以满足所有商店需求，则输出格式如下：每行第一个数表示供应商编号，第二个数为商店编号，第三个数为供应量。

如：1 2 20

表示第1个供应商给第2个商店供应20个单位量的商品

按商店编号顺序，输出所有供应路径（最后一行无换行符）。

若不满足，输出-1
【样例输入】

4 4

0 20 8

1 15 3

2 55 6

3 40 10

0 28

1 36

2 49

3 12
【样例输出】

1 0 15

2 0 13

2 1 36

2 2 6

0 2 20

3 2 23

3 3 12

import java.util.Scanner;
import java.util.Arrays;
public class Main {

    public static int[][] px(int[][] arr){
        Arrays.sort(arr,(a,b)->Integer.compare(a[2],b[2]));
        return arr;
    }

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        in.nextLine();
        int[][] pro=new int[n][3];//供应端列表
        int[][] need=new int[m][2];//需求端列表

        int gysum=0;

        for(int i=0;i<n;i++){
            int bh=in.nextInt();//编号
            int sx=in.nextInt();//上限
            int yf=in.nextInt();//运费
            in.nextLine();
            pro[i]= new int[]{bh, sx, yf};
            gysum+=sx;

        }
        int xqlsum=0;

        for(int i=0;i<m;i++){
            int bh2=in.nextInt();
            int xql=in.nextInt();//需求量
            in.nextLine();
            need[i]=new int[]{bh2,xql};
            xqlsum+=xql;
        }
        if(xqlsum>gysum){
            System.out.println("-1");
        }
        else{
            pro=px(pro);
            int j=0;
            for(int i=0;i<m;i++){
                while(need[i][1]!=0){
                    if(pro[j][1]>need[i][1]){
                        int temp=need[i][1];
                        need[i][1]=0;
                        pro[j][1]=pro[j][1]-temp;
                        System.out.println(pro[j][0]+" "+i+" "+temp);
                        break;
                    }
                    else if(pro[j][1]==need[i][1]){
                        need[i][1]=0;
                        int temp=pro[j][1];
                        pro[j][1]=0;
                        System.out.println(pro[j][0]+" "+i+" "+temp);
                        j++;
                    }
                    else if(pro[j][1]<need[i][1]){
                        need[i][1]=need[i][1]-pro[j][1];
                        int temp=pro[j][1];
                        pro[j][1]=0;
                        System.out.println(pro[j][0]+" "+i+" "+temp);
                        j++;
                    }



                }
            }
        }



    }
}

【问题描述】写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。

【输入形式】输入N个字符
【输出形式】输出该字符串反转后的字符串

【样例输入】

abcd
【样例输出】

dcba

import java.util.Scanner;

public class Test_eight{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        int len=str.length();
        StringBuilder ans = new StringBuilder();
        for(int i=len-1;i>=0;i--){
            ans.append(str.charAt(i));
        };
        System.out.println(ans.toString());


    }
}

【问题描述】

两个人是朋友通常意味着他们存在着许多共同的兴趣。然而作为一个宅男，你发现自己与他人相互了解的机会并不太多。幸运的是，你意外得到了一份湖大图书馆的图书借阅记录，于是你挑灯熬夜地编程，想从中发现潜在的朋友。

首先你对借阅记录进行了一番整理，把N个读者依次编号为1,2,…,N，把M本书依次编号为1,2,…,M。同时，按照“臭味相投”的原则，和你喜欢读同一本书的人，就是你的潜在朋友。你现在的任务是从这份借阅记录中计算出每个人有几个潜在朋友。

【输入形式】

每个案例第一行两个整数N,M。接下来有N行，第i(i = 1,2,…,N)行每一行有一个数，表示读者i-1最喜欢的图书的编号P(1<=P<=M)

【输出形式】

每个案例包括N行，每行一个数，第i行的数表示读者i有几个潜在朋友。如果i和任何人都没有共同喜欢的书，则输出“BeiJu”（即悲剧，^ ^）

【样例输入】

4 5

【样例输出】

BeiJu

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int n,m;
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        m=in.nextInt();
        in.nextLine();
        int[] book=new int[m];
        for(int i=0;i<m;i++){
            book[i]=0;
        }
        int[] person=new int[n];
        for(int i=0;i<n;i++){
            int myg=in.nextInt();
            person[i]=myg;
            in.nextLine();
            book[myg-1]++;
        }
        for(int i=0;i<n;i++){
            //System.out.println(book[person[i]-1]);
            if(book[person[i]-1]==1){
                System.out.println("BeiJu");
            }
            else{
                System.out.println(book[person[i]-1]-1);
            }
        }
    }
}

10.

【问题描述】写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。(多组同时输入)

【输入形式】输入一个十六进制的数值字符串。

【输出形式】输出该数值的十进制字符串。

【样例输入】0xA

【样例输出】10

import java.util.Scanner;
public class Main {
    public static int s(int c){
        int d=1;
        /*if(c==0){
            d=1;
        }
        else{
            for(int i=1;i<=c;i++){
                d*=16;
            }
        }*/
        if(c!=0){
            for(int i=1;i<=c;i++){
                d*=16;
            }
        }
        return d;
    };

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String myh;
        while(in.hasNextLine()){
            myh=in.nextLine();
            String num=myh.substring(myh.indexOf("x")+1);
            int len=num.length();
            int ans=0;
            for(int i=len-1;i>=0;i--){
                int a=0;
                char h=num.charAt(i);
                if('0'<=h&&h<='9'){
                    a=Character.getNumericValue(h);
                }
                else if(h=='A'){
                    a=10;
                }
                else if(h=='B'){
                    a=11;
                }
                else if(h=='C'){
                    a=12;
                }
                else if(h=='D'){
                    a=13;
                }
                else if(h=='E'){
                    a=14;
                }
                else if(h=='F'){
                    a=15;
                }
                ans+=s(len-i-1)*a;

            }
            System.out.println(ans);
        }
    }
}

小雷不爱编程

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java程序设计基础训练一（6-10）

放置在平面上，用L表示向左翻转一次，用R表示向右翻转一次，用F表示向前翻转一次，用B表示向后翻转一次，用A表示逆时针旋转90度，用C表示顺时针旋转90度，现从初始状态开始，根据输入的动作序列，计算得到最终的状态。有n个某种商品供应商，某地有m个商店，商店需要从供应商那里进货该商品，每个供应商的供应能力有上限，每个商店都有自己的商品需求量（need[i]:表示第i个商店的需求），每个供应商运送单位商品到商店需要一个运费。【输入形式】输入只包含LRFBAC的字母序列，最大长度为50，可重复。
复制链接

扫一扫