Die Sanduhr-Herausforderung

43

Die Sanduhr

Diese Sanduhr hat 60 "Sandstunden" und füllt jede Kammer vollständig aus. Die Uhr ist 19 Zeichen breit und 13 Zeichen hoch. Jede Kammer hat 5 Sandreihen und in der Mitte befindet sich eine Reihe, die 1 Sand aufnehmen kann. Die oberste Reihe kann 17 Sande aufnehmen, die nächste 15 und so weiter (siehe unten). Sand fällt mit einer Geschwindigkeit von einem Sand pro Sekunde in die untere Kammer.

       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 
███████     ███████            ███████  .  ███████            ███████  .  ███████  
█████         █████            █████    .    █████            █████    .    █████   
███             ███            ███      .      ███            ███....         ███
██               ██            ██               ██            ██...............██  
█                 █            █                 █            █.................█  
███████████████████            ███████████████████            ███████████████████   

Die Herausforderung

Zeigen Sie die Sanduhr nach einer bestimmten Zeit an (keine Nummern oder Überschriften erforderlich) (0 ≤ t ≤ 60).

Codierungsregeln

  1. Die Sanduhr sollte genau so aussehen, wie hier gezeigt. Sie können das Zeichen und / oder das .Zeichen durch das ersetzen, was Sie für Ihre Sprache benötigen (Unicode-, ASCII-Kompatibilitätsprobleme).
  2. Die Eingabe sollte eine Zahl wie 45 oder 7 sein. Zeigen Sie die Uhr nach diesen vielen Sekunden an.
  3. Die Ausgabe kann entweder angezeigt oder in einer Datei gespeichert werden. Es sind keine zusätzlichen Texte oder Beschriftungen wie oben gezeigt erforderlich - nur die Sanduhr ist alles, was wir brauchen.
  4. Wenn der Benutzer t> 60 eingibt, müssen Sie den Fehler nicht behandeln.

Punkte

  1. Kürzester Code gewinnt.
Renae Lider
quelle
Ich weiß nicht, ob es nur ich bin, aber die Sanduhr sieht im Editor ganz anders aus als im Post. Dies liegt wahrscheinlich daran, dass das Zeichen █ nicht in der richtigen Breite angezeigt wird.
Dennis
1
Berührt ein Sandkorn die aktuelle Schicht und richtet sich eine Sekunde später nach links aus?
8.
2
Was soll die Ausgabe für t == 59 sein?
edc65
3
Herzlichen Glückwunsch zur Erstellung der Liste der Hot Network-Fragen für Stack Exchange!
Alex A.
1
Dies ist keine wirkliche Antwort, da sie nicht den Spezifikationen entspricht. Schauen Sie hier, um eine Einreichung in Desmos zu erhalten. (Drücken Sie die Wiedergabetaste und stellen Sie die Geschwindigkeit auf 0,15x für ~ 1 Einheit / Sekunde)
Conor O'Brien

Antworten:

27

JavaScript ( ES6 ), 203 208 233 270 256 Zeichen

Bearbeiten Überarbeitet mit einer Schleife anstelle einer Abfolge von Aufrufen.

Bearbeiten Die fehlenden oberen und unteren Zeilen wurden hinzugefügt.

Eine Funktion, die die Ausgabe zurückgibt. Führen Sie das Snippet zum Testen in Firefox aus.

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>

edc65
quelle
5
Warum wurde das aus Neugier zweimal abgelehnt? Ich kann kein Problem damit finden.
Manatwork
Diese Antwort ist fantastisch ! Öffne es in Firefox, Leute!
Cristian Lupascu
1
Gute Antwort, aber die Oberseite und die Unterseite der Sanduhr scheinen zu fehlen.
Renae Lider
@manatwork nicht sicher (natürlich), aber es gab tatsächlich einen Fehler
edc65
Bitte machen Sie ein setInterval (), Javascript wäre toll dafür:setTimeout( tick, 1000);
Martijn
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

xnor hat im Chat eine 197- Byte-Version erstellt .

Ich würde eine Erklärung posten, aber ich habe den Überblick verloren, wie es tatsächlich funktioniert ...

Hier ist auch eine animierte Version mit Flüchen:

Sanduhr

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
quelle
1
Ein dickes Lob, Sie haben mir gezeigt, dass Strings eine center () -Methode haben!
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]

Sanduhr

Ausgabe bei 38 Sekunden:

###################
#                 #
##               ##
###.......      ###
#####.........#####
#######.....#######
#########.#########
#######  .  #######
#####    .    #####
###...   .      ###
##...............##
#.................#
###################
Dieter
quelle
2
Was für ein Python-Code ist das? Ich würde gerne lernen, wie sie zu programmieren. Bitte in die richtige Richtung führen.
Rajat Saxena
1
Ich bin nicht sicher, ob dies eine gültige Antwort ist. Wenn Sie sich das Beispiel ansehen, das er für 38 Sekunden erstellt hat, können Sie sehen, dass der niedrigste Punkt, der immer noch fällt, nicht in der Linie liegt, in der die Punkte ausgerichtet sind. (in der 4. Zeile von unten, in der Mitte)
RononDex
3
@RononDex: Wie in den Kommentaren der Frage erläutert, ist die Füllreihenfolge nicht so streng - meine Implementierung klebt die Sandkörner auf eine Weise nach links, die sich leicht von der Frage unterscheidet, aber immer noch gültig ist
Dieter
3

C 544

Folgendes habe ich bisher für eine C-Lösung.

#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);}

Kompiliert mit folgendem Befehl:

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.

Zugegeben, diese Sprache hat eine Menge Masse - die Aussage war ein kleines Handicap, das direkt aus den Blöcken kam, aber ich suchte wirklich nur nach einer Ausrede, um mit C zu üben.

Ich hoffe, Ihnen gefällt meine Lösung und Sie können mich über Verbesserungsmöglichkeiten informieren.

martin
quelle
2
Es gibt viele Möglichkeiten, sich zu verbessern und es schlimmer zu machen, C aber viel kürzer.
Edc65
1
Hinweise: forstatt where, ?:statt if else, globales int Variablen nicht braucht int, includenicht benötigt. (Ich mag deine Mathematik)
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);}(Vorsicht, merkwürdige unsichtbare Zeichen werden zu langen Kommentaren wie diesem hinzugefügt)
edc65
3

Matlab, 252 Bytes

Die Idee ist, eine Matrix zu konstruieren, die so aussieht:

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

Von dort aus ist es einfach, die Einträge mit den abhängigen Zeichenfolgen zu füllen n(alle Einträge, die größer als nund kleiner als sind, werden n+60mit Punkten gefüllt ).

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

Denn n=38wir bekommen diese Ausgabe:

¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶
¶                 ¶
¶¶               ¶¶
¶¶¶.......      ¶¶¶
¶¶¶¶¶.........¶¶¶¶¶
¶¶¶¶¶¶¶.....¶¶¶¶¶¶¶
¶¶¶¶¶¶¶¶¶.¶¶¶¶¶¶¶¶¶
¶¶¶¶¶¶¶  .  ¶¶¶¶¶¶¶
¶¶¶¶¶    .    ¶¶¶¶¶
¶¶¶...   .      ¶¶¶
¶¶...............¶¶
¶.................¶
¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶¶
fehlerhaft
quelle
2

Java, 712

Die Eingabe erfolgt über die Befehlszeile. Behandelt sowohl negative Werte für die Zeit als auch größere als erforderlich.

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);}}

Ausgabe:

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

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

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

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

Es füllt den Sand von der Mitte nach außen aus. Ich kann wahrscheinlich mehr Golf spielen, wenn ich faul bin, wie es die untere Hälfte füllt und die obere Hälfte leert. Aber im Moment gefällt es mir ganz gut.

Jack Ammo
quelle
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#'|'] 

Eingang m 55

Ausgabe

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

Eingabe m 48 Ausgabe

    |||||||||||||||||||
    |                 |
    ||               ||
    |||             |||
    |||||......   |||||
    |||||||.....|||||||
    |||||||||.|||||||||
    |||||||  .  |||||||
    |||||..       |||||
    |||.............|||
    ||...............||
    |.................|
    |||||||||||||||||||
Brander
quelle
1
Willkommen bei PPCG! Ich sehe, Sie haben dies schon einiges golfen, aber es ist immer noch viel unnötiger weißer Raum übrig, z. umgebung ++. Sie können auch einige Bytes sparen, indem Sie lengthund vordefinieren reverse.
Laikoni
1

C #, 382 410

es könnte immer noch möglich sein, es um ein paar Bytes zu reduzieren ...

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);}}

Fiddler - 38 Sek

Fredou
quelle
Cool! Wie nimmt es Eingaben auf?
Isaacg
@isaacg, hoppla, ich werde das später heute beheben, ich wusste, es war zu kurz für eine ac # -Lösung :-) Jetzt ändere u = 60-22 auf etwas anderes
Fredou
Warum benutzt du int u=60-22und nicht nur int u=38??
Dev-Masih
1

Ruby: 196 190 186 185 184 Zeichen

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 stimmt nicht genau mit den angegebenen Proben überein, da dieser von links beginnend Sand verbraucht. Meist nur eine Demonstration der String.[]=Methode.

Probelauf:

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

Ruby: 215 Zeichen

Dies erzeugt die genau erforderliche Ausgabe:

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

Probelauf:

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