Tarea
Usando cualquier tipo de paralelización, espere varios períodos, para un tiempo total de sueño de al menos un minuto (pero menos de un minuto y medio).
El programa / función debe finalizar dentro de los 10 segundos y devolver (por cualquier medio y en cualquier formato) dos valores: el tiempo total transcurrido y el tiempo total de suspensión ejecutado. Ambos valores de tiempo deben tener una precisión de al menos 0.1 segundos.
Esto es similar al concepto de horas hombre : un trabajo que lleva 60 horas se puede completar en solo 6 horas si 10 trabajadores están dividiendo el trabajo. Aquí podemos tener 60 segundos de tiempo de suspensión, por ejemplo, en 10 subprocesos paralelos, lo que requiere solo 6 segundos para completar todo el trabajo.
Ejemplo
El programa MyProgram crea 14 hilos, cada hilo duerme durante 5 segundos:
MyProgram
→ [5.016,70.105]
El tiempo de ejecución es superior a 5 segundos y el tiempo de suspensión total es superior a 70 segundos debido a la sobrecarga.
Respuestas:
Dyalog APL,
65272321 bytesEs decir:
Explicación:
⎕DL&¨9/7
: separa 9 hilos, cada uno de los cuales espera 7 segundos.⎕DL
devuelve la cantidad real de tiempo de espera, en segundos, que será el mismo que su argumento da o toma unos pocos milisegundos.⎕TSYNC
: espere a que se completen todos los hilos y obtenga el resultado de cada hilo.(⌈/,+/)
: devuelve el tiempo de ejecución más largo de un solo subproceso (durante la ejecución de la cual finalizaron todos los demás subprocesos, por lo que este es el tiempo de ejecución real), seguido de la suma del tiempo de ejecución de todos los subprocesos.Pruébalo en línea!
fuente
Python 2, 172 bytes
Esto requiere un sistema operativo con una precisión de tiempo superior a 1 segundo para funcionar correctamente (en otras palabras, cualquier sistema operativo moderno). Se crean 8 hilos que duermen durante 9 segundos cada uno, lo que resulta en un tiempo de ejecución en tiempo real de ~ 9 segundos y un tiempo de ejecución paralelo de ~ 72 segundos.
Aunque la documentación oficial dice que
Thread
debe llamarse al constructor con argumentos de palabras clave, de todos modos tengo precaución y uso argumentos posicionales. El primer argumento (group
) debe serNone
, y el segundo argumento es la función objetivo.nneonneo señaló en los comentarios que el acceso al atributo (p
f.t
. ej. ) es más corto que el acceso al índice de la lista (pt[0]
. ej .). Desafortunadamente, en la mayoría de los casos, los pocos bytes obtenidos al hacer esto se perderían al necesitar crear un objeto que permita crear atributos definidos por el usuario en tiempo de ejecución. Afortunadamente, las funciones admiten atributos definidos por el usuario en tiempo de ejecución, por lo que aprovecho esto al guardar el tiempo total en elt
atributo def
.Pruébalo en línea
Gracias a DenkerAffe por -5 bytes con el
exec
truco.Gracias a kundor por -7 bytes al señalar que el argumento del hilo es innecesario.
Gracias a nneonneo por -7 bytes de mejoras diversas.
fuente
f()
y los dos últimos argumentosThread
(eliminando así 7 caracteres) y utilizandot.append(m()-n)
para evitar asignar una variable localt
(utilizando 5 caracteres más que+=
.)t
cont=[0]
, reemplazar el agregar port[0]+=m()-n
y reemplazarsum(t)
port[0]
.import threading as H,time as t
; guardar otros dos bytes usandoz=H.Thread
ymap(z.join,r)
; ahorre otros dos bytes escondiendo el tiempo total como un atributo (por ejemploT.z+=m()-n
)Bash + utilidades GNU, 85
Fuerza el uso del
time
ejecutable en lugar del shell incorporado al prefijar con a\
.Se agrega a un archivo
j
, que debe estar vacío o inexistente al inicio.fuente
if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fi
o algo así? ¿Sería eso contrario a las reglas o algo que no entiendo sobre las especificaciones? [editar; Perdí el requisito de salida. ¡Oh, eso lo hace interesante!](($1<9))&&$0 $[$1+1]&sleep 7
Ir - 189 bytes
Gracias @cat!
Salidas (ms): 160.9939ms, 60001 (160ms para esperar 60.001 segundos)
fuente
@Rob In some languages the obvious solution is already (close to) the shortest. Besides, one way to view code-golf challenges is finding the shortest solution in EACH language. Otherwise Jelly will win most of the time... So: go ahead.
no significa que no debas intentar descifrar tu respuesta, sino que está bien si no gana. ¿Puedes por favor agregar una solución de golf?tot
a algo asíq
.Bash
19611711493 bytesActualizado para admitir una mejor precisión de tiempo mediante la integración de sugerencias de @manatwork y @Digital Trauma, así como algunas otras optimizaciones de espacio:
Tenga en cuenta que esto supone que el
j
archivo está ausente al principio.fuente
function s
→s()
,b=`date +%s`
→b=$SECONDS
,expr $t + $i
→$[t+i]
,`cat j`
→$(<j)
y, en general, vea Consejos para jugar golf en Bash sobre cómo reducirlo a esto: pastebin.com/DDqUaDug5↵5↵5↵…
escribir+5+5+5…
, luego cargarlo todo directamente en la evaluación aritmética y ahorrar el segundo bucle: pastebin.com/LB0BjDMZb=`date +%s`
→b=$SECONDS
.bash
que la aritmética de enteros, toda la solución debe reescribirse para usar una herramienta externa para el cálculo. Por lo generalbc
: pastebin.com/eYFEVUuzJavaScript (ES6), 148 bytes
Promete esperar 9 veces durante 7 segundos por un total de 63 segundos (en realidad 63.43 cuando lo intento), pero solo toma 7.05 segundos de tiempo real cuando lo intento.
fuente
C, 127 bytes (gira la CPU)
Esta solución hace girar la CPU en lugar de dormir, y cuenta el tiempo usando la
times
función POSIX (que mide el tiempo de CPU consumido por el proceso padre y en todos los niños esperados).Bifurca 7 procesos que giran durante 9 segundos cada uno e imprime los tiempos finales en los relojes C (en la mayoría de los sistemas, 100 tics de reloj = 1 segundo).
Salida de muestra:
es decir, 9,06 segundos en tiempo real y 63,47 segundos de tiempo total de CPU.
Para obtener mejores resultados, compile con
-std=c90 -m32
(forzar código de 32 bits en una máquina de 64 bits).fuente
PowerShell v4, 144 bytes
Establece
$d
igual aGet-Date
, y borra cualquier historial de trabajo existente conGet-Job | Remove-Job
. Luego realizamos un ciclo1..20|%{...}
y cada iteración se ejecutaStart-Job
pasándole el bloque de script{$x=date;sleep 3;((date)-$x).ticks/1e7}
para el trabajo (lo que significa que cada trabajo ejecutará ese bloque de script). Canalizamos esa salida para>$null
suprimir la retroalimentación (es decir, nombre del trabajo, estado, etc.) que se devuelve.El bloque de secuencia de comandos se establece
$x
enGet-Date
, luegoStart-Sleep
durante3
segundos, luego toma una nuevaGet-Date
lectura, resta$x
, obtiene el.Ticks
y divide por1e7
para obtener los segundos (con precisión).De vuelta en el hilo principal, siempre y cuando cualquier trabajo siga siendo
-S
tatus"Running"
, giramos dentro de unwhile
bucle vacío . Una vez hecho esto, debemosGet-Job
extraer los objetos para todos los trabajos existentes, canalizar aquellos a losReceive-Job
que extraerá el equivalente de STDOUT (es decir, lo que generan),-join
los resultados junto con+
, y canalizarlo aiex
(Invoke-Expression
y similar aeval
). Esto generará el tiempo de suspensión resultante más los gastos generales.La línea final es similar, ya que obtiene una nueva fecha, resta el sello de fecha original
$d
, obtiene el.Ticks
y divide por1e7
para generar el tiempo total de ejecución.nótese bien
Bien, esto es un poco incómodo con las reglas. Aparentemente, en la primera ejecución, PowerShell necesita cargar un conjunto de ensamblados .NET desde el disco para las diversas operaciones de subproceso, ya que no se cargan con el perfil de shell predeterminado. Las ejecuciones posteriores , debido a que los ensamblados ya están en la memoria, funcionan bien. Si deja la ventana de shell inactiva el tiempo suficiente, obtendrá la recolección de basura incorporada de PowerShell y descargará todos esos ensamblajes, lo que hará que la próxima ejecución tarde mucho tiempo ya que los vuelve a cargar. No estoy seguro de una forma de evitar esto.
Puede ver esto en los tiempos de ejecución en las siguientes ejecuciones. Comencé un nuevo shell, navegué a mi directorio de golf y ejecuté el script. La primera ejecución fue horrenda, pero la segunda (ejecutada inmediatamente) funcionó bien. Luego dejé el shell inactivo durante unos minutos para dejar pasar la recolección de basura, y luego esa ejecución es nuevamente larga, pero las ejecuciones posteriores nuevamente funcionan bien.
Ejecuciones de ejemplo
fuente
Javascript (ES6),
212203145 bytesEste código crea 10 imágenes con un intervalo de tiempo de exactamente 6 segundos cada una, al cargarse.
El tiempo de ejecución va un poco por encima (debido a la sobrecarga).
¡Este código sobrescribe todo en el documento!
Esto supone que usa una codificación de un solo byte para los backticks, lo cual es necesario para que el motor Javascript no se dispare.
Alternativamente, si no desea pasar 6 segundos esperando, aquí hay una solución de 1 byte más que termina en menos de un segundo:
La diferencia es que este código espera 600 ms en 100 imágenes. Esto le dará una gran cantidad de gastos generales.
Versión anterior (203 bytes):
Este código crea 10 iframes con un intervalo de tiempo de exactamente 6 segundos cada uno, en lugar de crear 10 imágenes.
Versión original (212 bytes):
fuente
Ruby, 92
fuente
Javascript (ES6),
10892 bytesEstoy haciendo una nueva respuesta ya que esto utiliza un enfoque ligeramente diferente.
Genera una cantidad masiva de
setTimeout
s, que casi todos se ejecutan con 4 ms entre ellos.Cada intervalo es de 610 milisegundos, en un total de 99 intervalos.
Por lo general, se ejecuta dentro de 610 ms, para un tiempo de ejecución total de alrededor de 60.5 segundos.
Esto se probó en Google Chrome versión 51.0.2704.84 m, en Windows 8.1 x64.
Versión anterior (108 bytes):
fuente
Scratch - 164 bytes (16 bloques)
Véalo en acción aquí .
Utiliza una variable llamada 't' y un sprite llamado 's'. El sprite crea clones de sí mismo, cada uno de los cuales espera 8 segundos, e incrementa una variable que registra el tiempo de espera completo. Al final dice el tiempo total de ejecución y el tiempo total de espera (por ejemplo
65.488 8.302
).fuente
Clojure,
135120111109 bytesVersión formateada con variables con nombre:
salida (en nanosegundos):
Se modificó el formato. Gracias Adám, podría haber perdido esa especificación de formato en la pregunta cuando la leí.
Cambiado a nanoTime para habilidades de golf.
Gracias cliffroot, me olvidé por completo de la notación científica y no puedo creer que no haya visto
apply
. Creo que usé eso en algo que estaba jugando al golf ayer pero que nunca publiqué. Me salvaste 2 bytes.fuente
7e3
lugar de7000
y usar enapply
lugar dereduce
Óxido,
257, 247 bytesYo uso las mismas veces que la respuesta Python de Mego.
Realmente, el único bit ligeramente inteligente es usar ii para obtener una duración de 0 segundos.
Huellas dactilares:
Sin golf:
Editar: bueno para el bucle es un poco más corto
fuente
JavaScript (ES6, utilizando WebWorkers),
233215 bytesUPD: reemplazó la forma en que un trabajador se ejecuta desde una cadena por una más compacta y de navegador cruzado, en el aspecto de las políticas de origen cruzado. No funcionará en Safari, si todavía tiene un
webkitURL
objeto en lugar deURL
, y en IE.fuente
{ "message": "Uncaught SecurityError: Failed to construct 'Worker': Script at 'data:application/javascript,a%3Dnew%20Date()%3BsetTimeout(()%3D%3EpostMessage(new%20Date()-a)%2C5e3)' cannot be accessed from origin 'null'.", "filename": "http://stacksnippets.net/js", "lineno": 13, "colno": 45 }
Python 2, 130 bytes
Esta es una derivación de la respuesta de Mego, pero es lo suficientemente diferente como para pensar que debería ser una respuesta separada. Está probado para funcionar en Windows.
Básicamente, bifurca 9 hilos, que duermen durante 7 segundos mientras el padre duerme durante 8. Luego imprime los tiempos. Salida de muestra:
En Windows,
time.clock
mide el tiempo de pared desde la primera llamada.fuente
time.clock()
comporta de manera diferente entre las plataformas Windows y UNIX / Linux .Perl 6,
7271 bytesPuede haber una forma más corta de hacer esto
esto produce
fuente
Mathematica, 109 bytes
Función anónima. Requiere una licencia con más de 7 sub-núcleos para ejecutarse. Toma 9 segundos en tiempo real y 63 segundos en tiempo de kernel, sin tener en cuenta los gastos generales. Asegúrese de ejecutar solo las declaraciones anteriores una vez (para que no intente reiniciar los núcleos). Pruebas:
fuente
Javascript (ES6), 105 bytes
Versión actualizada: 106 bytes Prestada de @Ismael Miguel ya que tuvo la gran idea de reducir el tiempo de sueño y aumentar los intervalos.
Javascript Ungolfed, 167 bytes
fuente
d+=t()-s;if(!c)alert([t()-i,d])
, puede escribird+=t()-s;c||alert([t()-i,d])
, lo que ahorrará algunos bytes. Además, si se quita la función y volver a escribir todo, puede competir con mi solución a largo 92 bytes:for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t())
. Y sí, este también tiene 92 bytes de longitud.Java,
358343 337 316313 bytesy sin golf
no lo intentes en casa, ya que esta solución no es segura para subprocesos.
Editar:
Tomé las sugerencias de @A Boschman y @ Adám, y ahora mi programa requiere menos de 10 segundos para ejecutarse, y es más corto en 15 bytes.
fuente
Thread.
llamadas al método estático sleep ()? Además, ¿este programa no terminará en poco más de 10 segundos, descalificándolo?static long t
. Solo menciono esto porque la especificación dice "Ambos valores de tiempo deben tener una precisión de al menos 0.1 segundos".long
antess
y agregar,s
alstatic long t,i,s;
para guardar algunos bytes.C (con subprocesos),
339336335 bytesfuente
C90 (OpenMP), 131 Bytes (+ 17 para la variable env) = 148 Bytes
Salida de ejemplo:
Notas:
7091 está en ciclos (100 / seg), por lo que el programa se ejecutó durante 70 segundos
Podría ser mucho más corto si descubriera una forma de hacer que un temporizador funcione aparte de omp_get_wtime () porque entonces también podría eliminar la declaración de inclusión.
Ejecutar con OMP_NUM_THREADS = 9
fuente
Lisp común (SBCL) 166 bytes:
Esto solo genera hilos que duermen y luego aumentan atómicamente el tiempo necesario, con un bucle externo que gira esperando que el tiempo total sea más de 60000 tics (es decir, 60 s en sbcl). El contador se almacena en una lista debido a limitaciones en los tipos de lugares que atomic-incf puede modificar. Esto puede quedarse sin espacio antes de terminar en máquinas más rápidas.
Sin golf:
fuente
Perl, 101 bytes
Bifurca 7 procesos secundarios, cada uno de los cuales espera 9 segundos.
Salida de muestra:
fuente
Groovy,
158143 caracteresEjecución de muestra:
fuente
Elixir, 168 bytes
Ejecución de muestra:
La salida es el tiempo total esperado seguido por el tiempo que el programa se ha ejecutado, en microsegundos.
El programa genera 14
Task
s, y espera a cada uno de ellos mediante un mapeo sobre ellos, y luego encuentra la suma de su tiempo transcurrido. Utiliza Erlang'stimer
para medir el tiempo.fuente
Haskell,
278271262246 bytes!
mide el tiempo empleado por la accióna
(segundo argumento) y se aplicab
(primer argumento) al resultado.w
Es la función del sueño.main
se mide y el resultado se imprime (print!...
).#
es decirreplicateM
, repitiendo la acción dada N veces (y regresandot
debido al golf).Dentro de la parte medida, 9 hilos (
replicate 9 $ forkIO ...
) duermen durante5^10
milisegundos (9.765625 segundos) y publican el resultado (writeChan
) en una tubería creada por el hilo principal (newChan
), que suma los 9 resultados e imprime el total (getChanContents >>= print . sum . take 9
).Salida:
fuente
Python 2, 132 bytes
Utiliza un grupo de procesos para generar 9 procesos y dejar que cada uno duerma durante 7 segundos.
Imprime el tiempo de sueño total acumulado primero, luego el tiempo de ejecución real:
fuente
Rubí (con
parallel
gema),123116bytesEditar: se agregó la referencia "Time.now" de la respuesta Ruby de histocrat.
fuente
Matlab, 75 bytes
Explicación rápida:
parfor
crea un bucle for paralelo, distribuido en el grupo de trabajadores.tic
ytoc
medir el tiempo transcurrido (y en mi opinión son una de las funciones mejor nombradas en MATLAB). La última línea (una matriz con el tiempo total dormido y el tiempo real transcurrido) se emite ya que no termina con un punto y coma.Sin embargo, tenga en cuenta que esto crea la friolera de 9 procesos MATLAB completos. Es probable que este programa en particular no termine dentro de los 10 segundos asignados en su máquina. Sin embargo, creo que con una instalación de MATLAB que no tiene cajas de herramientas a excepción de la caja de herramientas de Computación Paralela instalada, instalada en un sistema de alta gama con SSD, es posible que pueda terminar en 10 segundos. Si es necesario, puede ajustar los parámetros para que menos procesos duerman más.
fuente
b
probablemente se deba a que ya tenía algo en su espacio de trabajo. No tengo problemas con 2015b usandoparfor q=b