Unterer Teil der Sanduhr

14

Herausforderung:

Eingabe: Drei Ganzzahlen: Länge der Unterkante; Ausgangsmenge von Sandkörnern; Index

Ausgabe: Gibt den Zustand des unteren Teils einer Sanduhr am angegebenen Index aus, basierend auf der angegebenen Länge der Unterkante und der Menge der Sandkörner.

Herausforderungsregeln:

  • Wir simulieren die Sandkörner mit den Ziffern 1-9
  • Wir setzen die aktuell verbleibende Menge Sandkörner oben in die Mitte, gefolgt von einem einzelnen Zeichen Ihrer Wahl (ohne Ziffern, Leerzeichen und -Zeilenumbrüche ; dh ) in der Zeile darunter
  • Wenn die Sanduhr gefüllt wird, füllen wir sie zeilenweise, ziffernweise
  • Wenn der Sand nach links oder rechts wandern kann, gehen wir IMMER nach rechts (das gleiche gilt für das Ausgleichen der verbleibenden Sandkörnermenge über der Sanduhr).
  • Wenn wir 9 erreicht haben, ist es voll und wir können an dieser bestimmten Stelle in der Sanduhr keinen Sand mehr hineinpassen
  • Die Menge der verbleibenden Sandkörner ist auch immer richtig ausgerichtet
  • Sobald die untere Hälfte der Sanduhr vollständig gefüllt ist oder die verbleibende Menge an Sandkörnern 0 erreicht, können wir nicht weiter gehen, und dies wäre die Ausgabe für alle Indizes, die über diesen Punkt hinausgehen
  • Sowohl 0-indiziert als auch 1-indiziert ist zulässig. Bitte geben Sie an, was Sie in Ihrer Antwort verwendet haben.
  • Nachgestellte und führende Leerzeichen und eine einzelne nachgestellte oder führende neue Zeile sind optional
  • Sie können anstelle einer Null ein beliebiges anderes Zeichen verwenden, um leere Stellen im unteren Teil der Sanduhr auszufüllen (mit Ausnahme von Ziffern, Zeilenumbrüchen oder dem Zeichen, das Sie als Hals verwendet haben), wenn Sie diese anzeigen möchten.
  • Die Länge der Unterkante ist immer ungerade
  • Die Länge der Unterkante beträgt >= 3; und die Mengen an Sandkörnern>= 0
  • Wenn Sie möchten, können Sie auch alle Status bis einschließlich des angegebenen Index drucken
  • Sie können davon ausgehen, dass der Index (mit dem Index 0) niemals größer ist als die Gesamtmenge der Sandkörner (wenn also 100 Sandkörner vorhanden sind, ist der Index 100 die maximal gültige Indexeingabe).
  • Der erste Index (0 für 0-indexiert; 1 für 1-indexiert) gibt eine leere Sanduhr mit der Menge an Sandkörnern darüber aus.

Beispiel: Bilder (oder ASCII-Kunst) sagen mehr als tausend Worte. Hier ist ein Beispiel:

Länge der unteren Kante eingeben: 5
Menge der Sandkörner eingeben: 100
Anstelle eines aktuellen Index zeige ich hier alle Schritte an:

Ausgabe für alle möglichen Indizes mit Unterkantenlänge 5und Sandkornmenge 100:

 100
  -
  0
 000
00000

  99
  -
  0
 000
00100

  98
  -
  0
 000
00110

  97
  -
  0
 000
01110

  96
  -
  0
 000
01111

  95
  -
  0
 000
11111

  94
  -
  0
 000
11211

  93
  -
  0
 000
11221

  92
  -
  0
 000
12221

  91
  -
  0
 000
12222

  90
  -
  0
 000
22222

  89
  -
  0
 000
22322

  88
  -
  0
 000
22332

  87
  -
  0
 000
23332

  86
  -
  0
 000
23333

  85
  -
  0
 000
33333

  84
  -
  0
 000
33433

  83
  -
  0
 000
33443

  82
  -
  0
 000
34443

  81
  -
  0
 000
34444

  80
  -
  0
 000
44444

  79
  -
  0
 000
44544

  78
  -
  0
 000
44554

  77
  -
  0
 000
45554

  76
  -
  0
 000
45555

  75
  -
  0
 000
55555

  74
  -
  0
 000
55655

  73
  -
  0
 000
55665

  72
  -
  0
 000
56665

  71
  -
  0
 000
56666

  70
  -
  0
 000
66666

  69
  -
  0
 000
66766

  68
  -
  0
 000
66776

  67
  -
  0
 000
67776

  66
  -
  0
 000
67777

  65
  -
  0
 000
77777

  64
  -
  0
 000
77877

  63
  -
  0
 000
77887

  62
  -
  0
 000
78887

  61
  -
  0
 000
78888

  60
  -
  0
 000
88888

  59
  -
  0
 000
88988

  58
  -
  0
 000
88998

  57
  -
  0
 000
89998

  56
  -
  0
 000
89999

  55
  -
  0
 000
99999

  54
  -
  0
 010
99999

  53
  -
  0
 011
99999

  52
  -
  0
 111
99999

  51
  -
  0
 121
99999

  50
  -
  0
 122
99999

  49
  0
 222
99999

  48
  -
  0
 232
99999

  47
  -
  0
 233
99999

  46
  -
  0
 333
99999

  45
  -
  0
 343
99999

  44
  -
  0
 344
99999

  43
  -
  0
 444
99999

  42
  -
  0
 454
99999

  41
  -
  0
 455
99999

  40
  -
  0
 555
99999

  39
  -
  0
 565
99999

  38
  -
  0
 566
99999

  37
  -
  0
 666
99999

  36
  -
  0
 676
99999

  35
  -
  0
 677
99999

  34
  -
  0
 777
99999

  33
  -
  0
 787
99999

  32
  -
  0
 788
99999

  31
  -
  0
 888
99999

  30
  -
  0
 898
99999

  29
  -
  0
 899
99999

  28
  -
  0
 999
99999

  27
  -
  1
 999
99999

  26
  -
  2
 999
99999

  25
  -
  3
 999
99999

  24
  -
  4
 999
99999

  23
  -
  5
 999
99999

  22
  -
  6
 999
99999

  21
  -
  7
 999
99999

  20
  -
  8
 999
99999

  19
  -
  9
 999
99999

Also als Beispiel:

inputs: 5,100,1
output:
  99
  -
  0
 000
00100

Same example with another valid output format:
  99
  ~
  . 
 ...
..1..

Allgemeine Regeln:

  • Das ist , also gewinnt die kürzeste Antwort in Bytes.
    Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
  • Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
  • Standardlücken sind verboten.
  • Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
  • Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

INPUTS: bottom-edge length, amount of grains of sand, index (0-indexed)

inputs: 5,100,1
output:
  99
  -
  0
 000
00100

inputs: 5,100,24
output:
  76
  -
  0
 000
45555

inputs: 5,100,100
output:
  19
  -
  9
 999
99999

inputs: 5,10,15
output:
  0
  -
  0
 000
22222

inputs: 3,30,20
output:
 10
 -
 0
677

inputs: 3,3,0
 3
 -
 0
000

inputs: 9,250,100
   150
    -
    0
   000
  00000
 2333332
999999999

inputs: 9,225,220
    5
    -
    4
   999
  99999
 9999999
999999999

inputs: 13,1234567890,250
  1234567640
      -
      0
     000
    00000
   0000000
  344444443
 99999999999
9999999999999

inputs: 25,25,25
             0
             -
             0
            000
           00000
          0000000
         000000000
        00000000000
       0000000000000
      000000000000000
     00000000000000000
    0000000000000000000
   000000000000000000000
  00000000000000000000000
 1111111111111111111111111
Kevin Cruijssen
quelle
1
Für 5,100,10000warum tut 20+9+9+9+9+9+9+9+9+9 = 101?
Neil
@Neil Ich werde die Regeln ein wenig ändern, damit der Index nie über die Gesamtsumme hinausgeht. Wahrscheinlich besser zu verstehen.
Kevin Cruijssen
3
Related
Laikoni
Ist die erste Eingabe immer eine ungerade Zahl?
Brian H.
@BrianH. " Die Länge der unteren Kante wird immer ungerade sein. " Mir ist klar, dass ich bei dieser Herausforderung ein bisschen zu viele Regeln habe, sodass ich verstehen kann, dass Sie darüber hinausgelesen haben. :)
Kevin Cruijssen

Antworten:

3

05AB1E , 68 63 59 57 56 Bytes

IÅÉÅ9[DOO²Q#ćD_Piˆëć<¸«¸ì]ćā<ΣÉ}2äćR¸ì˜è¸ì¯ìJDSOIα'-‚ì.C

Probieren Sie es online!

Erläuterung

IÅÉÅ9
Wir initialisieren den Stack mit einer Liste von Neunern.
Jede Liste stellt eine Zeile dar, sodass die Länge jeder Liste ungerade ist und die Länge der letzten Liste der ersten Eingabe entspricht.
Eine Eingabe von 5 würde ergeben[[9], [9, 9, 9], [9, 9, 9, 9, 9]]

[DOO²Q#ćD_Piˆëć<¸«¸ì]
Wir iterieren dann über diese Listen und dekrementieren die Elemente in einer Liste, bis die Liste nur noch aus Nullen besteht. Dann fahren wir mit der nächsten Liste fort. Wir hören auf, wenn die Gesamtsumme der zweiten Eingabe entspricht.

[     #              ]   # loop until
 DOO                     # the sum of the list of lists
    ²Q                   # equals the second input
        ć                # extract the first list
         D_Pi            # if the product of the logical negation of all elements is true
             ˆ           # add the list to the global list
              ë          # else
               ć<        # extract the head and decrement it
                 ¸«      # append it to the list
                   ¸ì    # and prepend the list to the list of lists

Jetzt müssen wir die endgültige Liste aussortieren, indem wir das Entfernen von Elementen von wechselnden Seiten simulieren, anstatt wie bisher von links nach rechts.

ć                   # extract the row we need to sort
 ā<                 # push a list of indices of the elements [0 ... len(list)-1]
   ΣÉ}              # sort it by even-ness
      2äćR¸ì˜       # reverse the run of even numbers
                    # the resulting list will have 0 in the middle,
                      odd number increasing to the right and
                      even numbers increasing to the left
             è      # index into our final row with this
              ¸ì¯ì  # reattach all the rows to eachother

Jetzt formatieren wir die Ausgabe richtig

J              # join list of lists to list of strings
 DSOIα         # calculate the absolute difference of sum of our triangle and the 3rd input
      '-‚ì     # pair it with the string "-" and append to the list of rows
          .C   # join by newlines and center each row
Emigna
quelle
"Ja wirklich?" War das kompliziert?
Magic Octopus Urn
@MagicOctopusUrn: Sie sind herzlich eingeladen, mich herauszufordern :) Einige Dinge an dieser Methode wurden etwas chaotisch aufgrund von Sprachproblemen, die ich nicht besser gelöst habe. Vielleicht gibt es insgesamt einen besseren Weg? Vielleicht etwas Mathematischeres?
Emigna
Ich dachte irgendwie darüber nach, Binärzahlen zu verwenden ... dachte nicht ganz nach, hatte keine freie Stunde.
Magic Octopus Urn
Es ist eine Weile her, dass ich versucht habe, eine Ihrer Lösungen, die mehr als 20 Bytes umfasst, zu übertreffen. Etwas beschämt, es zuzugeben, aber wenn ich Ihre Antworten sehe, verschwende ich normalerweise keine Zeit mehr damit, nach Verbesserungen zu suchen. weil ich normalerweise kein hah finden kann!
Magic Octopus Urn
@MagicOctopusUrn: Schade. In der Regel finden Sie interessante Alternativen (und / oder Verbesserungen) zu meinen Lösungen. Große Programme in Golfsprachen sind sicherlich schwieriger zu bearbeiten.
Emigna
5

Sauber , 305 289 Bytes

import StdEnv
@[h:t]|all((==)9)h|t>[]=[h: @t]=[h]
#s=length h/2
#m=hd(sort h)+1
=[updateAt(hd[e\\e<-flatten[[s+i,s-i]\\i<-[0..s]]|h!!e<m])m h:t]
$a b c=flatlines(map(cjustify(a+1))[fromString(fromInt(b-c)),['-']:reverse(map(map(toChar o(+)48))((iterate@[repeatn(a-r)0\\r<-[0,2..a]])!!c))])

Probieren Sie es online!

Οurous
quelle
1
@ KevinCruijssen Behoben.
Οurous
1

Perl 5 , 301 Bytes

($x,$t,$u)=<>;$s=$x;$t-=$g=$t>$u?$u:$t;while($s>0){@{$a[++$i]}=((0)x$s,($")x($x-$s));$a[$i][$_%$s]++for 0..($f=$g<$s*9?$g:$s*9)-1;$g-=$f;$s-=2}say$"x(($x-length($g+=$t))/2+.5),$g,$/,$"x($x/2),'-';while(@b=@{pop@a}){for($i=1;$i<@b;$i+=2){print$b[-$i]}print$b[0];for($i=1;$i<@b;$i+=2){print$b[$i]}say''}

Probieren Sie es online!

Xcali
quelle
1

Charcoal , 68 63 62 Bytes

NθNηNζF⊘⊕θF⁹F⁻θ⊗ι«J⊘⎇﹪λ²⊕λ±λ±ι≔¬¬ζλ↑I⁺λIKK≧⁻λη≧⁻λζ»↑-M⊘⊖LIη←Iη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 5 Bytes gespart, indem die jetzt nicht mehr benötigte Indexbereichsprüfung entfernt wurde. Erläuterung:

NθNηNζ

Geben Sie die Länge in q, die Anzahl der Sandkörner in hund den Index in ein z.

F⊘⊕θF⁹F⁻θ⊗ι«

Führen Sie eine Schleife über die (q+1)/2Zeilen (von unten nach oben), dann 9 Körner in jeder Zelle in der Zeile und dann eine Schleife über die Ziffern in der Zeile.

J⊘⎇﹪λ²⊕λ±λ±ι

Zur Ziffer springen.

≔¬¬ζλ↑I⁺λIKK≧⁻λη≧⁻λζ»

Verteilen Sie nach Möglichkeit ein Sandkorn auf diese Ziffer, und verringern Sie dabei die verbleibende Sandmenge und den verbleibenden Index. Wenn wir den Index übergeben haben, werden dabei immer noch Leerzeichen in Nullen umgewandelt, wodurch die Sanduhr gefüllt wird. Die Ziffer wird nach oben gedruckt, da sich der Cursor nach der letzten Ziffer am Hals befindet.

↑-

Drucken Sie den Hals.

M⊘⊖LIη←Iη

Die verbleibende Sandmenge zentrieren und ausdrucken.

Neil
quelle