দশমিকগুলি ব্যাখ্যা কর

12

আকারে দশমিক দেওয়া <float>, <precision>, আপনি ভাসনের দশমিক অংশ (অর্থাত্ ভগ্নাংশ) এর গ্রাফিকাল উপস্থাপনা আঁকুন। উদাহরণ:

  1. ইনপুট:, 6.75, 4আউটপুট:

    6||| 7
 ----

    6.75(ইনপুট থেকে প্রথম সংখ্যা) ব্যাখ্যা করার সংখ্যা, 4(ইনপুট থেকে দ্বিতীয় সংখ্যা) পাইপগুলির নীচে ড্যাশগুলির সংখ্যা। 6মেঝে 6.75, 7সিলিং হয় 6.75। পাইপ সংখ্যা decimal part of first input number * second input number।

  2. ইনপুট:, 10.5, 6আউটপুট:

    10|||   11
  ------

  3. ইনপুট:, 20.16, 12আউটপুট

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

    .16 আসলে ১.৯২ পাইপ লাগে, তবে যেহেতু আমি ১.৯২ পাইপ আঁকতে পারি না, তাই আমি এটি সিলিং করে ২ এ to

  4. ইনপুট:, 1.1, 12আউটপুট:

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

    .1 এই ক্ষেত্রে 1.2 পাইপ হয়, তাই এটি 1 পাইপ থেকে মেঝেতে।

  5. এছাড়াও, একটি প্রান্ত মামলা। ইনপুট: 5, 4(অর্থাত্ সংখ্যাটি একটি পূর্ণসংখ্যা), আউটপুট:

    5    6
 ----
  • ব্যাখ্যা করার সংখ্যাটি হ'ল ইতিবাচক ভাসা, কেবল আপনার ভাষার দক্ষতার দ্বারা সীমাবদ্ধ।
  • যথার্থ সংখ্যাটি একটি সমান পূর্ণসংখ্যা, 2 টিরও বেশি (যেমন সর্বনিম্ন প্রয়োজনীয় নির্ভুলতা 4 হয়)। এটি স্বেচ্ছাসেবী বড় হতে পারে।
  • > = এন 5 পাইপগুলি গোল করা হয়, এন + 1 পর্যন্ত (অর্থাত্ 1.5 কে 2 এবং 2.5 কে গোল করে 3 করা হয়)। <এন .5 পাইপগুলিকে n এর সাথে গোল করা হয় (অর্থাত্ 1.4 কে 1 এর সাথে গোল করা হয় এবং ২.৪ এর সাথে গোল করা হয়)।
  • যদি এটি আপনার ভাষার পক্ষে আরও সুবিধাজনক হয় তবে আপনি ইনপুটটিকে অ্যারে হিসাবে নিতে পারেন, যেমন [6.75, 4]। যদি আপনি বিপরীত ক্রমে ইনপুট নেন তবে [4, 6.75], দয়া করে আপনার উত্তরে এটি নির্দিষ্ট করুন।
code-golf  ascii-art 
— nicael
সূত্র
পছন্দসই আউটপুট ফর্ম্যাটটি ঠিক কী সম্পর্কে আপনি আরও সুনির্দিষ্ট হতে পারেন?
— isaacg
@ আইস্যাচজি আমি চারটি উদাহরণ আউটপুট দেখিয়েছি। অস্পষ্ট কি?
— নিকেল
উন্মুক্ত কয়েকটি কর্নার মামলা রয়েছে বলে মনে হচ্ছে। যেমন ইনপুট 5.0 4: এটা থেকে আকর্ষণ করেন 5করার 6বা থেকে 4থেকে 5, অথবা গ্রহণযোগ্য? ইনপুট 1.25 2: এটিতে 0 বা 1 |টি রয়েছে এবং কেন (অর্থাত্ রাউন্ডিং বিধিটি কী)? ইনপুটটিতে প্রথম সংখ্যাটি কি ইতিবাচক হতে হবে? এর সর্বাধিক নির্ভুলতা এবং পরিমাণ কত? ইনপুটটিতে দ্বিতীয় নম্বরটি কি ইতিবাচক হতে হবে? যদি এটি নেতিবাচক হয় তবে আমরা কি পিছনের দিকে আঁকবো?
— পিটার টেলর
@ পিটার স্পষ্ট।
— নিকেল 12
আমি মনে করি না আপনি গোলাকার নিয়মটি কভার করেছেন।
— পিটার টেলর

উত্তর:

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

গণিত, 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
সূত্র
আপনি সম্ভবত একটি ওয়ার্কিং ডেমো সরবরাহ করতে পারেন, বা এটি সম্ভব নয়?
— নিকেল
3

জাভা, 253 206 181 বাইট

একবারে ব্যবহৃত শর্তাদি এবং ভেরিয়েবলগুলি ইনলাইন করে, এবং অপ্রয়োজনীয় ভেরিয়েবলগুলি বাছাই করে 47 বাইটগুলি ধন্যবাদ সংরক্ষণ করা হয়েছে K

25 বাইট পুনরায় সংরক্ষিত হয়েছে টের্নারি অপারেটরগুলির সাথে 2 লুপ ইনলাইন করে @ কেনিকে ধন্যবাদ।

খাঁটি স্ট্রিং ম্যানিপুলেশন:

ইনলাইনড লুপস সংস্করণ (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;}

অবরুদ্ধ সংস্করণ:

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.

আদর্শের.কম এ এখানে কাজ উদাহরণ । সম্পূর্ণ প্রোগ্রামটি হিসাবে STDIN ইনপুট গ্রহণ করে <float>,<precision>।

দ্রষ্টব্য: জাভার Math.round(float)রাউন্ডগুলি RoundingMode.HALF_UPডিফল্ট হিসাবে ব্যবহার করে যা ওপি'র প্রয়োজনীয় আচরণ।

প্রদত্ত পরীক্ষার কেসগুলির আউটপুট ওপি যা সরবরাহ করেছিল তার সাথে মেলে।

— তমোঘনা চৌধুরী
সূত্র
আমি আশা করি আপনি কিছু মনে করবেন না! আপনি সরাতে ভুলে গেছি a(কখনও ব্যবহৃত), 233 এ সেটিং আপনি অন্য 23 রক্ষা 210 বাইট এ পেতে পারে: প্রতিস্থাপন q.length()সঙ্গে bসংরক্ষণ 13: int g=(int)f, b=(""+g).length(), c=b, i=0;। অবস্থার পুনরুক্তিকারীর বৃদ্ধিশীল for6 সঞ্চয়, এবং ইনলাইনিং 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অপ্রচলিত aswell ওঠে ;-) আপনি এখনও জন্য 2nd 1 বাইট সংরক্ষণ করুন: for(;i++<=c+p;)। আপনি পারে Windows এ UNIX লাইন শেষা w শ সঙ্গে ফাইলটি সংরক্ষণ, কিন্তু দুর্ভাগ্যবশত জাভা অনুমতি দেয় না একাধিক লাইন স্ট্রিং ..
— Kenney
@ কেনি, না আমি চেষ্টা করেছিলাম। এটি ভুলভ্রান্ত হাইফেন্স বাড়ে। জাভা কোনওভাবেই কাজের জন্য সঠিক মানুষ নয়।
— তমোঘনা চৌধুরী
লুপের জন্য মাত্র 2 ব্যবহার করে আমি এটি 181 বাইটে নামিয়েছি:for(;i<c+p;)h+=i++<c?" ":"-";for(i=c;i<p+c;)q+=i++<c+Math.round((f-g)*p)?"|":" ";
— কেনে
3

জাভাস্ক্রিপ্ট ES6, 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 বাইট সংরক্ষণ করা হয়েছে ধন্যবাদ, উম, কীভাবে আপনি টাইপ করেন?

— নিল
সূত্র
দুঃখিত, আমি বুঝতে পারি না ড্যাশগুলি আউটপুটটির অংশ ছিল, আমি ভেবেছিলাম যে স্পেসগুলি কল্পনা করার জন্য তারা কেবল সেখানে ছিল।
— নিল
(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একটি আসল নিউলাইন দিয়ে প্রতিস্থাপন করুন । এবং এটি টেম্পলেট স্ট্রিংগুলিতে মোড়ানো নিশ্চিত করুন।
— মামা ফান রোল
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
সূত্র
এটির কোনও অনলাইন ডেমো দেখা কি সম্ভব?
— নিকেল
@ এনিকায়েল: ডেমো ( mainপুরো প্রোগ্রামের জন্য একটি মোড়ক সহ )।
— নিমি
দেখে মনে হচ্ছে সবকিছু ঠিক আছে (বিটিডব্লিউ: সেখানে পরীক্ষা করা হয়েছে , মনে করুন এটি আরও সুবিধাজনক সংকলক)।
— নিকেল 17
2

এমএটিএল , 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'
— Kenney
সূত্র
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)

অবরুদ্ধ সংস্করণ:

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)
— জ্যাক ব্রাউনস্টাইন
সূত্র
আপনি কি একটি ওয়ার্কিং ডেমো সরবরাহ করতে পারেন?
— নিকেল 19
এই trinket.io লিঙ্কটি কাজ করা উচিত: trinket.io/python/409b1488f8
— জ্যাক Brounstein
এটি সঞ্চয় করার চেয়ে কেবল স্থানের আক্ষরিক ব্যবহার করতে কম অক্ষর লাগে। আপনি কেবল এর সাথে সমস্ত লাইনে যোগ দিতে পারেন ;। আপনি কেবল hএকবার ব্যবহার করেন , তাই আপনার এটিও ইনলাইন করা উচিত। কিছু অক্ষর সংরক্ষণ করা উচিত।
— ই
@ সিক স্পেস আক্ষরিক উপর ভাল ধরা। প্রথমদিকে আমি দ্বিতীয় লাইনের শেষে সাদা স্পেস প্যাডিং মুদ্রণ করছিলাম; আমি বুঝতে পারলাম যে এটি অপ্রয়োজনীয়, আমি সঞ্চয়ী কোডটি ডাবল চেক করিনি। hTrickier হয়। lenকাজ করার জন্য শেষ দুটি সারিতে সংমিশ্রণ এবং ফাংশনের জন্য lএকটি স্ট্রিং hহওয়া দরকার , তাই এটির সাথে প্রতিস্থাপন করা প্রয়োজন str(int(l)+1)। hরূপান্তর করার আগে সেট করা lকয়েকটি অক্ষর সংরক্ষণ করে।
— জ্যাক ব্রাউনস্টেইন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.