জাভাতে গল্ফ করার টিপস


86

জাভা ব্যবহার করা যেতে পারে যে কোন দরকারী শর্টকাট আছে?

নীচে প্রদর্শিত হিসাবে, importইতিমধ্যে একটি প্রোগ্রামে কমপক্ষে 17 টি অক্ষর যুক্ত করুন।

import java.io.*;

আমি বুঝতে পারি যে সহজ সমাধানটি হ'ল অন্য ভাষা ব্যবহার করা হবে তবে জাভা প্রোগ্রামগুলি সংক্ষিপ্ত করা এটি একটি আসল চ্যালেঞ্জ বলে মনে হচ্ছে।


টিপস জাভা সম্পর্কিত সুনির্দিষ্ট হওয়া উচিত: যদি সেগুলি বেশিরভাগ সি-জাতীয় ভাষার ক্ষেত্রে প্রযোজ্য হয় তবে সেগুলি টিপসের আরও সাধারণ তালিকায় অন্তর্ভুক্ত


9
packageএড়িয়ে যেতে পারে
st0le

একটি উত্তরে, আমি কি আমদানিগুলি সেখানে রয়েছে তা ধরে রেখে কেবল বাদ দিতে পারি না?
ফ্যাব্রিকিও

1
ওপেন সুনির্দিষ্ট না করে @ ফ্যাব্রিকিও না।
nyuszika7h

32
গল্ফিং জাভা সম্পর্কে সেরা টিপ: এটি ব্যবহার করবেন না। ;)
kirbyfan64sos

4
"আমি জাভাতে গল্ফ করতে চাই" শুভকামনা
sagiksp

উত্তর:


85
  • অতি সাম্প্রতিকতম জাভা ব্যবহার করুন। জাভা 8 আপনাকে ল্যাম্বডা এক্সপ্রেশনগুলি ব্যবহার করতে দেয়, সুতরাং আপনার যদি কার্যক্ষম বস্তুর মতো কোনও কিছুর প্রয়োজন হয় তবে এটি ব্যবহার করুন ।

  • আপনি প্রচুর পরিমাণে ব্যবহার করেন এমন জিনিসগুলির জন্য সংক্ষিপ্ত ফাংশনগুলি সংজ্ঞায়িত করুন। উদাহরণস্বরূপ, আপনার কাছে কয়েকশ কল রয়েছে exampleClassInstance.doSomething(someParameter), একটি নতুন ফাংশন সংজ্ঞায়িত করুন void d(ParameterType p){exampleClassInstance.doSomething(p)}এবং নিজেকে কিছু অক্ষর বাঁচাতে এটি ব্যবহার করুন।

  • আপনি যদি কোনও নির্দিষ্ট দীর্ঘ শ্রেণীর নাম একাধিকবার ব্যবহার করেন তবে লাইক দিন

    MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory

    পরিবর্তে একটি নতুন শ্রেণীর সংজ্ঞা দিন:

    class X extends MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory{}

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

  • জিনিসগুলি সংক্ষিপ্ত করতে ফাংশনের ধরণের পরামিতি ব্যবহার করুন, যেখানে এটি সম্ভব:

    <T>void p(T o){System.out.println(o);}
  • for(;;)পরিবর্তে ব্যবহার করুন while(true)

  • একেবারে প্রয়োজনীয় না হলে অ্যাক্সেস মডিফায়ার ব্যবহার করবেন না।

  • finalকোন কিছুর জন্য ব্যবহার করবেন না ।

  • forলুপের পরে কখনও কোনও ব্লক রাখবেন না (তবে একটি অগ্রণী লুপটি for(x:y)আলাদা)। অতিরিক্ত বিবৃতি forবিবৃতিতে নিজেই রাখা উচিত , যেমন for(int i=0;i<m;a(i),b(++i))c(i);

  • ইনলাইন অ্যাসাইনমেন্ট, ইনক্রিমেন্টেশন, ইনস্ট্যান্টেশন ব্যবহার করুন। উপযুক্ত যেখানে বেনামে ইনলাইন ক্লাস ব্যবহার করুন। সম্ভব হলে ল্যাম্বডাস ব্যবহার করুন। নীড় ফাংশন কল। কিছু ফাংশন তাদের পিতা বা মাতা বস্তুর আসতে গ্যারান্টী আছে এদেরকেই আসলে এমনকি বোঝানো একসঙ্গে শৃঙ্খলিত করা হয়।

  • আপনার mainপদ্ধতিটি throws Exceptionতাদের ধরে না।

  • Errorতুলনায় খাটো Exception। যদি কোনও কারণে আপনাকে সত্যিইthrow স্ট্যাকটি বার্তা দেওয়ার প্রয়োজন হয় Errorতবে এটি পুরোপুরি স্বাভাবিক পরিস্থিতি হলেও একটি ব্যবহার করুন ।

  • যদি কিছু শর্ত অবিলম্বে সমাপ্তির প্রয়োজন হয় তবে তার int a=1/0;পরিবর্তে throw null;বা ব্যবহার করুন System.exit(0);। চলমান সময়ে, এটি একটি ছুড়ে দেয় ArithmeticException। আপনার কোডটিতে যদি ইতিমধ্যে একটি সংখ্যার পরিবর্তনশীল থাকে তবে পরিবর্তে এটি ব্যবহার করুন। (আপনার যদি ইতিমধ্যে থাকে import static java.lang.System.*;তবে সাথে যান exit(0);))

  • ইন্টারফেস বাস্তবায়নের পরিবর্তে List<E>, তাত্ক্ষণিকভাবে প্রসারিত করুন (বা না-তাই-তাত্ক্ষণিকভাবে যদি কিছু করার কোনও সুবিধা থাকে তবে) শিশু শ্রেণি, যেমন AbstractList<E>বেশিরভাগ পদ্ধতির ডিফল্ট বাস্তবায়ন সরবরাহ করে এবং কেবলমাত্র এর বাস্তবায়ন প্রয়োজন কয়েক কী টুকরা।

  • নতুন কোডস, ইনডেন্টেশন এবং সম্পূর্ণ ভেরিয়েবলের নাম সহ প্রথমে আপনার কোডটি লম্বা হ্যান্ডে লিখুন। একবার আপনার কোডিং কোডিং হয়ে গেলে আপনি নামগুলি সংক্ষিপ্ত করতে পারেন, ঘোষণাগুলি চারপাশে স্থানান্তর করতে এবং শর্টকাট পদ্ধতি যুক্ত করতে পারেন। এটি শুরু করার জন্য দীর্ঘ সময় লিখে, আপনি নিজেকে পুরো প্রোগ্রামটি সরল করার আরও বেশি সুযোগ দিন give

  • কোডের টুকরোটির সাথে বিকল্প অপ্টিমাইজেশনের তুলনা করুন, কারণ সর্বাধিক অনুকূল কৌশলটি কোডে খুব ছোট পরিবর্তন করে নাটকীয়ভাবে পরিবর্তন করতে পারে। এই ক্ষেত্রে:

    • আপনার যদি কেবল দুটি কল পর্যন্ত কল করে থাকে Arrays.sort(a), তবে এর সবচেয়ে কার্যকরী উপায় হ'ল এর সম্পূর্ণরূপে যোগ্যতাসম্পন্ন নাম সহ কল ​​করা java.util.Arrays.sort(a)
    • তিন বা ততোধিক কল সহ এটির পরিবর্তে একটি শর্টকাট পদ্ধতি যুক্ত করা আরও দক্ষ void s(int[]a){java.util.Arrays.sort(a);}। এটি এখনও এই ক্ষেত্রে পুরোদস্তুর যোগ্য নাম ব্যবহার করা উচিত। (যদি আপনার একাধিক ওভারলোডের প্রয়োজন হয় তবে আপনি সম্ভবত এটি ভুল করছেন))
    • তবে, যদি আপনার কোডটিতেও কোনও বিন্যাসে একটি অ্যারের অনুলিপি করা প্রয়োজন হয় (সাধারণত forসহজেই অ্যাক্সেসযোগ্য লাইব্রেরি পদ্ধতির অভাবে গল্ফিংয়ে একটি সংক্ষিপ্ত লুপ দিয়ে সম্পন্ন করা হয় ), আপনি Arrays.copyOfকাজটি করার সুবিধা নিতে পারেন । যখন একাধিক পদ্ধতি ব্যবহৃত হয় এবং সেখানে 3 বা ততোধিক কল আসে, import static java.util.Arrays.*;তখন সেই পদ্ধতিগুলির বিষয়ে উল্লেখ করার সর্বাধিক দক্ষ উপায়। এর পরে, কেবলমাত্র যদি আপনার কাছে 8 টিরও বেশি আলাদা কল থাকে তবে sortএটির জন্য শর্টকাট পদ্ধতিটি ব্যবহার করা উচিত এবং কেবল 5 বা ততোধিক কলের জন্য শর্টকাট ওয়্যারেন্টড copyOf

    কোডে এই জাতীয় বিশ্লেষণ করার একমাত্র আসল উপায়টি আসলে কোডের অনুলিপিগুলিতে সম্ভাব্য সংশোধন করা এবং তারপরে ফলাফলগুলি তুলনা করা।

  • someTypeValue.toString();পদ্ধতি ব্যবহার করা এড়িয়ে চলুন , পরিবর্তে কেবল সংযোজন করুন someTypeValue+""

  • আপনার যদি উইন্ডোগুলির প্রয়োজন হয় তবে সুইং ব্যবহার করবেন না, এডাব্লুটিটি ব্যবহার করুন (যদি না আপনার সত্যিই সুইং থেকে কোনও কিছু প্রয়োজন হয়)। তুলনা import javax.swing.*;এবং import java.awt.*;। উপরন্তু, সুইং মধ্যে উপাদান একটি আছে Jতাদের নাম (আগে লেখা JFrame, JLabelইত্যাদি), কিন্তু AWT মধ্যে উপাদান করবেন না ( Frame, Labelইত্যাদি)


43

interfaceপরিবর্তে ব্যবহার করুন class

জাভা 8-এ, ইন্টারফেসে স্থির পদ্ধতি যুক্ত করা হয়েছিল। ইন্টারফেসে, সমস্ত পদ্ধতি ডিফল্টরূপে সর্বজনীন। অতএব

class A{public static void main(String[]a){}}

এখন সংক্ষিপ্ত করা যেতে পারে

interface A{static void main(String[]a){}}

যা স্পষ্টতই খাটো।

উদাহরণস্বরূপ, আমি এই বৈশিষ্ট্যটি হ্যালো, ওয়ার্ল্ডে ব্যবহার করেছি! চ্যালেঞ্জ।


8
আমি জানতাম না! +1, দুর্দান্ত কৌশল
হাইপারনিউটারিনো

হ্যাঁ, কম বয়লারপ্লেট!
ক্যালকুলেটরফলাইন

3
আমি আংশিকভাবে একমত হতে হবে না (এছাড়াও, আমি সেই কৌশলটি ব্যবহার করে আপনাকে "হ্যালো, ওয়ার্ল্ড!" চ্যালেঞ্জে পরাজিত করেছি )।
অলিভিয়ার

37

সঙ্গে ভারার্গস আপনি একই ধরণের একটি অ্যারের সময়ে একটি মাপদণ্ড "কাস্ট" করতে পারেন:

void f(String...x){
    x=x[0].split("someregex");
    // some code using the array
}

পরিবর্তে

void f(String s){
    String[]x=s.split("someregex");
    // some code using the array
}

31

একটি স্থিতিশীল আমদানি সহ :

import static java.lang.System.out;
// even shorter (thanks to Johannes Kuhn):
import static java.lang.System.*;

আপনি পরে কিছু বয়লারপ্লেট সংরক্ষণ করতে পারেন, তবে আপনাকে অর্থ প্রদানের জন্য পৌঁছানোর জন্য একাধিক নিমন্ত্রণ প্রয়োজন:

public static void main (String[] args) {
    out.println ("foo");    
    out.println ("bar");    
    out.println ("baz");    
}

8
হে। তুমি এটি করতে পারো?! এবং এই সমস্ত সময় আমি ভেবেছিলাম যে এটি অসম্ভব Java!
জাস্টিন

12
আপনি এমনকি ব্যবহার করতে পারেন import static java.lang.System.*
জোহানেস কুহেন

1
আমি জানি এটি একটি পুরানো উত্তর, তবে জাভা 10-এ আপনি এখন var o=System.out;যা করতে পারবেন তা পরিশোধের আগে কেবল দুবারই ব্যবহার করা দরকার
লুইক স্টিভেনস

@ লুক্সটিভেনস: আচ্ছা, আপনি সম্ভবত জাভা 10 এর সাথে আরও কিছু উন্নতি পেয়েছেন এবং জাভা 10 এর চারপাশে একটি পৃথক উত্তর গঠন করেছেন?
ব্যবহারকারী অজানা

1
@ লুক্স স্টিভেনস var o=System.out.printlnকাজ করবে?
মিল্কিওয়ে 90

25

আর্গুমেন্টটি কল করতে mainহবে না argsএবং আপনি কিছু সাদা জায়গা কেটে দিতে পারেন:

public static void main(String[]a){}

ঠিক আছে করতে হবে।


1
যদি পূর্ণাঙ্গ প্রোগ্রাম লেখার জন্য স্পষ্টভাবে বিবরণ না দেওয়া হয় তবে উত্তরগুলিতে কী মূল ফাংশন অন্তর্ভুক্ত করা দরকার? আমি উত্তর হিসাবে ল্যাম্বডা এক্সপ্রেশন ব্যবহার করছি।
মকোটোসান

3
@ মাকোটোসান না তারা না; লাম্বদাস সাধারণত ভাল থাকে।
দানিরো

21

আপনার যদি কখনও বুলিয়ান এক্সপ্রেশন ব্যবহার করতে হয় trueবা falseএগুলি যথাক্রমে 1>0এবং প্রতিস্থাপন করুন 1<0

উদাহরণ স্বরূপ:

boolean found=false;
for(i=0; i<10; i++) if(a[i]==42) found=true;

এই লিনিয়ার অনুসন্ধান উদাহরণটি হ্রাস করা যেতে পারে

boolean f=1<0;
for(i=0;i<10;)if(a[i++]==42)f=1>0;

11
যদি আপনার প্রচুর প্রয়োজন হয় true/falseতবে কেবল যুক্ত করুন boolean t=1>0,f=1<0;। তার পরিবর্তে 1>0, ব্যবহার করুন tএবং প্রতি ব্যবহার দুটি অক্ষর সংরক্ষণ করুন। পেওফ ওভার 1>0পদ্ধতিটি 10 ​​টি ব্যবহারে আসে।
জিওবিটস

24
@ জিওবিটস: boolean t=1>0,f=!t;- একটি চর খাটো!
বববেল

6
উদাহরণটি আসলে ভাল নয়। এক্ষেত্রে এবং আরও অনেক (!) আপনি যেভাবে true/ falseসরাসরি ব্যবহার এড়াতে পারবেন : f|=a[i++]==42;অনেক কিছু সঞ্চয় করে।
ইনগো বার্ক

@ ইনগোবার্ক সত্য আমি যখন এটি লিখছিলাম তখন আমি প্রায়শই লাইব্রেরির ফাংশনগুলি সম্পর্কে চিন্তা করি যা ব্যবহার করে booleanতবে আমি লেখার সময় কোনও উদাহরণ নিয়ে আসতে পারি নি (আমি সাধারণত জাভাতে কোড করি না) আমি কেবল একটি সাধারণ উদাহরণ লিখেছিলাম।
#HongKongInd dependence

1
@ জিওবাইটস জাভা সম্পর্কে খুব বেশি পরিচিত না তবে আপনি কেবল 1 টি সংজ্ঞায়িত করতে পারেন এবং টি এবং টি ব্যবহার করতে পারেন (আবার আমি জাভা জানি না, কেবল কৌতূহলী)
অ্যালবার্ট রেনশওয়া

20

আপনি যদি কিছু পদ্ধতি প্রচুর পরিমাণে ব্যবহার করতে যাচ্ছেন তবে এর আবাসিক ক্লাসটি একটি ভেরিয়েবলের জন্য বরাদ্দ করুন। উদাহরণস্বরূপ, System.outএকটি ভেরিয়েবল বরাদ্দ করুন :

java.io.PrintStream o=System.out;
//now I can call o.print() or o.println() to the same effect as System.out.println()

এছাড়াও Integer.parseInt():

Integer i=1;
i.parseInt("some string");

এটি প্রায় অবশ্যই "পরিবর্তনশীল থেকে স্থির পদ্ধতি অ্যাক্সেস" সম্পর্কে একটি আদর্শ সতর্কতা ট্রিগার করবে


((Integer)1).parseInt("1")খুব কাজ করে।
ম্যাজিক অক্টোপাস উরন

5
@carusocomputing new Integer("1")এমনকি খাটো। কিন্তু জাস্টিন তার উত্তরের সাথে যা বোঝায় তা হ'ল আপনি স্থায়ী কলগুলির জন্য ইতিমধ্যে থাকা পরিবর্তনগুলি পুনরায় ব্যবহার করতে পারেন। আমি এই উত্তরের নীচে ব্যাখ্যা হিসাবে।
কেভিন ক্রুইজসেন

19

বিবৃতিগুলিতে import static java.lang.System.*সঞ্চয় করার কৌশলটি ব্যবহার করার পরিবর্তে println(), আমি খুঁজে পেয়েছি যে নিম্নলিখিত পদ্ধতিটি নির্ধারণ করা অক্ষরগুলি সংরক্ষণে অনেক বেশি কার্যকর:

static<T>void p(T p){
    System.out.println(p);
}

এর কারণ এটি দ্রুত এবং আরও বেশি নাটকীয় চরিত্রের পেওফ রয়েছে p(myString)তার চেয়েও অনুরোধ করা যেতে পারে out.println(myString)


19

এটি সুস্পষ্ট বলে মনে হতে পারে তবে কিছু Mathফাংশনের জন্য ছোট বিকল্প রয়েছে :

a=Math.max(b,c);
a=b>c?b:c;

a=Math.min(b,c);
a=b<c?b:c;

a=Math.abs(b);
a=b<0?-b:b;

a=Math.round(b);
a=(int)(b+.5);          // watch for precision loss if it matters

14

আপনার যদি প্রয়োজন হয় Integer.MAX_VALUE(2147483647), ব্যবহার করুন -1>>>1Integer.MIN_VALUE(-2147483648) ভাল লেখা হয় 1<<31


14

আপনার যদি কোনও যুক্তি (বা অন্য কোনও স্ট্রিং) থেকে কোনও সংখ্যা দখল করতে হয় তবে সাধারণত আপনি এরকম কিছু দেখতে পান:

public static void main(String[]a){
    int n=Integer.valueOf(a[0]);
    ...
}

অনেক সময়, আপনি না প্রয়োজন একটি Integer। প্রচুর চ্যালেঞ্জ বিপুল সংখ্যক ব্যবহার করে না। যেহেতু Shortএবং Byteউভয়ই একটিতে আনবক্স করবে int, valueOf()পরিবর্তে আরও উপযুক্ত ব্যবহার করুন এবং একটি দম্পতি বাইট সংরক্ষণ করুন।

আপনার প্রকৃত পরিবর্তনশীলটিকে হিসাবে হিসাবে রাখুন int, যেহেতু এটি উভয়ের চেয়ে কম byteএবং short:

int n=Byte.valueOf(a[0]);

আপনার যদি একাধিক সংখ্যার জন্য এটি করতে হয় তবে আপনি এই পদ্ধতির সাথে একত্রিত করতে পারেন :

Byte b=1;
int n=b.valueOf(a[0]),m=b.valueOf(a[1])...

9
int n=new Byte(a[0]);তিনটি খাটো। যদি সংখ্যাটি আরও বড় হতে পারে তবে ব্যবহার করুন long n=new Long(a[0]), এটি intবেশিরভাগ ক্ষেত্রেই এর চেয়ে ভাল ।
Ypnypn

14

ব্যবহার করবেন না public class। মূল পদ্ধতিটি সর্বজনীন হওয়া দরকার, তবে এর শ্রেণিটি হয় না। এই কোডটি কাজ করে:

class S{public static void main(String[]a){System.out.println("works");}}

আপনি পাবলিক ক্লাস না java Sহলেও চালাতে পারেন class S। ( আপডেট: । আমি জাভা 7 ব্যবহার করছিলেন যখন আমি এই ডগা লিখেছিলেন জাভা 8, আপনার প্রধান পদ্ধতি একটি ইন্টারফেসের মধ্যে হওয়া উচিত জাভা 5 বা 6। আপনার প্রধান পদ্ধতি একটি enum থাকা উচিত ।)

প্রচুর জাভা প্রোগ্রামার এটি জানেন না! নন-পাবলিক ক্লাসে মেইন সম্পর্কে স্ট্যাক ওভারফ্লো প্রশ্নের প্রায় অর্ধেক উত্তর ভুলভাবে দাবি করে যে মূল পদ্ধতিটি অবশ্যই একটি পাবলিক ক্লাসে থাকতে হবে। এখন আপনি আরও ভাল জানেন। মুছুন publicমধ্যে public classএবং 7 টি অক্ষর সংরক্ষণ করুন।


1
আপনি যদি 1.8 এর আগে কোনও জাভা লক্ষ্য না করে থাকেন interface s{static void main(String[]...তবে নির্মাণটি আরও ছোট। আপনার অবশ্যই একটি সংকলনযোগ্য উত্স ফাইল এবং প্রধান পদ্ধতি থাকতে হবে। কারণ একটি জাভা 1.8 ইন্টারফেসে, সমস্ত পদ্ধতিগুলি সর্বজনীন যাতে আপনি পদ্ধতিতে (গুলি) পরিবর্তন করতে পারেন।
ডগলাস

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

আমি প্রোগ্রামিং থেকে এটি শিখিনি; আমি এটি গল্ফিং থেকে শিখেছি :)
ডগলাস

14

কিছু ছোট কোড-গল্ফিং টিপস

পৃথক উত্তরগুলির জন্য এই টিপসটি কিছুটা ছোট ছিল, তাই আমি এই উত্তরটি খুব ছোট কোডগল্ফিং টিপসের জন্য ব্যবহার করব যা আমি পেয়েছি বা এনেছি, এবং অন্যান্য টিপসে এখনও উল্লেখ করা হয়নি:

কোনও স্ট্রিংয়ের শেষ চরিত্রটি সরানো:

// 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আমার এই উত্তরের


আপনার শেষ পয়েন্টের জন্য আরও সাধারণভাবে আপনি স্থিতিশীল সদস্যদের অ্যাক্সেসের জন্য যেমন অ-স্থিতিশীল প্রসঙ্গ থেকে অ্যাক্সেস / আবেদন করতে পারেন।
পোকে

1
আমি আপনার সিল টিপ বুঝতে পারি না। আপনি সিলিং করতে চান কেন positive integers? এছাড়াও, সিল বাস্তবায়ন কাজ করে কিনা আমি নিশ্চিত নই ।
জোনাথন ফ্রেচ

1
since Java automatically floors on integers; আমি মনে করি সঠিক শব্দটি ছাঁটাই , মেঝে নয় ।
জোনাথন ফ্রেচ

1
আরেকটি প্যালিনড্রোম কৌশলString t="";for(int i=s.length();--i>=0;t+=s.charAt(i));return s.equals(t);
রবার্তো গ্রাহাম

1
@ রুবার্তো গ্রাহাম আমি আসলে আমার আসল কোডটি ভুল চ্যালেঞ্জ থেকে অনুলিপি করেছি .. কেবল s.equals(new StringBuffer(s).reverse()+"")যথেষ্ট।
কেভিন ক্রুজসেন

11

গল্ফিংয়ের জন্য যার জন্য ইনপুট লাগবে না, আপনি স্ট্যাটিক ব্লকগুলি ব্যবহার করতে পারেন এবং কোনও মূল পদ্ধতি ছাড়াই ঠিক সূক্ষ্মভাবে চালাতে পারেন, কেবল এটি জাভা 6 দিয়ে সংকলন করুন।

public class StaticExample{
    static {
        //do stuff
    }
}

1
আপনি এটি সংকলন এবং চালানোর চেষ্টা করেছেন? ক্লাস লোডার দ্বারা ক্লাস লোড হয়ে গেলে এই ব্লকটি চালানো হয়। তবে ক্লাস লোডার কোনও প্রধান পদ্ধতি সহ কোনও শ্রেণীর সম্পর্কে না জানা পর্যন্ত কিছুই লোড করবে না।
ক্রંચার

@ ক্রাঙ্কার আপনি নিজেরাই javaকমান্ড লাইনে / ম্যানিফেস্ট ফাইলটিতে কোন ক্লাসটি লোড করবেন তা জানাতে পারেন।
এজেম্যানসফিল্ড

6
@ ক্রাঙ্কার, এটি জাভা with এর সাথে কাজ করেছে Java জাভা it এর কাজ করার পদ্ধতিটি পরিবর্তন করেছে।
পিটার টেলর

1
শেষে একটি ব্যতিক্রম ছোঁড়ে কিন্তু এটি কার্যকর! এমনকি জাভা 7
stommestack

2
@ জোপ ভার্নুইজ আপনি যদি নিজের মুখে কোনও ব্যতিক্রম না চান তবে আপনি সিস্টেমটি ছাড়তে পারেন (ছাড়ুন), তবে আপনি চরিত্রগুলি নষ্ট করবেন না, কোনও গল্ফ চ্যালেঞ্জ আপনাকে ব্যতিক্রমগুলি এড়াতে বলবে না;)
ফেবিনআউট

11

আমরা সকলেই বিটওয়াইজ জোর ( ^) সম্পর্কে জানি তবে এটি একটি যৌক্তিক জোরও।

তাই (a||b)&&!(a&&b)সহজ হয়ে যায় a^b

এখন আমরা xor ব্যবহার করতে পারেন।

অতিরিক্তভাবে , অপারেটরগুলি |এবং & এছাড়াও কাজ করে , কেবল মনে রাখবেন যে অপারেটরের অগ্রাধিকার পরিবর্তিত হয়।


5
যতক্ষণ আপনি প্রাধান্য মনে রাখবেন ততক্ষণ আপনি ব্যবহার করতে পারেন & এবং |এটিও করতে পারেন । যদি আপনার শর্তগুলি ইতিমধ্যে বন্ধনীগুলিতে থাকে বা আপনি ইতিমধ্যে বুলিয়ানদের সাথে কাজ করছেন তবে এটি কার্যকর হতে পারে।
জিওবিটস

1
আপনার যদি (অনেক) নিম্নতর অগ্রাধিকার প্রয়োজন হয় তবে আপনি জোরের !=পরিবর্তে ^এবং ==এক্সনরের জন্য ব্যবহার করতে পারেন
সাইওস

11

আপনি ব্যবহার করতে হবে না Character.toLowerCase(char c)। পরিবর্তে ব্যবহার (c|32)। পরিবর্তে Character.toUpperCase(char c)ব্যবহার (c&~32)। এটি কেবল ASCII অক্ষরের সাথে কাজ করে।


c|~32ফলাফল -1 ... আরও ভাল ব্যবহার করা হবে c-32
feersum

5
@ ফেয়ারসাম আপনি যদি একটি বড় হাতের অক্ষর বড় হাতের অক্ষর করতে চান তবে এটি কার্যকর হবে না।
TheNumberOne

11

স্ট্রিংকে সংখ্যায় রূপান্তর করুন

স্ট্রিংকে একটি সংখ্যাসূচক মানতে রূপান্তর করার একাধিক উপায় রয়েছে:

String s = "12";

এবিসি.পার্সএএবিসি :

Short.parseShort(s); // 20 bytes
Integer.parseInt(s); // 20 bytes
Long.parseLong(s);   // 18 bytes

এবিসি.ভ্যালুওফ :

Short.valueOf(s);    // 17 bytes
Integer.valueOf(s);  // 19 bytes
Long.valueOf(s);     // 16 bytes

এবিসি.ডাইকোড :

// Note: does not work for numeric values with leading zeros,
// since these will be converted to octal numbers instead
Short.decode(s);     // 16 bytes
Integer.decode(s);   // 18 bytes
Long.decode(s);      // 15 bytes

নতুন এবিসি :

new Short(s);        // 13 bytes
new Integer(s);      // 15 bytes
new Long(s);         // 12 bytes

সুতরাং, কোড-গল্ফিংয়ের জন্য, একটি স্ট্রিংকে একটি সংখ্যার মান হিসাবে রূপান্তর করার সময় কনস্ট্রাক্টর ব্যবহার করা ভাল।

একই প্রযোজ্য Double; Float; এবং Byte


আপনি যখন বস্তু হিসাবে ইতিমধ্যে উপস্থিত আদিমকে পুনরায় ব্যবহার করতে পারেন তখন এটি সর্বদা প্রযোজ্য নয়।
উদাহরণস্বরূপ, আসুন আমাদের নীচের কোড রয়েছে বলে দিন:

// NOTE: Pretty bad example, because changing the short to int would probably be shorter..
//       but it's just an example to get the point across

short f(short i,String s){
  short r=new Short(s);  // 21 bytes
  ... // Do something with both shorts
}

আপনি .decodeপারামিতিটিকে বস্তু হিসাবে পুনরায় ব্যবহার করে সংক্ষিপ্ত নির্মাণকারীর পরিবর্তে ব্যবহার করতে পারেন :

short f(Short i,String s){   // Note the short parameter has changed to Short here
  short r=i.decode(s);   // 20 bytes
  ... // Do something with both shorts
}

10

ব্যবহার করবেন না Random!

সাধারণভাবে, আপনার যদি এলোমেলো সংখ্যার প্রয়োজন হয় তবে Randomএটি চালিয়ে যাওয়া একটি ভয়ঙ্কর উপায়। Math.random()পরিবর্তে ব্যবহার করা আরও ভাল । ব্যবহার করার জন্য Random, আপনাকে এটি করতে হবে (আসুন আমরা বলি যে আমাদের একটি প্রয়োজন int):

import java.util.*;
Random r=new Random();
a=r.nextInt(9);
b=r.nextInt(9);

এর সাথে তুলনা করুন:

a=(int)(Math.random()*9);
b=(int)(Math.random()*9);

এবং:

int r(int m){return(int)(Math.random()*m);}
a=r(9);
b=r(9);

প্রথম পদ্ধতিতে 41+15nঅক্ষর লাগে ( nকলগুলির সংখ্যা)। দ্বিতীয়টি 25nঅক্ষর, এবং তৃতীয়টি 43+7n

সুতরাং, আপনার যদি কেবল একবার বা দুবার প্রয়োজন হয় তবে ইনলাইন Math.random()পদ্ধতিটি ব্যবহার করুন । তিন বা ততোধিক কলের জন্য, আপনি কোনও ফাংশন ব্যবহার করে সংরক্ষণ করবেন। হয় কেউ প্রথম ব্যবহারের পরে অক্ষর সংরক্ষণ করে Random


আপনি যদি ইতিমধ্যে ব্যবহার করে Math.random()থাকেন তবে doubleমনে রাখবেন যে চারটি ব্যবহারে এটি এটিকে টানতে এখনও একটি সঞ্চয়:

double r(){return Math.random();}

33 টি অক্ষরের জন্য, আপনি প্রতিটি কলটিতে 10 টি সংরক্ষণ করবেন r()


হালনাগাদ

আপনার যদি কোনও পূর্ণসংখ্যার প্রয়োজন হয় এবং কাস্টিংয়ে সংরক্ষণ করতে চান তবে এটি কাস্ট করবেন না! আপনি যদি কোনও অ্যাসাইনমেন্টের পরিবর্তে কোনও অপারেশন করেন তবে জাভা অটো কাস্ট করবে। তুলনা করা:

a=(int)(Math.random()*9);
a=9;a*=Math.random();

* যদি আপনার ভবিষ্যদ্বাণীীয় ফলাফলের জন্য পিআরএনজি বজায় না থাকে। তারপরে, আমি এর আশেপাশে খুব একটা উপায় দেখতে পাচ্ছি না।


2
Random#nextGaussianযদিও সম্পর্কে ভুলবেন না ।
জাস্টিন

@ কুইন্টাক্স সত্য, একটি ভাল সাধারণ বিতরণ পাওয়ার জন্য গণিত করা আপনার যে কোনও সঞ্চয় হারাবে তা হারাবে। আমি কেবলমাত্র সেই ব্যতিক্রম হিসাবে উল্লেখ করব যা নিয়ম প্রমাণ করে;)
জিওবিটস

লক্ষ্য করুন (int)(Math.random()*9)একটি খুব ছোট মডিউল পক্ষপাত আছে, কারণ Math.random()রিটার্ন 2 53 সম্ভাব্য মান, এবং 2 53 9. এর গুণিতক প্রতিটি সংখ্যা সম্ভাব্যতা মধ্যে নয় 1/9 প্লাস বা মাইনাস 5 / (9 * 2 ** 53), একটি ত্রুটি এত ছোট, এটি প্রায় ঠিক 1/9।
কর্নিগ

@ কার্নেহ রাইট, আমি 9উদাহরণ হিসাবে ব্যবহার করছিলাম , এটি যে কোনও কিছু হতে পারে। আমি তুলনামূলকভাবে নিশ্চিত যে nextInt()(বা অন্য কোনও Randomপদ্ধতিতে) জাভাটির পিআরএনজি কীভাবে কাজ করে তার কারণে একটি ছোট পক্ষপাতও রয়েছে।
জিওবিটস

1
কিছু যখন আপনি একটি র্যান্ডম বুলিয়ান চান তাদের জন্য সম্পর্কিত: পরিবর্তে new java.util.Random().nextBoolean()আপনি ব্যবহার করতে পারেন Math.random()<.5
কেভিন ক্রুইজসেন

7

আপনি এই 'খাঁটি' জাভা বিবেচনা করবেন কিনা তা আমি জানি না, তবে প্রসেসিং আপনাকে সামান্য প্রাথমিক সেটআপ (স্বয়ংক্রিয়ভাবে সমাপ্ত) সহ প্রোগ্রামগুলি তৈরি করতে দেয়।

কনসোল আউটপুট এর জন্য আপনার মতো সাধারণ কিছু থাকতে পারে:

println("hi"); //done

গ্রাফিকাল আউটপুট জন্য, আরও কিছু:

void setup() {
  size(640,480);
}
void draw() {
  fill(255,0,0); //color used to fill shapes
  rect(50,50,25,25); //25x25 pixel square at x=50,y=50
}

1
+1 দুর্দান্ত উত্স! আমি এটি সঙ্গে চারপাশে খেলা নিশ্চিত হবে।
রব

আমি যদি এর সাথে অন্য লোকের উত্তর যুক্ত করি তবে তা ঠিক হবে? বা এটি কোনও সম্প্রদায়ের উইকির উদ্দেশ্যকে পরাজিত করে?
রব

2
যাইহোক, আপনি এমনকি কল sizeকরতে হবে না; এটি 100 বাই 100 পিক্সেল স্কোয়ারে ডিফল্ট হবে। বেশিরভাগ ওএসে, এর চারপাশের ফ্রেমটি প্রায় দ্বিগুণ হবে, বর্গাকার কেন্দ্রিক এবং বাকী অঞ্চলটি ডেস্কটপ থেকে নেওয়া সামগ্রীতে ভরা হবে।
এজেম্যানসফিল্ড

1
গ্রাফিকাল আউটপুট জন্য, যদি আপনার অ্যানিমেশন প্রয়োজন হয় না, আপনি কেবল বাইরে কিছু লিখতে setup()এবং draw()"স্ট্যাটিক মোড" ব্যবহার করতে পারেন। আপনি 6-সংখ্যার হেক্স রঙগুলিও ব্যবহার করতে পারেন এবং দোভাষী তাদের পরিবর্তন করবেন যা কখনও কখনও ( #FF8000< 255,128,0) প্রদান করে এবং যদি আপনি গ্রেস্কেল ব্যবহার করেন তবে কেবলমাত্র একটি নম্বর নির্দিষ্ট করা দরকার ( 255< 255,255,255)
কোট

7

ছোট করে ফিরছে returning

আপনি এর সাথে বাইট দ্বারা স্ট্রিংগুলির রিটার্ন স্টেটমেন্টগুলি ছোট করতে পারেন:

return "something";

প্রতি

return"something";

এবং, যদি আপনি কোনও প্রথম বন্ধনী দিয়ে আপনার রিটার্নের বিবৃতি শুরু করেন, আপনি তাদের সাথে একই জিনিসটি করতে পারেন:

return (1+taxRate)*value;

প্রতি

return(1+taxRate)*value;

আমার ধারণা অনুমানগুলি প্যারেন্টিথিকালগুলির মতো বিবেচিত? আমি আসলে অ্যাপলস্ক্রিপ্টের মাধ্যমে এটি উপভোগ করেছি, মজাদারভাবে যথেষ্ট, এবং ভেবেছিলাম এটি সম্ভবত উল্লেখযোগ্য worth


1
একই সংখ্যার চিহ্নগুলিতে প্রয়োগ হয় যেমন return-n;পরিবর্তে return -n;বা return~n;পরিবর্তে return ~n;। পাশাপাশি ডাবল উদ্ধৃতিগুলির পরিবর্তে একক:return'A';
কেভিন ক্রুইজসেন

1
মূলত, এমন কোনও কিছুর জন্য কাজ করে যা সনাক্তকারীর অংশ হতে পারে না (যেমন নন-লেটার এবং অ-অঙ্ক))
পাওলো ইবারম্যান

7

বৈজ্ঞানিক স্বরলিপি ব্যবহার করতে ভয় পাবেন না

আপনি যদি ডাবল, বা ভাসমান বিষয় নিয়ে কাজ করে থাকেন তবে আপনি সংখ্যার জন্য বৈজ্ঞানিক স্বরলিপি ব্যবহার করতে পারেন। সুতরাং লেখার পরিবর্তে double a=1000আপনি এটি পরিবর্তন করে double a=1e31 বাইট সংরক্ষণ করতে পারেন ।


7

এর intপরিবর্তে ব্যবহার করার চেষ্টা করুনboolean

কিছু ক্ষেত্রে আমি দেখতে পেয়েছি যে সি প্রোগ্রামগুলিতে করা হতে পারে একইভাবে একটি বুলিয়ান ফেরত দিতে পারে এমন একটি পদ্ধতি থেকে পূর্ণসংখ্যার মানটি সংক্ষিপ্ত করা কম।

ব্যাট থেকে ডানদিকে int4 বাইটের চেয়ে কম খাটো boolean। প্রতিবার return 0পরিবর্তে আপনি যখন লিখবেন return 1<0, আপনি অতিরিক্ত 2 বাইট এবং একই জন্য সংরক্ষণ return 1 করবেন return 1>0

এখানে সমস্যাটি হ'ল প্রতিবার আপনি রিটার্নের মানটি সরাসরি বুলিয়ান হিসাবে ব্যবহার করতে চাইলে এর ব্যয় হয় 2 বাইট ( if(p(n))v। if(p(n)>0))। বুলিয়ান পাটিগণিত ব্যবহার করে এটি তৈরি করা যেতে পারে। আপনি যেখানে লিখতে চান সেখানে একটি কনট্রিভাইড দৃশ্যাবলী

void a(int[]t){t[0]+=p(n)?10:0;}

আপনি পরিবর্তে লিখতে পারেন

void a(int[]t){t[0]+=p(n)*10;}

2 বাইট সংরক্ষণ করার জন্য।


6
আমি প্রায় প্রায়ই এই কাজ যখন golfing কিন্তু মনে রাখবেন যে সাধারণ ঐক্যমত্য যে 0এবং 1মিথ্যা / জাভা সত্য গঠন নেই (এবং JLS তাদের যে ভাবে পারেন বিবেচনা করে না)। সুতরাং যদি গল্ফটি বিশেষত সত্যবাদী / মিথ্যা বলার অনুরোধ করে তবে আপনার এটি বুলেটিনাইজ করা দরকার (এবং দুর্ভাগ্যক্রমে এটি এটিকে booleanআরও বেশি বাইট ছুঁড়ে ফাংশন করে তোলা)।
জিওবিটস

2
t[0]+=p(n):10?0;এটি কি বৈধ?
dorukayhan

@ ডোরুকায়হান না, এটি বোঝানো হয়েছে t[0]+=p(n)?10:0;। (আমি এটি সম্পাদনা করেছি))
পাওলো ইবারম্যান

6

আপনি যদি ক্লাসের পরিবর্তে এনাম ব্যবহার করেন তবে আপনি একটি অক্ষর সংরক্ষণ করুন।

enum NoClass {
    F, G, H;    
    public static void main (String[] args) {

    }
}

তবে আপনাকে অন্তত একটি এনাম উদাহরণ চালু করতে হবে (এফ, জি, এইচ উদাহরণস্বরূপ) যা তাদের নিজেরাই পরিশোধ করতে হবে।


2
দেখে মনে হচ্ছে আপনার কোনও এনাম উদাহরণ প্রয়োজন নেই। আমি enum M{;public static void main(String[]a){...}কোন সমস্যা ছাড়াই করেছি।
ড্যানি

3
@ ড্যানি তবে তারপরে এটি কোনও অক্ষর সংরক্ষণ করে না। class M{ঠিক একই দৈর্ঘ্য হিসাবে enum M{;। সেক্ষেত্রে আমি তার সাথে যাব classকারণ এটি সুন্দর (আইএমও)
জাস্টিন

1
কমপক্ষে আমার জন্য enum{একটি ;পরে ছাড়া কাজ করে ; এটির কেবল আইডিই
শোক করছে যে বুথ

@ মাস্টারএক্স 244 কি সংকলন / সংস্করণ? আমার একটি তন্ত্র ছুঁড়ে ফেলেছে এবং এটি করবে না।
জিওবিটস

জাভা ১.7 এ আমার জন্য কাজ করেছেন (উপস্থিত হয়ে .8 এর আপডেটের সাথে আরও কারণ অনুসন্ধানে তদন্ত করার জন্য এটি কাজ বন্ধ করে দিয়েছিল)
এক্স 244

5

আপনি যদি একটি পদ্ধতি যা একটি ফিরতি উচিত যখন booleanবা Boolean, অর্থাত্:

// Return true if the (non-negative) input is dividable by 5
boolean c(int i){return i%5<1;}

আপনি 1 টি বাইট সংরক্ষণ করতে boolean/ Booleanরিটার্ন-টাইপ পরিবর্তন করতে পারেন Object:

Object c(int i){return i%5<1;}

এছাড়াও, আপনি যেমন খেয়াল করেছেন, আপনি বাইট সংরক্ষণ করার <1পরিবর্তে একটি চেক ব্যবহার করতে পারেন ==0। যদিও এটি জাভা-নির্দিষ্টের পরিবর্তে সাধারণ কোড-গল্ফ টিপ।
দৈর্ঘ্য পরীক্ষা করার মতো পূর্ণসংখ্যাটি নেতিবাচক হতে না পারলে এটি বেশিরভাগ ক্ষেত্রে ব্যবহৃত হয়:

a.length<1

পরিবর্তে

a.length==0

1
সুন্দর টিপ! বর্তমানের সাথে c(-21)প্রত্যাবর্তন trueকরার কারণে আপনি এটি উদাহরণস্বরূপ "যদি এটি নেতিবাচক হতে না পারে" বিভাগে অন্য একটি উদাহরণ যুক্ত করতে চাইতে পারেন returns
জিওবিটস

ব্যাখ্যা। এছাড়াও, আপনি c(-20)পরিবর্তে মানে না -21? -21 % 5 = 4এবং -20 % 5 = 0
কেভিন ক্রুইজসেন

1
না, আমি বোঝানো -21-21 % 5 != 4জাভা, যা আমার পয়েন্ট। পাঁচটি ফাংশন দ্বারা বিভাজ্য হবে সঠিকভাবে কাজ যদি মডুলাস সবসময় অ নেতিবাচক ফিরে, কিন্তু এটা না। দেখুন এই উদাহরণে স্নিপেট
জিওবিটস

@ জিওবিটস আহ, উদাহরণের জন্য ধন্যবাদ আমি প্রায় কখনই এর সাথে নেতিবাচক সংখ্যা ব্যবহার করি না %, তাই আমি জাভাকে ভুলে গিয়েছিলাম মডুলাসের পরিবর্তে বাকী অংশটি ফিরিয়ে
আনি

5

জাভাতে কীভাবে আঁকবেন ...

এখানে সংক্ষিপ্ততম জিইউআই পেইন্ট বয়লার-প্লেট রয়েছে:

import java.awt.*;
static void main(String[]x){
    new Frame(){
        public void paint(Graphics g){
            // Draw your stuff here.
        }    
    }.show();
}

111 বাইটের জন্য গল্ফড:

import java.awt.*;static void main(String[]x){new Frame(){public void paint(Graphics g){/*CodeHere*/}}.show();}

5

চলুন StringBuilderগুলি

স্টাফগুলিকে একটিতে যুক্ত Stringকরতে অনেক কম বাইট লাগে।

// s is a StringBuilder
s.append("Hello, World!");

// S is a String
S+="Hello, World!";

আপনার যদি কোনও স্ট্রিংকে বিপরীত করতে হয় এবং এখনই মুদ্রণ করতে হয় তবে এ ব্যবহার করুন StringBuffer

System.out.print(new StringBuilder("Hello, World!").reverse());
System.out.print(new StringBuffer("Hello, World!").reverse()); // Note that you can omit toString() when printing a non-String object

যদি আপনাকে কোনও স্ট্রিংকে বিপরীত করতে হয় এবং তারপরে এটি মুদ্রণ ব্যতীত অন্য কিছু করতে হয় তবে forপ্রতিটি লুপ ব্যবহার করুন ।

String b=new StringBuffer("Hello, World!").reverse().toString();
String B="";for(String c:"Hello, World!".split(""))B=c+B;

3
StringBufferবিপরীত স্ট্রিংয়ের চেয়ে ফোরচ লুপটি ছোট । String b="";for(char c:"Hello, World!".toCharArray()){b=c+b;}
পোকে

1
আপনি {}যদি সেই পদ্ধতিটি ব্যবহার করতে চলেছেন তবে আপনাকে সেই ফোরচ লুপ থেকে অপসারণ করা উচিত ।
জিওবিটস

1
এর String s:"".split("")পরিবর্তে 2 বাইট ব্যবহার করে সংরক্ষণ করুন char c:"".toCharArray()
চার্লি

আপনি যদি java.util.stream.Streamইতিমধ্যে আমদানি, এবং যদি আপনি চেইন ফলাফলের অন্য কল হবে (মত B.chartAt(42)) অথবা যদি আপনি শুধু একটি ফাংশন (যেমন কাছে ফলাফলের পাস করতে হবে f(B)), তারপর ব্যবহার for(:)করতে equall হয় Stream.of("Hello, World!".split("")).reduce("",(a,b)->b+a)
চার্লি

প্রতিটি উদাহরণ সহ উভয় লাইন গল্ফ করা যেতে পারে। প্রথমটি হতে পারে: String b=new StringBuffer("Hello, World!").reverse()+"";( .toStringপ্রতিস্থাপিত +""), এবং আপনার দ্বিতীয় লাইন হতে পারে: String B="";for(String c:"Hello, World!".split(""))B=c+B;( charথেকে Stringএবং .toCharArray()থেকে .split(""))।
কেভিন ক্রুইজসেন

5

জাভা 10 এর ব্যবহার করুন var

আপনি যদি একটি নির্দিষ্ট ধরণের একক চলক সংজ্ঞায়িত করেন তবে ব্যবহার করুন var

উদাহরণ

var i=0;                        // int
var l=0L;                       // long
var s="";                       // String
var a=new int[]{1,2,3};         // int[]
var i=java.math.BigInteger.ONE; // BigInteger
var m=new java.util.HashMap();  // HashMap
var i=3+"abc".length()          // int
var a="a b c".split(" ");       // String[]
for(var a:"a b c".split(" "))   // String

নিম্নলিখিত উদাহরণগুলির মধ্যে ব্যবহারযোগ্য নয়

var অনেক উদাহরণ ব্যবহার করা যাবে না

var i=1,j=2;           // only one variable is accepted at a time
var a={1,2,3};         // arrays must be explicitly declared
var f=a->a+" ";        // can't know what type a is.
var f=String::replace; // method references aren't properly implied (weirdly, though)

আর কেন এটি পদ্ধতির উল্লেখগুলির সাথে কাজ করে না, মনে রাখবেন যে স্বাক্ষরগুলির একটি ছোট সেট (এবং পদ্ধতিগুলি চেক করা ব্যতিক্রম ছুঁড়ে ফেলতে পারে) এর জন্য মানক কার্যকরী ইন্টারফেস রয়েছে।
জাকব


4

বেশিরভাগ ক্ষেত্রে, আপনার প্রোগ্রামটি একক থ্রেডযুক্ত হবে, অর্থাৎ এটির কেবল একটি থ্রেড চলবে। returnযখন আপনাকে তাত্ক্ষণিকভাবে প্রস্থান করতে হবে তখন আপনি মূল পদ্ধতিটি থেকে আইএন দিয়ে এই সত্যটি কাজে লাগাতে পারেন ।

static void main(String[]a){if(condition)return;}

প্রোগ্রামটিকে সমাপ্ত করে "সঠিকভাবে" এর সাথে তুলনা করুন:

static void main(String[]a){if(condition)System.exit(0);}

বা নির্দেশ করছে null:

static void main(String[]a){if(condition)throw null;}

বা 0 দ্বারা বিভাজন:

static void main(String[]a){if(condition)int A=1/0;}

4

কখনও কখনও, একটি একক জন্য লুপ বিবৃতি পরিবর্তনযোগ্য হতে পারে। নিম্নলিখিত কোড বিবেচনা করুন:

int m(int x){int i=1;for(;x%++i==0;);return i;}

এটি একটি সরল লুপ যা এই প্রশ্নের সমাধান ।

যেহেতু আমরা জানি যে iস্ট্যাকওভারফ্লো ত্রুটিগুলি ঘটানোর পক্ষে যথেষ্ট পরিমাণে বড় হবে না, আমরা তার পরিবর্তে পুনরাবৃত্তি সহ ফর লুপটি প্রতিস্থাপন করতে পারি:

int m(int x,int i){return x%++i>0?i:m(x,i);}

পুনরাবৃত্তির কারণ হিসাবে আমরা রিটার্ন বিবৃতিতে একটি টার্নারি অপারেটর ব্যবহার করে একটি লুপ অনুকরণ করতে পারি।

এই হ্রাস বরং সুনির্দিষ্ট, তবে আমি আরও পরিস্থিতি কল্পনা করতে পারি যেখানে এটি কার্যকর হবে।


4

...প্যারামিটার হিসাবে (varags) ব্যবহার করা

কিছু ক্ষেত্রে আলগা পরিবর্তে জাভা ভারার্গগুলি প্যারামিটার হিসাবে ব্যবহার করা সংক্ষিপ্ত।
উদাহরণ স্বরূপ:

// Example input/output: 5, 4, 3 -> 60000
int calculateVolumeInLiters(int width, int height, int depth){
  return width * height * depth * 1000;
}

এটি দ্বারা বেশিরভাগ দ্বারা গল্ফ হবে:

int c(int w,int h,int d){return w*h*d*1000;} // 44 bytes

তবে এতে অতিরিক্ত বাইট গল্ফ করা যেতে পারে:

int c(int...a){return a[0]*a[1]*a[2]*1000;}  // 43 bytes

মনে রাখবেন যে তিনটি পূর্ণসংখ্যা কেবল পদ্ধতিতে একবারে অ্যাক্সেস করা হয়। যেহেতু intবেশ সংক্ষিপ্ত, আপনি কেবলমাত্র সেগুলির মধ্যে একবারে এই পদ্ধতির অভ্যন্তরে একবার ব্যবহার করেন এবং সেগুলির মধ্যে তিন বা আরও বেশি প্যারামিটার হিসাবে থাকলে এটি কেবল উপকারী।

দীর্ঘ পরামিতি সহ এটি সাধারণত আরও কার্যকর। উদাহরণস্বরূপ, এই চ্যালেঞ্জের জন্য এটি আমার আসল উত্তর ছিল (ইনপুট স্ট্রিংয়ের ইনপুট চরিত্রের ঘটনাগুলি গণনা করুন):

// Example input/output: tttggloyoi, t -> 3

int c(String a,char b){return a.replaceAll("[^"+b+"]","").length();} // 68 bytes

এবং আমাকে এটিতে গল্ফ দেওয়ার জন্য সুপারিশ করা হয়েছিল:

int c(String a,char b){return a.split(b+"").length-1;}               // 54 bytes

তবে আমি এটি ব্যবহার করে এটি গল্ফ করে শেষ করেছি ...:

int c(String...a){return a[0].split(a[1]).length-1;}                 // 52 bytes

দ্রষ্টব্য: যদি প্রশ্ন / চ্যালেঞ্জ একটি নমনীয় ইনপুট চেয়ে থাকে তবে অবশ্যই ...এটি সংক্ষিপ্ত করা যেতে পারে []। যদি প্রশ্ন / চ্যালেঞ্জটি সুনির্দিষ্টভাবে জিজ্ঞাসা করে, তবে আসুন, তিনটি Stringইনপুট এবং Stringতিনটি মান সমেত একটি অ্যারেটিকে নিষ্ক্রিয় করে, আপনি তার String...পরিবর্তে ব্যবহার করতে পারেন String a,String b,String c


2
আপনি কি String[]ভ্যারেজ ব্যবহারের পরিবর্তে একটি ব্যবহার করতে পারবেন না ? (আরও 1 বাইট সাশ্রয় করে)
ক্রিটসি লিথোস

@ ক্রিতিক্সিলিথোস হুম .. ভাল কথা। তবে এটি মূলত নির্ভর করে যে চ্যালেঞ্জের জন্য ইনপুটটি কতটা নমনীয়। যদি কোনও ইনপুট ফর্ম্যাট অনুমোদিত হয় তবে এর চেয়ে সংক্ষিপ্ততর হবে। আমি এই টিপস এ এটি যোগ করব, ধন্যবাদ।
কেভিন ক্রুইজসেন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.