Dado un decimal en forma de <float>, <precision>, dibuja la representación gráfica de la parte decimal (es decir, fracción) del flotador. Ejemplos:

1. Entrada: 6.75, 4salida:

   6||| 7
    ---- 
   

   6.75(primer número de la entrada) es el número a explicar, 4(el segundo número de la entrada) es el número de guiones debajo de las tuberías. 6es el piso 6.75, 7es el techo 6.75. El número de tuberías es el decimal part of first input number * second input number.

2. Entrada: 10.5, 6salida:

   10|||   11
     ------
   

3. Entrada: 20.16, 12salida

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

   .16 en realidad toma 1.92 tuberías, pero como no puedo dibujar 1.92 tuberías, lo limito a 2.

4. Entrada: 1.1, 12salida:

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

   .1 es de 1.2 tubos en este caso, por lo que tiene un piso de 1 tubo

5. Además, un caso de borde. Entrada: 5, 4(es decir, el número es un entero), salida:

   5    6
    ----
   

• El número a explicar es la flotación positiva, limitada solo por sus habilidades lingüísticas.
• El número de precisión es un entero par, mayor que 2 (es decir, la precisión mínima requerida es 4). También puede ser arbitrariamente grande.
• > = n.5 tuberías se redondean hacia arriba, a n + 1 (es decir, 1.5 se redondea a 2 y 2.5 se redondea a 3). <n.5 tuberías se redondean a n (es decir, 1.4 se redondea a 1 y 2.4 se redondea a 2).
• Si fuera más conveniente para su idioma, puede tomar la entrada como una matriz, por ejemplo [6.75, 4]. Si toma la entrada en el orden inverso, es decir [4, 6.75], especifíquela en su respuesta.

CJam, 32 bytes

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

Toma la precisión primero y el segundo decimal, separados por un espacio.

Ejecute todos los casos de prueba.

Explicación

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 bytes

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

Lo intenté ... Prueba:

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 bytes

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

Solo un montón de sumar y repetir.

Pruébalo en línea

Java, 253 206 181 bytes

Ahorré 47 bytes gracias a @Kenney al alinear las condiciones y las variables utilizadas una vez, y al ordenar las variables redundantes.

Ahorré 25 bytes nuevamente gracias a @Kenney al alinear 2 bucles con operadores ternarios.

Manipulación de cuerda pura:

Versión de bucles en línea (181 bytes):

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

Versión de 4 bucles (206 bytes):

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

Versión sin golf:

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.

Ejemplo de trabajo aquí en ideone.com . El programa completo acepta la entrada STDIN como <float>,<precision>.

NOTA: las Math.round(float)rondas de Java se usan RoundingMode.HALF_UPpor defecto, que es el comportamiento requerido del OP.

El resultado de los casos de prueba proporcionados coincidió con lo que proporcionó el OP.

Javascript ES6, 105 104 bytes

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

Guardado 1 byte gracias a, um, ¿cómo se escribe ՊՓԼՃՐՊՃՈԲՍԼ de todos modos?

Haskell, 113 bytes

(%)=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

Ejemplo de uso:

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

properFractiondivide el decimal en su parte entera y fracción. La salida es una lista de las partes (número inicial, barras, espacios, ...) que se concatenan en una sola cadena (vía >>=id).

MATL , 49 bytes

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

Utiliza la versión 6.0.0 del lenguaje / compilador. Se ejecuta en Matlab u Octave.

Toma los números en el mismo orden que en el desafío.

Ejemplos

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

Explicación

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 bytes

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

Espera entrada como argumentos de línea de comandos. Guardar en un archivo (digamos 90.pl) y ejecutar comoperl 90.pl 6.75 4

Con comentarios

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 bytes

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

Similar a la mayoría de las otras respuestas. Veré si puedo jugar más al golf. La entrada puede estar separada por comas, espacio o casi cualquier cosa.

No compite porque Stackgoat se hizo después de este desafío

Explicación

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 bytes

Largo, pero no puedo encontrar una solución más corta

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

Sin 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

Puede probar lua en línea , los siguientes casos de prueba podrían ser útiles :)

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 bytes

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

Sin 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, 116108 bytes

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)

enlace trinket.io

Gracias a Seeq por guardar algunos caracteres.

Primera versión:

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)

Versión sin golf:

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)