কিছু ছোট কোড-গল্ফিং টিপস
পৃথক উত্তরগুলির জন্য এই টিপসটি কিছুটা ছোট ছিল, তাই আমি এই উত্তরটি খুব ছোট কোডগল্ফিং টিপসের জন্য ব্যবহার করব যা আমি পেয়েছি বা এনেছি, এবং অন্যান্য টিপসে এখনও উল্লেখ করা হয়নি:
কোনও স্ট্রিংয়ের শেষ চরিত্রটি সরানো:
// I used to do something like this:
s.substring(0,s.length()-1) // 27 bytes
// But this is shorter:
s.replaceAll(".$","") // 21 bytes
কিছু ক্ষেত্রে আপনি শেষ চরিত্রটি আগে কী তা জানেন এবং আপনিও জানেন যে এই চরিত্রটি কেবল স্ট্রিং-এ একবার ঘটে। সেক্ষেত্রে আপনি এর .splitপরিবর্তে ব্যবহার করতে পারেন :
// As example: "100%" to "100"
s.split("%")[0] // 15 bytes
এনকোডিং শর্টকাটগুলি:
// When you want to get the UTF-8 bytes I used to do this:
s.getBytes("UTF-8"); // 20 bytes
// But you can also use "UTF8" for the same result:
s.getBytes("UTF8"); // 19 bytes
সমস্ত এনকোডিংগুলিতে এপিআইতে একটি প্রচলিত নাম ব্যবহৃত হয় java.nio, তেমনি java.ioএবং java.langএপিআইগুলিতে একটি প্রচলিত নাম ব্যবহৃত হয় । এখানে জাভাতে সমর্থিত সমস্ত এনকোডিংগুলির একটি সম্পূর্ণ তালিকা রয়েছে। সুতরাং সর্বদা দু'জনের মধ্যে সংক্ষিপ্ততম ব্যবহার করুন; দ্বিতীয়টি সাধারণত খাটো (যেমন UTF-8বনাম utf8, Windows-1252বনাম Cp1252ইত্যাদি) তবে সর্বদা ( UTF-16BEবনাম UnicodeBigUnmarked) হয় না।
র্যান্ডম বুলিয়ান:
// You could do something like this:
new java.util.Random().nextBoolean() // 36 bytes
// But as mentioned before in @Geobits' answer, Math.random() doesn't require an import:
Math.random()<.5 // 16 bytes
primes:
প্রাইমগুলি পরীক্ষা করতে বা সমস্ত প্রাইম পাওয়ার জন্য বিভিন্ন উপায় রয়েছে তবে @ সারাজের উত্তরটি এখানে সবচেয়ে ছোট। রেফারেন্স হিসাবে এখানে একটি অনুলিপি আছে:
// Check if n is a prime:
n->{int i=1;for(;n%++i%n>0;);return n==i;}
// Which can easily be modified to loop through primes:
v->{for(int n=2,i;;){for(i=1;n%++i%n>0;);if(n++==i)/*do something with prime `i` here*/;}}
দ্রষ্টব্য: সাধারণত আপনি এটি কীভাবে ব্যবহার করতে চান তার উপর নির্ভর করে এটি অন্যান্য বিদ্যমান লুপগুলির সাথে একত্রীকরণ করতে পারেন, সুতরাং আপনার পৃথক পদ্ধতির প্রয়োজন হবে না। উদাহরণস্বরূপ এটি এই উত্তরে প্রচুর বাইট সংরক্ষণ করেছে।
ম্যাথ.ফ্লুর / ম্যাথ.সিলের পরিবর্তে পূর্ণসংখ্যার কাটা:
আপনি যদি পজিটিভ ডাবলস / ফ্লোট ব্যবহার করছেন এবং আপনি floorসেগুলি চান , Math.floorতবে (int)পরিবর্তে একটি কাস্ট ব্যবহার করবেন না (যেহেতু জাভা পূর্ণসংখ্যার উপর কাটা)
double d = 54.99;
int n=(int)Math.floor(d); // 25 bytes
int m=(int)d; // 13 bytes
// Outputs 54 for both
পরিবর্তে আপনি চান নেতিবাচক ডাবলস / ফ্লোটগুলিতে একই কৌশল প্রয়োগ করা যেতে পারে ceil:
double d = -54.99;
int n=(int)Math.ceil(d); // 24 bytes
int m=(int)d; // 13 bytes
// Outputs -54 for both
প্রথম বন্ধনী থেকে মুক্তি পেতে &1পরিবর্তে ব্যবহার করুন %2:
কারণ অপারেটর প্রাধান্য এর &ডিফল্ট গাণিতিক অপারেটর মত চেয়ে কম */+-এবং %, আপনি কিছু ক্ষেত্রে প্রথম বন্ধনী পরিত্রাণ পেতে পারেন।
// So instead of this:
(i+j)%2 // 7 bytes
// Use this:
i+j&1 // 5 bytes
মনে রাখবেন যে এটি বুলিয়ান-চেকগুলিতে সত্যই সহায়তা করে না, কারণ এরপরে আপনার এখনও বন্ধনী প্রয়োজন, তারা কেবল কিছুটা সরানো হয়েছে:
(i+j)%2<1 // 9 bytes
(i+j&1)<1 // 9 bytes
স্থির পদ্ধতি কলগুলির জন্য বিগইন্টিজার্স এবং ভেরিয়েবলগুলি তৈরি করা:
বিগইন্টিজার্স ব্যবহার করার সময়, কেবল একবার এটি তৈরি করুন যা আপনি আবার ব্যবহার করতে পারবেন। আপনি হয়তো জানেন যে, BigInteger জন্য স্ট্যাটিক ক্ষেত্র রয়েছে ZERO, ONEএবং TEN। সুতরাং আপনি যখন কেবল এই তিনটি ব্যবহার করেন, আপনার কোনও প্রয়োজন হয় না importতবে java.Math.BigIntegerসরাসরি ব্যবহার করতে পারেন ।
// So instead of this:
import java.math.BigInteger.*;
BigInteger a=BigInteger.ONE,b=BigInteger.ZERO; // 76 bytes
// or this:
java.math.BigInteger a=java.math.BigInteger.ONE,b=a.ZERO; // 57 bytes
// Use this:
java.math.BigInteger t=null,a=t.ONE,b=t.ZERO; // 45 bytes
দ্রষ্টব্য: আপনাকে ব্যবহার করতে হবে =nullযাতে ব্যবহারের tজন্য আরম্ভ করা হয় t.।
কখনও কখনও আপনি একাধিক বিগইন্টিজার যুক্ত করতে পারেন বাইট সংরক্ষণ করতে অন্য তৈরি করতে। সুতরাং আসুন আমরা বলি যে আপনি 1,10,12কোনও কারণে বিগইন্টিজারদের রাখতে চান :
// So instead of this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=new BigInteger(12); // 55 bytes
// Use this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=b.add(a).add(a); // 52 bytes
মন্তব্যে সঠিকভাবে নির্দেশিত হিসাবে, BigInteger t=null;এর স্থির পদ্ধতি কলগুলির জন্য কৌশলটি অন্য শ্রেণীর সাথেও ব্যবহার করা যেতে পারে।
উদাহরণস্বরূপ, ২০১১ সালের এই উত্তরটি গল্ফ করা যেতে পারে:
// 173 bytes:
import java.util.*;class g{public static void main(String[]p){String[]a=p[0].split(""),b=p[1].split("");Arrays.sort(a);Arrays.sort(b);System.out.print(Arrays.equals(a,b));}}
// 163 bytes
class g{public static void main(String[]p){java.util.Arrays x=null;String[]a=p[0].split(""),b=p[1].split("");x.sort(a);x.sort(b);System.out.print(x.equals(a,b));}}
getBytes() পরিবর্তে toCharArray()
আপনি যখন কোনও স্ট্রিংয়ের চরিত্রগুলি লুপ করতে চান, আপনি সাধারণত এটি করেন:
for(char c:s.toCharArray()) // 27 bytes
// or this:
for(String c:s.split("")) // 25 bytes
অক্ষরগুলির মুদ্রণ করার সময়, বা কোনও স্ট্রিংয়ে যুক্ত করা বা এর অনুরূপ কিছুতে লুপ করা কার্যকর হতে পারে।
তবে, আপনি যদি কিছু ইউনিকোড-সংখ্যা গণনার জন্য কেবল অক্ষরগুলি ব্যবহার করেন তবে আপনি এর charসাথে প্রতিস্থাপন করতে পারেন int, এবং আপনি এর toCharArray()সাথে প্রতিস্থাপন করতে পারেন getBytes():
for(int c:s.getBytes()) // 23 bytes
বা জাভা 8+ এর চেয়েও ছোট:
s.chars().forEach(c->...) // 22 bytes
জাভাতে 10+ মুদ্রণের জন্য অক্ষরটি লুপিং করা এখন 22 বাইটেও করা যেতে পারে:
for(var c:s.split("")) // 22 bytes
একটি থেকে এলোমেলো আইটেম List:
List l=...;
// When we have an `import java.util.*;` in our code, shuffling is shortest:
return l.get(new Random().nextInt(l.size())); // 45 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
Collections.shuffle(l);return l.get(0); // 39 bytes
// When we don't have an `import java.util.*` in our code, `Math.random` is shortest:
return l.get(new java.util.Random().nextInt(l.size())); // 55 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
java.util.Collections.shuffle(l);return l.get(0); // 49 bytes
কোনও স্ট্রিংয়ে শীর্ষস্থানীয় / পিছনের স্থান রয়েছে কিনা তা পরীক্ষা করুন
String s=...;
// I used to use a regex like this:
s.matches(" .*|.* ") // 20 bytes
// But this is shorter:
!s.trim().equals(s) // 19 bytes
// And this is even shorter due to a nice feature of String#trim:
s!=s.trim() // 11 bytes
!=স্ট্রিংগুলিতে জাভাতে মানের পরিবর্তে রেফারেন্সের জন্য কেন পরীক্ষা করা হয় কেন এই কাজ করে ? কারণ String#trim" এই স্ট্রিংয়ের একটি অনুলিপি মুছে ফেলা হবে শীর্ষস্থানীয় এবং অনুসরণযোগ্য শ্বেত স্থান সরানো, অথবা এই স্ট্রিংটির যদি কোনও শীর্ষস্থানীয় বা অনুসরণযোগ্য শ্বেত স্থান নেই । " আমার এই উত্তরে কেউ আমাকে এটি প্রস্তাব দেওয়ার পরে আমি এটি ব্যবহার করেছি ।
যে শব্দ কবিতা প্রভৃতি উলটা করিয়া পড়িলেও একই থাকে:
কোনও স্ট্রিং প্যালিনড্রোম কিনা তা পরীক্ষা করতে (স্ট্রিংয়ের .containsসমান এবং বিজোড় দৈর্ঘ্য উভয়কে মনে রেখে), এটি সবচেয়ে সংক্ষিপ্ত ( এখানে কাজ করে কারণ আমরা স্ট্রিং নিজেই জানি এবং এর বিপরীত রূপটি সমান দৈর্ঘ্যের):
String s=...;
s.contains(new StringBuffer(s).reverse()) // 41 bytes
.contains(...)পরিবর্তে এখানে @Asslias এর মন্তব্য.equals(...+"") ধন্যবাদ ।
হয় হয় 0, বা উভয় 0 হয়?
আমি মনে করি এটি ইতিমধ্যে একটি জানেন: আপনি যদি শূন্য aবা bশূন্য কিনা তা পরীক্ষা করতে চান , বাইটগুলি সংরক্ষণ করার পরিবর্তে গুণ করুন:
a==0|b==0 // 9 bytes
a*b==0 // 6 bytes
আর তুমি উভয় যদি চেক করতে চান যদি aএবং bশূন্য হলে, আপনি একটি bitwise-বা ব্যবহার, অথবা তাদের একসাথে যোগ তারা সবসময় যদি ইতিবাচক পারে:
a==0&b==0 // 9 bytes
(a|b)==0 // 8 bytes (if either `a`, `b` or both can be negative)
a+b<1 // 5 bytes (this only works if neither `a` nor `b` can be negative)
এমনকি = 1, বিজোড় = -1; অথবা উলটা
// even = 1; odd = -1:
n%2<1?1:-1 // 10 bytes
1-n%2*2 // 7 bytes
// even = -1; odd = 1:
n%2<1?-1:1 // 10 bytes
n%2*2-1 // 7 bytes
কারনেই আমি এই অ্যাড দেখার পর ছিল k+(k%2<1?1:-1)এ এই উত্তর :
k+(k%2<1?1:-1) // 14 bytes
// This would already have been shorter:
k%2<1?k+1:k-1 // 13 bytes
// But it can also be:
k%2*-2-~k // 9 bytes
nসম্পূর্ণ প্রোগ্রামে লুপ বার
যদি আমাদের একটি চ্যালেঞ্জ থাকে যেখানে একটি পূর্ণ প্রোগ্রামটি বাধ্যতামূলক এবং আমাদের একটি নির্দিষ্ট পরিমাণ সময় লুপ করা প্রয়োজন, আমরা নিম্নলিখিতটি করতে পারি:
// instead of:
interface M{static void main(String[]a){for(int n=50;n-->0;)/*do something*/}} // 78 bytes
// we could do:
interface M{static void main(String[]a){for(M m:new M[50])/*do something*/}} // 76 bytes
ইনপুট হিসাবে যখন আমাদের এই ব্যাপ্তিটি নিতে হয় তখন একই প্রয়োগ হয়:
interface M{static void main(String[]a){for(int n=new Byte(a[0]);n-->0;)/*do something*/}} // 90 bytes
interface M{static void main(String[]a){for(M m:new M[new Byte(a[0])])/*do something*/}} // 88 bytes
এই মন্তব্যটিতে @ জ্যাকআ্যাম্মোকে ক্রেডিট করুন ।
ফিরে আসার সময় এবং কখন ব্যবহার করতে হবে তা চেষ্টা করে দেখার পরিবর্তে চেষ্টা করুন (ব্যতিক্রম ই)
আপনি যদি ব্যবহার করতে না পারেন throws Exceptionতবে catchফিরে আসার আগে এটির সাথে কিছু করতে এবং কিছু করতে না পারলে আপনি এর finallyপরিবর্তে ব্যবহার করতে পারেন :
try{...}catch(Exception e){return ...;} // 33 bytes
try{...}finally{return ...;} // 22 bytes
কখন ব্যবহার করতে হবে তার উদাহরণ হিসাবে try-catch, আমি আমার এই উত্তরটি উল্লেখ করতে পারি (পরোক্ষ গল্ফের জন্য কৃতিত্ব @ কামিলড্রাকারীতে যায় )। এই চ্যালেঞ্জে আমাদের একটি এনএক্সএম ম্যাট্রিক্সের উপর ত্রিভঙ্গভাবে লুপ করতে হবে, সুতরাং কলামগুলির পরিমাণ বা সারিগুলির পরিমাণটি ফর-লুপে আমাদের সর্বোচ্চ হিসাবে সর্বনিম্ন কিনা তা নির্ধারণ করতে হবে (যা বাইটসের ক্ষেত্রে বেশ ব্যয়বহুল i<Math.min(a.length,a[0].length):)। সুতরাং, কেবল সংক্রামক ArrayIndexOutOfBoundsExceptionব্যবহার catch-finallyএই চেক তুলনায় খাটো, এবং এইভাবে বাইট সংরক্ষণ:
int[] a = ...;
int r=0,i=0;for(;i<Math.min(a.length,a[0].length);)r=...i++...;return r; // 66 bytes
int r=0,i=0;try{for(;;)r=...i++...;}finally{return r;} // 48 bytes
দ্রষ্টব্য: এটি কেবল return r;শেষ পর্যন্ত কাজ করেছে। আমাকে প্রথম ঘরটি পরিবর্তন করার পরামর্শ দেওয়া হয়েছে, যেমন @ কামিলড্রাকারি তার সি # উত্তর বাইটস সংরক্ষণ করার জন্য করেছিলেন। যাইহোক, জাভাতে এর অর্থ আমাকে এটিকে m->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}}((৩ বাইট) পরিবর্তন করতে হবে , আমি যদি ব্যবহার করতে পারতাম তবে বাইট সংখ্যা বাড়ানোর পরিবর্তে হ্রাস করার পরিবর্তে বাড়িয়েছিলাম finally।
Math.pow (2, ঢ)
আপনি যখন 2 এর শক্তি চান, তখন একটি বিট-বুদ্ধিমান পদ্ধতির পরিমাণ আরও খাটো হয়:
(int)Math.pow(2,n) // 16 bytes
(1<<n) // 6 bytes
প্রথম বন্ধনী ব্যবহারের পরিবর্তে বিট-ওয়াইজ এবং লজিক্যাল চেকগুলির সংমিশ্রণ
আমি এখন দ্বারা এটি সুপরিচিত হয় মনে &এবং |পরিবর্তে ব্যবহার করা যেতে পারে &&এবং ||জাভা (বুলিয়ান) লজিক্যাল চেক। কিছু ক্ষেত্রে আপনি তবুও ত্রুটিগুলি প্রতিরোধ করার &&পরিবর্তে ব্যবহার করতে চান &, পছন্দ করুন index >= 0 && array[index].doSomething। যদি এখানে &&পরিবর্তিত হয় &, এটি এখনও সেই অংশটি মূল্যায়ন করবে যেখানে এটি অ্যারেতে সূচকটি ব্যবহার করে, যার ArrayIndexOutOfBoundsExceptionফলে এটি এর &&পরিবর্তে এই ক্ষেত্রে ব্যবহার করা হবে &।
এখন পর্যন্ত জাভা &&/ ||বনাম &/ |এর বেসিকগুলি।
আপনি যখন যাচাই করতে চান (A or B) and C, সংক্ষিপ্ততম সম্ভবত বিট-বুদ্ধিমান অপারেটরগুলি ব্যবহার করতে পারে:
(A|B)&C // 7 bytes
তবে, বিট-ওয়াইজ অপারেটরগুলির লজিকাল চেকগুলির তুলনায় অপারেটরের প্রাধান্য রয়েছে, তাই আপনি এখানে দুটি বাইট সংরক্ষণ করতে একত্রিত করতে পারেন:
A|B&&C // 6 bytes
n+=...-nপরিবর্তে ব্যবহার করুন(long)...
যখন আপনার ল্যাম্বডায় দীর্ঘ এবং ইনপুট উভয়ই দীর্ঘ হয়, উদাহরণস্বরূপ ব্যবহার করার সময় Math.pow, আপনি এর n+=...-nপরিবর্তে ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন (long)...।
উদাহরণ স্বরূপ:
n->(long)Math.pow(10,n) // 23 bytes
n->n+=Math.pow(10,n)-n // 22 bytes
এই একটি বাইট সংরক্ষিত আমার এই উত্তরের এবং মিশ্রন দ্বারা এমনকি দুই বাইট -n-1থেকে +~nএ আমার এই উত্তরের ।
packageএড়িয়ে যেতে পারে