12

के रूप में एक दशमलव को देखते हुए <float>, <precision>, आप फ्लोट के दशमलव भाग (यानी अंश) के चित्रमय प्रतिनिधित्व को आकर्षित करते हैं। उदाहरण:

इनपुट: 6.75, 4आउटपुट:
```
6||| 7
 ---- 
```
6.75(इनपुट से पहला नंबर) समझाने के लिए नंबर है, 4(इनपुट से दूसरा नंबर) पाइप के नीचे डैश की संख्या है। 66.75 7में तैरता है, छत पर है 6.75। पाइप की संख्या है decimal part of first input number * second input number।
इनपुट: 10.5, 6आउटपुट:
```
10|||   11
  ------
```
इनपुट: 20.16, 12आउटपुट
```
20||          21
  ------------
```
.16 वास्तव में 1.92 पाइप लगते हैं, लेकिन जब से मैं 1.92 पाइप नहीं खींच सकता, मैं इसे 2 तक बढ़ा देता हूं।
इनपुट: 1.1, 12आउटपुट:
```
1|           2
 ------------
```
.1 इस मामले में 1.2 पाइप है, इसलिए इसे 1 पाइप पर रखा गया है।
इसके अलावा, एक किनारे का मामला। इनपुट: 5, 4(यानी संख्या पूर्णांक है), आउटपुट:
```
5    6
 ----
```

समझाने की संख्या सकारात्मक फ्लोट है, केवल आपकी भाषा क्षमताओं द्वारा सीमित है।
सटीक संख्या एक पूर्णांक है, 2 से अधिक (यानी न्यूनतम आवश्यक परिशुद्धता 4 है)। यह मनमाना बड़ा भी हो सकता है।
> = n.5 पाइपों को गोल किया जाता है, n + 1 तक (यानी 1.5 को 2 तक और 2.5 को 3 पर गोल किया जाता है)। <n.5 पाइप्स को n से गोल किया जाता है (यानी 1.4 को 1 से गोलाकार किया जाता है और 2.4 को 2 से गोल किया जाता है)।
यदि यह आपकी भाषा के लिए अधिक सुविधाजनक होगा, तो आप इनपुट को एक सरणी के रूप में ले सकते हैं, उदाहरण के लिए [6.75, 4]। यदि आप उल्टे क्रम में इनपुट लेते हैं, अर्थात [4, 6.75], कृपया अपने उत्तर में निर्दिष्ट करें।

code-golf ascii-art

— nicael
स्रोत

क्या आप वास्तव में वांछित आउटपुट प्रारूप के बारे में अधिक विशिष्ट हो सकते हैं?

— इसहाक

@isaacg मैंने चार उदाहरण आउटपुट दिखाए हैं। क्या अस्पष्ट है?

— निकेल

वहाँ कुछ कोने मामलों खुला होना प्रतीत होता है। उदाहरण के लिए इनपुट 5.0 4: यह से आकर्षित करता है 5करने के लिए 6या से 4करने के लिए 5, या किसी भी स्वीकार्य है? इनपुट 1.25 2: इसमें 0 या 1 |s है, और क्यों (यानी गोलाई नियम क्या है)? क्या इनपुट में पहला नंबर सकारात्मक होना चाहिए? इसकी अधिकतम परिशुद्धता और परिमाण क्या है? क्या इनपुट में दूसरा नंबर सकारात्मक होना चाहिए? यदि यह नकारात्मक है, तो क्या हम पीछे की ओर आकर्षित होते हैं?

— पीटर टेलर

@Peter स्पष्ट।

— निकेल

मुझे नहीं लगता कि आपने गोलाई नियम को कवर किया है।

— पीटर टेलर

6

सीजेएम, 32 बाइट्स

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

एक स्थान से अलग होने वाले पहले और दशमलव दूसरे को सटीक लेता है।

सभी परीक्षण मामलों को चलाएं।

व्याख्या

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.

— मार्टिन एंडर
स्रोत

हाँ, ठीक काम करने लगता है।

— निकेल

4

Mathematica, 119 बाइट्स

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

मैंने कोशिश की ... परीक्षण:

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

— LegionMammal978
स्रोत

क्या आप शायद एक कार्यशील डेमो प्रदान कर सकते हैं, या यह संभव नहीं है?

— 13

3

जाप, 47 46 बाइट्स

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

बस जोड़ने और दोहराने का एक गुच्छा।

इसे ऑनलाइन आज़माएं

— Downgoat
स्रोत

(U-Uf)U%1दो बाइट्स की बचत के समान है ।

— ETHproductions

3

जावा, 253 206 181 बाइट्स

सहेजे गए 47 बाइट्स @Kenney के लिए धन्यवाद, एक बार उपयोग की जाने वाली स्थितियों और चर द्वारा, और निरर्थक चरों को छांट कर।

टर्नरी ऑपरेटरों के साथ 2 छोरों को चालू करके @Kenney के लिए 25 बाइट्स के लिए धन्यवाद फिर से सहेजा गया।

शुद्ध स्ट्रिंग हेरफेर:

इनलाइन लूप संस्करण (181 बाइट्स):

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

4 छोरों संस्करण (206 बाइट्स):

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 संस्करण:

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.

काम करने के उदाहरण यहाँ ideone.com पर । पूरा कार्यक्रम STDIN इनपुट को स्वीकार करता है <float>,<precision>।

नोट: जावा के Math.round(float)राउंड RoundingMode.HALF_UPडिफ़ॉल्ट के रूप में उपयोग करते हैं , जो ओपी का आवश्यक व्यवहार है।

प्रदान किए गए परीक्षण मामलों का आउटपुट ओपी द्वारा प्रदान किए गए कार्यों से भिन्न था।

— तमोग्ना चौधरी
स्रोत

मुझे आशा है कि आप बुरा नहीं मानेंगे! आप a233 पर सेट करने के लिए (कभी भी उपयोग नहीं किए गए) को हटाना भूल गए । 210 बाइट्स में प्राप्त करने के लिए आप एक और 23 बचा सकते हैं: 13 के q.length()साथ प्रतिस्थापित करना b: 13 int g=(int)f, b=(""+g).length(), c=b, i=0;। forबचाता 6 की स्थिति में पुनरावृत्ति को बढ़ाना, और इनलाइनिंग d(एक बार उपयोग किया जाता है) 4: बचाता है

int c = b; for(;i++<b;)h+=" ";  for(;i++<=b+p;)h+="-";  for(i=c;i<c+Math.round((f-g)*p);i++)q+="|";  for(;i++<p+b;)q+=" ";

।

— केनेई

इसके अलावा, किसी ने भागने के अनुक्रम के बजाय एक वास्तविक न्यूलाइन का उपयोग करने का सुझाव दिया, लेकिन जब से मैं विंडोज पर हूं, यह एक सीआरएलएफ है, वैसे भी 2 बाइट्स दिए गए हैं\n

— तमोग्ना चौधरी

अच्छा - हाँ, bअप्रचलित रूप में अच्छी तरह बन गया ;-) आप कर सकते हैं अभी भी के लिए 2 में 1 बाइट बचाने: for(;i++<=c+p;)। आप खिड़कियों पर यूनिक्स लाइन के अंत के साथ फाइल को बचा सकते हैं, लेकिन दुर्भाग्य से जावा मल्टीलाइन स्ट्रिंग्स की अनुमति नहीं देता है ..

— केने

@ केनी, नहीं। मैंने वो कोशिश की। यह गलत तरीके से हाइफ़न ले जाता है। वैसे भी नौकरी के लिए जावा सही आदमी नहीं है।

— तमोग्ना चौधरी

मैं इसे 181 बाइट्स में केवल 2 छोरों के लिए इस्तेमाल करके नीचे ले आया:for(;i<c+p;)h+=i++<c?" ":"-";for(i=c;i<p+c;)q+=i++<c+Math.round((f-g)*p)?"|":" ";

— केनेई

3

जावास्क्रिप्ट ईएस 6, 105 104 बाइट्स

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

सहेजे गए 1 बाइट के लिए धन्यवाद, उम, आप वैसे भी thanks कैसे टाइप करते हैं?

— नील
स्रोत

क्षमा करें, मुझे महसूस नहीं हुआ कि डैश आउटपुट का हिस्सा थे, मुझे लगा कि वे रिक्त स्थान की कल्पना करने के लिए वहां थे।

— नील

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

— मामा फन रोल

अरे हाँ, \nएक वास्तविक newline के साथ बदलें । और इसे टेम्पलेट स्ट्रिंग्स में लपेटना सुनिश्चित करें।

— मामा फन रोल

2

हास्केल, 113 बाइट्स

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

उपयोग उदाहरण:

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

properFractionदशमलव को पूर्णांक और भिन्न भाग में विभाजित करता है। आउटपुट भागों (प्रारंभिक संख्या, बार, रिक्त स्थान, ...) की एक सूची है जिसे एक स्ट्रिंग (के माध्यम से >>=id) में समाहित किया जाता है ।

— nimi
स्रोत

क्या इसका ऑनलाइन डेमो देखना संभव है?

— निकेल

@nicael: डेमो ( mainएक पूर्ण कार्यक्रम के लिए एक आवरण के साथ )।

— nimi

सब कुछ ठीक लगता है (btw: वहाँ परीक्षण किया गया , लगता है कि यह एक और अधिक सुविधाजनक संकलक है)।

— निकेल

2

MATL , 49 बाइट्स

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

भाषा / संकलक के रिलीज 6.0.0 का उपयोग करता है । मतलाब या ऑक्टेव पर चलता है।

चुनौती के रूप में उसी क्रम में संख्या लेता है।

उदाहरण

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

व्याख्या

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

— लुइस मेंडो
स्रोत

क्या आपके पास ऑनलाइन दुभाषिया है?

— निकेल

अभी तक नहीं :-( मैटलैब या ऑक्टेव पर चलता है

— लुइस मेंडो

2

पर्ल, 90 बाइट्स

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

कमांडलाइन तर्कों के रूप में इनपुट की अपेक्षा करता है। एक फ़ाइल में सहेजें (कहते हैं 90.pl) और के रूप में चलाते हैंperl 90.pl 6.75 4

टिप्पणियों के साथ

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'

— केनी
स्रोत

1

स्टैकगोट , 31 27 बाइट्स

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

अधिकांश अन्य उत्तरों के समान। मैं देखूंगा कि क्या मैं ज्यादा गोल्फ कर सकता हूं। इनपुट को अल्पविराम से अलग किया जा सकता है, अंतरिक्ष को अलग किया जा सकता है, या लगभग कुछ भी अलग किया जा सकता है।

गैर-प्रतिस्पर्धा क्योंकि स्टैकजेट को इस चुनौती के बाद बनाया गया था

व्याख्या

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

— Downgoat
स्रोत

1

लुआ, 157 बाइट्स

लंबा, लेकिन एक छोटा समाधान नहीं मिल सकता है

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

आप ऑनलाइन लुआ का परीक्षण कर सकते हैं , निम्नलिखित परीक्षण मामले उपयोगी हो सकते हैं :)

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

— Katenkyo
स्रोत

1

सी, 233 231 बाइट्स

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

— कोल कैमरन
स्रोत

1

पायथन 3, 116 108 बाइट्स

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 लिंक

कुछ किरदारों को सहेजने के लिए सीके का शुक्रिया।

पहला संस्करण:

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 संस्करण:

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)

— जैक ब्रोंस्टीन
स्रोत

क्या आप कृपया एक कार्यशील डेमो प्रदान कर सकते हैं?

— निकेल

यह trinket.io लिंक काम करना चाहिए: trinket.io/python/409b1488f8

— जैक ब्रॉनस्टीन

यह वास्तव में स्टोर करने की तुलना में अंतरिक्ष शाब्दिक का उपयोग करने के लिए कम वर्ण लेता है। तुम भी बस के साथ सभी लाइनों में शामिल हो सकते हैं ;। आप केवल hएक बार उपयोग करते हैं , इसलिए आपको इसे भी इनलाइन करना चाहिए। कुछ वर्णों को बचाना चाहिए।

— देखिए

@ शाब्दिक अंतरिक्ष शाब्दिक पर अच्छी पकड़। आरंभ में मैं दूसरी पंक्ति के अंत में सफ़ेद स्थान की पैडिंग छाप रहा था; जब मुझे पता चला कि यह अनावश्यक था, मैंने बचत के लिए कोड की दोहरी जांच नहीं की। hजटिल काम है। lenकाम करने के लिए अंतिम दो पंक्तियों में संघनन और कार्य के लिए, lएक स्ट्रिंग होना चाहिए, इसलिए hइसे बदलने की आवश्यकता होगी str(int(l)+1)। hपरिवर्तित करने से पहले सेटिंग lकुछ वर्ण सहेजता है।

— जैक ब्रूनस्टीन 16-16 को 16

दशमलव समझाएं

सीजेएम, 32 बाइट्स

व्याख्या

Mathematica, 119 बाइट्स

जाप, 47 46 बाइट्स

जावा, 253 206 181 बाइट्स

जावास्क्रिप्ट ईएस 6, 105 104 बाइट्स

हास्केल, 113 बाइट्स

MATL , 49 बाइट्स

उदाहरण

व्याख्या

पर्ल, 90 बाइट्स

स्टैकगोट , 31 27 बाइट्स

व्याख्या

लुआ, 157 बाइट्स

Ungolfed

सी, 233 231 बाइट्स

Ungolfed:

पायथन 3, 116 108 बाइट्स

पहला संस्करण: