Espere um minuto - em menos de dez segundos

69

Tarefa

Usando qualquer tipo de paralelização, aguarde vários períodos, para um tempo total de sono de pelo menos um minuto (mas menos de um minuto e meio).

O programa / função deve terminar em 10 segundos e retornar (por qualquer meio e em qualquer formato) dois valores: o tempo total decorrido e o tempo total de suspensão executado. Ambos os valores de tempo devem ter uma precisão de pelo menos 0,1 segundos.

Isso é semelhante ao conceito de horas de trabalho: um trabalho que leva 60 horas pode ser concluído em apenas 6 horas se 10 trabalhadores estiverem dividindo o trabalho. Aqui podemos ter 60 segundos de tempo de suspensão, por exemplo, em 10 threads paralelos, exigindo apenas 6 segundos para que todo o trabalho seja concluído.

Exemplo

O programa MyProgram cria 14 threads, cada thread dorme por 5 segundos:

MyProgram[5.016,70.105]

O tempo de execução é maior que 5 segundos e o tempo total de suspensão é maior que 70 segundos devido a sobrecarga.

Adão
fonte
2
Eu li a pergunta várias vezes e não entendi. Você pode esclarecer um pouco? Por que "10 segundos" e um atraso de "70 segundos"? Como todos esses tempos estão relacionados?
Luis Mendo
3
Quantos threads podemos assumir que serão executados em paralelo?
milhas
3
Que precisão é necessária para o tempo de saída?
Edc65
20
Gostaria de saber se isso fará com que todos os autores da linguagem do golfe se envolvam em uma corrida louca para adicionar multi-threading às suas criações ...
Adám
3
@NoOneIsHere Ah, bem, um método de suspensão implementado corretamente não deve ocupar um núcleo; portanto, o número de threads pode exceder o número de processadores (virtuais).
Adám 16/06/16

Respostas:

15

Dyalog APL, 65 27 23 21 bytes

(⌈/,+/)⎕TSYNC⎕DL&¨9/7

Ou seja:

      (⌈/,+/)⎕TSYNC⎕DL&¨9/7
7.022 63.162

Explicação:

  • ⎕DL&¨9/7: desmonte 9 threads, cada um deles aguardando 7 segundos. ⎕DLretorna a quantidade real de tempo gasto em espera, em segundos, que será o mesmo que seu argumento em alguns milissegundos.
  • ⎕TSYNC: aguarde a conclusão de todos os threads e obtenha o resultado para cada thread.
  • (⌈/,+/): retorna o tempo de execução mais longo de um único encadeamento (durante a execução em que todos os outros encadeamentos terminaram, portanto esse é o tempo de execução real), seguido pela soma do tempo de execução de todos os encadeamentos.

Experimente online!

marinus
fonte
Isso não funcionará se executado às 23:59:57. No entanto, você está no caminho certo ... Enquanto você já é o mais baixo, pode jogar fora outros 40 bytes?
Adám 16/06/16
11
@ Adám: não, mas posso jogar 38 bytes de distância. É bastante óbvio, não sei por que não pensei nisso da primeira vez.
marinus
Ai está. Apenas mais 6 bytes até você receber uma marca de seleção. As três coisas que você precisa fazer também são bastante óbvias, economizando 1, 2 e 3 bytes, respectivamente.
Adám 16/06/16
Muito bom, você encontrou o número 1 e o número 3. O número 2 não é realmente um jogo de golfe, mas uma alternativa de implementação ...
Adám
Número 2: Como você não precisa de argumentos, basta transformá-lo em um corpo tfn.
Adám 17/06/16
18

Python 2, 172 bytes

import threading as H,time as T
m=T.time
z=H.Thread
s=m()
r=[]
def f():n=m();T.sleep(9);f.t+=m()-n
f.t=0
exec"r+=[z(None,f)];r[-1].start();"*8
map(z.join,r)
print m()-s,f.t

Isso requer um sistema operacional com precisão de tempo maior que 1 segundo para funcionar corretamente (em outras palavras, qualquer sistema operacional moderno). São criados 8 threads que dormem por 9 segundos cada, resultando em um tempo de execução em tempo real de ~ 9 segundos e em um tempo de execução paralelo de ~ 72 segundos.

Embora a documentação oficial diga que o Threadconstrutor deve ser chamado com argumentos de palavra-chave, atento ao vento e uso argumentos posicionais de qualquer maneira. O primeiro argumento ( group) deve ser Nonee o segundo argumento é a função de destino.

nneonneo apontou nos comentários que atribuir acesso (por exemplo f.t) é menor que o acesso ao índice de lista (por exemplo t[0]). Infelizmente, na maioria dos casos, os poucos bytes obtidos com isso seriam perdidos pela necessidade de criar um objeto que permita a criação de atributos definidos pelo usuário em tempo de execução. Felizmente, as funções suportam atributos definidos pelo usuário em tempo de execução, então eu exploro isso economizando o tempo total no tatributo de f.

Experimente online

Graças à DenkerAffe por -5 bytes com o exectruque.

Graças ao kundor por -7 bytes, apontando que o argumento do thread é desnecessário.

Graças a nneonneo por -7 bytes de melhorias diversas.

Mego
fonte
Você pode salvar dois bytes, removendo o argumento para f(), e os dois últimos argumentos para Thread(assim removendo 7 caracteres) e usando t.append(m()-n)para evitar a atribuição de uma variável local t(usando 5 mais personagens do que +=.)
Nick Matteo
E você pode economizar mais cinco mantendo a soma em vez de uma lista de horários: inicialize tcom t=[0], substitua o anexo por t[0]+=m()-ne substitua sum(t)por t[0].
Nick Matteo
Os nomes de threads podem ser omitidos.
pppery
@ppperry: não se você precisa usar os argumentos posicionais subseqüentes (. Mas como eu mencionei em comentários anteriores, você pode realmente elidir aqueles)
Nick Matteo
Salve três bytes usando import threading as H,time as t; salve mais dois bytes usando z=H.Threade map(z.join,r); salvar mais dois bytes por stashing o tempo total como um atributo (por exemplo T.z+=m()-n)
nneonneo
11

Utilitários Bash + GNU, 85

\time -f%e bash -c 'for i in {1..8};{ \time -aoj -f%e sleep 8&};wait'
paste -sd+ j|bc

Força o uso do timeexecutável em vez do shell incorporado, prefixando com a \.

Anexa a um arquivo j, que deve estar vazio ou inexistente no início.

Trauma Digital
fonte
Que tal um script de bifurcação; if [ $1 -lt 9 ];then { ./a $(( $1 + 1 )) &};sleep 7;fiou algo assim? Isso seria contra as regras, ou algo que eu não estou entendendo sobre as especificações? [editar; Perdi o requisito de saída. Ooh, que o torna interessante]!
Dewi Morgan
11
@DewiMorgan Sim, o requisito de saída o torna um pouco mais difícil. O que você sugere pode ser jogado para algo como(($1<9))&&$0 $[$1+1]&sleep 7
Digital Trauma
9

Ir - 189 bytes

Obrigado @cat!

package main
import(."fmt";."time");var m,t=60001,make(chan int,m);func main(){s:=Now();for i:=0;i<m;i++{go func(){Sleep(Millisecond);t<-0}()};c:=0;for i:=0;i<m;i++{c++};Print(Since(s),c)}

Saídas (ms): 160.9939ms, 60001 (160ms para aguardar 60.001 segundos)

Roubar
fonte
11
Olá, e bem-vindo ao PPCG! Esse comentário @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.,, não significa que você não deve tentar dar um tapa na sua resposta, mas que tudo bem se não vencer. Você pode adicionar uma solução de golfe?
NoOneIsHere
Sinto muito, acabei de ler sua edição. Para os jogadores de golfe, talvez você possa remover novas linhas e espaços ou mudar totpara algo como q.
NoOneIsHere
@NoOneIsHere, obrigado por isso, eu tinha esquecido completamente essa variável! Também bateu juntos me.
Rob
11
codebeautify.org/javaviewer - click minify
cat
8

Bash 196 117 114 93 bytes

Atualizado para oferecer melhor precisão do tempo, integrando sugestões do @manatwork e do @Digital Trauma, além de algumas outras otimizações de espaço:

d()(date +$1%s.%N;)
b=`d`
for i in {1..8};{ (d -;sleep 8;d +)>>j&}
wait
bc<<<`d`-$b
bc<<<`<j`

Observe que isso pressupõe que o jarquivo está ausente no início.

Julie Pelletier
fonte
2
function ss(), b=`date +%s`b=$SECONDS, expr $t + $i$[t+i], `cat j`$(<j)e geralmente consulte Dicas para jogar golfe no Bash sobre como reduzi-lo a isso: pastebin.com/DDqUaDug
manatwork
Para reduzir ainda mais, é melhor escrever diretamente uma fórmula no arquivo j. Quero dizer, em vez de 5↵5↵5↵…escrever +5+5+5…- carregue tudo diretamente na avaliação aritmética e poupe o segundo loop: pastebin.com/LB0BjDMZ
manatwork
Como a precisão mínima foi especificada mais tarde, esqueça a sugestão b=`date +%s`b=$SECONDS.
manatwork
11
Assim como a basharitmética inteira, toda a solução precisa ser reescrita para usar uma ferramenta externa para cálculo. Normalmente bc: pastebin.com/eYFEVUuz
manatwork
11
@JuliePelletier Ok, vou publicá-la como minha própria resposta. Ainda assim, acho que você ainda pode aplicar algumas das técnicas de golfe à sua resposta sem alterar significativamente a abordagem: pastebin.com/ssYzVs1n (93 bytes)
Digital Trauma
8

JavaScript (ES6), 148 bytes

with(performance)Promise.all([...Array(9)].map(_=>new Promise(r=>setTimeout(_=>r(t+=now()),7e3,t-=now())),t=0,n=now())).then(_=>alert([now()-n,t]));

Promete esperar 9 vezes por 7 segundos, durante um total de 63 segundos (na verdade 63,43 quando tento), mas na verdade leva apenas 7,05 segundos em tempo real quando tento.

Neil
fonte
8

C, 127 bytes (gira a CPU)

Essa solução gira a CPU em vez de dormir e conta o tempo usando a timesfunção POSIX (que mede o tempo da CPU consumido pelo processo pai e em todos os filhos esperados).

Ele realiza 7 processos, que são girados por 9 segundos cada, e imprime os tempos finais nos relógios C (na maioria dos sistemas, 100 tiques = 1 segundo).

t;v[4];main(){fork(fork(fork(t=time(0))));while(time(0)<=t+9);wait(0);wait(0);wait(0)>0&&(times(v),printf("%d,%d",v[0],v[2]));}

Saída de amostra:

906,6347

ou seja, 9,06 segundos em tempo real e 63,47 segundos no tempo total da CPU.

Para obter melhores resultados, compile com -std=c90 -m32(force o código de 32 bits em uma máquina de 64 bits).

nneonneo
fonte
5

PowerShell v4, 144 bytes

$d=date;gjb|rjb
1..20|%{sajb{$x=date;sleep 3;((date)-$x).Ticks/1e7}>$null}
while(gjb -s "Running"){}(gjb|rcjb)-join'+'|iex
((date)-$d).Ticks/1e7

Define $digual a Get-Datee limpa todos os históricos de trabalhos existentes Get-Job | Remove-Job. Em seguida, fazemos um loop 1..20|%{...}e cada iteração é executada Start-Jobpassando o bloco de scripts {$x=date;sleep 3;((date)-$x).ticks/1e7}para o trabalho (o que significa que cada trabalho executará esse bloco de script). Canalizamos essa saída para >$nullsuprimir o feedback (nome do trabalho, status etc.) que é retornado.

O bloco de script define $xcomo Get-Date, então, Start-Sleeppor 3segundos, em seguida, recebe uma nova Get-Dateleitura, subtrai $x, obtém o .Tickse divide por 1e7para obter os segundos (com precisão).

De volta à thread principal, desde que qualquer trabalho ainda seja -Sobrigatório "Running", giramos dentro de um whileloop vazio . Uma vez feito isso, Get-Jobpuxamos objetos para todos os trabalhos existentes, canalizamos aqueles para os Receive-Jobquais o equivalente a STDOUT (ou seja, o que eles produzem), -joinos resultados juntos +, e canalizamos iex( Invoke-Expressione semelhante a eval). Isso produzirá o tempo de suspensão resultante mais a sobrecarga.

A linha final é semelhante, na medida em que obtém uma nova data, subtrai o carimbo de data original $d, obtém o .Tickse divide por 1e7para gerar o tempo total de execução.


NB

OK, então isso é um pouco flexível das regras. Aparentemente, na primeira execução, o PowerShell precisa carregar vários assemblies .NET do disco para as várias operações de encadeamento, pois elas não são carregadas com o perfil de shell padrão. Execuções subseqüentes , porque os assemblies já estão na memória, funcionam bem. Se você deixar a janela do shell inativa por tempo suficiente, você fará com que a coleta de lixo interna do PowerShell apareça e descarregue todos esses assemblies, fazendo com que a próxima execução demore muito tempo enquanto ela é carregada novamente. Eu não tenho certeza de uma maneira de contornar isso.

Você pode ver isso nos tempos de execução nas execuções abaixo. Comecei um novo shell, naveguei para o meu diretório de golfe e executei o script. A primeira corrida foi horrenda, mas a segunda (executada imediatamente) funcionou bem. Em seguida, deixei o shell inativo por alguns minutos para permitir a coleta de lixo e, em seguida, essa execução é novamente demorada, mas as execuções subseqüentes novamente funcionam bem.

Execuções de exemplo

Windows PowerShell
Copyright (C) 2014 Microsoft Corporation. All rights reserved.

PS H:\> c:

PS C:\> cd C:\Tools\Scripts\golfing

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
63.232359
67.8403415

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.0809705
8.8991164

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
62.5791712
67.3228933

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.1303589
8.5939405

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.3210352
8.6386886

PS C:\Tools\Scripts\golfing>
AdmBorkBork
fonte
11
Eu vou dizer que está bem. :-)
Adám
5

Javascript (ES6), 212 203 145 bytes

Esse código cria 10 imagens com um intervalo de tempo de exatamente 6 segundos cada, após o carregamento.

O tempo de execução vai um pouco acima dele (devido à sobrecarga).

Este código substitui tudo no documento!

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,6e3) >'.repeat(i=10)

Isso pressupõe que você use uma codificação de byte único para os backticks, necessária para o mecanismo Javascript não desarmar.


Como alternativa, se você não quiser esperar 6 segundos, aqui está uma solução de 1 byte a mais que termina em menos de um segundo:

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,600) >'.repeat(i=100)

A diferença é que esse código espera 600ms em 100 imagens. Isso dará uma enorme quantidade de sobrecarga.


Versão antiga (203 bytes):

Esse código cria 10 iframes com um intervalo de tempo de exatamente 6 segundos cada, em vez de criar 10 imagens.

for(P=performance,M=P.now(T=Y=i=0),D=document,X=_=>{T+=_,--i||alert([P.now()-M,T])};i<10;i++)I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)


Versão original (212 bytes):

P=performance,M=P.now(T=Y=0),D=document,X=_=>{T+=_,Y++>8&&alert([P.now()-M,T])},[...''+1e9].map(_=>{I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)})

Ismael Miguel
fonte
2
+1 Abordagem muito agradável e diferente. O que aconteceria em um navegador de thread único?
Adám 16/06/16
2
@ Adám Nenhuma mudança de comportamento. Ainda haveria um atraso de cerca de 6 segundos. Às vezes, o Firefox (um navegador de thread único) produz coisas engraçadas, como um tempo de execução de 59999. <algo>.
Ismael Miguel
4

Ruby, 92

n=->{Time.now}
t=n[]
a=0
(0..9).map{Thread.new{b=n[];sleep 6;a+=n[]-b}}.map &:join
p n[]-t,a
histocrata
fonte
4

Javascript (ES6), 108 92 bytes

Estou fazendo uma nova resposta, pois isso usa uma abordagem um pouco diferente.

Ele gera uma quantidade enorme de setTimeouts, que são quase todos executados com 4ms entre eles.

Cada intervalo é de 610 milissegundos, em um total de 99 intervalos.

M=(N=Date.now)(T=Y=0),eval('setTimeout("T+=N()-M,--i||alert([N()-M,T])",610);'.repeat(i=99))

Geralmente, é executado em 610ms, para um tempo total de execução de cerca de 60,5 segundos.

Isso foi testado no Google Chrome versão 51.0.2704.84 m, no Windows 8.1 x64.


Versão antiga (108 bytes):

P=performance,M=P.now(T=Y=0),eval('setTimeout("T+=P.now()-M,--i||alert([P.now()-M,T])",610);'.repeat(i=99))

Ismael Miguel
fonte
4

Scratch - 164 bytes (16 blocos)

when gf clicked
set[t v]to[
repeat(9
  create clone of[s v
end
wait until<(t)>[60
say(join(join(t)[ ])(timer
when I start as a clone
wait(8)secs
change[t v]by(timer

Script visual

Veja em ação aqui .

Usa uma variável chamada 't' e um sprite chamado 's'. O sprite cria clones de si mesmo, cada um deles aguardando 8 segundos, e incrementa uma variável com o tempo inteiro de espera. No final, indica o tempo total de execução e o tempo total de espera (por exemplo 65.488 8.302).

Scimonster
fonte
4

Clojure, 135 120 111 109 bytes

(let[t #(System/nanoTime)s(t)f #(-(t)%)][(apply +(pmap #(let[s(t)](Thread/sleep 7e3)%(f s))(range 9)))(f s)])

Versão formatada com variáveis ​​nomeadas:

(let [time #(System/currentTimeMillis)
      start (time)
      fmt #(- (time) %)]
  [(apply +
           (pmap #(let [thread-start (time)]
                   (Thread/sleep 7e3)
                   %
                   (fmt thread-start)) (range 9)))
   (fmt start)])

saída (em nanossegundos):

[62999772966 7001137032]

Formato alterado. Obrigado Adám, eu poderia ter perdido essa especificação de formato na pergunta quando a li.

Alterado para nanoTime para habilidades de golfe.

Obrigado, cliffroot, esqueci completamente a notação científica e não acredito que não vi apply. Acho que usei isso em algo que jogava golfe ontem, mas nunca postei. Você me salvou 2 bytes.

Chris F
fonte
Bem-vindo ao PPCG! Bom primeiro post! Você pode perguntar ao OP sobre o formato de saída.
Rɪᴋᴇʀ
Não há necessidade de reverter. OP: por qualquer meio e em qualquer formato .
Adám 19/06/2016
Parece que você pode usar 7e3em vez de 7000e usar applyem vez dereduce
cliffroot
3

Ferrugem, 257 , 247 bytes

Uso os mesmos tempos da resposta Python do Mego.

Realmente, o único bit um pouco inteligente é usar ii para obter uma duração de 0 segundos.

fn main(){let n=std::time::Instant::now;let i=n();let h:Vec<_>=(0..8).map(|_|std::thread::spawn(move||{let i=n();std::thread::sleep_ms(9000);i.elapsed()})).collect();let mut t=i-i;for x in h{t+=x.join().unwrap();}print!("{:?}{:?}",t,i.elapsed());}

Impressões:

Duration { secs: 71, nanos: 995877193 }Duration { secs: 9, nanos: 774491 }

Ungolfed:

fn main(){
    let n = std::time::Instant::now;
    let i = n();
    let h :Vec<_> =
        (0..8).map(|_|
            std::thread::spawn(
                move||{
                    let i = n();
                    std::thread::sleep_ms(9000);
                    i.elapsed()
                }
            )
        ).collect();
    let mut t=i-i;
    for x in h{
        t+=x.join().unwrap();
    }
    print!("{:?}{:?}",t,i.elapsed());
}

Edit: bom velho para loop é um pouco mais curto

esfarrapado
fonte
3

JavaScript (ES6, usando WebWorkers), 233 215 bytes

c=s=0;d=new Date();for(i=14;i-->0;)(new Worker(URL.createObjectURL(new Blob(['a=new Date();setTimeout(()=>postMessage(new Date()-a),5e3)'])))).onmessage=m=>{s+=m.data;if(++c>13)console.log((new Date()-d)/1e3,s/1e3)}

UPD: substituiu a maneira como um trabalhador é executado a partir de uma string por um mais compacto e entre navegadores, no aspecto das políticas de origem. Não funcionará no Safari, se ele ainda tiver um webkitURLobjeto em vez de URLno IE.

bodqhrohro
fonte
11
Estou recebendo um erro ao executar isso:{ "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 }
DJMcMayhem
3

Python 2, 130 bytes

import thread as H,time as T
m=T.clock;T.z=m()
def f(k):T.sleep(k);T.z+=m()
exec"H.start_new_thread(f,(7,));"*9
f(8);print m(),T.z

Esta é uma derivação da resposta de Mego, mas é suficientemente diferente que eu pensei que deveria ser uma resposta separada. Foi testado para funcionar no Windows.

Basicamente, ele obtém 9 threads, que dormem por 7 segundos enquanto o pai dorme por 8 anos. Depois, imprime as horas. Saída de amostra:

8.00059192923 71.0259046024

No Windows, time.clockmede o tempo de parede desde a primeira chamada.

nneonneo
fonte
É importante observar que isso funciona no Windows - time.clock()se comporta de maneira diferente entre as plataformas Windows e UNIX / Linux .
Mego
3

Perl 6, 72 71 bytes

Pode haver uma maneira mais curta de fazer isso

say sum await map {start {sleep 7;now -ENTER now}},^9;say now -INIT now

isso gera

63.00660729694
7.0064013
Teclas de atalho
fonte
2

Mathematica, 109 bytes

a=AbsoluteTiming;LaunchKernels@7;Plus@@@a@ParallelTable[#&@@a@Pause@9,{7},Method->"EvaluationsPerKernel"->1]&

Função anônima. Requer uma licença com mais de 7 sub-kernels para executar. Leva 9 segundos em tempo real e 63 segundos em tempo de kernel, sem levar em conta a sobrecarga. Certifique-se de executar apenas as instruções anteriores uma vez (para não tentar reiniciar os kernels). Testando:

In[1]:= a=AbsoluteTiming;LaunchKernels@7;func=Plus@@@a@ParallelTable[#&@@a@Pause
@9,{7},Method->"EvaluationsPerKernel"->1]&;

In[2]:= func[]

Out[2]= {9.01498, 63.0068}

In[3]:= func[]

Out[3]= {9.01167, 63.0047}

In[4]:= func[]

Out[4]= {9.00587, 63.0051}
LegionMammal978
fonte
2
Deixe que a Wolfram imponha restrições de licença ao bifurcar um processo filho.
Mario Carneiro
2

Javascript (ES6), 105 bytes

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},8e3,c,t())})(Date.now,8,0)

Versão atualizada: 106 bytes Emprestado do @Ismael Miguel, pois ele teve a ótima idéia de diminuir o tempo de sono e aumentar os intervalos.

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},610,c,t())})(Date.now,99,0)

Javascript Ungolfed, 167 bytes

(function(t, c, d){
	i = t();
	while(c--){
		setTimeout(function(c, s){
			d += t() - s;
			if (!c) alert([t() - i, d])
		}, 8e3, c, t())
	}
})(Date.now, 8, 0)

Andrew
fonte
2
Em vez de d+=t()-s;if(!c)alert([t()-i,d]), você pode escrever d+=t()-s;c||alert([t()-i,d]), o que economizará alguns bytes. Além disso, se você remover a função e reescrever tudo, você pode competir com a minha solução de longo 92-byte: for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()). E sim, este também tem 92 bytes.
Ismael Miguel
2

Java, 358 343 337 316 313 bytes

import static java.lang.System.*;class t extends Thread{public void run(){long s=nanoTime();try{sleep(999);}catch(Exception e){}t+=nanoTime()-s;}static long t,i,x;public static void main(String[]a)throws Exception{x=nanoTime();for(;++i<99;)new t().start();sleep(9000);out.println((nanoTime()-x)/1e9+" "+t/1e9);}}

e ungolfed

import static java.lang.System.*;

class t extends Thread {
    public void run() {
        long s = nanoTime();
        try {
            sleep(999);
        } catch (Exception e) {
        }
        t += nanoTime() - s;
    }

    static long t,i,x;

    public static void main(String[] a) throws Exception {
        x = nanoTime();
        for (; ++i < 99;)
            new t().start();
        sleep(9000);
        out.println((nanoTime() - x) / 1e9 + " " + t / 1e9);
    }
}

não tente em casa, pois esta solução não é segura para threads.

Editar:

Peguei as sugestões de @A Boschman e @ Adám, e agora meu programa leva menos de 10 segundos para ser executado, e é mais curto em 15 bytes.

user902383
fonte
2
Você está dentro de um filho da classe Thread, não pode omitir as Thread.chamadas do método sleep () estático? Além disso, este programa não será encerrado em pouco mais de 10 segundos, desqualificando-o?
Reintegrar Monica
@ABoschman obrigado pela sugestão, e seu fixado por agora, ele não é executado mais de 10 segundos mais
user902383
11
Além disso, não se esqueça de que temos uma excelente base de dicas de usuários para jogar golfe em java :) #
1655
11
Isso parece suscetível a condições de corrida de leitura, modificação e gravação. Você não tem nenhum tipo de bloqueio ou qualquer coisa em torno do seu static long t. Só mencionei isso porque a especificação diz "Ambos os valores de tempo precisam ter uma precisão de pelo menos 0,1 segundo".
Puxa
11
Você pode remover o long antes do se adicionar ,sao static long t,i,s;para salvar alguns bytes.
Kevin Cruijssen
2

C (com pthreads), 339 336 335 bytes

#include<stdio.h>
#include<sys/time.h>
#include<pthread.h>
#define d double
d s=0;int i;pthread_t p[14];d t(){struct timeval a;gettimeofday(&a,NULL);return a.tv_sec+a.tv_usec/1e6;}
h(){d b=t();sleep(5);s+=t()-b;}
main(){d g=t();for(i=14;i-->0;)pthread_create(&p[i],0,&h,0);for(i=14;i-->0;)pthread_join(p[i],0);printf("%f %f",t()-g,s);}
bodqhrohro
fonte
2

C90 (OpenMP), 131 bytes (+ 17 para a variável env) = 148 bytes

#include <omp.h>
#define o omp_get_wtime()
n[4];main(t){t=o;
#pragma omp parallel
while(o-9<t);times(n);printf("%d,%f",n[0],o-t);}

Saída de exemplo:

7091,9.000014

Notas:

7091 está em ciclos (100 / s), portanto, o programa foi executado por 70 segundos

Poderia ser muito mais curto se eu descobrisse uma maneira de fazer com que um cronômetro funcionasse além de omp_get_wtime (), porque então eu poderia remover a instrução include também.

Execute com OMP_NUM_THREADS = 9

dj0wns
fonte
Você pode configurar o env var, mas precisaria contar os bytes para fazer isso, exceto se a configuração escolhida for um padrão comum.
Adám 19/06/2016
@ Adám Obrigado, isso é o que eu pensava, ele salva 6 ou 7 bytes
dj0wns
2

Lisp comum (SBCL) 166 bytes:

(do((m #1=(get-internal-real-time))(o(list 0)))((>(car o)60000)`(,(car o),(- #1#m)))(sb-thread:make-thread(lambda(&aux(s #1#))(sleep 1)(atomic-incf(car o)(- #1#s)))))

Isso gera threads que dormem e aumentam atomicamente o tempo gasto, com um loop externo que gira esperando que o tempo total seja superior a 60000 ticks (ou seja, 60s no sbcl). O contador é armazenado em uma lista devido a limitações nos tipos de locais que o atomic-incf pode modificar. Isso pode ficar sem espaço antes de terminar em máquinas mais rápidas.

Ungolfed:

(do ((outer-start (get-internal-real-time))
       (total-inner (list 0)))
      ((> (car total-inner) 60000)
       `(,(car total-inner)
      ,(- (get-internal-real-time) outer-start)))
    (sb-thread:make-thread
     (lambda (&aux(start (get-internal-real-time)))
       (sleep 1)
       (atomic-incf (car total-inner) (- (get-internal-real-time) start)))))
Jason
fonte
2

Perl, 101 bytes

use Time::HiRes<time sleep>;pipe*1=\time,0;
print time-$1,eval<1>if open-print{fork&fork&fork}-sleep 9

Garfo 7 processos filho, cada um dos quais espera 9 segundos.

Saída de amostra:

perl wait-one-minute.pl
9.00925707817078-63.001741
primo
fonte
1

Groovy, 158 143 caracteres

d={new Date().getTime()}
s=d(j=0)
8.times{Thread.start{b=d(m=1000)
sleep 8*m
synchronized(j){j+=d()-b}}}addShutdownHook{print([(d()-s)/m,j/m])}

Exemplo de execução:

bash-4.3$ groovy wait1minute.groovy
[8.031, 64.055]
homem a trabalhar
fonte
1

Elixir, 168 bytes

import Task;import Enum;IO.puts elem(:timer.tc(fn->IO.puts(map(map(1..16,fn _->async(fn->:timer.tc(fn->:timer.sleep(4000)end)end)end),&(elem(await(&1),0)))|>sum)end),0)

Exemplo de execução:

$ elixir thing.exs
64012846
4007547

A saída é o tempo total esperado, seguido pelo tempo em que o programa foi executado, em microssegundos.

O programa gera 14 Tasksegundos e aguarda cada um deles mapeando-os e depois encontra a soma do tempo decorrido. Ele usa o Erlang timerpara medir o tempo.

Candy Gumdrop
fonte
Bem-vindo à comunidade !!
Erik the Outgolfer
1

Haskell, 278 271 262 246 bytes

import Control.Concurrent.Chan
import Data.Time
import GHC.Conc
t=getCurrentTime
b!a=b=<<flip diffUTCTime<$>t<*>(a>>t)
w=threadDelay$5^10
0#_=t
i#a=a>>(i-1)#a
main=print!do r<-newChan;9#(forkIO$writeChan r!w);getChanContents r>>=print.sum.take 9

!mede o tempo gasto pela ação a(segundo argumento) e aplica-se b(primeiro argumento) ao resultado.

w é a função do sono.

mainé medido em si e o resultado é impresso ( print!...).

#é replicateMrepetir a ação especificada N vezes (e retornar tporque joga golfe).

Dentro da peça medida, 9 threads ( replicate 9 $ forkIO ...) dormem por 5^10milissegundos (9.765625 segundos) e postam o resultado ( writeChan) em um tubo criado pelo thread principal ( newChan), que soma os 9 resultados e imprime o total ( getChanContents >>= print . sum . take 9).

Resultado:

87.938546708s
9.772032144s
Koterpillar
fonte
11
@ Adám 6 ^ 9> 10 ^ 7 (10 segundos).
Koterpillar
1

Python 2, 132 bytes

Usa um pool de processos para gerar 9 processos e deixar cada um dormir por 7 segundos.

import time as t,multiprocessing as m
def f(x):d=s();t.sleep(x);return s()-d
s=t.time
a=s()
print sum(m.Pool(9).map(f,[7]*9)),s()-a

Imprime o total de sono acumulado primeiro, depois o tempo de execução real:

$ python test.py
63.0631158352 7.04391384125
moooeeeep
fonte
1

Ruby (com parallelgema), 123 116 bytes

require'parallel'
n=->{Time.now}
t=n[]
q=0
Parallel.each(1..10,:in_threads=>10){z=n[];sleep 6;q+=n[]-z}
puts n[]-t,q

Edit: Adicionada a referência "Time.now" da resposta Ruby do histocrat.

Gosha U.
fonte
1

Matlab, 75 bytes

tic;parpool(9);b=1:9;parfor q=b
a=tic;pause(7);b(q)=toc(a);end
[sum(b);toc]

Explicação rápida: parforcria um loop for paralelo, distribuído pelo conjunto de trabalhadores. tice tocmedir o tempo decorrido (e, na minha opinião, é uma das funções mais bem nomeadas do MATLAB). A última linha (uma matriz com o tempo total gasto e o tempo real decorrido) é gerada, pois não é finalizada com ponto e vírgula.

Observe, no entanto, que isso cria 9 processos MATLAB completos. As chances são de que esse programa em particular não seja concluído nos 10 segundos alocados em sua máquina. No entanto, acho que com uma instalação do MATLAB que não possui caixas de ferramentas, exceto a caixa de ferramentas Parallel Computing instalada - instalada em um sistema high-end com SSD - pode ser concluída em 10 segundos. Se necessário, você pode ajustar os parâmetros para que menos processos durmam mais.

Sanchises
fonte
O erro sobre bprovavelmente é apenas porque você já tinha algo em seu espaço de trabalho. Eu não tenho problemas em 2015b usandoparfor q=b
Suever
@ Suever Oh hey, eu tinha um script chamado bm na minha pasta MATLAB.
Sanchises