Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commite46a10e

Browse files
committed
Agregando palabras library/heapq
1 parent0612320 commite46a10e

File tree

2 files changed

+67
-66
lines changed

2 files changed

+67
-66
lines changed

‎dictionaries/library_heapq.txt

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
secuenciador
2+
desapilando

‎library/heapq.po

Lines changed: 65 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ msgstr ""
2121

2222
#:../Doc/library/heapq.rst:2
2323
msgid":mod:`heapq` --- Heap queue algorithm"
24-
msgstr":mod:`heapq` --- Algoritmo de colascon prioridad omontículos"
24+
msgstr":mod:`heapq` --- Algoritmo de colas montículos (*heap*)"
2525

2626
#:../Doc/library/heapq.rst:12
2727
msgid"**Source code:** :source:`Lib/heapq.py`"
@@ -45,11 +45,11 @@ msgid ""
4545
"is that its smallest element is always the root, ``heap[0]``."
4646
msgstr""
4747
"Los montículos son árboles binarios para los cuales cada nodo padre tiene un "
48-
"valor menor o igual que cualquiera de sus hijos.Esta implementación "
49-
"utilizamatrices para las cuales ``heap[k] <= heap[2*k+1]`` y ``heap[k] <= "
50-
"heap[2*k+2]`` para todo *k*, contando los elementos desde cero.Para poder "
51-
"comparar,los elementos inexistentes se consideran infinitos.La propiedad "
52-
"interesantede un montículo es que su elemento más pequeño es siempre la raíz, "
48+
"valor menor o igual que cualquiera de sus hijos. Esta implementación utiliza "
49+
"matrices para las cuales ``heap[k] <= heap[2*k+1]`` y ``heap[k] <=heap[2*k"
50+
"+2]`` para todo *k*, contando los elementos desde cero. Para poder comparar, "
51+
"los elementos inexistentes se consideran infinitos. La propiedad interesante "
52+
"de un montículo es que su elemento más pequeño es siempre la raíz, "
5353
"``heap[0]``."
5454

5555
#:../Doc/library/heapq.rst:26
@@ -63,10 +63,10 @@ msgid ""
6363
"sorting)."
6464
msgstr""
6565
"El API que se presenta a continuación difiere de los algoritmos de los "
66-
"libros de texto en dos aspectos: a) Utilizamos la indexación basada en "
67-
"cero.Esto hace que la relación entre el índice de un nodo y los índices de "
66+
"libros de texto en dos aspectos:(a) Utilizamos la indexación basada en "
67+
"cero. Esto hace que la relación entre el índice de un nodo y los índices de "
6868
"sus hijos sea un poco menos evidente, pero es más adecuado ya que Python "
69-
"utiliza la indexación basada en cero. b) Nuestro método\"pop\"devuelve el "
69+
"utiliza la indexación basada en cero.(b) Nuestro método\"pop\"retorna el "
7070
"elemento más pequeño, no el más grande (llamado\"min heap\" o montículo por "
7171
"mínimo en los libros de texto; un\"max heap\" o montículo por máximos es "
7272
"más común en los textos debido a su idoneidad para la clasificación in situ)."
@@ -77,9 +77,9 @@ msgid ""
7777
"surprises: ``heap[0]`` is the smallest item, and ``heap.sort()`` maintains "
7878
"the heap invariant!"
7979
msgstr""
80-
"Estos dos permiten ver el montículo como una lista Python normal sinsorpresas:"
81-
"``heap[0]`` es el ítem más pequeño, y ``heap.sort()`` mantiene el montículo "
82-
"invariable!"
80+
"Estos dos permiten ver el montículo como una lista Python normal sin "
81+
"sorpresas:``heap[0]`` es el ítem más pequeño, y ``heap.sort()`` mantiene el "
82+
"montículoinvariable!"
8383

8484
#:../Doc/library/heapq.rst:37
8585
msgid""
@@ -97,28 +97,27 @@ msgstr "Las siguientes funciones están provistas:"
9797
#:../Doc/library/heapq.rst:45
9898
msgid"Push the value *item* onto the *heap*, maintaining the heap invariant."
9999
msgstr""
100-
"Empujar el valor *item* en el *montículo*, manteniendo el montículo "
101-
"invariable."
100+
"Empujar el valor *item* en el *heap*, manteniendo el montículo invariable."
102101

103102
#:../Doc/library/heapq.rst:50
104103
msgid""
105104
"Pop and return the smallest item from the *heap*, maintaining the heap "
106105
"invariant. If the heap is empty, :exc:`IndexError` is raised. To access "
107106
"the smallest item without popping it, use ``heap[0]``."
108107
msgstr""
109-
"Desapile o *pop* ydevuelva elartículo más pequeño del *montículo*, "
110-
"manteniendoel montículo invariable.Si el montículo está vacío, :exc:"
111-
"``IndexError`` selanza.Para acceder al elemento más pequeño sin necesidad "
112-
"de desapilar,usa``heap[0]``."
108+
"Desapila o *pop* yretorna elelemento más pequeño del *heap*, manteniendo "
109+
"el montículo invariable. Si el montículo está vacío, :exc:`IndexError` se"
110+
"lanza. Para acceder al elemento más pequeño sin necesidad de desapilar, "
111+
"usa``heap[0]``."
113112

114113
#:../Doc/library/heapq.rst:57
115114
msgid""
116115
"Push *item* on the heap, then pop and return the smallest item from the "
117116
"*heap*. The combined action runs more efficiently than :func:`heappush` "
118117
"followed by a separate call to :func:`heappop`."
119118
msgstr""
120-
"Apila elartículo o *iem* en el montículo, y luego desapila ydevuelve el "
121-
"artículo más pequeño del montículo. La acción combinada se ejecuta más "
119+
"Apila elelemento o *iem* en el montículo, y luego desapila yretorna el "
120+
"elemento más pequeño del montículo. La acción combinada se ejecuta más "
122121
"eficientemente que :func:`heappush` seguido de una llamada separada a :func:"
123122
"`heappop`."
124123

@@ -133,8 +132,8 @@ msgid ""
133132
"*item*. The heap size doesn't change. If the heap is empty, :exc:"
134133
"`IndexError` is raised."
135134
msgstr""
136-
"Desapile ydevuelve elartículo más pequeño del *montículo*, y también apile "
137-
"elnuevo *artículo*. El tamaño del montículo no cambia. Si el montículo está "
135+
"Desapila yretorna elelemento más pequeño del *heap*, y también apile el "
136+
"nuevo *item*. El tamaño del montículo no cambia. Si el montículo está "
138137
"vacío, :exc:`IndexError` se eleva."
139138

140139
#:../Doc/library/heapq.rst:72
@@ -146,7 +145,7 @@ msgid ""
146145
msgstr""
147146
"Esta operación de un solo paso es más eficiente que un :func:`heappop` "
148147
"seguido por :func:`heappush` y puede ser más apropiada cuando se utiliza un "
149-
"montículo de tamaño fijo. La combinación pop/push siempredevuelve un "
148+
"montículo de tamaño fijo. La combinación pop/push siempreretorna un "
150149
"elemento del montículo y lo reemplaza con *item*."
151150

152151
#:../Doc/library/heapq.rst:77
@@ -156,10 +155,9 @@ msgid ""
156155
"combination returns the smaller of the two values, leaving the larger value "
157156
"on the heap."
158157
msgstr""
159-
"El valor devuelto puede ser mayor que el *articulo* añadido. Si no se desea "
160-
"eso, considere usar :func:`heappushpop` en su lugar. Su combinación push/"
161-
"pop devuelve el menor de los dos valores, dejando el mayor valor en el "
162-
"montículo."
158+
"El valor retornado puede ser mayor que el *item* añadido. Si no se desea "
159+
"eso, considere usar :func:`heappushpop` en su lugar. Su combinación push/pop "
160+
"retorna el menor de los dos valores, dejando el mayor valor en el montículo."
163161

164162
#:../Doc/library/heapq.rst:83
165163
msgid"The module also offers three general purpose functions based on heaps."
@@ -174,16 +172,16 @@ msgid ""
174172
"over the sorted values."
175173
msgstr""
176174
"Fusionar varias entradas ordenadas en una sola salida ordenada (por ejemplo, "
177-
"fusionar entradas con marca de tiempo de varios archivos de registro)."
178-
"Devuelva un :term:`iterator` sobre los valores ordenados."
175+
"fusionar entradas con marca de tiempo de varios archivos de registro). "
176+
"Retorna un :term:`iterator` sobre los valores ordenados."
179177

180178
#:../Doc/library/heapq.rst:92
181179
msgid""
182180
"Similar to ``sorted(itertools.chain(*iterables))`` but returns an iterable, "
183181
"does not pull the data into memory all at once, and assumes that each of the "
184182
"input streams is already sorted (smallest to largest)."
185183
msgstr""
186-
"Similar a ``sorted(itertools.chain(*iterables))`` perodevuelve un iterable, "
184+
"Similar a ``sorted(itertools.chain(*iterables))`` peroretorna un iterable, "
187185
"no hala los datos a la memoria de una sola vez, y asume que cada uno de los "
188186
"flujos de entrada ya están ordenado (de menor a mayor)."
189187

@@ -201,7 +199,7 @@ msgid ""
201199
"``None`` (compare the elements directly)."
202200
msgstr""
203201
"*key* especifica una :term:`key function` de un argumento que se utiliza "
204-
"para extraer una clave de comparación de cada elemento de entrada.El valor "
202+
"para extraer una clave de comparación de cada elemento de entrada. El valor "
205203
"por defecto es ``None`` (compara los elementos directamente)."
206204

207205
#:../Doc/library/heapq.rst:102
@@ -211,7 +209,7 @@ msgid ""
211209
"to ``sorted(itertools.chain(*iterables), reverse=True)``, all iterables must "
212210
"be sorted from largest to smallest."
213211
msgstr""
214-
"*reverse* es un valor booleano.Si se establece en ``True``, entonces los "
212+
"*reverse* es un valor booleano. Si se establece en ``True``, entonces los "
215213
"elementos de entrada se fusionan como si cada comparación se invirtiera. "
216214
"Para lograr un comportamiento similar a ``sorted(itertools."
217215
"chain(*iterables), reverse=True)``, todos los iterables deben ser ordenados "
@@ -229,10 +227,10 @@ msgid ""
229227
"example, ``key=str.lower``). Equivalent to: ``sorted(iterable, key=key, "
230228
"reverse=True)[:n]``."
231229
msgstr""
232-
"Devuelve una lista con los *n* elementos más grandes del conjunto de datos "
233-
"definidos por *iterable*.*key*, si se proporciona, especifica una función "
230+
"retorna una lista con los *n* elementos más grandes del conjunto de datos "
231+
"definidos por *iterable*. *key*, si se proporciona, especifica una función "
234232
"de un argumento que se utiliza para extraer una clave de comparación de cada "
235-
"elemento en *iterable* (por ejemplo, ``key=str.lower``).Equivalente a: "
233+
"elemento en *iterable* (por ejemplo, ``key=str.lower``). Equivalente a: "
236234
"``sorted(iterable, key=clave, reverse=True)[:n]``."
237235

238236
#:../Doc/library/heapq.rst:122
@@ -243,10 +241,10 @@ msgid ""
243241
"example, ``key=str.lower``). Equivalent to: ``sorted(iterable, key=key)[:"
244242
"n]``."
245243
msgstr""
246-
"Devuelve una lista con los *n* elementos más pequeños del conjunto de datos "
247-
"definidos por *iterable*.*key*, si se proporciona, especifica una función "
244+
"retorna una lista con los *n* elementos más pequeños del conjunto de datos "
245+
"definidos por *iterable*. *key*, si se proporciona, especifica una función "
248246
"de un argumento que se utiliza para extraer una clave de comparación de cada "
249-
"elemento en *iterable* (por ejemplo, ``key=str.lower``).Equivalente a: "
247+
"elemento en *iterable* (por ejemplo, ``key=str.lower``). Equivalente a: "
250248
"``sorted(iterable, key=clave)[:n]``."
251249

252250
#:../Doc/library/heapq.rst:128
@@ -257,10 +255,10 @@ msgid ""
257255
"`max` functions. If repeated usage of these functions is required, consider "
258256
"turning the iterable into an actual heap."
259257
msgstr""
260-
"Las dos últimas funciones funcionan mejor para valores más pequeños de *n*."
261-
"Para valores más grandes, es más eficiente usar la función :func:`sorted`."
258+
"Las dos últimas funciones funcionan mejor para valores más pequeños de *n*. "
259+
"Para valores más grandes, es más eficiente usar la función :func:`sorted`. "
262260
"Además, cuando ``n==1``, es más eficiente usar las funciones incorporadas :"
263-
"func:`min` y :func:`max``.Si se requiere el uso repetido de estas "
261+
"func:`min` y :func:`max``. Si se requiere el uso repetido de estas "
264262
"funciones, considere convertir lo iterable en un verdadero montículo."
265263

266264
#:../Doc/library/heapq.rst:136
@@ -290,7 +288,7 @@ msgid ""
290288
"Heap elements can be tuples. This is useful for assigning comparison values "
291289
"(such as task priorities) alongside the main record being tracked::"
292290
msgstr""
293-
"Los elementos del montículo pueden ser tuplas.Esto es útil para asignar "
291+
"Los elementos del montículo pueden ser tuplas. Esto es útil para asignar "
294292
"valores de comparación (como las prioridades de las tareas) junto con el "
295293
"registro principal que se está rastreando::"
296294

@@ -312,7 +310,7 @@ msgid ""
312310
"returned in the order they were originally added?"
313311
msgstr""
314312
"Estabilidad de la clasificación: ¿cómo se consigue que dos tareas con "
315-
"iguales prioridades seandevueltas en el orden en que fueron añadidas "
313+
"iguales prioridades seanretornadas en el orden en que fueron añadidas "
316314
"originalmente?"
317315

318316
#:../Doc/library/heapq.rst:175
@@ -350,8 +348,8 @@ msgid ""
350348
msgstr""
351349
"Una solución a los dos primeros desafíos es almacenar las entradas como una "
352350
"lista de 3 elementos que incluya la prioridad, un recuento de entradas y la "
353-
"tarea.El recuento de entradas sirve como un desempate para que dos tareas "
354-
"con la misma prioridad seandevueltas en el orden en que fueron añadidas. Y "
351+
"tarea. El recuento de entradas sirve como un desempate para que dos tareas "
352+
"con la misma prioridad seanretornadas en el orden en que fueron añadidas. Y "
355353
"como no hay dos recuentos de entradas iguales, la comparación tupla nunca "
356354
"intentará comparar directamente dos tareas."
357355

@@ -372,8 +370,8 @@ msgid ""
372370
"with a dictionary pointing to an entry in the queue."
373371
msgstr""
374372
"Los desafíos restantes giran en torno a encontrar una tarea pendiente y "
375-
"hacer cambios en su prioridad o eliminarla por completo.Encontrar una "
376-
"tarease puede hacer con un diccionario que apunta a una entrada en la cola."
373+
"hacer cambios en su prioridad o eliminarla por completo. Encontrar una tarea "
374+
"se puede hacer con un diccionario que apunta a una entrada en la cola."
377375

378376
#:../Doc/library/heapq.rst:205
379377
msgid""
@@ -382,7 +380,7 @@ msgid ""
382380
"mark the entry as removed and add a new entry with the revised priority::"
383381
msgstr""
384382
"Eliminar la entrada o cambiar su prioridad es más difícil porque rompería "
385-
"las invariantes de la estructura del montículo.Por lo tanto, una posible "
383+
"las invariantes de la estructura del montículo. Por lo tanto, una posible "
386384
"solución es marcar la entrada como eliminada y añadir una nueva entrada con "
387385
"la prioridad revisada::"
388386

@@ -399,7 +397,7 @@ msgid ""
399397
msgstr""
400398
"Los montículos son conjuntos para los cuales``a[k] <= a[2*k+1]`` y\"a[k] <= "
401399
"a[2*k+2]`` para todos los *k*, contando los elementos desde 0. Para "
402-
"comparar, los elementos no existentes se consideran infinitos.La "
400+
"comparar, los elementos no existentes se consideran infinitos. La "
403401
"interesante propiedad de un montículo es que ``a[0]`` es siempre su elemento "
404402
"más pequeño."
405403

@@ -409,7 +407,7 @@ msgid ""
409407
"representation for a tournament. The numbers below are *k*, not ``a[k]``::"
410408
msgstr""
411409
"La extraña invariante de arriba intenta ser una representación eficiente de "
412-
"la memoria para un torneo.Los números de abajo son *k*, no``a[k]``::"
410+
"la memoria para un torneo. Los números de abajo son *k*, no``a[k]``::"
413411

414412
#:../Doc/library/heapq.rst:259
415413
msgid""
@@ -426,9 +424,9 @@ msgstr ""
426424
"En el árbol de arriba, cada celda *k* está coronada por ``2*k+1`` y ``2*k"
427425
"+2``. En un torneo binario habitual que vemos en los deportes, cada celda es "
428426
"el ganador sobre las dos celdas que supera, y podemos rastrear al ganador "
429-
"hasta el árbol para ver todos los oponentes que tuvo.Sin embargo, en "
430-
"muchasaplicaciones informáticas de tales torneos, no necesitamos rastrear "
431-
"lahistoria de un ganador. Para ser más eficientes en la memoria, cuando un "
427+
"hasta el árbol para ver todos los oponentes que tuvo. Sin embargo, en muchas "
428+
"aplicaciones informáticas de tales torneos, no necesitamos rastrear la "
429+
"historia de un ganador. Para ser más eficientes en la memoria, cuando un "
432430
"ganador es ascendido, tratamos de reemplazarlo por algo más en un nivel "
433431
"inferior, y la regla se convierte en que una celda y las dos celdas que "
434432
"supera contienen tres elementos diferentes, pero la celda superior\"gana\" "
@@ -445,7 +443,7 @@ msgid ""
445443
"items, you get an O(n log n) sort."
446444
msgstr""
447445
"Si esta invariante del montículo está protegida en todo momento, el índice 0 "
448-
"es claramente el ganador general.La forma algorítmica más simple de "
446+
"es claramente el ganador general. La forma algorítmica más simple de "
449447
"eliminarlo y encontrar el\"próximo\" ganador es mover algún perdedor "
450448
"(digamos la celda 30 en el diagrama de arriba) a la posición 0, y luego "
451449
"filtrar este nuevo 0 por el árbol, intercambiando valores, hasta que la "
@@ -467,11 +465,11 @@ msgstr ""
467465
"Una buena característica de este tipo es que puedes insertar nuevos "
468466
"elementos de manera eficiente mientras se realiza la clasificación, siempre "
469467
"y cuando los elementos insertados no sean\"mejores\" que el último 0'th "
470-
"elemento que has extraído.Esto es especialmente útil en contextos de "
468+
"elemento que has extraído. Esto es especialmente útil en contextos de "
471469
"simulación, donde el árbol contiene todos los eventos entrantes, y la "
472-
"condición de\"ganar\" significa el menor tiempo programado.Cuando un "
470+
"condición de\"ganar\" significa el menor tiempo programado. Cuando un "
473471
"evento programa otros eventos para su ejecución, se programan en el futuro, "
474-
"para que puedan ir fácilmente al montículo.Por lo tanto, un montículo es "
472+
"para que puedan ir fácilmente al montículo. Por lo tanto, un montículo es "
475473
"una buena estructura para implementar planificadores o *schedulers* (esto es "
476474
"lo que usé para mi secuenciador MIDI :-)."
477475

@@ -503,11 +501,11 @@ msgid ""
503501
"which are twice the size of the memory for random input, and much better for "
504502
"input fuzzily ordered."
505503
msgstr""
506-
"Los montículos también son muy útiles en las grandesordenaciónes de "
504+
"Los montículos también son muy útiles en las grandesordenaciones de "
507505
"elementos en discos de memoria. Lo más probable es que todos sepan que un "
508-
"tipo grande implica la producción de\"corridas\" (que son secuencias "
506+
"tipo grande implica la producción de\"ejecuciones\" (que son secuencias "
509507
"preclasificadas, cuyo tamaño suele estar relacionado con la cantidad de "
510-
"memoria de la CPU), seguidas de una fusión de pases para estascorridas, "
508+
"memoria de la CPU), seguidas de una fusión de pases para estasejecuciones, "
511509
"cuya fusión suele estar muy inteligentemente organizada [#]_. Es muy "
512510
"importante que la clasificación inicial produzca las ejecuciones posibles "
513511
"más largas. Los torneos son una buena manera de lograrlo. Si, utilizando "
@@ -531,18 +529,19 @@ msgstr ""
531529
"último valor de salida), no puede caber en el montículo, por lo que el "
532530
"tamaño del montículo disminuye. La memoria liberada podría ser "
533531
"ingeniosamente reutilizada inmediatamente para construir progresivamente un "
534-
"segundo montículo, que crece exactamente al mismo ritmo que el primer montículo se "
535-
"está fundiendo. Cuando el primer montículo se desvanece completamente, se "
536-
"cambia de montículo y se inicia una nueva carrera. ¡Ingenioso y muy efectivo!"
532+
"segundo montículo, que crece exactamente al mismo ritmo que el primer "
533+
"montículo se está fundiendo. Cuando el primer montículo se desvanece "
534+
"completamente, se cambia de montículo y se inicia una nueva carrera. "
535+
"¡Ingenioso y muy efectivo!"
537536

538537
#:../Doc/library/heapq.rst:308
539538
msgid""
540539
"In a word, heaps are useful memory structures to know. I use them in a few "
541540
"applications, and I think it is good to keep a 'heap' module around. :-)"
542541
msgstr""
543-
"En una palabra, los montículos son estructuras de memoria útiles a "
544-
"conocer.Las uso en algunas aplicaciones, y creo que es bueno tener un "
545-
"módulo 'heap'alrededor. :-)"
542+
"En una palabra, los montículos son estructuras de memoria útiles aconocer."
543+
"Las uso en algunas aplicaciones, y creo que es bueno tener un módulo 'heap' "
544+
"alrededor. :-)"
546545

547546
#:../Doc/library/heapq.rst:312
548547
msgid"Footnotes"

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp