Bei einer Dezimalzahl in Form von <float>, <precision>zeichnen Sie die grafische Darstellung des Dezimalteils (dh des Bruchs) des Gleitkommas. Beispiele:

1. Eingang: 6.75, 4Ausgang:

   6||| 7
    ---- 
   

   6.75(erste Zahl von der Eingabe) ist die zu erklärende Zahl, 4(die zweite Zahl von der Eingabe) ist die Anzahl der Striche unter den Rohren. Ist 6der Boden 6,75, 7ist die Decke 6.75. Die Anzahl der Rohre ist die decimal part of first input number * second input number.

2. Eingang: 10.5, 6Ausgang:

   10|||   11
     ------
   

3. Eingang: 20.16, 12Ausgang

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

   .16 Tatsächlich dauert 1,92 Pfeifen, aber da ich 1,92 Pfeifen nicht zeichnen kann, decke ich es auf 2.

4. Eingang: 1.1, 12Ausgang:

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

   .1 beträgt in diesem Fall 1,2 Rohre, es ist also auf 1 Rohr ausgelegt.

5. Auch ein Randfall. Eingabe: 5, 4(dh die Zahl ist eine Ganzzahl), Ausgabe:

   5    6
    ----
   

• Die Zahl, die zu erklären ist, ist der positive Schwimmer, der nur durch Ihre Sprachfähigkeiten begrenzt wird.
• Die Genauigkeitszahl ist eine gerade Ganzzahl, die größer als 2 ist (dh die erforderliche Mindestgenauigkeit beträgt 4). Es kann auch beliebig groß sein.
• > = n.5 Pipes werden auf n + 1 aufgerundet (dh 1.5 wird auf 2 gerundet und 2.5 wird auf 3 gerundet). <n.5 Rohre werden auf n gerundet (dh 1.4 wird auf 1 gerundet und 2.4 wird auf 2 gerundet).
• Wenn es für Ihre Sprache praktischer wäre, können Sie die Eingabe als Array verwenden, z [6.75, 4]. Wenn Sie die Eingabe in umgekehrter Reihenfolge vornehmen [4, 6.75], geben Sie dies bitte in Ihrer Antwort an.

CJam, 32 Bytes

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

Nimmt die Genauigkeit zuerst und die Dezimalsekunde, getrennt durch ein Leerzeichen.

Führen Sie alle Testfälle aus.

Erläuterung

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

Ich habe versucht ... Testen:

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

Nur ein Haufen Hinzufügen und Wiederholen.

Probieren Sie es online aus

Java, 253 206 181 Bytes

Dank @Kenney 47 Byte gespart, indem Bedingungen und Variablen, die einmal verwendet wurden, eingefügt und redundante Variablen aussortiert wurden.

Dank @Kenney konnten erneut 25 Byte gespart werden, indem 2 Schleifen mit ternären Operatoren eingefügt wurden.

Reine Saitenmanipulation:

Inline-Loop-Version (181 Byte):

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 mit 4 Schleifen (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;}

Ungolfed-Version:

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.

Arbeitsbeispiel hier bei ideone.com . Das vollständige Programm akzeptiert die STDIN-Eingabe als <float>,<precision> .

HINWEIS: Javas Math.round(float)Runden verwendenRoundingMode.HALF_UP standardmäßig verwendet. Dies ist das erforderliche Verhalten des OP.

Die Ausgabe der bereitgestellten Testfälle stimmte nicht mit der Ausgabe des OP überein.

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)

1 Byte gespart dank, ähm, wie tippst du überhaupt??

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

Anwendungsbeispiel:

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

properFractionTeilt die Dezimalzahl in Ganzzahl und Bruchteil. Die Ausgabe ist eine Liste der Teile (Anfangsnummer, Striche, Leerzeichen, ...), die zu einer einzelnen Zeichenfolge (Via >>=id) verkettet sind .

MATL , 49 Bytes

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

Verwendet Release 6.0.0 der Sprache / des Compilers. Läuft auf Matlab oder Octave.

Nimmt Zahlen in der gleichen Reihenfolge wie bei der Challenge.

Beispiele

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

Erläuterung

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

Erwartet Eingaben als Befehlszeilenargumente. In einer Datei speichern (sprich 90.pl) und ausführen alsperl 90.pl 6.75 4

Mit Kommentaren

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

Ähnlich wie bei den meisten anderen Antworten. Ich werde sehen, ob ich mehr Golf spielen kann. Die Eingabe kann durch Kommas, Leerzeichen oder fast alles getrennt sein.

Nicht konkurrierend, da Stackgoat nach dieser Herausforderung hergestellt wurde

Erläuterung

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

Lange, aber keine kürzere Lösung finden

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

Ungolfed

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

Sie können lua online testen , die folgenden Testfälle könnten hilfreich sein :)

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

Ungolfed:

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

trinket.io Link

Vielen Dank an Seeq für das Speichern einiger Zeichen.

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

Ungolfed-Version:

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)