如果您想了解在Swift中一次遍历两个集合和foreach遍历两个list的知识，那么本篇文章将是您的不二之选。我们将深入剖析在Swift中一次遍历两个集合的各个方面，并为您解答foreach遍历两个

如果您想了解在Swift中一次遍历两个集合和foreach遍历两个list的知识，那么本篇文章将是您的不二之选。我们将深入剖析在Swift中一次遍历两个集合的各个方面，并为您解答foreach遍历两个list的疑在这篇文章中，我们将为您介绍在Swift中一次遍历两个集合的相关知识，同时也会详细的解释foreach遍历两个list的运用方法，并给出实际的案例分析，希望能帮助到您！

• 在Swift中一次遍历两个集合（foreach遍历两个list）
• ios – 在Swift中创建水平滚动集合视图
• Swift 2.0学习笔记（Day 17）——Swift中数组集合
• Swift 给定一个集合，返回这个集合所有的子集
• Swift-C函数未在Swift中显示

在Swift中一次遍历两个集合（foreach遍历两个list）

说我有一个数组[1, 2, 3, 4, 5]。如何一次迭代两个？

Iteration 1: (1, 2)Iteration 2: (3, 4)Iteration 3: (5, nil)

答案1

您可以使用称为stride（to :, by :)的进度循环，每n个元素对元素进行一次迭代：

Xcode 8.3.2•Swift 3.1

let array = Array(1...5)let pairs = stride(from: 0, to: array.endIndex, by: 2).map {    (array[$0], $0 < array.index(before: array.endIndex) ? array[$0.advanced(by: 1)] : nil)}   // [(.0 1, {some 2}), (.0 3, {some 4}), (.0 5, nil)]print(pairs)  // "[(1, Optional(2)), (3, Optional(4)), (5, nil)]\n"

ios – 在Swift中创建水平滚动集合视图

var myArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
let rows = 3
let columnsInFirstPage = 5
// calculate number of columns needed to display all items
var columns: Int { return myArray.count<=columnsInFirstPage ? myArray.count : myArray.count > rows*columnsInFirstPage ? (myArray.count-1)/rows + 1 : columnsInFirstPage }

override func collectionView(collectionView: UICollectionView,numberOfItemsInSection section: Int) -> Int {        
    return columns*rows
}

override func collectionView(collectionView: UICollectionView,cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
    let cell = collectionView.dequeueReusableCellWithReuseIdentifier("Cell",forIndexPath: indexPath)
    //These three lines will convert the index to a new index that will simulate the collection view as if it was being filled horizontally
    let i = indexPath.item / rows
    let j = indexPath.item % rows         
    let item = j*columns+i

    guard item < myArray.count else {
        //If item is not in myArray range then return an empty hidden cell in order to continue the layout
        cell.hidden = true
        return cell
    }
    cell.hidden = false

    //Rest of your cell setup,Now to access your data You need to use the new "item" instead of "indexPath.item"
    //like: cell.myLabel.text = "\(myArray[item])"

    return cell
}

var myArray = [1,18]
let rows = 3
let columnsInPage = 5
var itemsInPage: Int { return columnsInPage*rows }
var columns: Int { return myArray.count%itemsInPage <= columnsInPage ? ((myArray.count/itemsInPage)*columnsInPage)  + (myArray.count%itemsInPage) : ((myArray.count/itemsInPage)+1)*columnsInPage }

override func collectionView(collectionView: UICollectionView,forIndexPath: indexPath)

    let t = indexPath.item / itemsInPage
    let i = indexPath.item / rows - t*columnsInPage
    let j = indexPath.item % rows      
    let item = (j*columnsInPage+i) + t*itemsInPage

    guard item < myArray.count else {
        cell.hidden = true
        return cell
    }
    cell.hidden = false

    return cell
}

Swift 2.0学习笔记（Day 17）——Swift中数组集合

数组（Array）是一串有序的由相同类型元素构成的集合。数组中的集合元素是有序的，可以重复出现。

var studentList1:Array<String>

var studentList2: [String]

声明的Array还不能用，还需要进行初始化，Array类型往往在声明的同时进行初始化。示例代码如下：

var studentList1:Array<String> = ["张三","李四","王五","董六"]

var studentList2:[String] = ["张三","董六"]

let studentList3:[String] = ["张三","董六"]

var studentList4 = [String]()

数组遍历

数组最常用的操作是遍历，就是将数组中的每一个元素取出来，进行操作或计算。整个遍历过程与循环分不开，可以使用for-in循环。

下面是遍历数组的示例代码：

var studentList:[String] = ["张三","王五"]

for item in studentList {

print (item)

}

for (index,value) instudentList.enumerate() {

print("Item \(index + 1 ) :\(value)")

}

运行结果如下：

张三

李四

王五

Item 1 : 张三

Item 2 : 李四

Item 3 : 王五

欢迎关注关东升新浪微博@tony_关东升。

关注智捷课堂微信公共平台，了解最新技术文章、图书、教程信息

@H_301_396@

更多精品iOS、Cocos、移动设计课程请关注智捷课堂官方网站：http://www.zhijieketang.com

智捷课堂论坛网站：http://51work6.com/forum.PHP

Swift 给定一个集合，返回这个集合所有的子集

//思路1：位
//解这道题的思想本质上就是元素选与不选的问题，于是我们就可以想到用二进制来代表选与不选的情况。“1”代表这个元素已经选择，而“0”代表这个元素没有选择。假如三个元素ABC，那么101就代表B没有选择，所以101代表的子集为AC
func getSubsetsOfSet<T>(set: Set<T>) -> Array<Set<T>> {
    let count = 1 << set.count
    let elements = Array(set)
    var subSets = Array<Set<T>>()
    for i in 0..<count {
        var subSet = Set<T>()
        for j in 0...elements.count {
            if ((i >> j) & 1) == 1 {
                subSet.insert(elements[j])
            }
        }
        subSets.append(subSet)
    }
    return subSets
}

let set: Set = ["a", "b", "c"]
for subset in getSubsetsOfSet(set: set) {
    print(subset)
}

//思路2：递归
//如果只有一个元素，那么它的子集有两个，分别是本身和空集，然后在已经有一个元素的子集的基础上，第二个元素有两种选法，那就是加入到前面的子集里面或者不加入到前面的子集里面，也就是选与不选的问题。而前面的子集一共有两个，对每一个子集都有来自于下一个元素的加入和不加入两种选法。那么就可以得出两个元素的子集一共有四个。以此类推，就可以得出n的元素所有子集（这里n个元素的子集一共有2的n次方个，非空子集一共有2的n次方-1个）。
func getSubsetsOfSet2<T>(set: Set<T>) -> Array<Set<T>> {
    let elements = Array(set)
    return getSubsetsOfSet3(elements: elements, index: elements.count - 1, count: elements.count)
}

func getSubsetsOfSet3<T>(elements: Array<T>, index: Int, count: Int) -> Array<Set<T>> {
    var subSets = Array<Set<T>>()
    if index == 0 {// 处理第一个元素
        subSets.append(Set<T>())
        var subSet = Set<T>()
        subSet.insert(elements[0])
        subSets.append(subSet)
        return subSets
    }
    subSets = getSubsetsOfSet3(elements: elements, index: index - 1, count: count)
    for subSet in subSets {
        var subSetWithCurrent = subSet
        subSetWithCurrent.insert(elements[index])
        subSets.append(subSetWithCurrent)
    }
    return subSets
}

let set2: Set = ["d", "e", "f"]
for subset in getSubsetsOfSet2(set: set2) {
    print(subset)
}

Swift-C函数未在Swift中显示

data[5]=1 # gives a ''bytes'' assignment error
open(''newfile'',''wb'').write(data)

void predictX010(const emxArray_char_T *inputString,emxArray_real_T *ypred);