O desafio da ampulheta

43

A ampulheta

Essa ampulheta possui 60 "areias do tempo" e preenche completamente cada câmara. O relógio tem 19 caracteres de largura e 13 caracteres de altura. Cada câmara possui 5 fileiras de areia e existe uma fileira no centro que pode conter 1 areia. A linha superior pode conter 17 areias, a próxima 15 e assim por diante (veja abaixo). As areias caem na câmara inferior a uma taxa de uma areia por segundo.

       START                     3 SECONDS LATER               38 SECONDS LATER

███████████████████            ███████████████████            ███████████████████
█.................█   17       █..............   █   14       █                 █    0
██...............██   15       ██...............██   15       ██               ██    0
███.............███   13       ███.............███   13       ███.......      ███    7  
█████.........█████   09       █████.........█████   09       █████.........█████   09 
███████.....███████   05       ███████.....███████   05       ███████.....███████   05 
█████████.█████████   01       █████████.█████████   01       █████████.█████████   01 
███████     ███████            ███████  .  ███████            ███████  .  ███████  
█████         █████            █████    .    █████            █████    .    █████   
███             ███            ███      .      ███            ███....         ███
██               ██            ██               ██            ██...............██  
█                 █            █                 █            █.................█  
███████████████████            ███████████████████            ███████████████████

O desafio

Exiba a ampulheta (não são necessários números ou títulos) após um certo período de tempo (0 ≤ t ≤ 60).

Regras de codificação

  1. A ampulheta deve parecer exatamente como mostrado aqui. Você pode substituir o █caractere e / ou o .caractere pelo que desejar para ajustar ao seu idioma (problemas de compatibilidade com Unicode, ASCII).
  2. A entrada deve ser um número como 45 ou 7. Exiba o relógio após esses segundos.
  3. A saída pode ser exibida ou salva em um arquivo. Não é necessário texto ou etiquetas extras, como mostrado acima - apenas a ampulheta é tudo o que precisamos.
  4. Se o usuário digitar t> 60, você não precisará lidar com o erro.

Pontos

  1. O menor código vence.
code-golf  ascii-art 
— Renae Lider
fonte
Não sei se sou só eu, mas as ampulhetas parecem completamente diferentes no editor e no próprio post. Provavelmente porque o caractere doesn't não é exibido com a largura adequada.
— Dennis
1
Um grão de areia toca a camada atual e depois se alinha à esquerda um segundo depois?
— Xnor
2
Qual deve ser a saída para t == 59?
— edc65
3
Parabéns por fazer a lista de Perguntas sobre a rede quente do Exchange da pilha!
— Alex A.
1
Esta não é realmente uma resposta, pois não se encaixa nas especificações, mas dê uma olhada aqui para um envio no Desmos. (Pressione o botão play e definir a velocidade para 0.15x para ~ 1 unidade / segundo)
— Conor O'Brien

Respostas:

27

JavaScript ( ES6 ), 203 208 233 270 256 caracteres

Editar Revisado usando um loop em vez de uma sequência de chamadas.

Editar Adicionada linha superior e inferior que estavam faltando.

Uma função retornando a saída. Execute o trecho no Firefox para testar.

f=w=>[h='█'[R='repeat'](19),...[17,15,13,9,5,1,5,9,13,15,17].map((d,i)=>(t=i>5?-v:v,v-=i<5?d:1-d,e=' '[R](d/2),b='█'[R](10-d/2),b+('.'[R](t<d&&d-t)+e+' .'[i>4&w>i-6&t>=d|0]+e).slice(0,d)+b),v=w),h].join`
`

// Less golfed
F=
w=>[h='█'.repeat(19),
    ... [17, 15, 13, 9, 5, 1, 5, 9, 13, 15, 17].map(
     (d,i) => (
       t = i>5 ? -v : v,
       v -= i<5 ? d : 1-d, 
       e = ' '.repeat(d / 2),
       b = '█'.repeat(10 - d / 2),
       b + 
        ('.'.repeat(t < d && d - t) 
         + e + ' .'[i > 4 & w > i-6 & t >= d | 0]
         + e).slice(0,d)
       + b
     ), v = w
    ),
    h].join('\n')

// TEST            

O.innerHTML=f(+I.value)

function tick(d) {
  var i=+I.value+d
  I.value=i
  O.innerHTML=f(i)
}

var int=0;

function auto()
{
  function go()
  {
    var t = I.value;
    O.innerHTML=f(++t)
    if (t>70)t=0;
    I.value = t;
  }
  if (A.checked && !int)
  { 
    int = setInterval(go, 200);
  }
  else if (!A.checked && int)
  {
    clearInterval(int);
    int = 0;
  }
}
input[type=text] { width: 3em }
<button onclick='tick(-1)'>-</button>
<input type=text id=I value=0 onchange='tick(0)' >
<button onclick='tick(1)'>+</button>
<input type=checkbox id=A onclick='auto()'>Fly time
<pre id=O><pre>
Expandir snippet

— edc65
fonte
5
Para minha curiosidade, por que isso foi rebaixado duas vezes? Não consigo encontrar nenhum problema com isso.
— manatwork
Esta resposta é incrível ! Abra no Firefox, pessoal!
— Cristian Lupascu
1
Boa resposta, mas o topo e a base da ampulheta parecem estar faltando.
— precisa
@manatwork não tenho certeza (é claro), mas houve uma falha na verdade
— edc65
Por favor, faça um setInterval (), o javascript seria ótimo para isso: #setTimeout( tick, 1000);
— 287
18

Python 2, 200

t=input()+1
s=' '*t+'.'*60+' '*70
n=0
d=sum((1<t<56,2<t<48,3<t<36,4<t<22))
for c in'ctrplhdhlprtc':i=ord(c)-99;print[s[n+i:n:-1],[s[180-n-i+d:][:i],'.'][5+d*3>i>0]][n>59].center(i).center(19,'#');n+=i

O xnor criou uma versão de 197 bytes no chat .

Gostaria de postar uma explicação, mas perdi a noção de como ela realmente funciona ...

Além disso, aqui está uma versão animada com maldições:

ampulheta

from curses import*
w=initscr()

for t in range(1,61):
    s=' '*t+'.'*60+' '*70
    n=0
    d=sum((1<t<56,2<t<48,3<t<36,4<t<22))
    for i in 0,17,15,13,9,5,1,5,9,13,15,17,0:w.addstr([s[n+i:n:-1],[s[180-n-i+d:][:i],'.'][5+d*3>i>0]][n>59].center(i).center(19,'#')+"\n");n+=i
    w.refresh()
    w.clear()
    napms(999)

endwin()
— grc
fonte
1
parabéns, você me fez descobrir que as strings têm um método center ()!
— Dieter
13

Python 2.7, 362 356 347

e,c,x,a,b,n=' .#ab\n';R,r,s,l,T,m=range,str.replace,'',19,[1,2,3,5,7,9],-1
for t in[T,T[:m][::m]]:s+=''.join([n+x*y+c*(l-y*2)+x*y for y in t]);c=b
s=list(s)
for i in R(130,220,20):s[i]=a
for _ in R(input()):s[s.index('.')]=e;i=s.index(a)if a in s else 219-s[::m].index(b);s[i]='.'
for l in(x*l+r(r(''.join(s),a,e),b,e)+n+x*l).split(n):print l[::m]

ampulheta

Saída em 38 segundos:

###################
#                 #
##               ##
###.......      ###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###...   .      ###
##...............##
#.................#
###################
— dieter
fonte
2
Que tipo de código Python é esse? Eu adoraria aprender a codificar como eles. Por favor, guie na direção certa.
— Rajat Saxena
1
Não tenho certeza se esta é uma resposta válida. Se você observar o exemplo que ele criou por 38 segundos, poderá ver que o ponto mais baixo que ainda está caindo não está na linha em que os pontos se alinham. (na 4a linha de baixo, no centro)
— RononDex 8/15/15
3
@RononDex: Como explicado nos comentários da pergunta, a fim de enchimento não é tão rigoroso - minha implementação fura os grãos de areia para a esquerda de uma forma que é ligeiramente diferente da questão, mas ainda válido
— dieter
3

C 544

Aqui está o que eu tenho até agora para uma solução C.

#include <stdio.h>
int main(int z,char **a){int r,i,y=i=0,v,d,t,m,s=atoi(a[1]),n[13]={0,43,28,15,6,1,0,1,5,13,25,39,0};char H[13][20];while(y<13){int x,b=x=i=0;v=y-6;t=3+abs(v);m=2*abs(v);d=t<m?t:m;d=9-d;if(d==0)d=10;while (b<d){H[y][b]='#';H[y][18-b]='#';b++;}while(x<19-2*b){if(x<=s-n[y])H[y][x+b]=v>0?' ':'.';else H[y][x+b]=v>0?'.':' ';x++;}if(s>58)r=0;else if(s==58)r=1;else if(s==57)r=2;else if(s==56)r=3;else if(s>38)r=4;else if(s>24)r=3;else if(s>12)r=2;else if(s>4)r=1;while(i<r){H[7+i][9]='.';i++;}H[y][19]='\n';y++;}fputs(H,stdout);}

Compilado com o seguinte comando:

gcc -w -o hourglass hourglass.c  // I realize I should have cast H as a char *, but since it works this way, I just decided to suppress the error from the compiler instead to save space.

É certo que essa linguagem tem muito volume - a instrução include foi um pouco prejudicial, mas eu realmente estava procurando uma desculpa para praticar o uso do C.

Espero que você goste da minha solução e deixe-me saber se você encontrar maneiras de melhorar.

— Martin
fonte
2
Há muitas maneiras de melhorar, tornando o C pior, mas muito mais curto.
— edc65
1
Dicas: em forvez de where, em ?:vez de if else, variáveis ​​int globais não precisam int, includenão são necessárias. (Eu gosto de sua matemática)
— edc65
1
317: r,i,y,x,b,d,n[]={0,43,28,15,6,1,0,1,5,13,25,39,0};char H[14][20];main(s,a)char**a;{for(s=atoi(a[1]);y<13;){b=x=i=0;d=abs(y-6);d+=3<d?3:d;d=9-d?9-d:10;r=s>55?59-s:s>38?4:s>24?3:s>12?2:s>4?1:r;for(;b<19;)H[y][b++]=35;for(;x<19-2*d;x++)H[y][x+d]=(x>s-n[y]?" .":". ")[y>6];for(;i<r;)H[7+i++][9]=46;H[y++][b]=10;}puts(H);}(cuidado, estranhos caracteres invisíveis são adicionados a comentários longos como este)
— edc65
3

Matlab, 252 bytes

A ideia é construir uma matriz que se parece com isso:

0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0
0   0  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18   0   0
0   0   0  45  44  43  42  41  40  39  38  37  36  35  34  33   0   0   0
0   0   0   0   0  54  53  52  51  50  49  48  47  46   0   0   0   0   0
0   0   0   0   0   0   0  59  58  57  56  55   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0  60   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0 116 117  61 118 119   0   0   0   0   0   0   0
0   0   0   0   0 108 109 110 111  62 112 113 114 115   0   0   0   0   0
0   0   0  96  97  98  99 100 101  63 102 103 104 105 106 107   0   0   0
0   0  82  83  84  85  86  87  88  64  89  90  91  92  93  94  95   0   0
0  66  67  68  69  70  71  72  73  65  74  75  76  77  78  79  80  81   0
0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

A partir daí, é fácil preencher as entradas com as sequências dependentes n(preenchendo todas as entradas maiores ne menores que n+60com pontos)

function c=f(n);
b=zeros(13,19);
z=[0,17,32,45,54,59];
y=-2:3;
for k=2:6;
    d=k+sum(k>4:5);
    b(k,d:20-d)=z(k):-1:z(k-1)+1;
    b(14-k,d:19-d)=68+(z(k-1):z(k)-2)-k;
end;
b(8:12,11:19)=b(8:12,10:18);
b(7:12,10)=60:65;c=[ones(13,19)*32,''];
c(~b)='¶';c(n<b)=46;c(b>n+60)=32

Para n=38obtermos esta saída:

¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶
¶                 ¶
¶¶               ¶¶
¶¶¶.......      ¶¶¶
¶¶¶¶¶.........¶¶¶¶¶
¶¶¶¶¶¶¶.....¶¶¶¶¶¶¶
¶¶¶¶¶¶¶¶¶.¶¶¶¶¶¶¶¶¶
¶¶¶¶¶¶¶  .  ¶¶¶¶¶¶¶
¶¶¶¶¶    .    ¶¶¶¶¶
¶¶¶...   .      ¶¶¶
¶¶...............¶¶
¶.................¶
¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶
— flawr
fonte
2

Java, 712

A entrada é retirada da linha de comando. Lida com ambos os valores negativos para o tempo, além de maiores que o necessário.

enum H{;public static void main(String[]r){int x=0,y=0,z=0,l,t=Integer.parseInt(r[0]);String b="",d="█",e=" ",f=".",n="\n",j,k,a="███████████████████"+n;int[]w={17,15,13,9,5},v;int[][]h=new int[10][];for(;x<5;){l=w[x];v=(h[x++]=new int[l--]);l/=2;v[l]=++z;for(y=0;y++<l;){v[l-y]=++z;v[l+y]=++z;}}for(z=0;x>0;){l=w[--x];v=(h[9-x]=new int[l--]);v[l/2]=++z;}for(;x<5;){l=(w[x]-1)/2;v=h[9-x++];for(y=0;y++<l;){v[l-y]=++z;v[l+y]=++z;}}p(a);for(x=0;x<5;x++){l=w[x];j=b;for(y=0;y++*2<19-l;)j+=d;k=b;for(y=0;y<l;)k+=t<h[x][y++]?f:e;p(j+k+j+n);}j="█████████";p(j+f+j+n);for(;x>0;){l=w[--x];j=b;for(y=0;y++*2<19-l;)j+=d;k=b;for(y=0;y<l;)k+=t<h[9-x][y++]?e:f;p(j+k+j+n);}p(a);}static void p(String s){System.out.print(s);}}

resultado:

time: 0
███████████████████
█.................█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████     ███████
█████         █████
███             ███
██               ██
█                 █
███████████████████

time: 1
███████████████████
█........ ........█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████         █████
███             ███
██               ██
█                 █
███████████████████

time: 9
███████████████████
█....         ....█
██...............██
███.............███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████    .    █████
███      .      ███
██       .       ██
█      .....      █
███████████████████

time: 41
███████████████████
█                 █
██               ██
███..         ..███
█████.........█████
███████.....███████
█████████.█████████
███████  .  ███████
█████    .    █████
███   .......   ███
██...............██
█.................█
███████████████████

Preenche a areia do centro, expandindo-se para fora. Provavelmente posso jogar mais se ficar preguiçoso com o modo como preenche a metade inferior e esvazia a metade superior. Mas por enquanto eu gosto bastante.

— Jack Munição
fonte
2

Haskell 512 Bytes

h=[17,15,13,9,5,1];b=drop 1$reverse h;n#s=[1..n]>>[s];s='.';n =' ';c q=(q#n)++(60-q)#s;f q|q<=5=q#s|3>2=g#s where{g=foldl i 5 (scanl (+) 0 h);i x y=if q>x+y then x-1 else x};e q=j#s++(59-length(k q)-(j))#n where{j=q-length(f q)};l q=c q++k q++(reverse$e q);p _ []=[];p x y=reverse(z++take q x++z):p (drop (head y) x) (tail y)where{q=head y;z=replicate(div (19-q) 2) '|'};k q= (concat.map(\x -> z x ++ "." ++ z x).take (length.f$q)$b)where{z x=(div x 2)#n};m n=mapM_ putStrLn $ t ++ p (l n) (h++b) ++ t;t=[19#'|']

Entrada m 55

Resultado 

|||||||||||||||||||
|                 |
||               ||
|||             |||
|||||         |||||
|||||||.... |||||||
|||||||||.|||||||||
|||||||  .  |||||||
|||||.........|||||
|||.............|||
||...............||
|.................|
|||||||||||||||||||

m 48 Saída de Entrada

    |||||||||||||||||||
    |                 |
    ||               ||
    |||             |||
    |||||......   |||||
    |||||||.....|||||||
    |||||||||.|||||||||
    |||||||  .  |||||||
    |||||..       |||||
    |||.............|||
    ||...............||
    |.................|
    |||||||||||||||||||
— brander
fonte
1
Bem-vindo ao PPCG! Vejo que você já jogou isso bastante, mas ainda há muito espaço em branco desnecessário, por exemplo. circundante ++. Além disso, você pode salvar alguns bytes predefinindo lengthe reverse.
— Laikoni
1

C #, 382 410

ainda é possível reduzi-lo em alguns bytes ...

class Program{static void Main(){int u=60-22,d=u,i,j,k,l,m;var c=new char[260];var r=new int[]{0,17,15,13,9,5,1,5,9,13,15,17,0,54,45,32,17,0};for(i=0;i<13;){m=0;l=(19-r[i])/2-1;for(j=19;j>=0;){k=i*20+j--;var b=j>=l&&j<r[i]+l;if(i>6&b)c[k-r[i]+m++ +m]=r[i+6]<d&&d-->0||j==8&r[i+6]>d&&d-->0?'.':' ';else c[k]=i<7&b?u-->1?' ':'.':'█';}c[++i*20-1]='\n';}System.Console.WriteLine(c);}}

Violinista - 38seg

— Fredou
fonte
Legal! Como é preciso receber informações?
— Isaacg
@isaacg, oops, eu vou consertar isso mais tarde hoje, eu sabia que era muito curto para solução ac # :-) para mudar agora u = 60-22 para outra coisa
— Fredou
Por que você usa int u=60-22e não apenas int u=38?
— Dev-masih #
1

Ruby: 196 190 186 185 184 caracteres

u=[0,17,15,13,9,5].map{|i|(?.*i).center 19,?#}*$/
(?1..$*[0]).map{u[?.]=' '}
l=u.reverse
5.times{|i|l[p=i*20+9]==?.&&l[' ']&&(l[p]=?|)&&l[' ']=?.}
puts u,?#*9+?.+?#*9,l.tr('. | ',' .')

CW porque não está em conformidade exatamente com as amostras postadas, pois isso consome areia a partir da esquerda. Principalmente apenas uma demonstração do String.[]=método.

Exemplo de execução:

bash-4.3$ ruby hg.rb 38
###################
#                 #
##               ##
###      .......###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###      .   ...###
##...............##
#.................#
###################

Ruby: 215 caracteres

Isso gera a saída exata exata:

u=[0,17,15,13,9,5].map{|i|(?.*i).center 19,?#}*$/
(?1..$*[0]).map{u[?.]=' '}
l=u.reverse
5.times{|i|l[p=i*20+9]==?.&&l[' ']&&(l[p]=?|)&&l[' ']=?.}
puts ([u,?#*9+?.+?#*9,l.tr('. | ',' .')]*$/).split($/).map &:reverse

Exemplo de execução:

bash-4.3$ ruby hg.rb 38
###################
#                 #
##               ##
###.......      ###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###...   .      ###
##...............##
#.................#
###################
— manatwork
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.