Étant donné une décimale sous la forme de <float>, <precision>, vous dessinez la représentation graphique de la partie décimale (c'est-à-dire la fraction) du flotteur. Exemples:

1. Entrée:, 6.75, 4sortie:

   6||| 7
    ---- 
   

   6.75(premier nombre de l'entrée) est le nombre à expliquer, 4(le deuxième nombre de l'entrée) est le nombre de tirets sous les tuyaux. 6est le plancher 6,75, 7est le plafond 6.75. Le nombre de tuyaux est le decimal part of first input number * second input number.

2. Entrée:, 10.5, 6sortie:

   10|||   11
     ------
   

3. Entrée:, 20.16, 12sortie

   20||          21
     ------------
   

   .16 prend en fait 1,92 tuyaux, mais comme je ne peux pas dessiner 1,92 tuyaux, je le plafonne à 2.

4. Entrée:, 1.1, 12sortie:

   1|           2
    ------------
   

   .1 est de 1,2 tuyau dans ce cas, il est donc fixé à 1 tuyau.

5. En outre, un cas de bord. Entrée: 5, 4(c'est-à-dire que le nombre est un entier), sortie:

   5    6
    ----
   

• Le nombre à expliquer est le flottant positif, limité uniquement par vos capacités linguistiques.
• Le nombre de précision est un entier pair, supérieur à 2 (c'est-à-dire que la précision minimale requise est 4). Il peut également être arbitraire.
• > = n.5 tuyaux sont arrondis à n + 1 (ie 1,5 est arrondi à 2 et 2,5 est arrondi à 3). <n.5 les tuyaux sont arrondis à n (c'est-à-dire que 1,4 est arrondi à 1 et 2,4 est arrondi à 2).
• Si cela serait plus pratique pour votre langue, vous pouvez prendre l'entrée comme un tableau, par exemple [6.75, 4]. Si vous prenez l'entrée dans l'ordre inverse, c'est [4, 6.75]-à- dire , veuillez le spécifier dans votre réponse.

CJam, 32 octets

l~1md@:X*mo'|*XSe]1$)NW$s,S*'-X*

Prend la précision en premier et la seconde décimale, séparées par un espace.

Exécutez tous les cas de test.

Explication

l~   e# Read input and evaluate, pushing precision and decimal on the stack.
1md  e# Divmod 1, separating the decimal into integer and fractional part.
@:X  e# Pull up precision, store in X.
*mo  e# Multiply precision by fractional part and round.
'|*  e# Push that many vertical bars.
XSe] e# Pad with length X with spaces.
1$)  e# Copy integer part and increment.
N    e# Push linefeed.
W$   e# Copy integer part.
s,   e# Get number of digits as length of string representation.
S*   e# Push that many spaces, to indent the hyphens correctly.
'-X* e# Push X hyphens.

Mathematica, 119 octets

a=ToString;b=Array;a[c=Floor@#]<>{b["|"&,d=Round[#2#~Mod~1]],b[" "&,#2-d],a[c+1],"
"," "&~b~IntegerLength@c,"-"&~b~#2}&

J'ai essayé ... Test:

In[1]:= a=ToString;b=Array;f=a[c=Floor@#]<>{b["|"&,d=Round[#2#~Mod~1]],b[" "&,#2-d],a[c+1],"\n"," "&~b~IntegerLength@c,"-"&~b~#2}&;

In[2]:= f[6.75, 4]

Out[2]= 6||| 7
         ----

In[3]:= f[10.5, 6]

Out[3]= 10|||   11
          ------

In[4]:= f[20.16, 12]

Out[4]= 20||          21
          ------------

In[5]:= f[1.1, 12]

Out[5]= 1|           2
         ------------

In[6]:= f[5, 4]

Out[6]= 5    6
         ----

Japt, 47 46 octets

Uf +'|pA=ºU-Uf)*V c)+SpV-A +Uc +R+SpUk l)+'-pV

Juste un tas d'ajouts et de répétitions.

Essayez-le en ligne

Java, 253 206 181 octets

Enregistrement de 47 octets grâce à @Kenney en insérant les conditions et les variables utilisées une fois et en triant les variables redondantes.

Encore 25 octets enregistrés grâce à @Kenney en insérant 2 boucles avec des opérateurs ternaires.

Manipulation de cordes pure:

Version des boucles intégrées (181 octets):

String m(float f,int p){int g=(int)f,i=0;String h="",q=""+g;int c=q.length();for(;i<c+p;)h+=i++<c?" ":"-";for(i=c;i<p+c;)q+=i++<c+Math.round((f-g)*p)?"|":" ";return q+(g+1)+"\n"+h;}

Version 4 boucles (206 octets):

String m(float f,int p){int g=(int)f,i=0;String h="",q=""+g;int c=q.length();for(;i++<c;)h+=" ";for(;i<=c+p;i++)h+="-";for(i=c;i<c+Math.round((f-g)*p);i++)q+="|";for(;i++<p+c;)q+=" ";return q+(g+1)+"\n"+h;}

Version non golfée:

String m(float f,int p){
//initialize some useful values, d is the number of pipes needed
int g=(int)f,d=Math.round((f-g)*p),i=0;
String h="",q=""+g;//append the floored value to the pipe string first
int c=q.length();
for(;i<c;i++)h+=" ";//pad hyphen string with spaces for alignment
for(++i;i<=c+p;i++)h+="-";//append hyphens
for(i=c;i<c+d;i++)q+="|";//append pipes
for(;i<p+c;i++)q+=" ";//append spaces for padding
return q+(g+1)+"\n"+h;}//concatenate the strings in order, separating the strings with a UNIX newline, and return it.

Exemple de travail ici sur ideone.com . Le programme complet accepte l'entrée STDIN en tant que <float>,<precision>.

REMARQUE: les Math.round(float)tours de Java utilisent RoundingMode.HALF_UPpar défaut, ce qui est le comportement requis de l'OP.

La sortie des cas de test fournis était différente de celle fournie par le PO.

Javascript ES6, 105 104 octets

(f,p)=>(i=f|0)+("|".repeat(j=(f-i)*p+.5|0)+" ".repeat(p-j))+(i+1)+(`
`+i).replace(/\d/g," ")+"-".repeat(p)

1 octet enregistré grâce à, euh, comment tapez-vous ՊՓԼՃՐՊՃՈԲՍԼ de toute façon?

Haskell, 113 octets

(%)=replicate.round
s=show
x!y|(n,m)<-properFraction x=[s n,(y*m)%'|',(y-y*m)%' ',s$n+1,"\n",s n>>" ",y%'-']>>=id

Exemple d'utilisation:

*Main> putStrLn $ 20.16 ! 12
20||          21
  ------------

properFractiondivise la décimale en sa partie entière et fraction. La sortie est une liste des parties (nombre initial, barres, espaces, ...) qui est concaténée en une seule chaîne (via >>=id).

MATL , 49 octets

2#1\tYUbiXK*Yo'|'1bX"tnKw-Z"hb1+YUhht4Y2m13*_45+c

Utilise la version 6.0.0 du langage / compilateur. Fonctionne sur Matlab ou Octave.

Prend les nombres dans le même ordre que dans le défi.

Exemples

>> matl
 > 2#1\tYUbiXK*Yo'|'1bX"tnKw-Z"hb1+YUhht4Y2m13*_45+c
 >
> 20.16
> 12
20||          21
  ------------

>> matl
 > 2#1\tYUbiXK*Yo'|'1bX"tnKw-Z"hb1+YUhht4Y2m13*_45+c
 >
> 5
> 4
5    6
 ----

Explication

2#1\       % implicit input 1st number. Separate decimal and integer part
tYU        % duplicate integer part and convert to string
biXK*Yo    % input 2nd number. Copy it. Multiply by decimal part of 1st number and round
'|'1bX"    % row vector of as many '|' as needed
tnKw-Z"    % row vector of as many spaces as needed
h          % concat horiontally
b1+YUhh    % integer part of 1st number plus 1. Convert to string. Concat twice
t4Y2m      % detect numbers in this string
13*_45+c   % transform numbers into spaces, and non-numbers into '|'
           % implicitly display both strings

Perl, 90 octets

print$f,"|"x($d=.5+($b=pop)*(($a=pop)-($f=0|$a))),$"x(1+$b-$d),$f+1,$/,$"x length$f,"-"x$b

Attend l'entrée comme arguments de ligne de commande. Enregistrer dans un fichier (par exemple 90.pl) et exécuter en tant queperl 90.pl 6.75 4

Avec commentaires

print $f,                        # floored input (initialized below due to expr nesting)
      "|" x ($d=.5+              # rounded pipe count (`x` operator casts to int)
             +($b=pop)           # second argument  (executed first)
             *( ($a=pop)         # first argument   (executed second)
               -($f=0|$a) )      # minus floored first argument = fractional part
            ),
      $"x(1+$b-$d),              # spaces
      $f+1,                      # floored + 1
      $/,                        # newline
      $"  x length $f,           # 2nd line alignment
      "-" x $b                   # the 'ruler'

Stackgoat , 31 27 octets

CFv1%C*D'|^w1P-Y^vHXNY^w'-^

Similaire à la plupart des autres réponses. Je vais voir si je peux jouer au golf plus. L'entrée peut être séparée par des virgules, séparée par des espaces ou presque n'importe quoi.

Non compétitif car Stackgoat a été créé après ce défi

Explication

CF   // Input, floored, push to stack
v1%  // Decimal part
C*   // Times second part
D    // Duplicate that result
'|^  // Repeat | by previous number
w    // Second input
1P   // Move # of |'s to the top of stack
-    // Subtract
Y^   // Repeat " " by above number
vH   // Ceil first input
X    // Newline
Z+   // Add to 
N    // Get length of first #
Y^   // Repeat by spaces
w'-  // Repeat - second input times

Lua, 157 octets

Long, mais ne trouve pas de solution plus courte

function f(d,n)r=""a=math.floor(d)d,s=d-a,a..r for i=1,#s do r=r.." "end for i=1,n do s,r=s..(i-.5>n*d and" "or"|"),r.."-"end s=s..a+1 return s.."\n"..r end

Non golfé

function g(d,n)
  r=""
  a=math.floor(d)
  d,s=d-a,a..r                         -- d now contains its decimal part
  for i=1,#s do r=r.." "end            -- padding the hyphens
  for i=1,n
  do
    s,r=s..(i-.5>n*d and" "or"|"),r.."-"
    -- s is concatenated with a "|" if i-.5>n*d, a space otherwise
  end
  s=s..a+1
  return s.."\n"..r
end

Vous pouvez tester lua en ligne , les cas de test suivants pourraient être utiles :)

function f(d,n)r=""a=math.floor(d)d,s=d-a,a..r for i=1,#s do r=r.." "end for i=1,n do s,r=s..(i-.5>n*d and" "or"|"),r.."-"end s=s..a+1 return s.."\n"..r end
print(f(16.75,4))
print(f(5,4))
print(f(20.16,12))

C, 233 231 octets

#include <stdlib.h>
#include <math.h>
i,n,l;main(c,v)char**v;{double m;l=atol(v[2]);n=(int)(modf(atof(v[1]),&m)*l+0.5);c=printf("%.f",m);for(;i++<l;)putchar(i>n?32:'|');printf("%.f\n",m+1);printf("%*s",c,"");for(;--i;)putchar(45);}

Non golfé:

#include <stdlib.h>
#include <math.h>
i,n,l;

main(c,v)
char**v;
{
    double m;
    l=atol(v[2]); /* Get length from command line */
    n=(int)(modf(atof(v[1]),&m)*l+0.5); /* Get number of pipes and lower limit */
    c=printf("%.f",m); /* print lower limit */

    /* print pipes and spaces */
    for(;i++<l;)
            putchar(i>n?32:'|');

    /* print upper limit */
    printf("%.f\n",m+1);

    /* print spaces before dashes */
    printf("%*s",c,"");

    /* print dashes */
    for(;--i;)
            putchar(45);
}

Python 3, 116 108 octets

def f(F,P):l=int(F);h,p=str(l+1),int((F-l)*P+.5);l=str(l);print(l+"|"*p+" "*(P-p)+h);print(" "*len(l)+"-"*P)

lien trinket.io

Merci à Seeq d'avoir sauvé quelques caractères.

Première version:

def f(F,P):
 l=int(F)
 h,s,p=str(l+1)," ",int((F-l)*P+.5)
 l=str(l)
 print(l+"|"*p+s*(P-p)+h)
 print(s*len(l)+"-"*P)

Version non golfée:

def frac(F,P):
        low = int(F)
        high = low+1
        pipes = int((F-low)*P+.5)
        print(str(low)+"|"*pipes+" "*(P-pipes)+str(high))
        print(" "*len(str(low))+"-"*P)