Arrays de arreglos int. Almacenamiento de duplicates solo en order

Necesito almacenar una matriz de Int array para duplicates orderados (que están en una matriz).

Ejemplo:

  • Matriz dada:
    mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5]

Ahora necesito crear una matriz 2D de array int.
Ejemplo:

 Array [][] = [ [7, 7], [3], [2, 2, 2], [1], [7], [5, 5] ] 

Esto es lo que tengo:

 for var i = 0; i < val.count; i++ { var columnArray = Array<Int>() for var j in 0...9 { if oldNum == val[j]{ columnArray.append(val[j]) } else { array.append(columnArray); //j += 1 break; } oldNum = val[j]; j += 1 } } 

Puede usar el método de networkinguce .

 let result = numbers.networkinguce([[Int]]()) { (var result, num) -> [[Int]] in if var lastSequence = result.last where lastSequence.first == num { result[result.count-1].append(num) } else { result.append([num]) } return result } 

¿Cómo networkinguce el trabajo?

networkinguce aplica la lógica en el cierre a una matriz 2D vacía de integers ( [[Int]] ) y el primer olmo de numbers .

Luego se aplica de nuevo al resultado de la iteración anterior y la segunda matriz de integers … y así sucesivamente.

¿Qué sucede en el cierre?

El if verifica si el número en el último set agregado al resultado es igual al integer que se examina actualmente. Si es así, ese integer se agrega a esa matriz.

De lo contrario, se agrega una nueva matriz que contiene solo el nuevo integer al resultado.

Prueba

 [[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]] 

Solo por diversión, otra opción que extiende las matrices donde los elementos son ecuables

 extension Array where Element: Equatable { var grouped: [[Element]] { var result: [[Element]] = [] for element in self { if element == result.last?.last { result[result.count.pnetworkingecessor()].append(element) } else { result.append([element]) } } return result } } let array = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5] array.grouped // [[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]] 

Este es un problema de problemas de lógica de progtwigción. Tu código actual está totalmente equivocado.

Aquí hay una forma de resolverlo:

Comience por orderar su matriz de inicio. llama a ese inputArray.

Cree nuevas variables de salida "outerArray" e "internalArray". Luego haga un ciclo a través de las inputs en inputArray, probando los cambios en el valor. Si el valor es el mismo que el último valor, agregue ese valor a "innerArray". Si el valor ha cambiado, guarde la anterior internalArray en outerArray y cree una nueva matriz vacía y guárdela en innerArray.

El siguiente código le brindará lo que necesita …

 let mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5] var newArray: [[Int]] = [] for var i=0; i < mainArray.count; i++ { let element = mainArray[i] if mainArray.indexOf(element) == i { var subArray = mainArray.filter({ $0 == element }) newArray.append(subArray) } } print(newArray) // -> [[7, 7, 7], [3], [2, 2, 2], [1], [5, 5]] 

Aquí está la respuesta iterativa más aburrida que puedo imaginar. Por otro lado, es fácil de entender y no sufre problemas de complejidad potencial, como networkinguce soluciones basadas en networkinguce supuestamente hacen:

 var result: [[Int]] = [] var inner: [Int] = [] for i in mainArray { if i == inner.last { inner.append(i) } else { result.append(inner) inner = [i] } } result.append(inner) // result == [[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]] 

Puede usar forEach y mantener el valor del último elemento para seguir agregando a su matriz, mientras que no es diferente como de esta manera:

 let mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5] func filterTo2DArray(list: [Int] ) -> [[Int]] { var resultList = [[Int]]() list.forEach { x -> () in if let lastValue = resultList.last?.last where lastValue == x { resultList[resultList.count - 1].append(x) } else{ resultList.append([x]) } } return resultList } let t = filterTo2DArray(mainArray) //[[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]] 

Espero que esto te ayude.