仓颉PAT程序设计 L3-037 夺宝大赛(乱走+内存超限+答案正确)

oobroono

已于 2024-08-10 21:28:35 修改

阅读量195

点赞数 3

文章标签：算法数据结构开发语言前端前端框架

于 2024-08-10 04:43:53 首次发布

本文链接：https://blog.csdn.net/oobroono/article/details/141075014

版权

// 夺宝大赛 hunt
import std.format.*
import std.math.*
import std.collection.*
import std.console.*
import std.convert.*
import std.random.*
import std.sync.*
import std.time.*

//判断输入的字符串是否为空。
func getOrThrow(p: ?String): String{
    match (p) {
        case Some(x) => x
        case None => ""
    }
}
//判断输入的字符串是否为数字。返回真假。
func isNumber(number_string :String):Bool{
    var number_rune :Array<Rune>=number_string.toRuneArray()
    for(number in number_rune){
        if(!number.isAsciiNumber()){
            return false   
        }
    }
    return true
}

//获取输入的数字字符串。返回字符串。
func getInputNumber():String{
    var input=Console.stdIn.readln()
    let input_to_strig: Option<String> = input
    var input_to_strig_to :String=getOrThrow(input_to_strig)
    if(isNumber(input_to_strig_to)){
        return input_to_strig_to
    }
    return ""
}

//获取输入的字符串。返回字符串。
func getInputString():String{
    var input=Console.stdIn.readln()
    let input_to_strig: Option<String> = input
    var input_to_strig_to :String=getOrThrow(input_to_strig)
        return input_to_strig_to
    return ""
}

//获取m和n。m=行 x，n=列 y
func 获取_行_列(temp :String):Array<Int64>{
    // println("temp = ${temp}")
    if(temp.size>0){
    var  tempArray :Array<String> =temp.split(" ",118,)
    // println("tempArray ${tempArray}")
    // println("tempArray[0].size ${tempArray[0].size}")
    if(tempArray.size==2){
        var m:Int64=Int64.parse(tempArray[0])
        var n:Int64=Int64.parse(tempArray[1])
        if(2<m && n<=100){
            //println("m = ${m} n = ${n}")
            return [m,n]
        }
    }
    }
    return []
}

//获取网格一行数据
func 获取一行数据(temp :String,列 :Int64):Array<String>{
    if(temp.size==2*列-1){
    var  tempArray :Array<String> =temp.split(" ",118,)
    var tempA =Array<String>(列,item:"")
    for(i in 0..tempArray.size){
        tempA[i]=tempArray[i]
        //println("tempA = ${tempA[i].size}")
    }
    return tempA
    }
    return []
}
//获取网格一行数据
func 获取一行人物数据(temp :String,列 :Int64):Array<String>{
    if(temp.size==2*列-1){
    var  tempArray :Array<String> =temp.split(" ",118,)
    var tempA =Array<String>(列,item:"")
    for(i in 0..tempArray.size){
        tempA[i]=tempArray[i]
        //println("tempA = ${tempA[i].size}")
    }
    return tempA
    }
    return []
}




//测试网格数据
func 测试网格数据():ArrayList<Array<String>>{
    var 测试数据=ArrayList<Array<String>>()
    测试数据.append(["1","1","1","1","1","0","1"])
    测试数据.append(["1","1","1","1","1","0","0"])
    测试数据.append(["1","1","0","2","1","1","1"])
    测试数据.append(["1","1","0","0","1","1","1"])
    测试数据.append(["1","1","1","1","1","1","1"])
    return 测试数据
}

//测试用户数据
func 测试用户数据():ArrayList<Array<String>>{
    var 测试数据=ArrayList<Array<String>>()
    测试数据.append(["7","5"])
    测试数据.append(["1","3"])
    测试数据.append(["7","1"])
    测试数据.append(["1","1"])
    测试数据.append(["5","5"])
    测试数据.append(["3","1"])
    测试数据.append(["3","5"])
    return 测试数据

}

//判断是否有障碍
func 判断是否有障碍(行:Int64,列:Int64,网格数据:ArrayList<Array<String>>):Bool{
   // println([行,列,网格数据.size,网格数据[0].size])
    if(行<网格数据.size&&列<网格数据[0].size){
        if(网格数据[行][列]!="0"){
            return true
        }
    }    
    return false
}

//判断是否进入大本营
func 判断是否进入大本营(行:Int64,列:Int64,网格数据:ArrayList<Array<String>>):Bool{
    if(行<网格数据.size&&列<网格数据[0].size){
        if(网格数据[行][列]=="2"){
            return true
        }
    }    
    return false
}

//随机生成行走方向
func 随机生成行走方向(行:Int64,列:Int64):Array<Int64>{
    var 随机概率:Random=Random()
    // 随机概率.seed=3
    
    var 随机数:Int64=Int64.parse(随机概率.nextUInt64(4).toString())
    // println("随机数 = ${随机数}")
    // println([行,列])
    match (随机数) {
        case 0 => return [行-1,列]
                
        case 1 => return [行+1,列]

        case 2 => return [行,列-1]

        case 3 => return [行,列+1]

        case _ => return []
                  
    }
    return []
}

//开始行走，记录行走步伐。
func 行走(行: Int64,列: Int64,步数: Int64,网格数据:ArrayList<Array<String>>,累加:Int64):Int64{
    var 走一步:Array<Int64>=[行,列]
    // println("行 列 = ${行} ${列}")
    while(true){
    走一步=随机生成行走方向(行,列)
    if(走一步[0]>=0&&走一步[1]>=0&&走一步[0]<网格数据.size&&走一步[1]<网格数据[0].size){
        break
    }
    }
    
    // println("走一步 = ${走一步}")

    if(判断是否有障碍(走一步[0],走一步[1],网格数据)){

        if(判断是否进入大本营(走一步[0],走一步[1],网格数据)){
        //    println("走一步 in ${步数}= ${走一步}")
            return 步数
        }
       // println("走一步 ${步数}= ${走一步}")
        return 行走(走一步[0],走一步[1],步数+1,网格数据,累加+1)
    }
    if(累加==500){

        return 500
    }
    return  行走(行,列,步数,网格数据,累加+1)
}





//获取网格
func 获取网格(){
    //输入游戏数据
   var 数组_行_列 :Array<Int64> =获取_行_列(getInputString())
// var 数组_行_列 :Array<Int64>=[5,7]
// println("数组_行_列  = ${数组_行_列}")
   var arraylistLine=ArrayList<(Array<String>,Array<String>)>()
   var 网格数据=ArrayList<Array<String>>()
   if(!数组_行_列.isEmpty()){
    for(i in 0..数组_行_列[0]){
        网格数据.append(获取一行数据(getInputString(),数组_行_列[1]))
        // 网格数据.append(测试网格数据()[i])
        // println("网格数据 i = ${网格数据[i]}")
        
      //  var tempArray:(Array<String>,Array<String>)=(["","","",""],获取一行数据(getInputString(),arrayMandN[1]))
        //arraylistLine.append(tempArray)   
    }
   }
    // println("网格数据 2 3 = ${网格数据[2][3]}")
//    println("网格数据  = ${网格数据}")
    //输入游戏人物数据
    var 游戏人物个数:Int64=Int64.parse(getInputString())
    // println("游戏人物个数 = ${游戏人物个数}")
    // var 游戏人物个数:Int64=7
    var 测试游戏人物个数:Int64=7
        // 游戏人物个数= 测试游戏人物个数
    var 游戏人物群=ArrayList<(Array<String>,Array<String>)>()
    var arrayGamer=ArrayList<Array<String>>()
    if(游戏人物个数>0&&游戏人物个数<数组_行_列[0]*数组_行_列[1]/2){
        for (i in 0..游戏人物个数){
        // var 单个游戏人物数据:(Array<String>,Array<String>)=(["","","",""],获取一行数据(getInputString(),arrayMandN[1]))
        // println("数组_行_列[1] = ${数组_行_列[1]}")
        var 单个游戏人物数据:(Array<String>,Array<String>)=(["","","",""],获取一行数据(getInputString(),2))
        // println("单个游戏人物数据 = ${单个游戏人物数据[1]}")
       // var 单个游戏人物数据:(Array<String>,Array<String>)=(["","","",""],测试用户数据()[i])
        游戏人物群.append(单个游戏人物数据)
        // println("游戏人物群 = ${游戏人物群[i][1]}")
        //var tempGamer:Array<String> =getInputString().split(" ",118,)
       // arrayGamer.append([i.toString,tempGamer[0],tempGamer[1],"0",""])
        }
        // println("游戏人物群 完成")
    }

    //计算每个人行走的步数。
    var 统计=ArrayList<Array<Int64>>()
    for(i in 0..游戏人物群.size){
         //println("游戏人物群[i][1].toString() = ${游戏人物群[i][1][1].toString()}  ${游戏人物群[i][1][0].toString()}")
         var 最小行走步数:Int64=500
        for(_ in 0..1000){
            var 临时行走步数:Int64=行走(Int64.parse(游戏人物群[i][1][1].toString())-1,Int64.parse(游戏人物群[i][1][0].toString())-1,0,网格数据,0)
            //println("最小行走步数 = ${最小行走步数}  临时行走步数 = ${临时行走步数}")
            if(最小行走步数>临时行走步数){
                最小行走步数=临时行走步数
            }
        }
        //println("最小行走步数 = ${最小行走步数}")

    if(最小行走步数<500){
        统计.append([i,最小行走步数]) 
    }else{ 
        统计.append([-1,最小行走步数]) 
    }
    
    }
    var 判断相等:Bool=false
    for(i in 0..统计.size){
        for(j in i+1..统计.size){
            
            if(i!=j){
                //println(" 统计[j][0] = ${统计[j][0]}  统计[j][1] ${统计[j][1]}")
                if(统计[i][0]!=-1){
                if(统计[i][1]==统计[j][1]){
                    统计[j][0]=-1
                    判断相等=true
                }
            }
            }
            
        }
        if(判断相等){
            统计[i][0]=-1
            判断相等=false
        }

    }

    for(i in 0..统计.size){
        for(j in i+1..统计.size){
           // println(" 统计[j][0] = ${统计[j][0]}  统计[j][1] ${统计[j][1]}")
            if(统计[i][0]!=-1&&统计[j][0]!=-1){
                
                if(统计[i][1]>统计[j][1]){
                    统计[i][0]=-1
                }else{
                    统计[j][0]=-1
                }
            }
             
        }
      //  println(" 统计[j][0] = ${统计[i][0]}  统计[j][1] ${统计[i][1]}")
    }

    var 没有赢家:Bool = true
    for( i in 统计){
        // println("最少步数人员 = ${i}")
        if(i[0]!=-1){
            没有赢家=false
        println("最少步数人员 = ${i[0]+1} ${i[1]+1}")
        }
    }
    if(没有赢家){
        println("No winner.")
    }
    
    

}
main(){
   //println("${获取一行数据("1 2 3 2",4)}")
   // println(随机生成行走方向(1,2))
    获取网格()
    return 0
}