একটি মানব পাঠযোগ্য বিন্যাসে প্রদত্ত বাইটের সংখ্যার বিন্যাস করুন

16

চ্যালেঞ্জ এবং উত্স

স্ট্যাক ওভারফ্লোতে একটি জনপ্রিয় প্রশ্ন হ'ল জাভাতে কীভাবে বাইট আকারকে মানব পাঠযোগ্য বিন্যাসে রূপান্তর করতে? সর্বাধিক ভোট দেওয়া উত্তরের কাছে এটি করার জন্য একটি দুর্দান্ত পদ্ধতি রয়েছে তবে এটি কোডগল্ফ এবং আমরা আরও ভাল করতে পারি, তাই না?

আপনার চ্যালেঞ্জটি হ'ল এমন একটি পদ্ধতি বা প্রোগ্রাম লিখুন যা প্রদত্ত সংখ্যক বাইটকে সঠিক মানব পাঠযোগ্য বিন্যাসে কভার করে এবং ফলাফলটি আপনার ভাষার বাইরে মানকে প্রিন্ট করে *

* আরও স্পষ্টতার জন্য বিধিগুলি দেখুন!

ইনপুট

ইনপুট সর্বদা সর্বাধিক (2 ^ 31) -1 সহ একটি ধনাত্মক সংখ্যক বাইট হবে।

আউটপুট

আপনি যদি আন্তর্জাতিক ইউনিটগুলির সিস্টেম বা বাইনারি স্বরলিপিটিকে আউটপুট হিসাবে পছন্দ করেন তবে আপনি চয়ন করতে পারেন (এসআই স্বরলিপি সম্ভবত আপনাকে কিছু বাইট সংরক্ষণ করে)।

SI:      B, kB,  MB,  GB  
Binary:  B, KiB, MiB, GiB

দ্রষ্টব্য: জিবি বা জিআইবির চেয়ে উচ্চতর ইউনিটগুলি সীমাবদ্ধ ইনপুট সীমার কারণে কার্যকর নয়।

উদাহরণ আউটপুট

আন্তর্জাতিক ইউনিটসমূহ:

Input       Output
0           0.0     B
999         999.0   B
1000        1.0     kB
1023        1.0     kB
1024        1.0     kB
1601        1.6     kB
160581      160.6   kB
4066888     4.1     MB
634000000   634.0   MB
2147483647  2.1     GB

বাইনারি:

Input       Output
0           0.0     B
999         999.0   B
1000        1000.0  B
1023        1023.0  B
1024        1.0     KiB
1601        1.6     KiB
160581      156.8   KiB
4066888     3.9     MiB
634000000   604.6   MiB
2147483647  2.0     GiB

বিধি

  • বাইট ফর্ম্যাটিংয়ের জন্য বিল্ড-ইন ফাংশনগুলি অনুমোদিত নয়!
  • আউটপুট সর্বদা একই স্বরলিপি মান হিসাবে হওয়া উচিত, আপনি এসআই বা বাইনারি মিশ্রিত করতে পারবেন না;
  • ফলাফল সর্বদা বৃহত্তর ইউনিটে হওয়া উচিত যেখানে ফলস্বরূপ সংখ্যাটি এখনও একের বেশি বা সমান;
  • আউটপুটটিতে সর্বদা একটি দশমিক সংখ্যা থাকা উচিত তবে ফলস্বরূপ আউটপুট বাইটস (বি) এ থাকা অবস্থায় আপনি একটি পূর্ণসংখ্যার সংখ্যা মুদ্রণ করতে বেছে নিতে পারেন;
  • আপনি নম্বর এবং ইউনিটের মধ্যে কোনও স্থান, ট্যাব বা কিছুই যুক্ত করতে চান কিনা তা চয়ন করতে পারেন;
  • এসটিডিআইএন বা ফাংশন পরামিতিগুলির মাধ্যমে ইনপুট প্রাপ্ত হয়;
  • আউটপুট কনসোলে মুদ্রিত হয় বা স্ট্রিং (বা অনুরূপ অক্ষরের ধারক) হিসাবে ফিরে আসে;
  • এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি জেতে। আনন্দ কর!

সম্পাদনা: আরও স্পষ্টতা

কিছু সংখ্যার 999950 নম্বরের মতো আকর্ষণীয় গোলাকার আচরণ রয়েছে Most বেশিরভাগ কোড বাস্তবায়ন 1.0 এমবি এর পরিবর্তে 1000.0 কেবি ফিরে আসবে। কেন? কারণ 999950/1000 999.950 এ মূল্যায়ন করে যা জাভাতে স্ট্রিং.ফর্ম্যাট ব্যবহার করার সময় কার্যকরভাবে 1000.0 তে পরিণত হয় (বেশিরভাগ অন্যান্য ভাষায়ও)। হেনচকে এই জাতীয় কেসগুলি পরিচালনা করতে কিছু অতিরিক্ত চেক প্রয়োজন।

এই চ্যালেঞ্জের জন্য, শেষ শৈলীর পছন্দ থাকলেও, 1000.0 কেবি এবং 1.0 এমবি উভয় স্টাইল গ্রহণ করা হয়।

সিউডো কোড / জাভা টেস্ট কোড:


public static String bytesToSI(long bytes){
      if (bytes < 1000){
          return bytes + ".0 B";
      }
      //Without this rounding check:
      //999950    would be 1000.0 kB instead of 1.0 MB
      //999950000 would be 1000.0 MB instead of 1.0 GB
      int p = (int) Math.ceil(Math.log(bytes) / Math.log(1000));
      if(bytes/Math.pow(1000, p) < 0.99995){
          p--;
      }
      //Format
      return String.format("%.1f %sB", bytes/Math.pow(1000, p), "kMGTPE".charAt(p-1));
}

code-golf 
— রল্ফ ツ
সূত্র
1
প্রযুক্তিগতভাবে, এসআই কিলোবাইট ব্যবহার করা উচিত kB(লোকেস কে কে নোট করুন)
— সুপারজেডি ২২৪
গুড পয়েন্ট, স্থির!
— রল্ফ ツ
1
আমি খুব বেশি সীমাবদ্ধ করতে চাই না, তাই আমি বলব যে ব্যবধানটি বেমানান হতে পারে। তবে এই নিয়মের সাথে: বিভিন্ন বৈধ ইনপুটগুলির জন্য স্থান এবং ট্যাব অক্ষরের পার্থক্য 10 এর বেশি হতে পারে না (এগুলি কিছুটা "মানব পাঠযোগ্য" রাখতে)
— রল্ফ ツ
2
এর প্রত্যাশিত আউটপুট কী 999999এবং 1000000? 160581গোলাকার প্রদর্শন, তাই এটি হওয়া উচিত 1000.0kBএবং 1.0MB?
— Sp3000
3
@ Sp3000 এটি একটি ভাল প্রশ্ন, সর্বোত্তম সমাধান 999999 এর জন্য 1.0 এমবি প্রদর্শন করা হবে। তবে এই চ্যালেঞ্জের জন্য আমি বলব 1000.0 কেবি এবং অনুরূপ গোলাকার কেসগুলিও ঠিক আছে।
— রল্ফ ツ

উত্তর:

10

টিআই-বেসিক, 44

টিআই-বেসিকের অর্ধেকটা শালীন স্ট্রিং ম্যানিপুলেশন থাকলে (ইউনিটের সাথে ইঞ্জিনিয়ারিং স্বরলিপিতে প্রদর্শিত সংখ্যার প্রকাশককে ওভাররাইটিংয়ের জন্য আমাকে অবলম্বন করতে হবে) কাজের জন্য সঠিক হাতিয়ার হবে। এটি গোলাকৃতি এবং সঠিকভাবে আউটপুট হিসাবে এটি, তবে এটি বিজয়ী এন্ট্রিগুলির কাছাকাছিও নয়। হতে পারে একটি ভিন্ন ক্যালকুলেটর ভাষা এই এক জিততে পারে?

Fix 1
Eng
ClrHome
Disp Ans
Output(1,15,sub(" kMG",1+iPart(log(Ans+.5)/3),1)+"B

[number]:[program name]হোমস্ক্রিনে ফর্মটি ইনপুট দিন ।

প্রদত্ত পরীক্ষার কেস:

Input       Output (leading spaces intentional; screen clear before each output)
0                      0.0 B
999                  999.0 B
1000                   1.0kB
1023                   1.0kB
1024                   1.0kB
1601                   1.6kB
160581               160.6kB
4066888                4.1MB
634000000            634.0MB
2147483647             2.1GB
— lirtosiast
সূত্র
আমার একেবারেই ধারণা ছিল না যে টিআই-বেসিক এত বহুমুখী হা হা
— বিটা ডেসে
1
টিআই-বেসিক বহুমুখী নয়, তবে এর কয়েকটি ত্রুটিগুলির জন্য প্রায়শই অদ্ভুতভাবে কাজ করা হয়।
— লিটারোসিয়াসট
6

সিজেম, 35 27 বাইট

ri{_e-3_i}g;1mOo]," kMG"='B

8 বাইট অপসারণ করার জন্য ডেনিস ধন্যবাদ।

এই মুদ্রণ নেই .0মধ্যে অনলাইন অনুবাদক । ডেনিস যেমন উল্লেখ করেছেন , এটি জাভা ইন্টারপ্রেটারে ঠিক কাজ করে।

ব্যাখ্যা

ri         e# Read the input as an integer.
{          e# Do:
    _e-3   e#   Make a copy and divide by 1000.
           e#   This will generate one more item in the stack for each iteration.
    _i     e#   Make a copy and truncate to integer.
}g         e# until the integer part is 0.
;          e# Discard the final value with integer part 0.
1mOo       e# Output the number before it with the correct format.
],         e# Count the number of iterations - 1.
" kMG"=    e# Select a character according to the number of iterations.
'B         e# Output B.
— jimmy23013
সূত্র
ri{_e-3XmO_i}g;o]," kMG"='B(27 বাইট)
— ডেনিস
@ ডেনিস এর জন্য ধন্যবাদ 1mO। তবে এই কোডটি 1149999...
— জিমি 23013
ri{_e-3_i}g;1mOo]," kMG"='Bউচিত।
— ডেনিস
স্ক্র্যাচ করুন যে, এতে অন্যান্য বাগ রয়েছে।
— ডেনিস
999999হয়ে 1000kB। প্রশ্নটি আবার পড়া, আমি নিশ্চিত না যে 1000kBআসলে ভুল হয়েছে কিনা ।
— ডেনিস
5

পাইথ, 29 27 বাইট

p@" kMG"Js.lQK^T3.RcQ^KJ1\B

প্রদর্শন. পরীক্ষার জোতা।

ব্যাখ্যা:

p@" kMG"Js.lQK^T3.RcQ^KJ1\B
                                 Implicit: Q = eval(input())
p                                print, in the order 2nd arg then 1st arg:
             K^T3                K = 10^3 = 1000
          .lQK                   log of Q base K
         s                       Floored
        J                        Store to J
 @" kMG"J                        The Jth character of ' kMG'
                     ^KJ         K^J
                   cQ            Q/K^J (Floating point division)
                 .R     1        Round to 1 decimal place.
                         \B      Print a trailing 'B'.
— isaacg
সূত্র
3

সিজেম, 28

r_dA@,(3/:X3*#/1mO" kMG"X='B

এটি অনলাইনে চেষ্টা করুন

দ্রষ্টব্য: এটি অনলাইন অনুবাদকের সাথে ".0" প্রদর্শন করে না, তবে এটি কর্মকর্তার সাথে করে does জাভা ইন্টারপ্রেটারের সাথে করে ।

ব্যাখ্যা:

r_          read and duplicate
dA          convert to double and push 10
@           bring the initial string to the top
,(          get the length and decrement
3/          divide by 3 (for thousands)
:X3*        store in X and multiply by 3 again
#           raise 10 to that power
/           divide the original number by it
1mO         round to 1 decimal
" kMG"X=    convert X from 0/1/2/3 to space/k/M/G
'B          add a 'B'
— aditsu
সূত্র
ব্যাকটিকটি কীসের জন্য?
— ডেনিস
@ ডেনিস অনলাইনে অনুবাদক .0 দেখায়
— অদিতসু
এটি ব্যাকটিক ছাড়াই জাভা ইন্টারপ্রেটারে দুর্দান্ত কাজ করে, তাই আমি মনে করি না আপনার এটির দরকার আছে need
— ডেনিস
3

পাইথন 2 - 76 বাইট

আপনার ইউনিটগুলির অভ্যন্তরীণ ব্যবস্থা ব্যবহার করে, কেবল আপনার মাথায় কাজ করা সহজ করার জন্য;)

n=input();m=0;f=1e3
while n>=f:n/=f;m+=2
print"%.1f%s"%(n,'B kBMBGB'[m:m+2])
— বেটা ক্ষয়
সূত্র
আমার কাছে এটি ঠিক আছে বলে মনে হচ্ছে না, এটি জিজ্ঞাসা করা বিন্যাসকে সম্মান করে না, উদাহরণ হিসাবে আমি যদি "2147483647" আমি "2.000000 গিগাবাইট" প্রাপ্ত করি - প্রশ্নটি একটি দশমিক, এবং সম্ভবত কোনও স্থান চাইবে।
— ডাইটার
1
এছাড়াও, এই অনুযায়ী 79 বাইট এই । এটি 75 বাইট। আমি বিশ্বাস করি না যে এটি নির্দিষ্ট করা হয়েছিল যে সংখ্যা এবং ইউনিটের মধ্যে একটি স্থান থাকা দরকার।
— কেড
আপনি একটি বাইট সংরক্ষণ করতে পারেনf=1e3
— mbomb007
@ mbomb007 আসলে এটি 2 বাইট সংরক্ষণ করেছে কারণ 1e3 একটি ভাসা
— বিটা
আমি জানতাম এটি একটি ভাসা। আমার ধারণা আমি কেবল গণনা করতে পারি না ...
— mbomb007
2

PowerShell, 190

$x=Read-Host
function f($a,$b){"$x`t"+[math]::Round($x/$a,1).ToString("F1")+"`t$b"}
if(1KB-gt$x){f 1 "B"}elseif(1MB-gt$x){f 1KB KiB}
elseif(1GB-gt$x){f 1MB MiB}elseif(1TB-gt$x){f 1GB GiB}

ব্যবহার

PS C:\> .\makehum.ps1
1601
1601    1.6     KiB
PS C:\> .\makehum.ps1
4066888
4066888 3.9     MiB
PS C:\> .\makehum.ps1
160581
160581  156.8   KiB
PS C:\> .\makehum.ps1
634000000
634000000       604.6   MiB
PS C:\> .\makehum.ps1
2147483647
2147483647      2.0     GiB
PS C:\>
— blabb
সূত্র
2

হাস্কেল, ১১৯

দুর্ভাগ্যক্রমে আমি ভাসমানের মধ্যে 1 দশমিক স্থান নিশ্চিত করার জন্য হাস্কেলের একটি ছোট্ট উপায় খুঁজে পাইনি, তবে আমি উত্তরোত্তর পোস্ট করছি।

import Text.Printf
a#n|p>=1=(a+1)#p|1<2=(a,n)where p=n/1000
m n=let(a,b)=0#n in printf"%.1f"b++["B","kB","MB","GB"]!!a

ব্যবহার: 

> m 160581
"160.6kB"

মাঝারিভাবে কম গল্ফ সংস্করণ:

import Text.Printf

countThousands :: Int -> Float -> (Int, Float)
countThousands count num
 |nextNum >= 1 = countThousands (count+1) nextNum
 |otherwise    = (count,num)
 where nextNum = num/1000

printHuman :: Float -> String
printHuman n = let (a,b) = countThousands 0 n in 
  (printf "%.1f" b) ++ (["B","kB","MB","GB"]!!a)
— ক্রেগ রায়
সূত্র
2

জাভা, 106 বাইট

এটি এমন একটি পদ্ধতি যা একটি সংখ্যা নেয় এবং একটি স্ট্রিং দেয়।

String f(int n){int k=0;for(;n>1e3;k++)n/=1e3;return(int)(10*n)/10.0+new String[]{"","k","M","G"}[k]+"B";}
— SuperJedi224
সূত্র
সম্পূর্ণ প্রোগ্রামের পরিবর্তে কোনও স্ট্রিং ফিরিয়ে ফাংশনে আপনাকে প্রোগ্রাম করার অনুমতি দেওয়া হয়, এটি আপনাকে কিছু বাইট বাঁচাতে পারে;)
— রল্ফ ツ
তিনটি জিনিস: আপনি একটি ডবল যাহাই হউক না কেন একটি রূপান্তর করেন তাহলে (আমি যদি এটা প্রয়োজনীয় জানি না), আপনি ব্যবহার করতে পারেন 1e3জন্য 1000; আপনি যে রূপান্তর করতে পারেন while()একটি থেকে for()এবং বিনামূল্যে সেমিকোলন ব্যবহার; এবং আমি জানি না যে এটি কাজ করে কেননা এটি দশমিক এক দশকের এক দশকের পরে নয়, সমস্ত দশমিক সংখ্যা প্রদর্শন করে।
— lirtosiast
@ থমাসকওয়া: সর্বশেষে আমি যাচাই করেছিলাম, প্রশ্নটি পরিষ্কারভাবে এটি নির্দিষ্ট করে বলে মনে হচ্ছে না। তবে আমার ধারণা এখন তা ঘটে।
— সুপারজেডি ২২৪
1

পাইথন 2, 127 বাইট

আইএসইউ ব্যবহার করছে। স্নিপেট একটি ফাংশন 'সি' ঘোষণা করে যা সংখ্যাটিকে আর্গুমেন্ট হিসাবে রূপান্তরিত করতে নেয় takes

C=lambda v:min(['%.1f %sB'%(x,u)for x,u in[(v/1000.0**i,'bkMG'[i])for i in range(4)]if x>=1]).replace('.0 b',' ')if v else'0 B'

কিছু পরীক্ষার কোড:

    print 'Input\tOutput'
for v in [0,999,1000,1023,1023,1601,160581,4066888,634000000,2147483647]:
 print v,C(v)
— Dieter
সূত্র
আপনি এর 1e3পরিবর্তে1000.0
— mbomb007
1

জাভাস্ক্রিপ্ট ( ES6 ), 71

এসআই ইউনিট ব্যবহার করে - অনুরোধ করা স্ট্রিংটি ফিরিয়ে দেওয়ার একটি ফাংশন। 

f=(a,b=3)=>+(r=eval('a/1e'+b*3).toFixed(1))[0]?r+' kMG'[b]+'B':f(a,b-1)

এই সংক্ষিপ্ততর একটি বিশেষত 3 এবং 4 নিয়ম অনুসরণ করে

  • ফলাফল সর্বদা সবচেয়ে বড় ইউনিটে থাকা উচিত যেখানে ফলাফলের সংখ্যাটি এখনও আরও বেশি বা একটির সমান 995 => 1.0 কেবি এর
  • আউটপুটটিতে সর্বদা একটি দশমিক সংখ্যা থাকা উচিত, তবে ফলস্বরূপ আউটপুট বাইট (বি) এ থাকা অবস্থায় আপনি একটি পূর্ণসংখ্যার সংখ্যা মুদ্রণ করতে পছন্দ করতে পারেন না পারেন, সুতরাং 10 => 10.0 বি

হায়রে, ফলাফলগুলি উদাহরণগুলির সাথে মেলে না।

উদাহরণগুলি মেলে, এখানে একটি দীর্ঘতর, ছোট সংখ্যার জন্য বিশেষ কেসযুক্ত (82 বাইট)

f=(a,b=3)=>a<1e3?a+'B':+(r=eval('a/1e'+b--*3).toFixed(1))[0]?r+'kMG'[b]+'B':f(a,b)

পরীক্ষার জন্য স্নিপেট চালান (কেবলমাত্র ইকামাস্ক্রিপ্ট 6, ফায়ারফক্স)

কোড স্নিপেট দেখান

— edc65
সূত্র
1

পাইথন, 61 বাইট

f=lambda n,i=0:"%.1f%cB"%(n," kMG"[i])*(n<1e3)or f(n/1e3,i+1)

কল করুন f(999)। দ্রষ্টব্য এটি 1e3একটি ভাসা, তাই এটি পাইথন 2 এবং পাইথন 3 উভয়ের সাথেই কাজ করে।

— Sp3000
সূত্র
1

PHP4.1, 63 62 বাইট

সেরা গল্ফিং নয়, তবে অবশ্যই এটি খুব ছোট।

<?for($S=kMG;$B>1e3;$I++)$B/=1e3;printf("%.1f{$S[$I-1]}B",$B);

এটি ব্যবহার করতে, পোষ্ট / জিইটি-র মাধ্যমে অ্যাক্সেস করুন বা কীটিতে SESSION এ একটি মান সেট করুন B।

কীটি Iআনসেট ছাড়ুন !

— ইসমাইল মিগুয়েল
সূত্র
1

স্পেসবিএএস - 100 বাইট

আইএসইউ কনভেনশন ব্যবহার করে।

আমি বুঝতে পেরেছিলাম যে ভেরিয়েবলটি 1e3 তে সেট করা হয়েছে (এটি নির্ধারণের জন্য একটি এলইটি স্টেটমেন্ট প্রয়োজন), এবং তারপরে সেই পরিবর্তনশীলটি ব্যবহার করে বাস্তবে যেখানে প্রয়োজন হয়েছিল সেখানে কেবল হার্ডকডিংয়ের চেয়ে বেশি অক্ষর ব্যবহার করেছেন।

1 INPUT n: LET i=1
2 DO WHILE n>1e3: LET n=n/1e3: INC i: LOOP 
3 PRINT USING$("&.*0#",n);" kMG"(i);"B"
— ব্রায়ান
সূত্র
1

রুবি, 128 বাইট

c=->i{p i.to_s+'B'if i<1e3;p (i/1e3).to_s+'kB'if i>=1e3&&i<1e6;p (i/1e6).to_s+'MB'if i>=1e6&&i<1e9;p (i/1e9).to_s+'GB'if i>=1e9}

আমি এটি দীর্ঘ পথ করেছি, এটি বেশ খারাপ।

আউটপুট

c[0] # => "0B"
c[999] # => "999B"
c[1000] # => "1.0kB" 
c[1023] # => "1.023kB"
c[1024] # => "1.024kB"
c[1601] # => "1.601kB"
c[160581] # => "160.581kB"
c[4066888] # => "4.066888MB"
c[634000000] # => "634.0MB"
c[2147483647] # => "2.147483647GB"

সম্পাদন করা

অতিরিক্ত 39 বাইটের জন্য টিবি যুক্ত করা হয়েছে

c=->i{p i.to_s+'B'if i<1e3;p (i/1e3).to_s+'kB'if i>=1e3&&i<1e6;p (i/1e6).to_s+'MB'if i>=1e6&&i<1e9;p (i/1e9).to_s+'GB'if i>=1e9&&i<1e12;p (i/1e12).to_s+'TB'if i>=1e12}

আউটপুট:

c[1000000000000] # => "1.0TB"
— Sheerforce
সূত্র
1

শেড -r, 218 + 1

আমি এসআই ইউনিট ব্যবহার করছি; আমি মনে করি যে বাইনারি ইউনিট নির্বাচন হবে একটি সাহসী নীতি । ;-)

s/(.)((...)+)$/\1z\2/;h;s/[^z]*z?//;s/.../k/g;s/kk/M/;s/Mk/G/;x;s/(z.)[5-9].*/\1c/;s/(z.c?).*/\1/;:;s/9c/c0/;s/zc/cz/;t;s/(^|0)c/1/;s/1c/2/;s/2c/3/;s/3c/4/;s/4c/5/;s/5c/6/;s/6c/7/;s/7c/8/;s/8c/9/;G;s/\n//;s/$/B/;y/z/./

ফরম্যাট:

#!/bin/sed -rf

# Place decimal point (use z as shorthand for \.)
s/(.)((...)+)$/\1z\2/
h

# count thousands into hold space
s/[^z]*z?//
s/.../k/g
s/kk/M/;s/Mk/G/
x

# truncate to 1 decimal place
s/(z.)[5-9].*/\1c/
s/(z.c?).*/\1/

# propagate carry
:
s/9c/c0/
s/zc/cz/
t
s/(^|0)c/1/
s/1c/2/
s/2c/3/
s/3c/4/
s/4c/5/
s/5c/6/
s/6c/7/
s/7c/8/
s/8c/9/

# Append units
G;s/\n//
s/$/B/
y/z/./

আউটপুট

1 => 1B
9 => 9B
99 => 99B
999 => 999B
1000 => 1.0kB
9999 => 10.0kB
99949 => 99.9kB
99950 => 100.0kB
99999 => 100.0kB
999999 => 1000.0kB
9999999 => 10.0MB
9999999999 => 10.0GB
1000 => 1.0kB
10000 => 10.0kB
10005 => 10.0kB
10440 => 10.4kB
10450 => 10.5kB
10950 => 11.0kB

প্রকারভেদ

নিয়মগুলি রাউন্ড-টু-নিকটতমকে বোঝায় বলে মনে হয় তবে মানব প্রদর্শনের জন্য আমি বিশ্বাস করি যে গোল করা ডাউন একটি গ্রহণযোগ্য বিকল্প এবং 123 বাইট (50% এর চেয়ে ভাল) সংরক্ষণ করে:

s/(.)((...)+)$/\1.\2/;h;s/[^\.]*\.?//;s/.../k/g;s/kk/M/;s/Mk/G/;x;s/(\..).*/\1/;G;s/\n//;s/$/B/

বৃহত্তর ইউনিটগুলিতে প্রাকৃতিক বর্ধন (এখনও নিচে, 130 + 1 বাইট):

s/(.)((...)+)$/\1.\2/;h;s/[^\.]*\.?//;s/.../k/g;s/kk/M/g;s/Mk/G/;s/MM/T/g;s/TT/Y/;s/TM/E/;s/TG/Z/;x;s/(\..).*/\1/;G;s/\n//;s/$/B/

পরিবর্তনের আউটপুট:

1 => 1B
9 => 9B
99 => 99B
999 => 999B
1000 => 1.0kB
9999 => 9.9kB
99949 => 99.9kB
99950 => 99.9kB
99999 => 99.9kB
999999 => 999.9kB
9999999 => 9.9MB
9999999999 => 9.9GB
1000 => 1.0kB
10000 => 10.0kB
10005 => 10.0kB
10440 => 10.4kB
10450 => 10.4kB
10950 => 10.9kB
1000000000 => 1.0GB
1000000000000 => 1.0TB
1000000000000000 => 1.0MGB
1000000000000000000 => 1.0EB
1000000000000000000000 => 1.0ZB
1000000000000000000000000 => 1.0YB
999999999999999999999999999 => 999.9YB
— টবির গতি
সূত্র
দারূন কাজ! আমি পছন্দ করি যে আপনি সমস্ত বিভিন্ন বিকল্প সম্পর্কে ভেবেছিলেন!
— রল্ফ ツ
1

সি, 77 75

f(float l){char*u=" kMG";while((l/=1e3)>=1)++u;printf("%.1f%cB",l*1e3,*u);}

এটি এসআই ইউনিট ব্যবহার করে এবং রাউন্ডিংয়ের জন্য 1000.0kB বিকল্পটি নেয়।

প্রসারিত কোড:

f(float l)
{
    char *u = " kMG";
    while ((l/=1000) >= 1)
        ++u;
    printf("%.1f%cB", l*1000, *u);
}

আউটপুট

9 => 9.0 B
9999 => 10.0kB
1023 => 1.0kB
1024 => 1.0kB
999990 => 1000.0kB
1048575 => 1.0MB
1048576 => 1.0MB
2147483647 => 2.1GB

ভেরিয়েন্ট

বাইনারি ইউনিট, পরিবর্তন করুন 1000থেকে 1024, এবং যোগ iএকটি গুণক আছে কিনা বিন্যাস স্ট্রিং। 4-অঙ্কের বৃত্তাকার এড়াতে তুলনা করুন>=.95 পরিবর্তে করুন >=1। বৃহত্তর ইউনিট গ্রহণ করতে, uস্ট্রিং প্রসারিত করুন । এই সমস্ত বিকল্পের সংমিশ্রণে আমরা পাই:

f(float l)
{
    char*u=" kMGTPEZY";
    while((l/=1024)>=.95)++u;
    printf(*u-' '?"%.1f%ciB":"%.0fB",l*1024,*u);
}

বৈকল্পিক আউটপুট

9 => 9B
9999 => 9.8kiB
1023 => 1.0kiB
1024 => 1.0kiB
999990 => 1.0MiB
1048575 => 1.0MiB
1048576 => 1.0MiB
2147483647 => 2.0GiB
1000000000 => 953.7MiB
1000000000000 => 931.3GiB
1000000000000000 => 909.5TiB
1000000000000000000 => 888.2PiB
1000000000000000000000 => 867.4EiB
1000000000000000000000000 => 847.0ZiB
999999999999999999999999999 => 827.2YiB
1176043059457204080886151645 => 972.8YiB

পরীক্ষা প্রোগ্রাম

কমান্ড-লাইন আর্গুমেন্ট হিসাবে যে কোনও সংখ্যক ইনপুট পাস করুন:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        printf("%s => ", *argv);
        f(strtod(*argv, 0));
        puts("");
    }
    return 0;
}
— টবির গতি
সূত্র
ভাল এক;) ভাল মৃত্যুদন্ড কার্যকর!
— রল্ফ ツ
0

রুবি, 91 বাইট

n=gets.to_i;i=0;while n>1023;n/=1024.0;i+=1;end;puts "#{n.round 1} #{%w[B KiB MiB GiB][i]}"

আমি আরও চেষ্টা করতে পারলে সম্ভবত আরও কিছুটা ভাল করতে পারতাম তবে এখন পর্যন্ত যা পেয়েছি তা এখানে।

— ডেভিড বেইলি
সূত্র
1024.পরিবর্তে ব্যবহার করুন 1024.0।
— mbomb007
0

জাভাস্ক্রিপ্ট ES5, 69 বাইট

এটি শেষ লক্ষ্যে পৌঁছানোর জন্য একটি ভিন্ন উপায় ব্যবহার করে যা @ edc65 এর উত্তর ।
আসলে, এটি আমার পিএইচপি উত্তরের খুব কাছাকাছি ।

for(i=+prompt(z=0);i>1e3;z++)i/=1e3;alert(i.toFixed(1)+' kMG'[z]+'B')
স্নিপেট প্রসারিত করুন

কেবল স্ট্যাক স্নিপেট চালান বা আপনার কনসোলে এটি পেস্ট করুন।

— ইসমাইল মিগুয়েল
সূত্র
0

রুবি, 90 বাইট

proc{|n|q=((1..3).find{|i|n<(1<<i*10)}||4)-1;[n*10/(1<<q*10)/10.0,%w[B kB MB GB][q]].join}
— csabahenk
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.