I have 2d Array which is declared like that init_ : Array[Array[Int]]
In this 2d array, i can only have "1","2" or "3".
I'm looking to print something different when i iterate on these elements, something like that :
override def toString = {
val c = init.map(_.clone);
c match{
case 1 => ret = "one"
case 2 => ret = "two"
case 3 => ret = "three"
}
ret
}
I'm beginning in Scala so please, be indulgent
Here is my 2d arrays :
val tab = $(
$(1, 2, 3,
$(1, 2, 3,
$(1, 2, 3)
I've imported things like that : import scala.{Array => $};
Thanks
Example to iterate a two 2D array and do pattern matching
import scala.{Array => $}
val tab = $(
$(1, 2, 1),
$(1, 2, 2),
$(3, 2, 3),
$(4, 2, 4))
val rowsSize = tab.length
val columnsSize = tab(0).length
for (i <- 0 to rowsSize - 1; j <- 0 to columnsSize - 1) {
tab(i)(j) match {
case 1 => println("one")
case 2 => println("two")
case 3 => println("three")
case x => println(x)
}
}
I want to find all the unique pairs whose sum will be equal to a given sum. I implement a solution but it returns only the first pair that it finds.
func checkPairs(in numbers: [Int], forSum target: Int) -> String {
for (i, x) in numbers.enumerated() {
for y in numbers[i+1 ..< numbers.count] {
if x + y == target {
return ("There is a pair that sums \(target): \(x)+\(y)=\(target)")
}
}
}
return "no pair"
}
print (checkPairs(in: [1, 2, 4, 4, 7, 5, 3], forSum: 8))
Output:
There is a pair that sums 8: 1+7=8
You exit the function early by calling return when the first pair is found. Instead, you should return an array of tuples containing the pairs, iterate over all pairs and add the ones satisfying the requirements to the return array.
func checkPairs(in numbers: [Int], forSum target: Int) -> [(Int,Int)] {
var pairs = [(Int,Int)]()
for (i, x) in numbers.enumerated() {
for y in numbers[i+1 ..< numbers.count] {
if x + y == target {
pairs.append((x,y))
}
}
}
return pairs
}
print(checkPairs(in: [1, 2, 4, 4, 7, 5, 3], forSum: 8))
Output:
[(1, 7), (4, 4), (5, 3)]
If you're looking for unique pairs, you can define a custom type holding the pair of numbers and return a Set instead of an Array (the custom type is needed, since you cannot make a Tuple conform to Hashable, which is needed to be able to add elements to a Set).
struct Pair: Hashable {
let smaller:Int
let bigger:Int
init(_ a:Int, _ b:Int) {
if a < b {
smaller = a
bigger = b
} else {
smaller = b
bigger = a
}
}
}
extension Pair: CustomStringConvertible {
var description:String {
return "\((smaller,bigger))"
}
}
func checkPairs(in numbers: [Int], forSum target: Int) -> Set<Pair> {
var pairs = Set<Pair>()
for (i, x) in numbers.enumerated() {
for y in numbers[i+1 ..< numbers.count] {
if x + y == target {
pairs.insert(Pair(x,y))
}
}
}
return pairs
}
print(checkPairs(in: [1, 2, 4, 4, 7, 5, 3], forSum: 8))
print(checkPairs(in: [1, 2, 4, 4, 7, 5, 3, 4, 1], forSum: 8))
Output:
[(4, 4), (3, 5), (1, 7)]
[(4, 4), (3, 5), (1, 7)]
here is one of options you can do
let array = [1, 2, 4, 4, 7, 5, 3]
let target = 8
func checkPairs(in numbers: [Int], forSum target: Int) -> String {
var pairs = ""
for (i, x) in numbers.enumerated() {
for y in numbers[i+1 ..< numbers.count] {
if x + y == target {
pairs += ("There is a pair that sums \(target): \(x)+\(y)=\(target)\n")
}
}
}
return pairs
}
print(checkPairs(in: array, forSum: target))
output will be There is a pair that sums 8: 1+7=8 There is a pair
that sums 8: 4+4=8 There is a pair that sums 8: 5+3=8
Given array of n elements, i.e.
var array = [1, 2, 3, 4, 5]
I can write an extension to the Array so I can modify array to achieve this output: [2, 3, 4, 5, 1]:
mutating func shiftRight() {
append(removeFirst())
}
Is there a way to implement such a function that would shift array by any index, positive or negative. I can implement this function in imperative style with if-else clauses, but what I am looking for is functional implementation.
The algorithm is simple:
Split array into two by the index provided
append first array to the end of the second
Is there any way to implement it in functional style?
The code I've finished with:
extension Array {
mutating func shift(var amount: Int) {
guard -count...count ~= amount else { return }
if amount < 0 { amount += count }
self = Array(self[amount ..< count] + self[0 ..< amount])
}
}
You can use ranged subscripting and concatenate the results. This will give you what you're looking for, with names similar to the standard library:
extension Array {
func shiftRight(var amount: Int = 1) -> [Element] {
guard count > 0 else { return self }
assert(-count...count ~= amount, "Shift amount out of bounds")
if amount < 0 { amount += count } // this needs to be >= 0
return Array(self[amount ..< count] + self[0 ..< amount])
}
mutating func shiftRightInPlace(amount: Int = 1) {
self = shiftRight(amount)
}
}
Array(1...10).shiftRight()
// [2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
Array(1...10).shiftRight(7)
// [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]
Instead of subscripting, you could also return Array(suffix(count - amount) + prefix(amount)) from shiftRight().
With Swift 5, you can create shift(withDistance:) and shiftInPlace(withDistance:) methods in an Array extension with the following implementation in order to solve your problem:
extension Array {
/**
Returns a new array with the first elements up to specified distance being shifted to the end of the collection. If the distance is negative, returns a new array with the last elements up to the specified absolute distance being shifted to the beginning of the collection.
If the absolute distance exceeds the number of elements in the array, the elements are not shifted.
*/
func shift(withDistance distance: Int = 1) -> Array<Element> {
let offsetIndex = distance >= 0 ?
self.index(startIndex, offsetBy: distance, limitedBy: endIndex) :
self.index(endIndex, offsetBy: distance, limitedBy: startIndex)
guard let index = offsetIndex else { return self }
return Array(self[index ..< endIndex] + self[startIndex ..< index])
}
/**
Shifts the first elements up to specified distance to the end of the array. If the distance is negative, shifts the last elements up to the specified absolute distance to the beginning of the array.
If the absolute distance exceeds the number of elements in the array, the elements are not shifted.
*/
mutating func shiftInPlace(withDistance distance: Int = 1) {
self = shift(withDistance: distance)
}
}
Usage:
let array = Array(1...10)
let newArray = array.shift(withDistance: 3)
print(newArray) // prints: [4, 5, 6, 7, 8, 9, 10, 1, 2, 3]
var array = Array(1...10)
array.shiftInPlace(withDistance: -2)
print(array) // prints: [9, 10, 1, 2, 3, 4, 5, 6, 7, 8]
let array = Array(1...10)
let newArray = array.shift(withDistance: 30)
print(newArray) // prints: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let array = Array(1...10)
let newArray = array.shift(withDistance: 0)
print(newArray) // prints: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
var array = Array(1...10)
array.shiftInPlace()
print(array) // prints: [2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
var array = [Int]()
array.shiftInPlace(withDistance: -2)
print(array) // prints: []
I took a stab at writing some extensions for this. It has some nice features:
Shifting by an amount greater than count causes a wrap-around.
Shifting by negative amounts flips the direction
Exposes functions as the bit-shift binary operators (<<, <<=, >>, >>=)
extension Array {
public func shiftedLeft(by rawOffset: Int = 1) -> Array {
let clampedAmount = rawOffset % count
let offset = clampedAmount < 0 ? count + clampedAmount : clampedAmount
return Array(self[offset ..< count] + self[0 ..< offset])
}
public func shiftedRight(by rawOffset: Int = 1) -> Array {
return self.shiftedLeft(by: -rawOffset)
}
public mutating func shiftLeftInPlace(by rawOffset: Int = 1) {
if rawOffset == 0 { return /* no-op */ }
func shiftedIndex(for index: Int) -> Int {
let candidateIndex = (index + rawOffset) % self.count
if candidateIndex < 0 {
return candidateIndex + self.count
}
return candidateIndex
}
// Create a sequence of indexs of items that need to be swapped.
//
// For example, to shift ["A", "B", "C", "D", "E"] left by 1:
// Swapping 2 with 0: ["C", "B", "A", "D", "E"]
// Swapping 4 with 2: ["C", "B", "E", "D", "A"]
// Swapping 1 with 4: ["C", "A", "E", "D", "B"]
// Swapping 3 with 1: ["C", "D", "E", "A", "B"] <- Final Result
//
// The sequence here is [0, 2, 4, 1, 3].
// It's turned into [(2, 0), (4, 2), (1, 4), (3, 1)] by the zip/dropFirst trick below.
let indexes = sequence(first: 0, next: { index in
let nextIndex = shiftedIndex(for: index)
if nextIndex == 0 { return nil } // We've come full-circle
return nextIndex
})
print(self)
for (source, dest) in zip(indexes.dropFirst(), indexes) {
self.swapAt(source, dest)
print("Swapping \(source) with \(dest): \(self)")
}
print(Array<(Int, Int)>(zip(indexes.dropFirst(), indexes)))
}
public mutating func shiftRightInPlace(by rawOffset: Int = 1) {
self.shiftLeftInPlace(by: rawOffset)
}
}
public func << <T>(array: [T], offset: Int) -> [T] { return array.shiftedLeft(by: offset) }
public func >> <T>(array: [T], offset: Int) -> [T] { return array.shiftedRight(by: offset) }
public func <<= <T>(array: inout [T], offset: Int) { return array.shiftLeftInPlace(by: offset) }
public func >>= <T>(array: inout [T], offset: Int) { return array.shiftRightInPlace(by: offset) }
You can see it in action here.
Here is a more general solution, which implements this functionality lazily for any type that meets the requirements:
extension RandomAccessCollection where
Self: RangeReplaceableCollection,
Self.Index == Int,
Self.IndexDistance == Int {
func shiftedLeft(by rawOffset: Int = 1) -> RangeReplaceableSlice<Self> {
let clampedAmount = rawOffset % count
let offset = clampedAmount < 0 ? count + clampedAmount : clampedAmount
return self[offset ..< count] + self[0 ..< offset]
}
func shiftedRight(by rawOffset: Int = 1) -> RangeReplaceableSlice<Self> {
return self.shiftedLeft(by: -rawOffset)
}
mutating func shiftLeft(by rawOffset: Int = 1) {
self = Self.init(self.shiftedLeft(by: rawOffset))
}
mutating func shiftRight(by rawOffset: Int = 1) {
self = Self.init(self.shiftedRight(by: rawOffset))
}
//Swift 3
static func << (c: Self, offset: Int) -> RangeReplaceableSlice<Self> { return c.shiftedLeft(by: offset) }
static func >> (c: Self, offset: Int) -> RangeReplaceableSlice<Self> { return c.shiftedRight(by: offset) }
static func <<= (c: inout Self, offset: Int) { return c.shiftLeft(by: offset) }
static func >>= (c: inout Self, offset: Int) { return c.shiftRight(by: offset) }
}
Here's a functional implementation for "in place" rotation that doesn't require extra memory nor a temporary variable and performs no more than one swap per element.
extension Array
{
mutating func rotateLeft(by rotations:Int)
{
let _ = // silence warnings
(1..<Swift.max(1,count*((rotations+1)%(count+1)%1))) // will do zero or count - 1 swaps
.reduce((i:0,r:count+rotations%count)) // i: swap index r:effective offset
{ s,_ in let j = (s.i+s.r)%count // j: index of value for position i
swap(&self[j],&self[s.i]) // swap to place value at rotated index
return (j,s.r) // continue with next index to place
}
}
}
It optimally supports zero, positive and negative rotations as well as rotations of larger magnitude than the array size and rotation of an empty array (i.e. it cannot fail).
Uses negative values to rotate in the other direction (to the right).
Rotating a 3 element array by 10 is like rotating it by 1, the fist nine rotations will bring it back to its initial state (but we don't want to move elements more than once).
Rotating a 5 element array to the right by 3, i.e. rotateLeft(by:-3) is equivalent to rotateLeft(by:2). The function's "effective offset" takes that into account.
An easy solution,
public func solution(_ A : [Int], _ K : Int) -> [Int] {
if A.count > 0 {
let roundedK: Int = K % A.count
let rotatedArray = Array(A.dropFirst(A.count - roundedK) + A.dropLast(roundedK))
return rotatedArray
}
return []
}
I know I late to the party, but this answer based on the question works great?
extension Array {
mutating func shiftRight(p: Int) {
for _ in 0..<p {
append(removeFirst())
}
}
}
start [5, 0, 4, 11, 0]
shift [5, 0, 4, 11, 0] shift 0
shift [0, 4, 11, 0, 5] shift 1
shift [4, 11, 0, 5, 0] shift 2
shift [11, 0, 5, 0, 4] shift 3
Even better, if you ask it to shift more elements than there are in the array, it simply keeps circling.
Following the Nate Cook answers , I need also to shift an array returning reverse order, so I made:
//MARK: - Array extension
Array {
func shiftRight( amount: Int = 1) -> [Element] {
var amountMutable = amount
assert(-count...count ~= amountMutable, "Shift amount out of bounds")
if amountMutable < 0 { amountMutable += count } // this needs to be >= 0
return Array(self[amountMutable ..< count] + self[0 ..< amountMutable])
}
func reverseShift( amount: Int = 1) -> [Element] {
var amountMutable = amount
amountMutable = count-amountMutable-1
let a: [Element] = self.reverse()
return a.shiftRight(amountMutable)
}
mutating func shiftRightInPlace(amount: Int = 1) {
self = shiftRight(amount)
}
mutating func reverseShiftInPlace(amount: Int = 1) {
self = reverseShift(amount)
}
}
We have for example:
Array(1...10).shiftRight()
// [2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
Array(1...10).shiftRight(7)
// [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]
Array(1...10).reverseShift()
// [2, 1, 10, 9, 8, 7, 6, 5, 4, 3]
Array(1...10).reverseShift(7)
// [8, 7, 6, 5, 4, 3, 2, 1, 10, 9]
In objective C you can simply get left shifted array like this:
- (NSMutableArray *)shiftedArrayWithOffset:(NSInteger)offset
{
NSMutableArray *bufferArray = [[NSMutableArray alloc] initWithArray:originalArray];
for (int i = 0; i < offset; i++)
{
id object = [bufferArray firstObject];
[bufferArray removeObjectAtIndex:0];
[bufferArray addObject:object];
}
return bufferArray;
}
The fastest way is (but takes double memory!):
input:
var arr = [1,2,3,4,5]
let k = 1 (num steps to rotate)
let n = arr.count ( a little but faster )
rotation LEFT:
var temp = arr
for i in 0..<n {
arr[(n-i+k)%n] = temp[i]
}
result: [2, 1, 4, 3, 5]
rotation RIGHT:
var temp = arr
for i in 0..<n {
arr[(i+k)%n] = temp[i]
}
result: [4, 1, 2, 3, 5]
I've this method:
def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean = {
val sorted = for (it <- as.sliding(2))
yield {
if (it.length == 2) ordered.apply(it(0), it(1))
else true
}
sorted.find(!_).isEmpty
}
What I'd like to do is use foldLeftand apply the binary operator. However, foldLeft requires an initial value and I don't know what initial value I can provide without knowing the real type of A.
I think what you're doing can be simplified.
def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean = {
if (as.size < 2)
true
else
as.sliding(2).find(x => !ordered(x(0),x(1))).isEmpty
}
isSorted: [A](as: Array[A], ordered: (A, A) => Boolean)Boolean
scala> isSorted( Array(2), {(a:Int,b:Int) => a < b} )
res42: Boolean = true
scala> isSorted( Array(2,4), {(a:Int,b:Int) => a < b} )
res43: Boolean = true
scala> isSorted( Array(2,4,5), {(a:Int,b:Int) => a < b} )
res44: Boolean = true
scala> isSorted( Array(2,14,5), {(a:Int,b:Int) => a < b} )
res45: Boolean = false
Or, perhaps a little more concisely (but not necessarily easier to understand):
def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean = {
if (as.size < 2)
true
else
!as.sliding(2).exists(x => ordered(x(1),x(0)))
}
UPDATE
OK, I think I've got the concise prize nailed.
def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean =
as.isEmpty || as.init.corresponds(as.tail)(ordered)
For initial value for foldLeft you could use head of your input array. However foldLeft is not a good choise to check if array is sorted, since you should terminate method when first unsorted element found but foldLeft will traverse whole array
Edit:
I would use the combination of zip with tail and exists:
isSorted(...) =
if (as.isEmpty) true
else !as.zip(as.tail).exists { case (a,b) => !ordered(a,b)}
Adding to the other answers, you probably do not want to iterate through the entire array, but rather terminate the moment you find an unordered pair. So, how about this?
def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean = {
var sorted = true
val ita = as.sliding(2)
while (sorted && ita.hasNext) {
val it = ita.next
sorted = if (it.size > 1) ordered(it(0), it(1)) else true
}
sorted
}
val a = Array(1, 3, 2, 4, 5)
val b = Array(1, 2, 3, 4, 5)
isSorted[Int](a, _ < _) // returns false
isSorted[Int](b, _ < _) // returns true
I tried to copy it to array, but I can't accept two (Sets) parameters
def subset(a:Set[Int],b:Set[Int]):Boolean={
var x = new Array[Int](a.size)
var y = new Array[Int](b.size)
}
or can you explain how to recieve two arrays as parameter?
def main(args: Array[String]): Unit = {
val a = Set(2,3,4,5,6)
val b = Set(2,3,4,5)
var x = new Array[Int](a.size)
var y = new Array[Int](b.size)
i wish to put x and y to function subset and do same but not by Set
You can transform Set to Array or Array to Set:
scala> val array = Array(1, 3, 5)
array: Array[Int] = Array(1, 3, 5)
scala> array.toSet
res0: scala.collection.immutable.Set[Int] = Set(1, 3, 5)
scala> val set = Set(7, 3, 8)
set: scala.collection.immutable.Set[Int] = Set(7, 3, 8)
scala> set.toArray
res1: Array[Int] = Array(7, 3, 8)
If you want a program to take a collection of Ints as a command-line argument, you'll have to parse a string:
object Test extends App {
val x: Array[Int] = args(0).split(",").map{ _.toInt }
val y: Array[Int] = args(1).split(",").map{ _.toInt }
println("x: " + x.mkString("Array(", ", ", ")"))
println("y: " + y.mkString("Array(", ", ", ")"))
}
Usage:
>scala Test "1,2,3" "10,0,-5"
x: Array(1, 2, 3)
y: Array(10, 0, -5)