Agregando palabras library/heapq

python · cmaureir · Aug 21, 2020 · May 30, 2020 · May 30, 2020 · May 30, 2020
commit e46a10ef9736459f2927550ca063dff315f0119a
diff --git a/dictionaries/library_heapq.txt b/dictionaries/library_heapq.txt
@@ -0,0 +1,2 @@
+secuenciador
+desapilando
diff --git a/library/heapq.po b/library/heapq.po
@@ -21,7 +21,7 @@ msgstr ""
 
 #: ../Doc/library/heapq.rst:2
 msgid ":mod:`heapq` --- Heap queue algorithm"
-msgstr ":mod:`heapq` --- Algoritmo de colas con prioridad o montículos"
+msgstr ":mod:`heapq` --- Algoritmo de colas montículos (*heap*)"
 
 #: ../Doc/library/heapq.rst:12
 msgid "**Source code:** :source:`Lib/heapq.py`"
@@ -45,11 +45,11 @@ msgid ""
 "is that its smallest element is always the root, ``heap[0]``."
 msgstr ""
 "Los montículos son árboles binarios para los cuales cada nodo padre tiene un "
-"valor menor o igual que cualquiera de sus hijos.  Esta implementación "
-"utiliza matrices para las cuales ``heap[k] <= heap[2*k+1]`` y ``heap[k] <= "
-"heap[2*k+2]`` para todo *k*, contando los elementos desde cero.  Para poder "
-"comparar, los elementos inexistentes se consideran infinitos.  La propiedad "
-"interesante de un montículo es que su elemento más pequeño es siempre la raíz, "
+"valor menor o igual que cualquiera de sus hijos. Esta implementación utiliza "
+"matrices para las cuales ``heap[k] <= heap[2*k+1]`` y ``heap[k] <= heap[2*k"
+"+2]`` para todo *k*, contando los elementos desde cero. Para poder comparar, "
+"los elementos inexistentes se consideran infinitos. La propiedad interesante "
+"de un montículo es que su elemento más pequeño es siempre la raíz, "
 "``heap[0]``."
 
 #: ../Doc/library/heapq.rst:26
@@ -63,10 +63,10 @@ msgid ""
 "sorting)."
 msgstr ""
 "El API que se presenta a continuación difiere de los algoritmos de los "
-"libros de texto en dos aspectos: a) Utilizamos la indexación basada en "
-"cero.  Esto hace que la relación entre el índice de un nodo y los índices de "
+"libros de texto en dos aspectos: (a) Utilizamos la indexación basada en "
+"cero. Esto hace que la relación entre el índice de un nodo y los índices de "
 "sus hijos sea un poco menos evidente, pero es más adecuado ya que Python "
-"utiliza la indexación basada en cero. b) Nuestro método \"pop\" devuelve el "
+"utiliza la indexación basada en cero. (b) Nuestro método \"pop\" retorna el "
 "elemento más pequeño, no el más grande (llamado \"min heap\" o montículo por "
 "mínimo en los libros de texto; un \"max heap\" o montículo por máximos es "
 "más común en los textos debido a su idoneidad para la clasificación in situ)."
@@ -77,9 +77,9 @@ msgid ""
 "surprises: ``heap[0]`` is the smallest item, and ``heap.sort()`` maintains "
 "the heap invariant!"
 msgstr ""
-"Estos dos permiten ver el montículo como una lista Python normal sin sorpresas: "
-"``heap[0]`` es el ítem más pequeño, y ``heap.sort()`` mantiene el montículo "
-"invariable!"
+"Estos dos permiten ver el montículo como una lista Python normal sin "
+"sorpresas: ``heap[0]`` es el ítem más pequeño, y ``heap.sort()`` mantiene el "
+"montículo invariable!"
 
 #: ../Doc/library/heapq.rst:37
 msgid ""
@@ -97,28 +97,27 @@ msgstr "Las siguientes funciones están provistas:"
 #: ../Doc/library/heapq.rst:45
 msgid "Push the value *item* onto the *heap*, maintaining the heap invariant."
 msgstr ""
-"Empujar el valor *item* en el *montículo*, manteniendo el montículo "
-"invariable."
+"Empujar el valor *item* en el *heap*, manteniendo el montículo invariable."
 
 #: ../Doc/library/heapq.rst:50
 msgid ""
 "Pop and return the smallest item from the *heap*, maintaining the heap "
 "invariant.  If the heap is empty, :exc:`IndexError` is raised.  To access "
 "the smallest item without popping it, use ``heap[0]``."
 msgstr ""
-"Desapile o *pop* y devuelva el artículo más pequeño del *montículo*, "
-"manteniendo el montículo invariable.  Si el montículo está vacío, :exc:"
-"``IndexError`` se lanza.  Para acceder al elemento más pequeño sin necesidad "
-"de desapilar, usa``heap[0]``."
+"Desapila o *pop* y retorna el elemento más pequeño del *heap*, manteniendo "
+"el montículo invariable. Si el montículo está vacío, :exc:`IndexError` se "
+"lanza. Para acceder al elemento más pequeño sin necesidad de desapilar, "
+"usa``heap[0]``."
 
 #: ../Doc/library/heapq.rst:57
 msgid ""
 "Push *item* on the heap, then pop and return the smallest item from the "
 "*heap*.  The combined action runs more efficiently than :func:`heappush` "
 "followed by a separate call to :func:`heappop`."
 msgstr ""
-"Apila el artículo o *iem* en el montículo, y luego desapila y devuelve el "
-"artículo más pequeño del montículo.  La acción combinada se ejecuta más "
+"Apila el elemento o *iem* en el montículo, y luego desapila y retorna el "
+"elemento más pequeño del montículo. La acción combinada se ejecuta más "
 "eficientemente que :func:`heappush` seguido de una llamada separada a :func:"
 "`heappop`."
 
@@ -133,8 +132,8 @@ msgid ""
 "*item*. The heap size doesn't change. If the heap is empty, :exc:"
 "`IndexError` is raised."
 msgstr ""
-"Desapile y devuelve el artículo más pequeño del *montículo*, y también apile "
-"el nuevo *artículo*. El tamaño del montículo no cambia. Si el montículo está "
+"Desapila y retorna el elemento más pequeño del *heap*, y también apile el "
+"nuevo *item*. El tamaño del montículo no cambia. Si el montículo está "
 "vacío, :exc:`IndexError` se eleva."
 
 #: ../Doc/library/heapq.rst:72
@@ -146,7 +145,7 @@ msgid ""
 msgstr ""
 "Esta operación de un solo paso es más eficiente que un :func:`heappop` "
 "seguido por :func:`heappush` y puede ser más apropiada cuando se utiliza un "
-"montículo de tamaño fijo. La combinación pop/push siempre devuelve un "
+"montículo de tamaño fijo. La combinación pop/push siempre retorna un "
 "elemento del montículo y lo reemplaza con *item*."
 
 #: ../Doc/library/heapq.rst:77
@@ -156,10 +155,9 @@ msgid ""
 "combination returns the smaller of the two values, leaving the larger value "
 "on the heap."
 msgstr ""
-"El valor devuelto puede ser mayor que el *articulo* añadido.  Si no se desea "
-"eso, considere usar :func:`heappushpop` en su lugar.  Su combinación push/"
-"pop devuelve el menor de los dos valores, dejando el mayor valor en el "
-"montículo."
+"El valor retornado puede ser mayor que el *item* añadido. Si no se desea "
+"eso, considere usar :func:`heappushpop` en su lugar. Su combinación push/pop "
+"retorna el menor de los dos valores, dejando el mayor valor en el montículo."
 
 #: ../Doc/library/heapq.rst:83
 msgid "The module also offers three general purpose functions based on heaps."
@@ -174,16 +172,16 @@ msgid ""
 "over the sorted values."
 msgstr ""
 "Fusionar varias entradas ordenadas en una sola salida ordenada (por ejemplo, "
-"fusionar entradas con marca de tiempo de varios archivos de registro).  "
-"Devuelva un :term:`iterator` sobre los valores ordenados."
+"fusionar entradas con marca de tiempo de varios archivos de registro). "
+"Retorna un :term:`iterator` sobre los valores ordenados."
 
 #: ../Doc/library/heapq.rst:92
 msgid ""
 "Similar to ``sorted(itertools.chain(*iterables))`` but returns an iterable, "
 "does not pull the data into memory all at once, and assumes that each of the "
 "input streams is already sorted (smallest to largest)."
 msgstr ""
-"Similar a ``sorted(itertools.chain(*iterables))`` pero devuelve un iterable, "
+"Similar a ``sorted(itertools.chain(*iterables))`` pero retorna un iterable, "
 "no hala los datos a la memoria de una sola vez, y asume que cada uno de los "
 "flujos de entrada ya están ordenado (de menor a mayor)."
 
@@ -201,7 +199,7 @@ msgid ""
 "``None`` (compare the elements directly)."
 msgstr ""
 "*key* especifica una :term:`key function` de un argumento que se utiliza "
-"para extraer una clave de comparación de cada elemento de entrada.  El valor "
+"para extraer una clave de comparación de cada elemento de entrada. El valor "
 "por defecto es ``None`` (compara los elementos directamente)."
 
 #: ../Doc/library/heapq.rst:102
@@ -211,7 +209,7 @@ msgid ""
 "to ``sorted(itertools.chain(*iterables), reverse=True)``, all iterables must "
 "be sorted from largest to smallest."
 msgstr ""
-"*reverse* es un valor booleano.  Si se establece en ``True``, entonces los "
+"*reverse* es un valor booleano. Si se establece en ``True``, entonces los "
 "elementos de entrada se fusionan como si cada comparación se invirtiera. "
 "Para lograr un comportamiento similar a ``sorted(itertools."
 "chain(*iterables), reverse=True)``, todos los iterables deben ser ordenados "
@@ -229,10 +227,10 @@ msgid ""
 "example, ``key=str.lower``).  Equivalent to:  ``sorted(iterable, key=key, "
 "reverse=True)[:n]``."
 msgstr ""
-"Devuelve una lista con los *n* elementos más grandes del conjunto de datos "
-"definidos por *iterable*.  *key*, si se proporciona, especifica una función "
+"retorna una lista con los *n* elementos más grandes del conjunto de datos "
+"definidos por *iterable*. *key*, si se proporciona, especifica una función "
 "de un argumento que se utiliza para extraer una clave de comparación de cada "
-"elemento en *iterable* (por ejemplo, ``key=str.lower``).  Equivalente a:  "
+"elemento en *iterable* (por ejemplo, ``key=str.lower``). Equivalente a:  "
 "``sorted(iterable, key=clave, reverse=True)[:n]``."
 
 #: ../Doc/library/heapq.rst:122
@@ -243,10 +241,10 @@ msgid ""
 "example, ``key=str.lower``).  Equivalent to:  ``sorted(iterable, key=key)[:"
 "n]``."
 msgstr ""
-"Devuelve una lista con los *n* elementos más pequeños del conjunto de datos "
-"definidos por *iterable*.  *key*, si se proporciona, especifica una función "
+"retorna una lista con los *n* elementos más pequeños del conjunto de datos "
+"definidos por *iterable*. *key*, si se proporciona, especifica una función "
 "de un argumento que se utiliza para extraer una clave de comparación de cada "
-"elemento en *iterable* (por ejemplo, ``key=str.lower``).  Equivalente a:  "
+"elemento en *iterable* (por ejemplo, ``key=str.lower``). Equivalente a:  "
 "``sorted(iterable, key=clave)[:n]``."
 
 #: ../Doc/library/heapq.rst:128
@@ -257,10 +255,10 @@ msgid ""
 "`max` functions.  If repeated usage of these functions is required, consider "
 "turning the iterable into an actual heap."
 msgstr ""
-"Las dos últimas funciones funcionan mejor para valores más pequeños de *n*.  "
-"Para valores más grandes, es más eficiente usar la función :func:`sorted`.  "
+"Las dos últimas funciones funcionan mejor para valores más pequeños de *n*. "
+"Para valores más grandes, es más eficiente usar la función :func:`sorted`. "
 "Además, cuando ``n==1``, es más eficiente usar las funciones incorporadas :"
-"func:`min` y :func:`max``.  Si se requiere el uso repetido de estas "
+"func:`min` y :func:`max``. Si se requiere el uso repetido de estas "
 "funciones, considere convertir lo iterable en un verdadero montículo."
-"funciones, considere convertir lo iterable en un verdadero montículo."
+"funciones, considere convertir el iterable en un verdadero montículo."
-"funciones, considere convertir lo iterable en un verdadero montículo."
+"funciones, considere convertir el iterable en un verdadero montículo."
 
 #: ../Doc/library/heapq.rst:136
@@ -290,7 +288,7 @@ msgid ""
 "Heap elements can be tuples.  This is useful for assigning comparison values "
 "(such as task priorities) alongside the main record being tracked::"
 msgstr ""
-"Los elementos del montículo pueden ser tuplas.  Esto es útil para asignar "
+"Los elementos del montículo pueden ser tuplas. Esto es útil para asignar "
 "valores de comparación (como las prioridades de las tareas) junto con el "
 "registro principal que se está rastreando::"
 
@@ -312,7 +310,7 @@ msgid ""
 "returned in the order they were originally added?"
 msgstr ""
 "Estabilidad de la clasificación: ¿cómo se consigue que dos tareas con "
-"iguales prioridades sean devueltas en el orden en que fueron añadidas "
+"iguales prioridades sean retornadas en el orden en que fueron añadidas "
 "originalmente?"
 
 #: ../Doc/library/heapq.rst:175
@@ -350,8 +348,8 @@ msgid ""
 msgstr ""
 "Una solución a los dos primeros desafíos es almacenar las entradas como una "
 "lista de 3 elementos que incluya la prioridad, un recuento de entradas y la "
-"tarea.  El recuento de entradas sirve como un desempate para que dos tareas "
-"con la misma prioridad sean devueltas en el orden en que fueron añadidas. Y "
+"tarea. El recuento de entradas sirve como un desempate para que dos tareas "
+"con la misma prioridad sean retornadas en el orden en que fueron añadidas. Y "
 "como no hay dos recuentos de entradas iguales, la comparación tupla nunca "
 "intentará comparar directamente dos tareas."
 
@@ -372,8 +370,8 @@ msgid ""
 "with a dictionary pointing to an entry in the queue."
 msgstr ""
 "Los desafíos restantes giran en torno a encontrar una tarea pendiente y "
-"hacer cambios en su prioridad o eliminarla por completo.  Encontrar una "
-"tarea se puede hacer con un diccionario que apunta a una entrada en la cola."
+"hacer cambios en su prioridad o eliminarla por completo. Encontrar una tarea "
+"se puede hacer con un diccionario que apunta a una entrada en la cola."
 
 #: ../Doc/library/heapq.rst:205
 msgid ""
@@ -382,7 +380,7 @@ msgid ""
 "mark the entry as removed and add a new entry with the revised priority::"
 msgstr ""
 "Eliminar la entrada o cambiar su prioridad es más difícil porque rompería "
-"las invariantes de la estructura del montículo.  Por lo tanto, una posible "
+"las invariantes de la estructura del montículo. Por lo tanto, una posible "
 "solución es marcar la entrada como eliminada y añadir una nueva entrada con "
 "la prioridad revisada::"
 
@@ -399,7 +397,7 @@ msgid ""
 msgstr ""
 "Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y \"a[k] <= "
-"Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y \"a[k] <= "
+"Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y a[k] <= "
-"Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y \"a[k] <= "
+"Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y a[k] <= "
 "a[2*k+2]`` para todos los *k*, contando los elementos desde 0. Para "
-"comparar, los elementos no existentes se consideran infinitos.  La "
+"comparar, los elementos no existentes se consideran infinitos. La "
 "interesante propiedad de un montículo es que ``a[0]`` es siempre su elemento "
 "más pequeño."
 
@@ -409,7 +407,7 @@ msgid ""
 "representation for a tournament.  The numbers below are *k*, not ``a[k]``::"
 msgstr ""
 "La extraña invariante de arriba intenta ser una representación eficiente de "
-"la memoria para un torneo.  Los números de abajo son *k*, no``a[k]``::"
+"la memoria para un torneo. Los números de abajo son *k*, no``a[k]``::"
 
 #: ../Doc/library/heapq.rst:259
 msgid ""
@@ -426,9 +424,9 @@ msgstr ""
 "En el árbol de arriba, cada celda *k* está coronada por ``2*k+1`` y ``2*k"
 "+2``. En un torneo binario habitual que vemos en los deportes, cada celda es "
 "el ganador sobre las dos celdas que supera, y podemos rastrear al ganador "
-"hasta el árbol para ver todos los oponentes que tuvo.  Sin embargo, en "
-"muchas aplicaciones informáticas de tales torneos, no necesitamos rastrear "
-"la historia de un ganador. Para ser más eficientes en la memoria, cuando un "
+"hasta el árbol para ver todos los oponentes que tuvo. Sin embargo, en muchas "
+"aplicaciones informáticas de tales torneos, no necesitamos rastrear la "
+"historia de un ganador. Para ser más eficientes en la memoria, cuando un "
 "ganador es ascendido, tratamos de reemplazarlo por algo más en un nivel "
 "inferior, y la regla se convierte en que una celda y las dos celdas que "
 "supera contienen tres elementos diferentes, pero la celda superior \"gana\" "
@@ -445,7 +443,7 @@ msgid ""
 "items, you get an O(n log n) sort."
 msgstr ""
 "Si esta invariante del montículo está protegida en todo momento, el índice 0 "
-"es claramente el ganador general.  La forma algorítmica más simple de "
+"es claramente el ganador general. La forma algorítmica más simple de "
 "eliminarlo y encontrar el \"próximo\" ganador es mover algún perdedor "
 "(digamos la celda 30 en el diagrama de arriba) a la posición 0, y luego "
 "filtrar este nuevo 0 por el árbol, intercambiando valores, hasta que la "
@@ -467,11 +465,11 @@ msgstr ""
 "Una buena característica de este tipo es que puedes insertar nuevos "
 "elementos de manera eficiente mientras se realiza la clasificación, siempre "
-"elementos de manera eficiente mientras se realiza la clasificación, siempre "
+"elementos de manera eficiente mientras se mantiene el orden, siempre "
-"elementos de manera eficiente mientras se realiza la clasificación, siempre "
+"elementos de manera eficiente mientras se mantiene el orden, siempre "
 "y cuando los elementos insertados no sean \"mejores\" que el último 0'th "
-"elemento que has extraído.  Esto es especialmente útil en contextos de "
+"elemento que has extraído. Esto es especialmente útil en contextos de "
 "simulación, donde el árbol contiene todos los eventos entrantes, y la "
-"condición de \"ganar\" significa el menor tiempo programado.  Cuando un "
+"condición de \"ganar\" significa el menor tiempo programado. Cuando un "
 "evento programa otros eventos para su ejecución, se programan en el futuro, "
-"para que puedan ir fácilmente al montículo.  Por lo tanto, un montículo es "
+"para que puedan ir fácilmente al montículo. Por lo tanto, un montículo es "
 "una buena estructura para implementar planificadores o *schedulers* (esto es "
 "lo que usé para mi secuenciador MIDI :-)."
 
@@ -503,11 +501,11 @@ msgid ""
 "which are twice the size of the memory for random input, and much better for "
 "input fuzzily ordered."
 msgstr ""
-"Los montículos también son muy útiles en las grandes  ordenaciónes de "
+"Los montículos también son muy útiles en las grandes  ordenaciones de "
 "elementos en discos de memoria. Lo más probable es que todos sepan que un "
-"tipo grande implica la producción de \"corridas\" (que son secuencias "
+"tipo grande implica la producción de \"ejecuciones\" (que son secuencias "
 "preclasificadas, cuyo tamaño suele estar relacionado con la cantidad de "
-"memoria de la CPU), seguidas de una fusión de pases para estas corridas, "
+"memoria de la CPU), seguidas de una fusión de pases para estas ejecuciones, "
 "cuya fusión suele estar muy inteligentemente organizada [#]_. Es muy "
 "importante que la clasificación inicial produzca las ejecuciones posibles "
 "más largas. Los torneos son una buena manera de lograrlo. Si, utilizando "
@@ -531,18 +529,19 @@ msgstr ""
 "último valor de salida), no puede caber en el montículo, por lo que el "
 "tamaño del montículo disminuye. La memoria liberada podría ser "
 "ingeniosamente reutilizada inmediatamente para construir progresivamente un "
-"segundo montículo, que crece exactamente al mismo ritmo que el primer montículo se "
-"está fundiendo. Cuando el primer montículo se desvanece completamente, se "
-"cambia de montículo y se inicia una nueva carrera. ¡Ingenioso y muy efectivo!"
+"segundo montículo, que crece exactamente al mismo ritmo que el primer "
+"montículo se está fundiendo. Cuando el primer montículo se desvanece "
+"completamente, se cambia de montículo y se inicia una nueva carrera. "
+"¡Ingenioso y muy efectivo!"
 
 #: ../Doc/library/heapq.rst:308
 msgid ""
 "In a word, heaps are useful memory structures to know.  I use them in a few "
 "applications, and I think it is good to keep a 'heap' module around. :-)"
 msgstr ""
-"En una palabra, los montículos son estructuras de memoria útiles a "
-"conocer.  Las uso en algunas aplicaciones, y creo que es bueno tener un "
-"módulo 'heap' alrededor. :-)"
+"En una palabra, los montículos son estructuras de memoria útiles a conocer. "
+"Las uso en algunas aplicaciones, y creo que es bueno tener un módulo 'heap' "
+"alrededor. :-)"
 
 #: ../Doc/library/heapq.rst:312
 msgid "Footnotes"