Swift 5 iOS 12.x
A stupid question I am sure, but I having a moment.
I got values from -100 to 100. I am interested in the values less than -10 or greater than 10. I wrote this code.
func returnPod() -> String {
defer {
pods.removeAll()
}
var aPitch: Float? = 0
var aRoll: Float? = 0
var aYaw: Float? = 0
for peas in pods {
print("peas \(peas)")
if peas.pitch! < Float(-10) && peas.pitch! > Float(10) {
// capture an average everything below 10, above 10
aPitch = aPitch! + peas.pitch!
aRoll = aRoll! + peas.roll!
aYaw = aYaw! + peas.yaw!
} else {
// drop everything return zero this should happen if pitch is between -10 and 10.
return "#:0:0:0\n"
}
}
return("#:\(String(describing: aRoll!)):\(String(describing: aPitch!)):\(String(describing: aYaw!))")
}
But it doesn't work, it just returns everything... What am I doing wrong.
Related
For a project in Uni I decided to make a binary calculator app to learn a little bit more about coding.
I've come as far as completing a regular calculator app (but it only has two numbers: 1 ; 0) but I can't figure out how to make the calculator work like it should ( 1010 + 1101 = 10111 not 2111). All help is appreciated.
var numberEkraanil:Double = 0;
var eelmineNumber:Double = 0;
var tehesmatemaatikat = false
var operation = 0;
#IBOutlet weak var label: UILabel!
#IBAction func Numbers(_ sender: UIButton) {
if tehesmatemaatikat == true
{
label.text = String(sender.tag-1)
numberEkraanil = Double(label.text!)!
tehesmatemaatikat = false
}
else
{
label.text = label.text! + String(sender.tag-1)
numberEkraanil = Double(label.text!)!
}
}
#IBAction func nupud(_ sender: UIButton) {
if label.text != "" && sender.tag != 6 && sender.tag != 8
{
eelmineNumber = Double(label.text!)!
if sender.tag == 3 //Liitmine
{
label.text = "+";
}
else if sender.tag == 4 //Lahutamine
{
label.text = "-";
}
else if sender.tag == 5 // Korrutamine
{
label.text = "x";
}
else if sender.tag == 7 // Jagamine
{
label.text = "÷";
}
operation = sender.tag
tehesmatemaatikat = true;
}
else if sender.tag == 8
{
if operation == 3
{
label.text = String(eelmineNumber + numberEkraanil)
}
else if operation == 4
{
label.text = String(eelmineNumber - numberEkraanil)
}
else if operation == 5
{
label.text = String(eelmineNumber * numberEkraanil)
}
else if operation == 7
{
label.text = String(eelmineNumber / numberEkraanil)
}
}
else if sender.tag == 6
{
label.text = ""
eelmineNumber = 0;
numberEkraanil = 0;
operation = 0;
}
You can possibly convert binary numbers to decimal numbers. For example turn "1010" into int "10" and then reverse the process to get the binary again. In your example "1010 + 1101 = 10111" you can convert "1010" and into "10" and "13", make the ordinary calculation with those decimals and convert the result "23", which will give you "23".
But of course there are other ways. This website can help you with binary calculation. It's a math website: http://www.calculator.net/binary-calculator.html.
You will need to write a base 10 to base 2 and a base 2 to base 10 converter. Here is pseudo-code for both:
To convert a binary string to an integer, do the following:
Seed a result value to zero.
while your input string is not empty:
shift the result value 1 bit to the left
remove the left-most character from your input string, and if it's a 1, add 1 to your result value.
To convert an int to a binary string, do the same in reverse:
Copy your int to a scratch variable, scratch.
Set your output string to an empty string.
While scratch is not 0:
if scratch && 1 is 0, append a "0" to the left of your output string
if scratch && 1 is 1, append a "1" to the left of your output string
shift scratch 1 bit to the right
Once you have those building-blocks getting your calculator to work is pretty straightforward. When the user inputs a binary string, convert it to an integer working value. Do your calculations on integer values, and then convert the integer result to a binary string for display.
I'm attempting to get a user input number and find the sum of all the digits. I'm having issues with larger numbers, however, as they won't register under an Int64. Any idea as to what structures I could use to store the value? (I tried UInt64 and that didn't work very well with negatives, however, I'd prefer something larger than UInt64, anyways. I'm having a hard time implementing a UInt128 from Is there a number type with bigger capacity than u_long/UInt64 in Swift?)
import Foundation
func getInteger() -> Int64 {
var value:Int64 = 0
while true {
//we aren't doing anything with input, so we make it a constant
let input = readLine()
//ensure its not nil
if let unwrappedInput = input {
if let unwrappedInt = Int64(unwrappedInput) {
value = unwrappedInt
break
}
}
else { print("You entered a nil. Try again:") }
}
return value
}
print("Please enter an integer")
// Gets user input
var input = getInteger()
var arr = [Int] ()
var sum = 0
var negative = false
// If input is less than 0, makes it positive
if input < 0 {
input = (input * -1)
negative = true
}
if (input < 10) && (input >= 1) && (negative == true) {
var remain = (-1)*(input%10)
arr.append(Int(remain))
input = (input/10)
}
else {
var remain = (input%10)
arr.append(Int(remain))
input = (input/10)
}
}
// Adds numbers in array to find sum of digits
var i:Int = 0
var size:Int = (arr.count - 1)
while i<=size {
sum = sum + arr[i]
i = (i+1)
}
// Prints sum
print("\(sum)")
You can use a string to perform the operation you describe. Loop through each character and convert it to an integer and add to the sum. Be careful to handle errors.
I want to calculate a number in real-time with UISlider, this is my method:
#IBAction func HPsliderValueChanged(_ sender: CustomUISlider) {
calculator.HPPercentage = Double(HPSlider.value)
HPValue.text = String(Int(HPSlider.value * 100)) + " %"
resultLabel.text = String(calculator.calculate())
}
Both the HPValue label and resultLabel are expected to change value when user swipes on slider, however, now only HPValue label changes, the resultLabel doesn't work.
calculator is not nil, here's its code:
class TurretDiveCalculator {
var hero: Heroes = .taka
var build = [DefenseItems](repeatElement(DefenseItems(name: "Empty Item", index: 0, price: 0, image: #imageLiteral(resourceName: "EmptyItem")), count: 6))
var HPPercentage: Double = 0
func calculate() -> Int {
let baseHP = hero.HPLow + (hero.HPHigh - hero.HPLow) / 12 * Double(hero.level)
let baseDefense = hero.armorLow + (hero.armorHigh - hero.armorLow) / 12 * Double(hero.level) + hero.shieldLow + (hero.shieldHigh - hero.shieldLow) / 12 * Double(hero.level)
var buildHP = 0.0
var buildDefense = 0.0
for item in build {
buildDefense += item.armor
buildDefense += item.shield
buildHP += item.HP
}
let fullHP = baseHP + buildHP
var HP = fullHP
let defense = baseDefense + buildDefense
var numberOfShots = 0
while HP > 0 {
let perShotDamageRaw: Double = 330 + Double(numberOfShots) * 0.09 * fullHP
let mitigatedDamage: Double = 0.09 * perShotDamageRaw + 0.9 * perShotDamageRaw / (100 + defense) * 100
HP -= mitigatedDamage
numberOfShots += 1
}
return numberOfShots
}
}
How do I get resultLabel's value to change in real-time, too?
As can be seen in the chat, we managed to find the problem.
This answer is just some general debugging tips and tricks when a problem like this arises.
The original problem was:
now only HPValue label changes, the resultLabel doesn't work.
Lets find out where the problem is. Here's the code:
resultLabel.text = String(calculator.calculate())
Two things can go wrong here:
The resultLabel is not properly wired. To see if that is the case, try setting the value to a plain ol' string and see if you can see that. I you can, well, the textfield is wired properly.
The calculate() method returns an unexpected value. Try verifying what the method returns by adding a print statement just before the return
And as you can see in the chat, once we'd isolated where the problem occurred it was easier for #bright-future to track down the issue.
Hope this helps anybody when they are trying to debug a problem :)
This code picks a random color from a array of pre-set colors. How do I make it so the same color doesn't get picked more than once?
var colorArray = [(UIColor.redColor(), "red"), (UIColor.greenColor(), "green"), (UIColor.blueColor(), "blue"), (UIColor.yellowColor(), "yellow"), (UIColor.orangeColor(), "orange"), (UIColor.lightGrayColor(), "grey")]
var random = { () -> Int in
return Int(arc4random_uniform(UInt32(colorArray.count)))
} // makes random number, you can make it more reusable
var (sourceColor, sourceName) = (colorArray[random()])
Create an array of indexes. Remove one of the indexes from the array and then use that to fetch a color.
Something like this:
var colorArray = [
(UIColor.redColor(), "red"),
(UIColor.greenColor(), "green"),
(UIColor.blueColor(), "blue"),
(UIColor.yellowColor(), "yellow"),
(UIColor.orangeColor(), "orange"),
(UIColor.lightGrayColor(), "grey")]
var indexes = [Int]();
func randomItem() -> UIColor
{
if indexes.count == 0
{
print("Filling indexes array")
indexes = Array(0..< colorArray.count)
}
let randomIndex = Int(arc4random_uniform(UInt32(indexes.count)))
let anIndex = indexes.removeAtIndex(randomIndex)
return colorArray[anIndex].0;
}
The code above creates an array indexes. The function randomItem looks to see if indexes is empty. if it is, it populates it with index values ranging from 0 to colorArray.count - 1.
It then picks a random index in the indexes array, removes the value at that index in the indexes array, and uses it to fetch and return an object from your colorArray. (It doesn't remove objects from the colorArray. It uses indirection, and removes objects from the indexesArray, which initially contains an index value for each entry in your colorArray.
The one flaw in the above is that after you fetch the last item from indexArray, you populate it with a full set of indexes, and it's possible that the next color you get from the newly repopulated array will be the same as the last one you got.
It's possible to add extra logic to prevent this.
based on the fact, that arc4random_uniform generate not only random, but also uniformly distributed numbers
import Foundation // arc4random_uniform
class Random {
var r:UInt32
let max: UInt32
init(max: UInt32) {
self.max = max
r = arc4random_uniform(max)
}
var next: UInt32 {
var ret: UInt32
repeat {
ret = arc4random_uniform(max)
} while r == ret
r = ret
return r
}
}
// usage example
let r = Random(max: 5)
for i in 0..<10 {
print(r.r, r.next) // there will never be a pair of the same numbers in the
// generated stream
}
/*
2 4
4 0
0 3
3 0
0 3
3 4
4 1
1 3
3 4
4 3
*/
simple test for different k and stream length of one milion
class Random {
var r:UInt32
let max: UInt32
init(max: UInt32) {
self.max = max
r = arc4random_uniform(max)
}
var next: (UInt32, Int) {
var i = 0
var ret: UInt32
repeat {
ret = arc4random_uniform(max)
i += 1
} while r == ret
r = ret
return (r,i)
}
}
for k in 3..<16 {
let r = Random(max: UInt32(k))
var repetition = 0
var sum = 0
for i in 0..<1000000 {
let j = r.next
repetition = max(repetition, j.1)
sum += j.1
}
print("maximum of while repetition for k:", k, "is", repetition, "with average of", Double(sum) / Double(1000000) )
}
prints
maximum of while repetition for k: 3 is 15 with average of 1.499832
maximum of while repetition for k: 4 is 12 with average of 1.334008
maximum of while repetition for k: 5 is 9 with average of 1.250487
maximum of while repetition for k: 6 is 8 with average of 1.199631
maximum of while repetition for k: 7 is 8 with average of 1.167501
maximum of while repetition for k: 8 is 7 with average of 1.142799
maximum of while repetition for k: 9 is 8 with average of 1.124096
maximum of while repetition for k: 10 is 6 with average of 1.111178
maximum of while repetition for k: 11 is 7 with average of 1.099815
maximum of while repetition for k: 12 is 7 with average of 1.091041
maximum of while repetition for k: 13 is 6 with average of 1.083582
maximum of while repetition for k: 14 is 6 with average of 1.076595
maximum of while repetition for k: 15 is 6 with average of 1.071965
finaly, here is more Swifty and functional approach based on the same idea
import Foundation
func random(max: Int)->()->Int {
let max = UInt32(max)
var last = arc4random_uniform(max)
return {
var r = arc4random_uniform(max)
while r == last {
r = arc4random_uniform(max)
}
last = r
return Int(last)
}
}
let r0 = random(8)
let r1 = random(4)
for i in 0..<20 {
print(r0(), terminator: " ")
}
print("")
for i in 0..<20 {
print(r1(), terminator: " ")
}
/*
4 5 4 3 4 0 5 6 7 3 6 7 5 4 7 4 7 2 1 6
0 3 0 1 0 2 3 1 2 0 1 0 1 0 1 3 0 3 0 2
*/
Fill an array with the colors and shuffle it with a Fisher-Yates shuffle. Then use the element at an end, remove it, and insert it at a random position at least n positions from the end.
For example, say my array has 10 elements. I shuffle it and take the last. I want at least 2 values to be chosen before I see it again so I generate a random position in the range 0...8 and insert it there.
var colorArray = [
(UIColor.redColor() , "red" ),
(UIColor.greenColor() , "green" ),
(UIColor.blueColor() , "blue" ),
(UIColor.yellowColor() , "yellow"),
(UIColor.orangeColor() , "orange"),
(UIColor.lightGrayColor(), "grey" )].shuffle() // shuffle() is from my link above
let spacing = 2 // Pick at least 2 colors before we see it again
if let randomColor = colorArray.popLast() {
colorArray.insert(randomColor,
atIndex: Int(arc4random_uniform(UInt32(colorArray.count - spacing))))
}
One case, described here: https://github.com/dimpiax/GenericSequenceType
Another is functional:
func getRandomItem<T>(arr: [T]) -> (unique: Bool) -> T {
var indexes: [Int]!
return { value in
let uniqIndex: Int
if value {
if indexes?.isEmpty != false {
indexes = [Int](0.stride(to: arr.count, by: 1))
}
uniqIndex = indexes.removeAtIndex(Int(arc4random_uniform(UInt32(indexes.count))))
}
else {
uniqIndex = Int(arc4random_uniform(UInt32(arr.count)))
}
return arr[uniqIndex]
}
}
let generate = getRandomItem(colorArray)
generate(unique: true).0 // greenColor
generate(unique: true).0 // redColor
generate(unique: true).0 // lightGrayColor
Try it it's work for me and 100% tested
let arrString = ["1","2","3","4","5","6"]
var selectedIndix = -1
#IBAction func btnClick(_ sender: Any) {
let randomElementIndex = randomElementString()
}
Call this function when button clicked
func randomElementString() -> Int{
let randomm = Int(arc4random_uniform(UInt32(arrString.count)))
if selectedIndix == randomm{
return randomElementString()
}else{
selectedIndix = randomm
return randomm
}
}
OUTPUT:-
5121242316513126
How about running a while loop with the condition:
while(self.source.backgroundColor == sourceColor) {
// get a new random sourceColor
}
This will keep looping until a new random color has been selected.
edit
Additional Note: The point was the while loop. There are ways to safeguard from an infinite loop, it's up to the coder to find the right solution. I don't think SO is a place to write other's code but instead to offer suggestions .. mine is a start.
But since my answer was given such a negative rating, i'll push instead of nudge in the right direction.
The other answers are unnecessarily bloated. And? The one I offered above offers a less than desirable time complexity. So, here's my new answer (in meta code):
// array of all background colors
var arrayOfColors = [..]
// get a random index
var randomIndex = arc4random(size of arrayOfColors)
// select new background color
var newBGColor = arrayOfColors[randomIndex]
// old background color
var oldBGColor = self.source.backgroundColor
// remove new color from array (so that it's excluded from choices next time)
arrayOfColors.removeAtIndex(randomIndex)
// set the new color to the background
self.source.backgroundColor = newBGColor
// add current color back into the pool of potential colors
arrayOfColors.addObject(oldBGColor)
I'd like to generate multiple different random numbers in Swift. Here is the procedure.
Set up an empty array
Generate a random number
Check if the array is empty
a. If the array is empty, insert the random number
b. If the array is not empty, compare the random number to the numbers in array
i. If the numbers are the same, repeat 2
ii. if the numbers are not the same, insert the random number and repeat 2
import UIKit
//the random number generator
func randomInt(min: Int, max:Int) -> Int {
return min + Int(arc4random_uniform(UInt32(max - min + 1)))
}
var temp = [Int]()
for var i = 0; i<4; i++ {
var randomNumber = randomInt(1, 5)
if temp.isEmpty{
temp.append(randomNumber)
} else {
//I don't know how to continue...
}
}
If you use your method the problem is, that you will create a new random-number each time. So you possibly could have the same random-number 4 times and so your array will only have one element.
So, if you just want to have an array of numbers from within a specific range of numbers (for example 0-100), in a random order, you can first fill an array with numbers in 'normal' order. For example with for loop etc:
var min = 1
var max = 5
for var i = min; i<= max; i++ {
temp.append(i)
}
After that, you can use a shuffle method to shuffle all elements of the array with the shuffle method from this answer:
func shuffle<C: MutableCollectionType where C.Index == Int>(var list: C) -> C {
let count = countElements(list)
for i in 0..<(count - 1) {
let j = Int(arc4random_uniform(UInt32(count - i))) + i
swap(&list[i], &list[j])
}
return list
}
Ater that you can do something like that:
shuffle(temp) // e.g., [3, 1, 2, 4, 5]
The construct you’re looking for with your approach might be something like:
var temp: [Int] = []
while temp.count < 4 {
var randomNumber: Int
do {
randomNumber = randomInt(1, 5)
} while contains(temp, randomNumber)
temp.append(randomNumber)
}
This will be fine for tiny ranges like yours, but for larger ranges it will be very slow, because for the last few numbers you are waiting for the random number to hit precisely the remaining handful of possibilities. I just tried generating from a range of 200 in a playground and it took 9 seconds.
If you want a random selection of numbers with guaranteed coverage over a range, you could generate it like by taking that range and shuffling it, like this:
func shuffle<S: SequenceType>(source: S) -> [S.Generator.Element] {
var rangen = GeneratorOf { arc4random() }
let a = Array(Zip2(rangen, source))
return a.sorted { $0.0 < $1.0 }.map { $0.1 }
}
let min = 1, max = 5
shuffle(min...max)
If you want a selection of n non-repeating random numbers from a range 0..<m, there’s a particularly pretty algorithm to do this that generates an ascending sequence of random numbers from that range:
func randomGeneratorOf(#n: Int, #from: Int) -> GeneratorOf<Int> {
var select = UInt32(n)
var remaining = UInt32(from)
var i = 0
return GeneratorOf {
while i < from {
if arc4random_uniform(remaining) < select {
--select
--remaining
return i++
}
else {
--remaining
++i
}
}
return nil
}
}
Which you could use like so:
let engines = [
"Duck","Emily","Gordon","Henry", "Mavis",
"Belle","James","Edward","Thomas","Toby"
]
let picks = Array(randomGeneratorOf(n: 3, from: engines.count))
for engine in PermutationGenerator(elements: engines, indices: picks) {
println(engine)
}
Below is my suggestion.
I like this way since it is short and simple :)
let totalCount: Int = 150 //Any number you asssign
var randomNumArray: [Int] = []
var i = 0
while randomNumArray.count < totalCount {
i++
let rand = Int(arc4random_uniform(UInt32(totalCount)))
for(var ii = 0; ii < totalCount; ii++){
if randomNumArray.contains(rand){
print("do nothing")
} else {
randomNumArray.append(rand)
}
}
}