swift蛇和梯子游戏程序
2019-03-27 19:31:00 weixin_30553777 阅读数 3

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号:山青咏芝(shanqingyongzhi)
➤博客园地址:山青咏芝(https://www.cnblogs.com/strengthen/
➤GitHub地址:https://github.com/strengthen/LeetCode
➤原文地址: https://www.cnblogs.com/strengthen/p/10609919.html 
➤如果链接不是山青咏芝的博客园地址,则可能是爬取作者的文章。
➤原文已修改更新!强烈建议点击原文地址阅读!支持作者!支持原创!
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

On an N x N board, the numbers from 1 to N*N are written boustrophedonically starting from the bottom left of the board, and alternating direction each row.  For example, for a 6 x 6 board, the numbers are written as follows:

You start on square 1 of the board (which is always in the last row and first column).  Each move, starting from square x, consists of the following:

  • You choose a destination square S with number x+1x+2x+3x+4x+5, or x+6, provided this number is <= N*N.
    • (This choice simulates the result of a standard 6-sided die roll: ie., there are always at most 6 destinations.)
  • If S has a snake or ladder, you move to the destination of that snake or ladder.  Otherwise, you move to S.

A board square on row r and column c has a "snake or ladder" if board[r][c] != -1.  The destination of that snake or ladder is board[r][c].

Note that you only take a snake or ladder at most once per move: if the destination to a snake or ladder is the start of another snake or ladder, you do not continue moving.  (For example, if the board is `[[4,-1],[-1,3]]`, and on the first move your destination square is `2`, then you finish your first move at `3`, because you do not continue moving to `4`.)

Return the least number of moves required to reach square N*N.  If it is not possible, return -1.

Example 1:

Input: [
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]]
Output: 4
Explanation: 
At the beginning, you start at square 1 [at row 5, column 0].
You decide to move to square 2, and must take the ladder to square 15.
You then decide to move to square 17 (row 3, column 5), and must take the snake to square 13.
You then decide to move to square 14, and must take the ladder to square 35.
You then decide to move to square 36, ending the game.
It can be shown that you need at least 4 moves to reach the N*N-th square, so the answer is 4.

Note:

  1. 2 <= board.length = board[0].length <= 20
  2. board[i][j] is between 1 and N*N or is equal to -1.
  3. The board square with number 1 has no snake or ladder.
  4. The board square with number N*N has no snake or ladder.

在一块 N x N 的棋盘 board 上,从棋盘的左下角开始,每一行交替方向,按从 1 到 N*N 的数字给方格编号。例如,对于一块 6 x 6 大小的棋盘,可以编号如下:

玩家从棋盘上的方格 1 (总是在最后一行、第一列)开始出发。

每一次从方格 x 起始的移动都由以下部分组成:

  • 你选择一个目标方块 S,它的编号是 x+1x+2x+3x+4x+5,或者 x+6,只要这个数字 <= N*N
  • 如果 S 有一个蛇或梯子,你就移动到那个蛇或梯子的目的地。否则,你会移动到 S。 

在 r 行 c 列上的方格里有 “蛇” 或 “梯子”;如果 board[r][c] != -1,那个蛇或梯子的目的地将会是 board[r][c]

注意,你每次移动最多只能爬过蛇或梯子一次:就算目的地是另一条蛇或梯子的起点,你也不会继续移动。

返回达到方格 N*N 所需的最少移动次数,如果不可能,则返回 -1。 

示例:

输入:[
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]]
输出:4
解释:
首先,从方格 1 [第 5 行,第 0 列] 开始。
你决定移动到方格 2,并必须爬过梯子移动到到方格 15。
然后你决定移动到方格 17 [第 3 行,第 5 列],必须爬过蛇到方格 13。
然后你决定移动到方格 14,且必须通过梯子移动到方格 35。
然后你决定移动到方格 36, 游戏结束。
可以证明你需要至少 4 次移动才能到达第 N*N 个方格,所以答案是 4。 

提示:

  1. 2 <= board.length = board[0].length <= 20
  2. board[i][j] 介于 1 和 N*N 之间或者等于 -1
  3. 编号为 1 的方格上没有蛇或梯子。
  4. 编号为 N*N 的方格上没有蛇或梯子。

Runtime: 84 ms
Memory Usage: 19 MB
 1 class Solution {
 2     func snakesAndLadders(_ board: [[Int]]) -> Int {
 3         var n:Int = board.count
 4         var arr:[Int] = [Int](repeating:0,count:n * n)
 5         var i:Int = n - 1
 6         var j:Int = 0
 7         var index:Int = 0
 8         var inc:Int = 1
 9         while (index < n * n)
10         {
11             arr[index] = board[i][j]
12             index += 1
13             if inc == 1 && j == n - 1
14             {
15                 inc = -1
16                 i -= 1
17             }
18             else if inc == -1 && j == 0
19             {
20                 inc = 1
21                 i -= 1
22             }
23             else
24             {
25                 j += inc
26             }
27         }
28         var visited:[Bool] = [Bool](repeating:false,count:n * n)
29         var q:[Int] = [Int]()
30         var start:Int = arr[0] > -1 ? arr[0] - 1 : 0
31         q.append(start)
32         visited[start] = true
33         var step:Int = 0
34         while (!q.isEmpty)
35         {
36             var size:Int = q.count
37             while(size > 0)
38             {
39                 var cur:Int = q.removeFirst()
40                 if cur == n * n - 1
41                 {
42                     return step
43                 }
44                 var next:Int = cur + 1
45                 while(next <= min(cur + 6, n * n - 1))
46                 {
47                     var dest:Int = arr[next] > -1 ? arr[next] - 1 : next
48                     if !visited[dest]
49                     {
50                         visited[dest] = true
51                         q.append(dest)
52                     }
53                     next += 1
54                 }
55                 size -= 1
56             } 
57             step += 1
58         }
59         return -1
60     }
61 }

96ms

 1 class Solution {
 2     func snakesAndLadders(_ board: [[Int]]) -> Int {
 3         var flatBoard = [Int]()
 4         let n = board.count
 5         var fromLeft = true
 6         for row in board.reversed() {
 7             if fromLeft {
 8                 fromLeft = false
 9                 for x in row {
10                     flatBoard.append(x)
11                 }
12             } else {
13                 fromLeft = true
14                 for x in row.reversed() {
15                     flatBoard.append(x)
16                 }
17             }
18         }
19         flatBoard.insert(0, at: 0)
20         var queue = [Int]()
21         queue.append(1)
22         var counter = [Int](repeating:-1, count: n*n + 1)
23         counter[1] = 0
24         while queue.count > 0 {
25             let curr = queue.removeLast()
26             
27             for i in 1...6 {
28                 var next = curr + i
29                 if next > n*n {
30                     break
31                 }
32                 if flatBoard[next] != -1 {
33                     next = flatBoard[next]
34                 }
35                 if next == n*n {
36                     return counter[curr] + 1
37                 }
38                 if counter[next] == -1 {
39                     queue.insert(next, at: 0)
40                     counter[next] = counter[curr] + 1
41                 }
42             }
43         }        
44         return -1
45     }
46 }

104ms

 1 class Solution {
 2     func snakesAndLadders(_ board: [[Int]]) -> Int {
 3         var newBoard: [Int] = []                
 4         var movingForward = true
 5         for i in (0..<board.count).reversed() {
 6             newBoard += movingForward ? board[i] : Array(board[i].reversed())
 7             movingForward = !movingForward
 8         }
 9         
10         var steps = 0
11         var queue: [Int] = [0]
12         var visited: [Bool] = Array(repeating: false, count: newBoard.count)
13         visited[0] = true                
14         
15         while(!queue.isEmpty) {
16             var size = queue.count
17             while (size > 0) {
18                 let curr = queue.removeFirst()            
19                 if curr >= newBoard.count - 1 {                     
20                     return steps
21                 }        
22 
23                 let range = curr + 1...min(curr + 6, newBoard.count - 1)              
24                 for j in range { 
25                     let dest = newBoard[j] > -1 ? newBoard[j] - 1 : j
26                     if !visited[dest] {  
27                         visited[dest] = true
28                         queue.append(dest) 
29                     }
30                 }                
31                 size -= 1
32             }
33             steps += 1            
34         }        
35         return -1
36     }
37 }

 

转载于:https://www.cnblogs.com/strengthen/p/10609919.html

2016-08-08 11:09:00 weixin_34372728 阅读数 16

一、构建项目

二、在MainScene.swift中定义背景图、地面图、精灵

1.1创建背景图

由于背景图是可以拉伸的,因此为了适配全屏,需要在X Y 方向放大

此处的疑问,多个资料显示的是在scene中创建Layer层;但是CALayer是继承自NSObjec,而不是框架的CCNode所以,没有找到,目前实现的方式是通过自定义Layer层继承自CCNode。感觉貌似不对,查看文档,没有发现Layer类。

需要设置Layer的position值和positionType类型

1.2创建地面图

同样应该是使用一个层,或者直接使用Node节点,将图片固定在某个位置,但是是否需要适配其他的屏幕,而需要相对的坐标。

1.3创建精灵sprite

使用ccactionmoveby and CCActionMoveTo两个Action,然后使用CCActionSecquence将这两个动作顺序使用,最后使用CCActionRepeatForever重复使用该队列。保证了精灵一直处于上下跳动。

1.4为精灵的移动使用控制按钮

CCActionButton.setTarget

1.5坐标系的问题

使用ccpDistance,计算两个点之间的距离,但是涉及到了坐标系的问题,目前还有细节不清楚!后续补充


多个坐标系,一个通用的UI坐标系,是左上角为原点,x 轴横向, y轴纵向。

cocos2d坐标系:右手笛卡尔坐标系,x 左延伸,y向上

使用cocosCreater的例子在ios中使用swift构建游戏,参考cocosCreater文档中的实例


http://www.cocos.com/docs/creator/

在设置了position后,计算的distance总是不对,分析是当前的移动的精灵是使用的世界坐标系,而固定的星星是使用的笛卡尔坐标系,因此需要将移动的精灵和星星都使用世界坐标系来计算距离,convertToWorldSpace

最后采用了将坐标系转换为屏幕坐标系convertToWorldSpace,计算的两个位置,最小也是5,不能达到预期的距离0,最后距离的设计临界值为40;


1.6定时和计时器的两个类

cctimer ccscheduler

通过使用schedule(#selector(MainScene.gameover), interval: 10)才能生成CCTimer,而CCTimer对象是可以取消计时器的功能的,及timer.invalide

这样就可以重新的添加计时器;

1.7ccaction的停止和运行

对于CCAction的停止可以使用名称也可以使用tag值,停止后我理解是释放了该对象,而需要重新添加action.

对于停止的位置,就是下一次action运行的起始位置,因此需要重新精灵的起始位置。

2015-04-20 11:33:00 weixin_30764883 阅读数 2

https://github.com/kenzan100/2dTowerDefence-Swift

 

转载于:https://www.cnblogs.com/helinzi/p/4441087.html

2019-08-01 10:28:32 lin1109221208 阅读数 6

1、描述

你和你的朋友,两个人一起玩Nim游戏:桌子上有一堆石头,每次你们轮流拿掉 1- 3块石头,拿掉最后一个石头的人就是获胜者。你作为先手

你们是聪明人,每一步都是最优解,编写一个函数,来判断你是否可以在给定石头数量的情况下赢得比赛。

例:输入:4

        输出:false

        解释:如果堆中有4块石头,那么你永远不会赢得比赛;因为无论你拿走1块、2块还是3块石头,最后一块石头总是会被你的朋友拿走。

 

2、算法

1)递归

 func canWinNim(_ n: Int)->Bool{
        
        /*
         递归
         */
        if n <= 0 {
            return false
        }
        if n <= 3 {
            return true
        }
        return !canWinNim(n-1) || !canWinNim(n-2) || !canWinNim(n-3)
    }

2)极小化极大

思想:
         如果堆中石头的数量 n 不能被 4 整除,那么你总是可以赢得 Nim 游戏的胜利。

  推理:
         让我们考虑一些小例子。显而易见的是,如果石头堆中只有一块、两块、或是三块石头,那么在你的回合,你就可以把全部石子拿走,从而在游戏中取胜。而如果就像题目描述那样,堆中恰好有四块石头,你就会失败。因为在这种情况下不管你取走多少石头,总会为你的对手留下几块,使得他可以在游戏中打败你。因此,要想获胜,在你的回合中,必须避免石头堆中的石子数为 4 的情况。

时间复杂度:O(1)

func canWinNim(_ n: Int)->Bool{
        /*
         极小化极大 

         */
        return n % 4 != 0
    }

 

2015-03-27 21:22:51 chen3426721 阅读数 126

打开Xcode,本次学习的Xcode版本是6.2

打开Xcode,会出现以下界面


Get started with a playground:创建一个playground单元,它能让你快速体验到playground的特性。

Create a new Xcode project:创建一个Xcode工程,通常我们新建一个项目都会选择此项。

Check out an existing project:打开一个已经存在的工程,这个功能在你的项目代码转移到其他工作站上的时候非常有用。

在这里我们选择Create a new Xcode project,当然也有另一种方式,依次选择屏幕顶部菜单栏中的菜单项:File - New - New Project。


在Choose a template(选择程序模板)对话框中,我们需要选择对应的程序类型,在这里可以看到iOS跟OS X分支下分别有几个子类别,点击每个子类可以看到包含的模板,通过选择模板,Xcode可以快速地位为我们快速创建出对应模板的干净应用,由于我们是初学Swift选择OS X - Application - Command Line Tool,然后点击Next


在Product Name里填入创建的项目所取的名字,Organization Identifier(机构名称)填入"com.qianbi"(组织标识,在新建的项目都会以这样的标识作为开头,在公司开发当中填入公司的域名即可),Language(开发语言)项目中有"Swift","Objective-C","C++","C"这几个可选项,在这里我们当然选择"Swift"。

然后点击Next,设置项目存储的目标文件夹,在这里我们选择左侧的文稿,然后点击New Folder新建一个helloworld的文件夹,存储对应的代码,单击Create按钮完成项目的新建。

此时工程窗口将自动打开,默认进入工程的参数设置界面


单击左边列表的"main.swift"单元,可以看到Xcode已经自动为我们生成了hello world。

同时按下Command键和R键,程序将开始编译,如果程序编译通过则会自动运行。这个时候你可以在Xcode右下角的Output输出窗口看到程序的输出。



注意Swift代码,跟OC不一样,不需要在每次代码结束后在后面加;

这样就避免了忘记输入分号而造成报错,不过在Swift下就算输入了分号,也不会报错的,而且你也不需要单独编写一个mian函数作为入口,而实际上main函数在进入你所编写的Swift代码之前,已经默认执行了,你的注意力可以放到抽象层次更高的地方。

第一个swift程序

阅读数 310

第一个swift程序

阅读数 258

没有更多推荐了,返回首页