Anonymous user
Lucky and even lucky numbers: Difference between revisions
Add Swift
m (forgot to say "even" in output) |
(Add Swift) |
||
Line 1,440:
10000th even lucky number: 111842
</pre>
=={{header|Swift}}==
{{trans|Python}}
The lucky numbers sequence:
<lang swift>struct LuckyNumbers : Sequence, IteratorProtocol {
let even: Bool
let through: Int
private var drainI = 0
private var n = 0
private var lst: [Int]
init(even: Bool = false, through: Int = 1_000_000) {
self.even = even
self.through = through
self.lst = Array(stride(from: even ? 2 : 1, through: through, by: 2))
}
mutating func next() -> Int? {
guard n != 0 else {
defer { n += 1 }
return lst[0]
}
while n < lst.count && lst[n] < lst.count {
let retVal = lst[n]
lst = lst.enumerated().filter({ ($0.offset + 1) % lst[n] != 0 }).map({ $0.element })
n += 1
return retVal
}
if drainI == 0 {
lst = Array(lst.dropFirst(n))
}
while drainI < lst.count {
defer { drainI += 1 }
return lst[drainI]
}
return nil
}
}</lang>
The main file:
<lang swift>let args = Array(CommandLine.arguments.dropFirst())
guard let sj = args.first, let j = Int(sj), j > 0, j <= 10_000 else {
fatalError("Incorrect j")
}
func evenString(_ even: Bool) -> String {
return even ? "even" : ""
}
func jLuckyNumber(_ j: Int, even: Bool) {
print("The \(j)th \(evenString(even)) lucky number is \(Array(LuckyNumbers(even: even))[j-1..<j].first!)")
}
func luckyNumbersKth(j: Int, k: Int, even: Bool) {
print("List of \(j) ... \(k) \(evenString(even)) lucky numbers: ", terminator: "")
for (offset, luck) in LuckyNumbers(even: even).lazy.enumerated() {
guard offset + 1 <= k else { break }
if offset + 1 >= j {
print(luck, terminator: ", ")
}
}
print()
}
func luckyNumbersRange(j: Int, k: Int, even: Bool) {
print("List of \(evenString(even)) lucky numbers in the range \(j) ... \(-k): ", terminator: "")
for lucky in LuckyNumbers(even: even).lazy {
guard lucky <= -k else { break }
if lucky >= j {
print(lucky, terminator: ", ")
}
}
print()
}
switch args.count {
case 1:
jLuckyNumber(j, even: false)
case 2:
switch Int(args.last!) {
case let k? where k > 0 && k <= 10_000 && k > j:
luckyNumbersKth(j: j, k: k, even: false)
case let k? where k < 0 && -k > j:
luckyNumbersRange(j: j, k: k, even: false)
case _:
fatalError("Bad args")
}
case 3:
switch (Int(args[1]), args.last!) {
case (nil, "lucky"):
jLuckyNumber(j, even: false)
case (nil, "evenLucky"):
jLuckyNumber(j, even: true)
case let (k?, "lucky") where k > 0 && k <= 10_000 && k > j:
luckyNumbersKth(j: j, k: k, even: false)
case let (k?, "evenLucky") where k > 0 && k <= 10_000 && k > j:
luckyNumbersKth(j: j, k: k, even: true)
case let (k?, "lucky") where k < 0 && -k > j:
luckyNumbersRange(j: j, k: k, even: false)
case let (k?, "evenLucky") where k < 0 && -k > j:
luckyNumbersRange(j: j, k: k, even: true)
case _:
fatalError("Bad args")
}
case _:
fatalError()
}</lang>
{{out}}
<pre>$ ./main 1 20 lucky
List of 1 ... 20 lucky numbers: 1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79,
$ ./main 1 20 evenLucky
List of 1 ... 20 even lucky numbers: 2, 4, 6, 10, 12, 18, 20, 22, 26, 34, 36, 42, 44, 50, 52, 54, 58, 68, 70, 76,
$ ./main 6000 -6100 lucky
List of lucky numbers in the range 6000 ... 6100: 6009, 6019, 6031, 6049, 6055, 6061, 6079, 6093,
$ ./main 6000 -6100 evenLucky
List of even lucky numbers in the range 6000 ... 6100: 6018, 6020, 6022, 6026, 6036, 6038, 6050, 6058, 6074, 6090, 6092,
$ ./main 10000
The 10000th lucky number is 115591
$ ./main 10000 , evenLucky
The 10000th even lucky number is 111842</pre>
=={{header|Tcl}}==
| |||