swift

//1、    创建一个函数，传入一个整型参数，并且无返回值，函数中实现把传入的参数转换成二进制（即十进制转换成二进制）
func decTobin(number:Int){
    var num = number
    var str = ""
    while num > 0 {
        str = "\(num % 2)" + str
        num /= 2
    }
    print(str)
}
decTobin(number: 10)

//1、    创建一个函数，无参数无返回值，实现把3，4，5，6四个数字组成互不相同无重复的3位数字，并打印出来
func din1() {
    var num1 = 0
    for h in 3...6 {
        for a in 3...6 {
            for n in 3...6 {
                if h != a && h != n && a != n{
                    print(h*100 + a * 10 + n)
                    num1+=1
                }
            }
        }
    }
}
din1()

//1、    创建一个函数，无参数无返回值，判断301~500中有多少个偶数，多少个奇数，并且输出偶数和奇数的个数，把所有的奇数和偶数分别打印出来
func din2() {
    var n = 1
    for h in 301...500 {
        if h % 2 == 0{
            n += 1
            print(h)
        }
    }
    for h in 301...500 {
        if h % 2 == 1{
            n+=1
            print(h)
        }
    }
}
din2()

//1、    创建一个数组Arr，数组成员[“a”,“b”,“c”，“d”，“e”,“f”,“g”]
//创建一另个数组Brr，数组成员[“b”,“d”,“f”,“g”]，求出数组Brr中成员在数组Arr中的下标，把下标组成一个新的数组，并把新数组打印出来
func name4(){
    var Arr = ["a" , "b" , "c" , "d" , "e" , "f" , "g" ,]
    var Brr = ["b" , "d" , "f" , "g" ,]
    var gongtong = [Int]()
    for  i in 0..<Arr.count{
        for  j in 0..<Brr.count{
            if Arr[i]==Brr[j]{
                gongtong.append(i)
            }
        }
    }
    print(gongtong)
}
name4()

//2222

//十进制转二进制
func shit(number:Int){
    var num = number
    var str = ""
    while num > 0 {
        str = "\(num % 2)" + str
        num /= 2
}
     print(str)
}
print(shit(number: 10))




//二进制转十进制
func fuck(num :String) ->Int {
    var sum = 0
    for c in num {
        sum = sum * 2 + Int("\(c)")!
    }
    return sum
}
print(fuck(num:"1111"))

//循环不重复数字

func din3(){
    var sum1 = 0  //定义变量用于记录个数
    for hudder in 3...6 {   //百位
        for ten in 3...6 {  //十位
            for num in 3...6 {  //个位
                if hudder != ten && hudder != num && ten != num {
                    print(hudder*100 + ten*10 + num)
                    sum1 += 1   //计算个数
                }
            }
        }
    }
}
//调用函数
din3()

//1、    创建一个函数，无参数无返回值，实现查找301~500中个位、十位、百位都不相同的三位数，并打印出来
func name3()  {
    for a in 301...500 {
        var geWei=a%10//分离出个位
        var shiWei=(a/10)%10//分离出十位
        var baiWei=(a/100)%10//分离出百位
        
        
        
        if(geWei != shiWei)
        {
            if (geWei != baiWei)
            {
                if(geWei != baiWei){
                    print("\(baiWei)\(shiWei)\(geWei)")
                }
            }
        }
    }
}
print( "name3" )
print(name3())

//1、    创建一个函数，无参数无返回值，实现把数组[“a”,“b”,“c”，“d”]
//进行遍历（使用元祖形式），打印下标和对应的字符；在数组后面添加两个元素[“e”,“f”]并打印数组，在下标为3处插入元素“h”并打印数组，删除数组的第一个元素并打印数组
func name4()  {
    var ziMu = ["a","b","c","d"]
    for (index,value) in ziMu.enumerated() {
        print(index,value)
        
    }
    ziMu.append("e")
    ziMu.append("f")
    print(ziMu)
    ziMu.insert("h", at: 3)
    print(ziMu)
}
print("name4")
print(name4())