swift - telefono - méxico prefijo telefónico

¿Cuál es el código más corto para obtener las coordenadas circundantes?

Question

No me gusta la siguiente implementación de las posiciones surroundingPositions para obtener las coordenadas xey en torno a una posición específica, porque en mi opinión es demasiado larga para la intención simple y tiene una estructura piramidal de fatalidad.

struct Position: CustomStringConvertible {

    let x, y: Int

    var surroundingPositions: [Position] {
        var surroundingPositions: [Position] = []
        for x in (self.x - 1)...(self.x + 1) {
            for y in (self.y - 1)...(self.y + 1) {
                if !(x == self.x && y == self.y) {
                    surroundingPositions.append(Position(x: x, y: y))
                }
            }
        }
        return surroundingPositions
    }

    var description: String {
        return "(/(x),/(y))"
    }

}

Uso:

let testPosition = Position(x: 1, y: 1)
print(testPosition.surroundingPositions)
// Output: [(0,0), (0,1), (0,2), (1,0), (1,2), (2,0), (2,1), (2,2)]

¿Cuál es la forma más corta de implementar esto con el mismo resultado (correcto)? Estoy pensando en funciones como map , filter , reduce , etc., pero no puedo encontrar la combinación correcta hasta el momento ...

Answer 1

Bueno, siempre puedes codificarlo. Aquí, codifiqué los deltas y creo una nueva Position para cada delta:

var surroundingPositionsHardcoded: [Position] {
    let deltas: [(Int, Int)] = [(-1, -1), (-1, 0), (-1, +1), (0, -1), (0, +1), (+1, -1), (+1, 0), (+1, +1)]
    return deltas.map { Position(x: x+$0.0, y: y+$0.1) }
}

O bien, puede calcular los deltas usando el map . Esto tiene el beneficio adicional de que puede aumentar la distancia circundante.

var surroundingPositionsComputed: [Position] {
    let deltas = (-1...1).map { dx in (-1...1).map { dy in (dx, dy) } }
        .joined()
        .filter { $0.0 != 0 || $0.1 != 0 }
    return deltas.map { Position(x: x+$0.0, y: y+$0.1) }
}

Answer 2

Como solo busca las posiciones vecinas y aparentemente no tiene ninguna restricción sobre x o y , puede guardar una matriz de (x, y) traducciones que cada una asigna una Position dada a una de sus 8 vecinas diferentes.

struct Position: CustomStringConvertible {
    let x, y: Int

    // order of resulting neighbouring positions, given a position P
    // (1)  (2)  (3)
    // (4)  (P)  (5)
    // (6)  (7)  (8)
    private static let surroundingPositionsTranslations: [(x: Int, y: Int)] = [
        (-1, -1), (0, -1), (1, -1),
        (-1,  0),          (1,  0),
        (-1, -1), (0, -1), (1, -1)]

    var surroundingPositions: [Position] {
        return Position.surroundingPositionsTranslations
            .map { Position(x: x + $0.x, y: y + $0.y) }
    }

    var description: String {
        return "(/(x),/(y))"
    }
}

// Note that I''ve changed the order w.r.t. OP:s original code
// (modify the transfotmation above to modify the order)
let testPosition = Position(x: 1, y: 1)
print(testPosition.surroundingPositions)
// Output: [(0,0), (1,0), (2,0), (0,1), (2,1), (0,0), (1,0), (2,0)]