Inverser une chaîne de caractères en Ruby

Comment inverser une chaîne de caractères en Ruby? Je sais sur la chaîne#inverse. Je suis intéressé par la compréhension de la façon de l'écrire dans le plus pur Rubis, de préférence une solution.

ce sera beaucoup plus lent que la chaîne#inverse btw.
comment savez-vous que cela soit le cas. Que pensez-vous qui se passe avec l'inverse?
ruby-doc.org/ruby-1.9/classes/String.src/M000609.html - C'est très peu probable que Ruby sera en mesure de rivaliser avec C la vitesse de la catégorie.
string#inverse internes utilisez C pour calculer l'inverse.
Par "en place de la solution" voulez-vous dire l'équivalent de string#reverse!? Une fonction qui modifie la chaîne directement plutôt que d'un duplicata?
Je me souviens de Jorg Mittag dire que Rubinius peut faire certaines choses dans le plus pur Rubis plus vite que YARV n'en C.
Au passage, "{{{1,2,3}},{4,5,6}}".reverse = "}}6,5,4{,}}3,2,1{{{". Depuis, il renverse les crochets, c'est en faire plus qu'un 'miroir'/'ordre' flip. C'est en manipulant les chiffres que les personnages représentent.

InformationsquelleAutor rubynoob | 2010-06-16

ruby

40

Il y a déjà une place inverser méthode, appelée "reverse!":
```
$ a = "abc"
$ a.reverse!
$ puts a
cba
```
Si vous voulez le faire manuellement, essayez ceci (mais il ne sera probablement pas être multi-octets en sécurité, par exemple UTF-8), et il sera plus lent:
```
class String
  def reverse_inplace!
    half_length = self.length / 2
    half_length.times {|i| self[i], self[-i-1] = self[-i-1], self[i] }
    self
  end
end
```
Ce swaps de tous les octets à partir du début avec tous les octets à partir de la fin jusqu'à ce que les deux indices se réunissent au centre:
```
$ a = "abcd"
$ a.reverse_inplace!
$ puts a
dcba
```
- Il doit être multi-octets en sécurité dans les versions de Ruby où la normale remplacer est, n'est-ce pas?
- Pas sûr, le C, qui est reliée à la source ci-dessus n'est pas (du moins pas de la boucle). Je ne sais pas ce que le "single_byte_optimizable" ne... BTW: La version de ruby n'est pas multi-octets en sécurité. J'ai juste essayé...
- 1.9.2 doit être multi-octets en sécurité. 1.8 versions ne seront probablement pas.
- "Ce swaps de tous les octets à partir du début avec tous les octets à partir de la fin jusqu'à ce que les deux indices se réunissent au centre" - pré-1.9.2 ce serait vrai, que Ruby considérés comme des caractères à l'équivalent d'octets. Dans 1,9+ ils pourraient être plusieurs octets, mais encore être en un seul caractère.
- Vous avez besoin de retourner l'auto, sinon la longueur va être renvoyée à la place.
- Je l'ai changé car il fait sens
InformationsquelleAutor hurikhan77

Juste pour la discussion, avec autant de suppléants, il est bon de voir si il ya de grandes différences dans la vitesse de l'efficience. J'ai nettoyé un peu le code que le code en montrant la sortie a été maintes fois d'inverser les sorties.

# encoding: utf-8
require "benchmark"
reverse_proc = Proc.new { |reverse_me| reverse_me.chars.inject([]){|r,c| r.unshift c}.join }
class String
def reverse # !> method redefined; discarding old reverse
each_char.to_a.reverse.join
end
def reverse! # !> method redefined; discarding old reverse!
replace reverse
end
def reverse_inplace!
half_length = self.length / 2
half_length.times {|i| self[i], self[-i-1] = self[-i-1], self[i] }
end
end
def reverse(a)
(0...(a.length/2)).each {|i| a[i], a[a.length-i-1]=a[a.length-i-1], a[i]}
return a
end
def reverse_string(string) # method reverse_string with parameter 'string'
loop = string.length       # int loop is equal to the string's length
word = ''                  # this is what we will use to output the reversed word
while loop > 0             # while loop is greater than 0, subtract loop by 1 and add the string's index of loop to 'word'
loop -= 1                  # subtract 1 from loop
word += string[loop]       # add the index with the int loop to word
end                        # end while loop
return word                # return the reversed word
end                        # end the method
lorum = <<EOT
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent quis magna eu
lacus pulvinar vestibulum ut ac ante. Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Suspendisse et pretium orci. Phasellus congue iaculis
sollicitudin. Morbi in sapien mi, eget faucibus ipsum. Praesent pulvinar nibh
vitae sapien congue scelerisque. Aliquam sed aliquet velit. Praesent vulputate
facilisis dolor id ultricies. Phasellus ipsum justo, eleifend vel pretium nec,
pulvinar a justo. Phasellus erat velit, porta sit amet molestie non,
pellentesque a urna. Etiam at arcu lorem, non gravida leo. Suspendisse eu leo
nibh. Mauris ut diam eu lorem fringilla commodo. Aliquam at augue velit, id
viverra nunc.
EOT

Et les résultats:

RUBY_VERSION # => "1.9.2"
name = "Marc-André"; reverse_proc.call(name) # => "érdnA-craM"
name = "Marc-André"; name.reverse! # => "érdnA-craM"
name = "Marc-André"; name.chars.inject([]){|s, c| s.unshift(c)}.join # => "érdnA-craM"
name = "Marc-André"; name.reverse_inplace!; name # => "érdnA-craM"
name = "Marc-André"; reverse(name) # => "érdnA-craM"
name = "Marc-André"; reverse_string(name) # => "érdnA-craM"
n = 5_000
Benchmark.bm(7) do |x|
x.report("1:") { n.times do; reverse_proc.call(lorum); end }
x.report("2:") { n.times do; lorum.reverse!; end }
x.report("3:") { n.times do; lorum.chars.inject([]){|s, c| s.unshift(c)}.join; end }
x.report("4:") { n.times do; lorum.reverse_inplace!; end }
x.report("5:") { n.times do; reverse(lorum); end }
x.report("6:") { n.times do; reverse_string(lorum); end }
end
# >>              user     system      total        real
# >> 1:       4.540000   0.000000   4.540000 (  4.539138)
# >> 2:       2.080000   0.010000   2.090000 (  2.084456)
# >> 3:       4.530000   0.010000   4.540000 (  4.532124)
# >> 4:       7.010000   0.000000   7.010000 (  7.015833)
# >> 5:       5.660000   0.010000   5.670000 (  5.665812)
# >> 6:       3.990000   0.030000   4.020000 (  4.021468)

C'est intéressant pour moi que le "C" version ("reverse_string()") est le plus rapide des pur-version de Ruby. #2 ("reverse!") est plus rapide, mais c'est profiter de la [].reverse, qui est en C.

Édition par Marc-André Lafortune *

L'ajout d'un supplément de cas de test (7):

def alt_reverse(string)
word = ""
chars = string.each_char.to_a
chars.size.times{word << chars.pop}
word
end

Si la chaîne est plus longue (lorum *= 10, n/=10), nous pouvons voir que la différence s'élargit parce que certaines fonctions sont en O(n^2), tandis que d'autres (le mien 🙂 O(n):

             user     system      total        real
1:      10.500000   0.030000  10.530000 ( 10.524751)
2:       0.960000   0.000000   0.960000 (  0.954972)
3:      10.630000   0.080000  10.710000 ( 10.721388)
4:       6.210000   0.060000   6.270000 (  6.277207)
5:       4.210000   0.070000   4.280000 (  4.268857)
6:      10.470000   3.540000  14.010000 ( 15.012420)
7:       1.600000   0.010000   1.610000 (  1.601219)

Test de Nice. Ne lorum *= 10, n /= 10 et les résultats vont vous montrer que toute solution à l'aide de [] n'est pas de l'ordre (i.e. O(n^2)) au lieu de O(n) pour les solutions avec each_char. Aussi, à l'aide de += comme #6 vous donne également #6. J'ai édité ma réponse avec une autre solution n'utilisant pas reverse.
Je voulais dire "vous donne également O(n^2)"
Lafortune, Bons points. N'hésitez pas à modifier et à ajouter les tests avec vos modifications puisque vous avez la réputation. 🙂
Lafortune, j'ai tenté de reproduire certains de vos critères de référence à l'aide de ruby 2.2.0, mais n'a pas obtenu la divergence de la vitesse vous avez montré ici. Plus précisément, il ne semble pas être l'inverse avec #unshift était en cours d'exécution O(n^2). Toutes les pensées?
Ruby maintenant optimise pour les unshifts et pré alloue de la mémoire pour éviter de déplacer tous les éléments.

InformationsquelleAutor the Tin Man

9

Le Rubis équivalent de la builtin reverse pourrait ressembler à:
```
# encoding: utf-8
class String
def reverse
each_char.to_a.reverse.join
end
def reverse!
replace reverse
end
end
str = "Marc-André"
str.reverse!
str # => "érdnA-craM"
str.reverse # => "Marc-André"
```
Note: cela suppose Ruby 1.9, ou d'autre require "backports" et définir $KCODE pour l'UTF-8.

Pour une solution n'impliquant pas reverse, que l'on pourrait faire:
```
def alt_reverse(string)
word = ""
chars = string.each_char.to_a
chars.size.times{word << chars.pop}
word
end                        
```
Note de: aucune solution à l'aide de [] pour accéder à lettres individuelles seront de l'ordre O(n^2); pour accéder à la 1000e lettre, Ruby doit passer par le premier 999, un par un pour vérifier les caractères multioctets. Il est donc important d'utiliser un itérateur comme each_char pour une solution à O(n).

Une autre chose à éviter est de construire des valeurs intermédiaires de l'augmentation de la longueur; à l'aide de += au lieu de << dans alt_reverse permettrait aussi de rendre la solution O(n^2) au lieu de O(n).

La construction d'un tableau avec unshift permettra également de faire la solution O(n^2), car elle implique de recopier tous les éléments d'un index de plus chaque fois on fait un unshift.

InformationsquelleAutor Marc-André Lafortune
8

Voici un moyen de le faire avec injection et unshift:
```
"Hello world".chars.inject([]) { |s, c| s.unshift(c) }.join
```
- Notez que l'utilisation de unshift rend votre solution en O(n^2). Voir mes solutions pour O(n).
InformationsquelleAutor elektronaut

str = "something"
reverse = ""
str.length.times do |i|
reverse.insert(i, str[-1-i].chr)
end

InformationsquelleAutor Rishav Rastogi

"abcde".chars.reduce{|s,c| c + s }          # => "edcba"

InformationsquelleAutor abigure

Utilisation

def reverse_string(string) # Method reverse_string with parameter 'string'.
loop = string.length # int loop is equal to the string's length.
word = '' # This is what we will use to output the reversed word.
while loop > 0 # while loop is greater than 0, subtract loop by 1 and add the string's index of loop to 'word'.
loop -= 1 # Subtract 1 from loop.
word += string[loop] # Add the index with the int loop to word.
end # End while loop.
return word # Return the reversed word.
end # End the method.

Downvoting parce que c'est écrit en C en Ruby.
merci pour les commentaires. J'ai décidé de quitter cette réponse est posté juste au cas ou quelqu'un est intéressé.

InformationsquelleAutor VoodooChild

La solution décrite ci-dessous. Il n'est pas nécessaire d'aller au-delà de la moitié de la taille de la matrice:

class ReverseString
def initialize(array)
@array = array
@size  = @array.size
end
def process
(0...@size/2).to_a.each_with_index do |e,i|
@array[i], @array[@size-i-1] = @array[@size-i-1], @array[i]
end
@array
end
end
require 'minitest/autorun'
class ReverseStringTest < Minitest::Unit::TestCase
def test_process
assert_equal "9876543210", ReverseString.new("0123456789").process
end
end

InformationsquelleAutor Anatoly

Aussi, en utilisant des Proc ...

Proc.new {|reverse_me| reverse_me.chars.inject([]){|r,c| r.unshift c}.join}.call("The house is blue")
=> "eulb si esuoh ehT"

Proc.de nouveau, ce serait pratique ici, car vous pourriez alors nest votre inversion de l'algorithme (et toujours garder les choses sur une seule ligne). Ce serait pratique si, par exemple, vous avez besoin pour inverser chaque mot dans une phrase inversée:

# Define your reversing algorithm
reverser = Proc.new{|rev_me| rev_me.chars.inject([]){r,c| r.unshift c}.join}
# Run it twice - first on the entire sentence, then on each word
reverser.call("The house is blue").split.map {|w| reverser.call(w)}.join(' ')
=> "blue is house The"

InformationsquelleAutor Ben

1

Difficile à lire, one-liner,
```
def reverse(a)
(0...(a.length/2)).each {|i| a[i], a[a.length-i-1]=a[a.length-i-1], a[i]}
return a
end
```
- Pas de multi-octets au courant... BTW, les deux derniers a.length peut être retiré
- il n'a pas demandé assez de code, les gars—cela ne mérite pas un -1.
- Lafortune, veuillez expliquer pourquoi il n'est pas multi-octets au courant. Il utilise tous les multibyte les appels.
- Homme de fer-blanc: je voulais dire qu'il n'est pas multi-octets connaissance de Ruby 1.8: avec $KCODE = "U", tous les caractères multi-octets ne s'inversera pas correctement. En Ruby 1.9, il fonctionne très bien.
- OK, et oui. < 1.9, il y en avait des problèmes avec les caractères multi-octets.
InformationsquelleAutor dagoof
1

Pensez regarder comment Rubinius implémente la méthode - ils mettre en œuvre une grande partie de la bibliothèque de base en Ruby lui-même, et je ne serais pas surpris si String#reverse et String#reverse! est mis en œuvre en Ruby.

InformationsquelleAutor Andrew Grimm

def palindrome(string)
s = string.gsub(/\W+/,'').downcase
t = s.chars.inject([]){|a,b| a.unshift(b)}.join
return true if(s == t)
false
end

ce n'injecter([]) faire?

InformationsquelleAutor nabin

1
```
def reverse(string)
result = ""
idx = string.length - 1
while idx >= 0
result << string [idx]
idx = idx - 1
end
result
end 
```
- Bienvenue DONC! Essayer de donner plus d'explications pour vos réponses. Voir le comment répondre à une page pour obtenir de l'aide dans l'amélioration de votre réponse.
- Veuillez expliquer plus en détail à propos de votre réponse et de ce qu'il est en train de faire. Veuillez voir ici stackoverflow.com/help/how-to-answer.
InformationsquelleAutor EdwardF

C'est la solution qui a le plus de sens pour moi qu'un rubis débutant

def reverse(string)
reversed_string = ''
i = 0
while i < string.length
reversed_string = string[i] + reversed_string
i += 1
end
reversed_string
end
p reverse("helter skelter")

InformationsquelleAutor Derek Kelmanson Jr.

Voici une solution de rechange à l'aide de la xor au niveau du bit opérations:

class String
def xor_reverse
len = self.length - 1
count = 0
while (count < len)
self[count] ^= self[len]
self[len] ^= self[count]
self[count] ^= self[len]
count += 1
len -= 1
end
self
end
"foobar".xor_reverse
=> raboof

btw, cela ne fonctionne pas dans 1,9 puisque le comportement de "a"[0] a changé.

InformationsquelleAutor patrick

En Ruby:

name = "Hello World"; reverse_proc.call(name) 
name = "Hello World"; name.reverse! 
name = "Hello World"; name.chars.inject([]){|s, c| s.unshift(c)}.join 
name = "Hello World"; name.reverse_inplace!; 
name = "Hello World"; reverse(name) 
name = "Hello World"; reverse_string(name)

InformationsquelleAutor bobsags

0

Je crois que ce travail aussi
```
def reverse(str)
string = ''
(0..str.size-1).each do |i|
string << str[str.size - 1 - i]
end
string
end
```
- Sauvage ou une hypothèse?
- Désolé merci de remarquer mon erreur, j'ai corrigé
InformationsquelleAutor James Lieu

def reverse(string)
reversed_string = ""
idx = 0
while idx < string.length
reversed_string = string[idx] + reversed_string
idx += 1
end
return reversed_string
end

Si ce n'est pas un "lieu" de la solution, il est valide.

InformationsquelleAutor Ethan

0

Si vous avez de la phrase "La plus grande victoire est celle" et vous voulez avoir un "c'est la victoire Le plus grand", vous devez utiliser cette méthode
```
def solution(sentance)
sentance.split.reverse.join(" ")
end
solution("The greatest victory is that")
```
InformationsquelleAutor Nikita Sitnikov

string = "This is my string"
string_arr = string.split('')
n = string_arr.length
new_arr = Array.new
17.times do |i|
new_arr << string_arr.values_at(n - i)
end
reversed_string = new_arr.flatten.join('')
=> "gnirts ym si sihT"

InformationsquelleAutor Bryan Finlayson

0

Ici est une alternative simple, il brise la chaîne en un tableau en compte la longueur et la soustrait un(à cause de rubis d'indexation de la règle pour tableau à partir de 0), crée une variable vide, puis exécute une itération sur les touches du tableau, tout en ajoutant la valeur de la longueur du tableau moins les index de tableau de la variable vide créé et quand il atteint le zéro(désolé pour mon français) de la valeur qu'il s'arrête. Espérons que cette aide.
```
class String
def rString
arr = self.split("")
len = arr.count - 1
final = ""
arr.each_index do |i|
final += arr[len - i]
end
final
end
end
```
InformationsquelleAutor Precious George

Vous devez vous connecter pour publier un commentaire.