string - texto - Cómo reemplazar el enésimo carácter de una cadena por otra

reemplazar una cadena por otra en c

Question

¿Cómo podría reemplazar el enésimo carácter de una String con otra?

func replace(myString:String, index:Int, newCharac:Character) -> String {
    // Write correct code here
    return modifiedString
}

Por ejemplo, replace("House", 2, "r") debe ser igual a "Horse" .

Answer 1

Aquí hay una respuesta eficiente:

import Foundation
func replace(myString:String, index:Int, newCharac:Character) -> String {
return myString.substringToIndex(index-1) + newCharac + myString.substringFromIndex(index)
}

Answer 2

Creo que lo que @Greg estaba tratando de lograr con su extensión es esto:

mutating func replace(characterAt index: Int, with newChar: Character) {
    var chars = Array(characters)
    if index >= 0 && index < self.characters.count {
        chars[index] = newChar
        let modifiedString = String(chars)
        self = modifiedString
    } else {
        print("can''t replace character, its'' index out of range!")
    }
}

uso:

let source = "House"
source.replace(characterAt: 2, with: "r") //gives you "Horse"

Answer 3

Después de mirar los Swift Docs, logré hacer esta función:

//Main function
func replace(myString:String, index:Int, newCharac:Character) -> String {
    //Looping through the characters in myString
    var i = 0
    for character in myString {
        //Checking to see if the index of the character is the one we''re looking for
        if i == index {
            //Found it! Now instead of adding it, add newCharac!
            modifiedString += newCharac
        } else {
            modifiedString += character
        }
        i = i + 1
    }
    // Write correct code here
    return modifiedString
}

Tenga en cuenta que esto no se ha probado, pero debería darle la idea correcta.

Answer 4

En Swift 4 es mucho más fácil.

let newString = oldString.prefix(n) + char + oldString.dropFirst(n + 1)

Esto es un ejemplo:

let oldString = "Hello, playground"
let newString = oldString.prefix(4) + "0" + oldString.dropFirst(5)

donde el resultado es

Hell0, playground

El tipo de newString es Substring. Tanto prefix como dropFirst devuelven la Substring . La subcadena es un segmento de una cadena; en otras palabras, las subcadenas son rápidas porque no necesita asignar memoria para el contenido de la cadena, pero se usa el mismo espacio de almacenamiento que la cadena original.

Answer 5

He ampliado la respuesta de Nate Cooks y la he transformado en una extensión de cadena.

extension String {

    //Enables replacement of the character at a specified position within a string
    func replace(_ index: Int, _ newChar: Character) -> String {
        var chars = Array(characters)
        chars[index] = newChar
        let modifiedString = String(chars)
        return modifiedString
    }
}

uso:

let source = "House"
let result = source.replace(2,"r")

el resultado es "caballo"

Answer 6

He encontrado esta solución.

var string = "Cars"
let index = string.index(string.startIndex, offsetBy: 2)
string.replaceSubrange(index...index, with: "t")
print(string)
// Cats

Answer 7

Las cadenas en swift no tienen un descriptor de acceso para leer o escribir un solo carácter. Hay una excelente publicación en el blog por Ole Begemann que describe cómo funcionan las cadenas en Swift.

Nota: la implementación a continuación es incorrecta, lea el apéndice

Así que la forma correcta es llevar la parte izquierda de la cadena hasta el carácter del index -1 , agregar el carácter de reemplazo y luego agregar la cadena desde el índice + 1 hasta el final:

func myReplace(myString:String, index:Int, newCharac:Character) -> String {
    var modifiedString: String

    let len = countElements(myString)

    if (index < len) && (index >= 0) {
        modifiedString = myString.substringToIndex(index) + newCharac + myString.substringFromIndex(index + 1)
    } else {
        modifiedString = myString
    }

    return modifiedString
}

Nota: en mi implementación, elegí devolver la cadena original si el índice no está en un rango válido

Addendum Gracias a @slazyk, que descubrió que mi implementación es incorrecta (ver comentario), estoy proporcionando una nueva versión única y rápida de la función.

func replace(myString:String, index:Int, newCharac:Character) -> String {
    var modifiedString: String

    if (index < 0) || (index >= countElements(myString)) {
        modifiedString = myString
    } else {
        var start = myString.startIndex
        var end = advance(start, index)

        modifiedString = myString[start ..< end]
        modifiedString += newCharac

        start = end.successor()
        end = myString.endIndex

        modifiedString += myString[start ... end]
    }

    return modifiedString
}

La respuesta de @Codester se ve muy bien, y es probablemente lo que yo usaría. Sin embargo, sería interesante saber cómo se comparan los rendimientos, utilizando una solución totalmente rápida y, en cambio, un puente hacia el objetivo-c.

Answer 8

Las soluciones que usan métodos de NSString fallarán para cualquier cadena con caracteres Unicode de múltiples bytes. Aquí hay dos formas nativas de Swift para abordar el problema:

Puede utilizar el hecho de que una String es una secuencia de Character para convertir la cadena en una matriz, modificarla y convertirla de nuevo:

func replace(myString: String, _ index: Int, _ newChar: Character) -> String {
    var chars = Array(myString)     // gets an array of characters
    chars[index] = newChar
    let modifiedString = String(chars)
    return modifiedString
}

replace("House", 2, "r")
// Horse

Alternativamente, puedes atravesar la cuerda tú mismo:

func replace(myString: String, _ index: Int, _ newChar: Character) -> String {
    var modifiedString = String()
    for (i, char) in myString.characters.enumerate() {
        modifiedString += String((i == index) ? newChar : char)
    }
    return modifiedString
}

Dado que estos se mantienen completamente dentro de Swift, ambos son seguros para Unicode:

replace("🏠🏡🏠🏡🏠", 2, "🐴")
// 🏠🏡🐴🏡🏠

Answer 9

Por favor vea la respuesta de NateCook para más detalles.

func replace(myString: String, _ index: Int, _ newChar: Character) -> String {
    var chars = Array(myString.characters)     // gets an array of characters
    chars[index] = newChar
    let modifiedString = String(chars)
    return modifiedString
}

replace("House", 2, "r")

Esto ya no es válido y en desuso.

Siempre puede usar swift String con NSString . Así que puede llamar a la función NSString en swift String . Por el viejo stringByReplacingCharactersInRange: puedes hacerlo así

var st :String = "House"
let abc = st.bridgeToObjectiveC().stringByReplacingCharactersInRange(NSMakeRange(2,1), withString:"r") //Will give Horse

Answer 10

func replace(myString:String, index:Int, newCharac:Character) -> String {

    var modifiedString = myString
    let range = Range<String.Index>(
        start: advance(myString.startIndex, index),
        end: advance(myString.startIndex, index + 1))
    modifiedString.replaceRange(range, with: "/(newCharac)")
    return modifiedString
}

Sin embargo, preferiría pasar una String que un Character .