Dessinez une chronologie

23

Étant donné l'entrée d'une liste d'entiers représentant des dates, affichez une chronologie artistique ASCII comme suit:

<----------------------------->
  A     B  C           D    E

La chronologie ci-dessus est la sortie pour l'entrée [1990, 1996, 1999, 2011, 2016]. Notez plusieurs choses sur la chronologie:

  • La première ligne de sortie est un signe inférieur à ( <), un nombre de tirets égal à dateOfLastEvent - dateOfFirstEvent + 3(car un doit être ajouté pour inclure la dernière date, puis deux autres pour le remplissage), puis un signe supérieur à ( >).

  • Dans la deuxième ligne de sortie, chaque événement est placé en position dateOfEvent - dateOfFirstEvent + 2(en supposant une indexation nulle). Par conséquent, le premier événement est placé en position 2, deux caractères à droite de la <, et le dernier événement est de même deux caractères à gauche de la >.

  • Chaque événement est représenté par une lettre. L'événement 1 est A, l'événement 2 est B, etc. Il n'y aura jamais plus de 26 événements. Vous pouvez utiliser des lettres minuscules si vous le souhaitez.

  • Il n'y a pas d'espace blanc arrière. Le seul espace supplémentaire autorisé est un retour à la fin à la fin du programme.

En outre,

  • Les événements ne sont pas nécessairement donnés dans l'ordre. Cependant, les dates sont toujours étiquetées en fonction de leur position dans le tableau. Par exemple, une entrée de [2, 3, 1, 5, 4]must output

    <------->
  CABED

  • Vous pouvez recevoir un ou plusieurs événements en entrée. Par exemple, une entrée de [12345]must output

    <--->
  A

  • Vous pouvez supposer que l'entrée ne contiendra jamais de dates en double.

L'entrée peut être donnée sous la forme d'un tableau / liste d'entiers / chaînes ou d'une chaîne unique séparée par un caractère non numérique. La plage de dates autorisée qui sera fournie en entrée est 1 ≤ x ≤ 32767.

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

Cas de test:

32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA
2015 2014
<---->
  BA
1990 1996 1999 2011 2016
<----------------------------->
  A     B  C           D    E
2 3 1 5 4
<------->
  CABED
12345
<--->
  A
code-golf ascii-art Poignée de porte
la source

Réponses:

5

Pyth, 37 36 35 34 octets

:*dlp++\<*\-+3-eJSQhJ">
"mhh-dhJQG

Explication: (pour cela la nouvelle ligne sera remplacée par \npour plus de simplicité)

:*dlp++\<*\-+3-eJSQhJ">\n"mhh-dhJQG

                                    - autoassign Q = eval(input())
                                    - G = "abcdefghijklmnopqrstuvwxyz"

    p++\<*\-+3-eJSQhJ">\n"          -    print out the first line

            +3-eJSQhJ               -        Get the number of dashes
                 SQ                 -            sorted(Q)
                J                   -           autoassign J = ^
               e                    -          ^[-1]
              -                     -         ^-V
                   hJ               -          J[0]
            +3                      -        ^+3

         *\-                        -       ^*"-"
      +\<                           -      "<"+^
     +               ">\n"          -     ^+"-->\n"
    p                               -    print(^)

 *dl                                -  work out the number of spaces to print
   l                                -   len(^)
 *d                                 -  ^*" "
:                                 G - For i in V: ^[i] = G[i]
                          mhh-dhJQ  -  Work out the positions of the characters
                          m      Q  -  [V for d in Q]
                               hJ   -     J[0]
                             -d     -    d-^
                           hh       -   ^+2

Essayez-le ici!

Bleu
la source
5

PowerShell, 120 108 octets

param($a)$n,$m=($a|sort)[0,-1];"<$('-'*($b=$m-$n+3))>";$o=,' '*$b;$i=97;$a|%{$o[$_-$n+2]=[char]$i++};-join$o

Prend entrée $apuis définit $net $maux valeurs minimale et maximale, respectivement. Nous sortons la chronologie avec la section suivante, en exécutant un bloc de code $(...)à l'intérieur de la chaîne pour générer le nombre approprié de -caractères. Nous générons ensuite un tableau de la même longueur contenant uniquement des espaces et définissons notre caractère de sortie sur $i.

Ensuite, nous parcourons l'entrée $aavec |%{...}. Chaque boucle, nous définissons la $ovaleur appropriée . Enfin, nous -join $oensemble pour former une chaîne. Étant donné que cela reste sur le pipeline, la sortie est implicite.

Modifié pour supprimer la .TrimEnd()commande, car le dernier caractère de $oest toujours garanti être une lettre.

Exemple

PS C:\Tools\Scripts\golfing> .\draw-a-timeline.ps1 2015,2014,2000
<------------------>
  c             ba
AdmBorkBork
la source
4

C - 294 287 220 191 184 178 174 174 octets

Après avoir regardé avec un code un peu fou, je l'ai au moins un peu descendu ...

Remarque: La première boucle requiert que l'exécution du binaire donne 0 comme résultat de atoi()on argv[0]. Sinon, cela entraînerait l'inclusion du binaire (nom) en tant qu'événement. Exemples qui invalident:

$ 42/program 1 2 3
# 42/program gives 42 from argv[0], fail.

$ 1program 3 2 9
# 1program gives 1 from argv[0], fail.

$ 842 3 2 9
# 842 gives 842 from argv[0], fail.

Je ne sais pas s'il s'agit d'une exigence valide.

char y[32769];n,m;main(i,a)char**a;{for(;n=atoi(a[--i]);y[n>m?m=n:n]=64+i);for(;!y[++i];);printf("<");for(n=i;i<=m;i+=printf("-"))!y[i]?y[i]=' ':0;printf("-->\n  %s\n",y+n);}

Courir:

./cabed 32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA

./cabed 2 1 3 5 4
<------->
  BACED

./cabed 2016
<--->
  A

./cabed 130 155 133 142 139 149 148 121 124 127 136
<------------------------------------->
  H  I  J  A  C  K  E  D     GF     B

Non golfé:

#include <stdio.h>
#include <stdlib.h>

char y[32769]; /* Zero filled as it is in global scope. */
int n, m;

int main(i, a) 
    char**a; 
{
    /* Loop argv and set y[argv[i] as int] = Letter, (Event name).
     * Set m = Max value and thus last data element in y. */
    for ( ; n = atoi(a[--i]); y[n > m ? m = n : n] = 64 + i)
        ;

    /* i = 0. Find first element in y that has a value. (Min value.) */
    for (; !y[++i]; )
        ;

    printf("<");

    /* Save min value / y-index where data starts to n.
     * Print dashes until y-index = max 
     * Build rest of event string by filling in spaces where no letters.*/
    for (n = i; i <= m; i += printf("-"))
        !y[i] ? y[i] = ' ' : 0;

    printf("-->\n  %s\n", y + n);

    return 0;
}
Runium
la source
3

MATL , 40 41 octets

0lY2in:)GtX<-I+(t~32w(ctn45lbX"60hP62hcw

Essayez-le en ligne!

0          % array initiallized to 0
lY2        % string 'ABC...Z'
in:)       % input array. Take as many letters as its length
GtX<-I+    % push input again. Duplicate, subtract minimum and add 3
(          % assign selected letter to those positions. Rest entries are 0
t~32w(     % replace 0 by 32 (space)
c          % convert to char
tn45lbX"   % duplicate, get length. Generate array of 45 ('-') repeated that many times
60hP62h    % prepend 60 ('<'), postpend 62 ('>')
c          % convert to char
w          % swap. Implicit display
Luis Mendo
la source
2

Ruby, 83 caractères

->a{n,m=a.minmax
s=' '*(d=m-n+3)
l=?@
a.map{|i|s[i-n+2]=l.next!}
puts ?<+?-*d+?>,s}

Exemple d'exécution:

irb(main):001:0> ->a{n,m=a.minmax;s=' '*(d=m-n+3);l=?@;a.map{|i|s[i-n+2]=l.next!};puts ?<+?-*d+?>,s}[[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762]]
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA
homme au travail
la source
2

JavaScript (ES6), 124

l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

TESTER 

F=
l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

console.log=x=>O.textContent+=x+'\n'

test= [[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762],
[2015,2014],[1990,1996,1999,2011,2016],[2,3,1,5,4],[12345]]

test.forEach(x=>console.log(x+'\n'+F(x)+'\n'))
<pre id=O></pre>
Développer l'extrait

edc65
la source
2

PHP, 129 126 125 121 117 115 115 octets

Utilise le codage ISO 8859-1.

$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

php -r '$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);' 1990 1996 1999 2016 2011 2>/dev/null;echo

Version non golfée:

// Get the highest input value.
$h = max($z = $argv);

// Get the lowest value, setting the first argument (script name) to the highest
// so it is ignored.
$l = min([$h] + $z);

// Output the first line.
echo "<".str_repeat("-",$h - $l + 3).">\n  ";

// Iterate from $l to $h.
for(;$l <= $h;)
    // Find the index of the current iteration. If found, convert the numeric
    // index to a char. If not found, print a space.
    echo ($s = array_search($l++, $z)) ? chr($s+64) : " ";
  • Sauvegardé 3 octets en imprimant les espaces de tête de la boucle et en changeant <=en <.
  • Enregistré un octet en utilisant str_padau lieu de str_repeat.
  • 4 octets enregistrés en utilisant la logique au niveau du bit pour convertir 0 ( false) en 32, et tout ce qui est supérieur à 0 en 97. Convertissez ensuite ce nombre en char.
  • Enregistré 4 octets en utilisant ASCII étendu niée Céder <, -, >et retour à la ligne
  • Enregistré 2 octets en annulant la chaîne après le remplissage au lieu d'avant
aross
la source
1

Perl, 109 octets

comprend +1 pour -p

$l=A;s/\d+/$h{$&}=$l++/ge;($a,$z)=(sort keys%h)[0,-1];$o.=$h{$_}//$"for$a..$z;$_='<'.'-'x($z-$a+3).">$/  $o"

Attend une entrée sur stdin: nombres séparés par des espaces. Exemple:

$ echo 2016 2012 2013 | perl -p file.pl
<------->
  BC  A

Assez lisible:

$l=A;                                   # Intialize $l with the letter A
s/\d+/$h{$&}=$l++/ge;                   # construct %h hash with number->letter
($a,$z) = (sort keys %h)[0,-1];         # grab min/max numbers
$o .= $h{$_} // $" for $a..$z;          # construct 2nd line: letter or space
$_= '<' . '-' x ($z-$a+3) . ">$/  $o"   # construct 1st line, merge both lines to $_ output
Kenney
la source
1

Python 2, 173 172 182 octets

puisque Python manque encore, voici mon premier post:

import sys
d=dict([(int(v),chr(65+i))for(i,v)in enumerate(sys.argv[1:])])
k=sorted(d.keys())
f=k[0]
s=k[-1]-f+3
o=list(" "*s)
for i in k:o[i-f+2]=d[i]
print "<"+"-"*s+">\n"+"".join(o)

l'original ressemble à ceci:

import sys

dates = dict([(int(v), chr(65+i)) for (i,v) in enumerate(sys.argv[1:])])
keys = sorted(dates.keys())
first = keys[0]
out_size = keys[-1] - first + 3
out = list(" " * out_size)
for date in keys: out[date - first + 2] = dates[date]
print "<" + "-" * out_size + ">\n" + "".join(out)
BloodyD
la source
1
Vous avez besoin import sysdans votre version golfée.
Mego
ok, je le ferai, mais je n'ai jamais vu d'importations dans les versions golf, alors je l'ai juste laissé de côté
BloodyD
0

Groovy, 106 99 caractères

{n=it.min()
o=[l="A"]
it.each{o[it-n]=l++}
"<${"-"*(it.max()-n+3)}>\n  "+o.collect{it?:" "}.join()}

Exemple d'exécution:

groovy:000> print(({n=it.min();o=[l="A"];it.each{o[it-n]=l++};"<${"-"*(it.max()-n+3)}>\n  "+o.collect{it?:" "}.join()})([32767,32715,32716,32750,32730,32729,32722,32766,32740,32762]))
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA
homme au travail
la source