una - funcion al reves python

¿Invertir una cadena sin usar reverse() o[::-1]?

Question

Me encontré con un extraño ejercicio de Codecademy que requería una función que tomaría una cadena como entrada y la devolvería en orden inverso. El único problema era que no se podía usar el método invertido o la respuesta común aquí en stackoverflow, [::-1] .

Obviamente, en el mundo real de la programación, lo más probable es que vaya con el método de división extendida , o incluso con la función reversed , pero tal vez haya algún caso en el que esto no funcione.

A continuación presento una solución en estilo de preguntas y respuestas, en caso de que sea útil para las personas en el futuro.

Answer 1

Acabo de resolver esto en la academia de código y estaba verificando mis respuestas y encontré esta lista. así que con una comprensión muy limitada de Python acabo de hacer esto y funcionó para funcionar.

def reverse(s):
i = len(s) - 1
sNew = ''''
while i >= 0:
sNew = sNew + str(s[i])
i = i -1
return sNew

Answer 2

Aquí está mi contribución:

def rev(test):
test = list(test)
i = len(test)-1
result = []
print test
while i >= 0:
result.append(test.pop(i))
i -= 1
return "".join(result)

Answer 3

Aquí hay uno que usa una lista como pila:

def reverse(s):
rev = [_t for _t in s]
t = ''''
while len(rev) != 0:
t+=rev.pop()
return t

Answer 4

Creé diferentes versiones de cómo invertir una cadena en python en mi repositorio: https://github.com/fedmich/Python-Codes/tree/master/Reverse%20a%20String

Puedes hacerlo usando la técnica de comprensión de listas o lambda :

# Reverse a string without using reverse() function
s = ''Federico'';
li = list( s ) #convert string to list
ret = [ li[i-1] for i in xrange(len(li),0,-1) ] #1 liner lambda
print ( "".join( ret ) )

o haciendo un ciclo hacia atrás para

# Reverse a string without using reverse() function
s = ''Federico'';
r = []
length = len(s)
for i in xrange(length,0,-1):
r.append( s[ i - 1] )
print ( "".join(r) )

Answer 5

Esta es mi solución usando el bucle for i in range:

def reverse(string):
tmp = ""
for i in range(1,len(string)+1):
tmp += string[len(string)-i]
return tmp

Es bastante fácil de entender. Empiezo desde 1 para evitar el índice fuera de límite.

Answer 6

Esta es una forma de hacerlo con un ciclo while:

def reverse(s):
t = -1
s2 = ''''
while abs(t) < len(s) + 1:
s2 = s2 + s[t]
t = t - 1
return s2

Answer 7

Esta es una pregunta muy interesante, me gustaría ofrecer una respuesta simple de un trazador de líneas:

>>> S=''abcdefg''
>>> ''''.join(item[1] for item in sorted(enumerate(S), reverse=True))
''gfedcba''

Breve explicacion:

enumerate() devuelve [(0, ''a''), (1, ''b''), (2, ''c''), (3, ''d''), (4, ''e''), (5, ''f''), (6, ''g'')] . Los índices y los valores. Para invertir los valores, solo instálelo por orden de sorted() . Finalmente, simplemente ponlo de nuevo junto a una str

Answer 8

Has recibido muchas respuestas alternativas, pero solo para agregar otra solución simple: lo primero que se me ocurrió es algo así:

def reverse(text):
reversed_text = ""
for n in range(len(text)):
reversed_text += text[-1 - n]
return reversed_text

No es tan rápido como algunas de las otras opciones que la gente ha mencionado (o construido en métodos), pero es fácil de seguir ya que simplemente estamos usando la longitud de la cadena de text para concatenar un carácter a la vez cortando desde el extremo hacia el frente.

Answer 9

Hoy me pidieron este mismo ejercicio en lápiz y papel, así que se me ocurrió esta función para las listas:

def rev(s):
l = len(s)
for i,j in zip(range(l-1, 0, -1), range(l//2)):
s[i], s[j] = s[j], s[i]
return s

que se puede usar con cadenas con "".join(rev(list("hello")))

Answer 10

Inspirado por la respuesta de Jon, ¿qué tal este

word = ''hello''
q = deque(word)
''''.join(q.pop() for _ in range(len(word)))

Answer 11

La forma en que puedo pensar sin usar ninguna función incorporada:

a = ''word''
count = 0
for letter in a:
count += 1
b = ''''
for letter in a:
b += a[count-1]
count -= 1

Y si imprime b:

print b
drow

Answer 12

La respuesta de Blender es encantadora, pero para una cadena muy larga, dará como resultado un enorme RuntimeError: maximum recursion depth exceeded . Uno podría refactorizar el mismo código en un ciclo while, como uno frecuentemente debe hacer con la recursión en python. Obviamente todavía está mal debido a problemas de tiempo y memoria, pero al menos no tendrá errores.

def reverse(text):
answer = ""
while text:
answer = text[0] + answer
text = text[1:]
return answer

Answer 13

No es muy inteligente, pero es una solución difícil

def reverse(t):
for j in range(len(t) // 2):
t = t[:j] + t[- j - 1] + t[j + 1:- j - 1] + t[j] + t[len(t) - j:]
return t

Answer 14

Pointfree:

from functools import partial
from operator import add
flip = lambda f: lambda x, y: f(y, x)
rev = partial(reduce, flip(add))

Prueba:

>>> rev(''hello'')
''olleh''

Answer 15

Puedes hacer simplemente así

def rev(str):
rev = ""
for i in range(0,len(str)):
rev = rev + str[(len(str)-1)-i]
return rev

Answer 16

Simplemente puede invertir iterar su cadena comenzando desde el último caracter. Con Python puede usar la comprensión de listas para construir la lista de caracteres en orden inverso y luego unirlos para obtener la cadena invertida en un solo trazo:

def reverse(s):
return "".join([s[-i-1] for i in xrange(len(s))])

si no se te permite usar indexación negativa, debes reemplazar s[-i-1] por s[len(s)-i-1]

Answer 17

Solo he estado codificando Python durante unos días, pero creo que esta fue una solución bastante limpia. Cree una lista vacía, recorra cada letra de la cadena y añádala al principio de la lista, devuelva la lista unida como una cadena.

def reverse(text):
backwardstext = []
for letter in text:
backwardstext.insert(0, letter)
return ''''.join(backwardstext)

Answer 18

Solo otra opción:

from collections import deque
def reverse(iterable):
d = deque()
d.extendleft(iterable)
return ''''.join(d)

Answer 19

También acabo de resolver el ejercicio correspondiente en codeacademy y quería comparar mi enfoque con los demás. No he encontrado la solución que utilicé hasta ahora, así que pensé en registrarme aquí y brindar mi solución a otros. Y tal vez recibo una sugerencia o un comentario útil sobre cómo mejorar el código.

Ok aquí va, no usé ninguna lista para almacenar la cadena, en vez de eso acabo de acceder al índice de cadena. Me tomó un poco al principio lidiar con el len () y el número de índice, pero al final funcionó :).

def reverse(x):
reversestring = ""
for n in range(len(str(x))-1,-1, -1):
reversestring += x[n]
return reversestring

Todavía me pregunto si el reversestring = "" podría resolverse de una manera más elegante, o si es "malo estilo" incluso, pero no pude encontrar una respuesta hasta el momento.

Answer 20

También puedes hacerlo con recursión:

def reverse(text):
if len(text) <= 1:
return text
return reverse(text[1:]) + text[0]

Y un simple ejemplo para la cadena hello :

 reverse(hello)
= reverse(ello) + h # The recursive step
= reverse(llo) + e + h
= reverse(lo) + l + e + h
= reverse(o) + l + l + e + h # Base case
= o + l + l + e + h
= olleh

Answer 21

Todo lo que hice para lograr una cadena inversa es utilizar la función xrange con la longitud de la cadena en un ciclo for y dar un paso atrás de la siguiente manera:

myString = "ABC"
for index in xrange(len(myString),-1):
print index

Mi salida es "CBA"

Answer 22

Una versión golfed: r=lambda x:"".join(x[i] for i in range(len(x-1),-1,-1)) Join r=lambda x:"".join(x[i] for i in range(len(x-1),-1,-1)) .

Answer 23

Usé esto:

def reverse(text):
s=""
l=len(text)
for i in range(l):
s+=text[l-1-i]
return s

Answer 24

Utilice el range invertido:

def reverse(strs):
for i in xrange(len(strs)-1, -1, -1):
yield strs[i]
...
>>> ''''.join(reverse(''hello''))
''olleh''

xrange o range con -1 paso devolvería los elementos en orden inverso, por lo que necesitamos iterar de len(string)-1 a -1 (exclusivo) y obtener elementos de la cadena uno por uno.

>>> list(xrange(len(strs) -1, -1 , -1))
[4, 3, 2, 1, 0] #iterate over these indexes and fetch the items from the string

Un trazador de líneas:

def reverse(strs):
return ''''.join([strs[i] for i in xrange(len(strs)-1, -1, -1)])
...
>>> reverse(''hello'')
''olleh''

Answer 25

tienes suficiente respuesta.

Solo quiero compartir otra forma.

puedes escribir una pequeña función para invertir y comparar la salida de la función con la cadena dada

var = ''''

def reverse (datos):

for i in data:
var = i + var
return var

si no var == datos:

imprimir "No palindrome"

else:

imprimir "Palindrome"

Answer 26

EDITAR

La actividad reciente en esta cuestión me llevó a mirar hacia atrás y cambiar mi solución a una línea rápida usando un generador:

rev = ''''.join([text[len(text) - count] for count in xrange(1,len(text)+1)])

Aunque obviamente hay algunas respuestas mejores aquí, como un paso negativo en el rango o la función de xrange. La siguiente es mi solución original:

Aquí está mi solución, lo explicaré paso a paso

def reverse(text):
lst = []
count = 1
for i in range(0,len(text)):
lst.append(text[len(text)-count])
count += 1
lst = ''''.join(lst)
return lst
print reverse(''hello'')

Primero, tenemos que pasar un parámetro a la función, en este caso text .

A continuación, configuré una lista vacía, llamada lst para usar más tarde. (De hecho, no sabía que necesitaría la lista hasta que llegué al ciclo for , verás por qué es necesario en un segundo).

La variable de count tendrá sentido una vez que entre al ciclo for

Echemos un vistazo a una versión básica de lo que estamos tratando de lograr:

Tiene sentido que agregar el último carácter a la lista comience en el orden inverso. Por ejemplo:

>>lst = []
>>word = ''foo''
>>lst.append(word[2])
>>print lst
[''o'']

Pero para continuar invirtiendo el orden, necesitamos agregar la word[1] y luego la word[0] :

>>lst.append(word[2])
>>lst.append(word[1])
>>lst.append(word[0])
>>print lst
[''o'',''o'',''f'']

Esto es genial, ahora tenemos una lista que tiene nuestra palabra original en orden inverso y puede convertirse de nuevo en una cadena usando .join() . Pero hay un problema. Esto funciona para la palabra foo, incluso funciona para cualquier palabra que tenga una longitud de 3 caracteres. Pero ¿qué pasa con una palabra con 5 caracteres? O 10 caracteres? Ahora no funcionará ¿Qué ocurre si hay una forma en la que podemos cambiar dinámicamente el índice que agregamos para que cualquier palabra se devuelva en orden inverso?

Ingrese para el bucle.

for i in range(0,len(text)):
lst.append(text[len(text)-count])
count += 1

En primer lugar, es necesario usar el in range() lugar de solo hacerlo, porque necesitamos iterar a través de los caracteres en la palabra, pero también necesitamos extraer el valor del índice de la palabra para que cambiemos el orden.

La primera parte del cuerpo de nuestro bucle for debe ser familiar. Es muy similar a

>>lst.append(word[..index..])

De hecho, el concepto de base es exactamente el mismo:

>>lst.append(text[..index..])

Entonces, ¿qué están haciendo todas las cosas en el medio?

Bueno, primero tenemos que anexar el índice de la última letra a nuestra lista, que es la longitud de la palabra, text , -1. A partir de ahora nos referiremos a él como l (t) -1

>>lst.append(text[len(text)-1])

Solo eso siempre obtendrá la última letra de nuestra palabra, y se lst a la lst , independientemente de la longitud de la palabra. Pero ahora que tenemos la última letra, que es l (t) - 1, necesitamos la penúltima letra, que es l (t) - 2, y así sucesivamente, hasta que no haya más caracteres para anexar a la lista . ¿Recuerdas nuestra variable de count desde arriba? Eso será util. Al usar un bucle for , podemos incrementar el valor del count por 1 a través de cada iteración, de modo que el valor que restamos aumente, hasta que el bucle for haya iterado a través de la palabra completa:

>>for i in range(0,len(text)):
..
.. lst.append(text[len(text)-count])
.. count += 1

Ahora que tenemos el corazón de nuestra función, veamos lo que tenemos hasta ahora:

def reverse(text):
lst = []
count = 1
for i in range(0,len(text)):
lst.append(text[len(text)-count])
count += 1

¡Ya casi hemos terminado! En este momento, si tuviéramos que llamar a nuestra función con la palabra ''hola'', obtendríamos una lista que se parece a:

[''o'', ''l'', ''l'', ''e'', ​​''h'']

No queremos una lista, queremos una cadena. Podemos usar .join para eso:

def reverse(text):
lst = []
count = 1
for i in range(0,len(text)):
lst.append(text[len(text)-count])
count += 1
lst = ''''.join(lst) # join the letters together without a space
return lst

Y eso es. Si llamamos a la palabra ''hola'' en reversa (), obtendríamos esto:

>>print reverse(''hello'')
olleh

Obviamente, esto es mucho más código de lo que es necesario en una situación de la vida real. El uso de la función invertida o rebanada extendida sería la forma óptima de llevar a cabo esta tarea, pero tal vez haya alguna instancia en la que no funcionaría, y la necesitarías. De cualquier manera, pensé que lo compartiría con cualquiera que estuviera interesado.

Si ustedes tienen otras ideas, ¡me encantaría escucharlas!

Answer 27

def reverse(s):
return "".join(s[i] for i in range(len(s)-1, -1, -1))

Answer 28

def reverse(text):
a=""
l=len(text)
while(l>=1):
a+=text[l-1]
l-=1
return a

Acabo de concatenar la cadena a con los índices más altos de texto (que sigue decreciendo en 1 cada ciclo).

Answer 29

def reverseThatString(theString):
reversedString = ""
lenOfString = len(theString)
for i,j in enumerate(theString):
lenOfString -= 1
reversedString += theString[lenOfString]
return reversedString

Answer 30

reduce(lambda x, y : y + x, "hello world")