கோட்ஜிம் மாணவர்களின் சிறந்த நண்பர்கள் நிரலாக்க பணிகள், ஜாவா மற்றும் பணி மதிப்பீட்டாளர். இருப்பினும், ஒவ்வொரு படவான் டெவலப்பரும் அடிபட்ட பாதையில் இருந்து விலகி, தனது சொந்த சிறு திட்டங்களைக் கண்டுபிடித்து, நேர்காணலுக்குத் தன்னைத் தயார்படுத்திக் கொள்ள வேண்டிய ஒரு காலம் வருகிறது. இந்த பாடத்திட்டத்தில் காணப்படும் அதே நடைமுறை ஜாவா பணிகளை நேர்காணல் கொண்டிருக்கும் என்று ஒருவர் நினைக்கலாம். பெரும்பாலான சந்தர்ப்பங்களில் இது உள்ளது, ஆனால் சில நிறுவனங்கள் தந்திரமான கேள்விகள் அல்லது அறிமுகமில்லாத ஒன்றைக் கேட்க விரும்புகின்றன. மன அழுத்தம் நிறைந்த நேர்காணலின் போது சத்தமிடுவதைத் தவிர்க்க, வீட்டிலேயே இதே போன்ற ஜாவா பணிகளைத் தீர்க்க முயற்சிப்பது உதவியாக இருக்கும்.
இந்த கட்டுரையில், இதுபோன்ற 5 தந்திரமான பணிகளை ஆராய்வோம். நீங்கள் முதலில் நிபந்தனைகளைப் படித்து அவற்றை நீங்களே தீர்க்க முயற்சிக்குமாறு நாங்கள் பரிந்துரைக்கிறோம். மேலும் ஒரு விஷயம்: இந்த பாடத்திட்டத்தில் தினமும் ஜாவா பணிகளை செய்ய மறக்காதீர்கள்!
பணி 1: புதிதாக ஒரு எல்லையற்ற வளையத்தை உருவாக்கவும்
குறியீடு தொகுதி வழங்கப்பட்டுள்ளது. வளையத்தை எல்லையற்றதாக மாற்ற அதனுடன் சேர்க்கவும்.
class ToInfinity {
public static void main(String[] args) {
// Insert code here
for (int i = start; i <= start + 1; i++) {
/* This should be an infinite loop, but don't change anything here */
}
}
}
" அது கடினம் அல்ல, " நீங்கள் சொல்கிறீர்கள். இந்த சூழ்நிலையில் நீங்கள் மீண்டும் மீண்டும் உங்களைக் கண்டுபிடித்திருக்கலாம்: ஜாவா பணியை முடிக்கும்போது, நீங்கள் ஒரு எல்லையற்ற சுழற்சியை உருவாக்கியுள்ளீர்கள், அதை எவ்வாறு அகற்றுவது என்பது பற்றி சிந்திக்க வேண்டியிருந்தது. சரி, இது வேறு வழி. இங்கே தந்திரமான பகுதி: நீங்கள் லூப்பை அல்லது அதன் வெளியேறும் நிலைகளை மாற்ற முடியாது. இரண்டு மறு செய்கைகள் மட்டுமே உள்ளன. ஆனால், அவை எல்லையற்ற வளையத்தை உருவாக்க போதுமானவை. இது இரண்டு மறு செய்கைகளுக்கு மட்டுமே இயக்க வேண்டும் என்று தோன்றுகிறது, ஆனால் நீங்கள் அதை ஓவர்ஃப்ளோவைப் பயன்படுத்தி எல்லையற்றதாக மாற்றலாம். எப்படி என்று நீங்கள் ஏற்கனவே யூகித்திருக்கிறீர்களா?
தீர்வு
நிரம்பி வழிவதால், ஜாவாவில் சேமிக்கக்கூடிய Integer.MAX_VALUEஅதிகபட்ச மதிப்பு . intநீங்கள் Integer.MAX_VALUEஇந்த மதிப்பை அடைந்து, அதிகரித்தால், நீங்கள் மீண்டும் Integer.MIN_VALUE, அல்லது மாறாக, சாத்தியமான குறைந்த Integerமதிப்புக்கு திரும்புவீர்கள். intஎனவே, இந்த ஜாவா பணியை முடிக்க, மாறிக்கு அதிகபட்ச மதிப்பை விட 1 குறைவாக ஒதுக்க வேண்டும் start. இந்த பணிக்கான ஜாவா குறியீடு:
class ToInfinity {
public static void main(String[] args) {
int start = Integer.MAX_VALUE - 1;
for (int i = start; i <= start + 1; i++) {
// Infinite loop
System.out.println(i); // Be sure we are in an infinite loop
}
}
}
என்ன நடக்கும்? நாங்கள் start=2147483645 (Integer.MAX_VALUE-1) உடன் தொடங்குகிறோம். அடுத்த மறு செய்கையில், மதிப்பு 2147483645 ஆகவும், பின்னர் 2147483646 ஆகவும், பின்னர் -2147483648, -2147483647... மற்றும் பலவாகவும் இருக்கும்.
பணி 2: இயங்கக்கூடிய கருத்தை உருவாக்கவும்
சரி, இங்கே நாங்கள் இருக்கிறோம்! முதல் பாடங்களிலிருந்தே, கருத்துகள் செயல்படுத்தப்படவில்லை என்று நாங்கள் கேள்விப்பட்டிருக்கிறோம். அதனால்தான் அவை கருத்துகள் என்று அழைக்கப்படுகின்றன. இந்த பணிக்கான தீர்வு ஜாவா புரோகிராமர்களுக்கு, அனுபவம் வாய்ந்தவர்களுக்கு கூட எப்போதும் தெளிவாக இருக்காது என்று நாங்கள் நினைக்கிறோம். இருப்பினும், JVM ஒரு கருத்தை செயல்படுத்த ஒரு தந்திரமான (ஆனால் "சட்ட") வழி உள்ளது. நாங்கள் எங்கு செல்கிறோம் என்பதை உங்களால் உணர முடிகிறதா? ஊகிக்க முயற்சி செய்!
தீர்வு
இந்த பணிக்கான ஜாவா குறியீடு:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
இந்த ஜாவா குறியீட்டை IDE இல் உள்ளிட்டால், நாம் பெறுவது இங்கே:
executable comment
ஏனென்றால், ஜாவா கம்பைலர் யூனிகோட் எழுத்தை \u000dஒரு புதிய வரியாக விளக்குகிறது, மேலும் எங்கள் குறியீட்டைப் படிக்கிறது: இந்த பணிக்கான ஜாவா குறியீடு, இது கம்பைலரால் விளக்கப்படுகிறது:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
பணி 3: பெயரிடப்பட்ட வளையத்தை உருவாக்கவும்
"கோள மாடுகளுக்கான நடைமுறை ஜாவா புரோகிராமிங் பிரச்சனைகள்" என்ற தலைப்பில் தொடரின் மற்றொரு உறுப்பினர் இதோ. இது ஏன் அவசியம் என்பது தெளிவாகத் தெரியவில்லை என்ற அர்த்தத்தில்: லூப் ஒரு பெயர் கொடுக்கப்படாததால் புண்படுத்தப்பட வாய்ப்பில்லை. எப்படியிருந்தாலும், இது மற்றொரு காரணத்திற்காக முக்கியமானது: மொழி உங்களை ஒரு வளையத்திற்கு பெயரிட அனுமதிக்கிறது.
தீர்வு
குறிப்பு: இந்த "பெயர்கள்" சிலருக்கு "லேபிள்கள்" என்று அறியப்படுகின்றன, மேலும் அவை நடைமுறையில் பயன்படுத்த பரிந்துரைக்கப்படவில்லை. பெயரிடப்பட்ட வளையத்தை விளக்குவதற்கான ஜாவா குறியீடு
public class NamedLoop {
public static void main(String[] args) {
loop1:
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (i == 3)
break loop1;
System.out.println("i = " + i + " j = " + j);
}
}
}
}
நீங்கள் நிரலை இயக்கினால் என்ன வெளியீடு இருக்கும் என்பது இங்கே:
i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 0 j = 3
i = 0 j = 4
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 1 j = 4
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2
i = 2 j = 3
i = 2 j = 4
பெயரிடப்பட்ட லூப்பின் தொடக்கத்திற்குத் திரும்புவதற்கு நீங்கள் முக்கிய சொல்லைப் பயன்படுத்தலாம். தேவைப்பட்டால், நீங்கள் break(அல்லது ) ஒரு லூப்புடன் continueஉள்ளமையில் பயன்படுத்தி பல சுழல்களை உடைக்கலாம் . இது அதிக எண்ணிக்கையிலான கொடிகளை உருவாக்குவதைத் தவிர்க்க உதவும் மற்றும் உள் வளையத்தைத் தொடர வேண்டுமா அல்லது வெளியேற வேண்டுமா என்பதைத் தீர்மானிக்க ஒரு அறிக்கையில் அவற்றைச் சரிபார்க்கும். if-elseforif-elseif-else
பணி 4: முழு எண்களின் வரிசையில் ஒற்றை நகலைக் கண்டறியவும்
ArrayList1 முதல் 100 வரை உள்ள ஒவ்வொன்றையும் கொண்ட ஒரு முழு எண் வரிசை (அல்லது ஒரு , நீங்கள் விரும்பினால்) வழங்கப்படும். Integerஅணிவரிசையில் ஒன்று மற்றும் ஒரே ஒரு நகல் உறுப்பு உள்ளது. அதை எப்படி கண்டுபிடிப்பது? முந்தைய மூன்றை விட ஜாவா புரோகிராமர் இந்த வகையான பணியைப் பெறுவது மிகவும் பொதுவானது. ஏனெனில் இது மொழியின் அரிதாகப் பயன்படுத்தப்படும் நுணுக்கங்களைப் பற்றிய உங்கள் அறிவைக் காட்டிலும் தர்க்கத்தைப் பற்றியது. மிருகத்தனமான சக்தியைப் பயன்படுத்துவதற்கான உங்கள் முதல் கட்டுப்பாடற்ற தூண்டுதல் உங்கள் மூளை உதைக்கும் போது அல்லது "நான் ஒரு புரோகிராமர். நான் புத்திசாலி" என்பதை நீங்கள் உணரும் போது விரைவாக கடந்து செல்லும். ஒரே பிரச்சனை என்னவென்றால், ஒரு நேர்காணலின் போது, நீங்கள் மன அழுத்தத்தில் இருக்கும்போது, இது நடக்காமல் போகலாம். எனவே தீர்வு காண்பதற்கு முன் இப்போது யோசியுங்கள்!
இதோ அல்காரிதம்
1 முதல் 100 வரை உள்ள அனைத்து எண்களின் கூட்டுத்தொகையைக் கணக்கிடுங்கள். இதை எப்படிச் செய்யலாம் என்று உங்களுக்குத் தெரியும் என்று நினைக்கிறோம் (உதாரணமாக, காஸ்ஸின் பிரபலமான முறையைப் பயன்படுத்தி). இப்போது உங்கள் வரிசையில் அல்லது ArrayList. மேலும்... முதல் தொகையை இரண்டாவதிலிருந்து கழிக்கவும். பிங்கோ! இதன் விளைவாக வரும் எண் நகல் உறுப்பு மதிப்பு. இந்தப் பணிக்கான ஜாவா குறியீடு ஒரு ArrayList.
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class FindDuplicate {
private static void findDuplicate(List<Integer> elements) {
int distinctSum = elements.stream().distinct().mapToInt(e -> e).sum();
// Find the sum of all list elements
int totalSum = elements.stream().mapToInt(e -> e).sum();
System.out.println("The repeated element is: " + (totalSum - distinctSum));
}
public static void main(String[] args) {
// Create a list of sequential elements in the interval [1..101).
List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
// Add the value 23 at index 53
elements.set(53, 23);
findDuplicate(elements);
}
}
மற்றொரு தீர்வு
import java.util.List;
import java.util.ArrayList;
public class Duplicate {
public int findDuplicateNumber(List<Integer> numbers) {
int highestNumber = numbers.size() - 1;
int total = getSum(numbers);
int duplicate = total - (highestNumber * (highestNumber + 1) / 2);
return duplicate;
}
public int getSum(List<Integer> numbers) {
int sum = 0;
for (int num : numbers) {
sum = sum + num;
}
return sum;
}
public static void main(String a[]) {
List <Integer> numbers = new ArrayList <Integer>();
for (int i = 1; i < 100; i++) {
numbers.add(i);
}
// Add a duplicate to the list
numbers.add(25);
Duplicate dn = new Duplicate();
System.out.println("The repeated element is: " + dn.findDuplicateNumber(numbers));
}
}
பணி 5: முழு எண்களின் வரிசையில் தனித்தன்மையற்ற நகல் ஒன்றைக் கண்டறியவும்
முந்தைய பணி உங்களுக்கு மிகவும் எளிதாக இருந்தால், இதைச் செய்ய முயற்சிக்கவும்: 1 முதல் 100 வரையிலான முழு எண்களின் பட்டியல் உங்களுக்கு வழங்கப்பட்டுள்ளது. அதில் நகல்கள் உள்ளன (ஒன்றுக்கு மேற்பட்டவை). ஒன்றுக்கு மேற்பட்ட முறை நிகழும் தனிமங்களை எவ்வாறு கண்டுபிடிப்பது (உறுப்புகளைக் கண்டுபிடித்து அவை எத்தனை முறை நிகழ்கின்றன என்பதைக் குறிப்பிடவும்)?
தீர்வு
இங்கே தர்க்கரீதியான தீர்வு, ஹாஷ்மேப் போன்ற ஒன்றைப் பயன்படுத்துவதாகும், ஏனெனில் இது தரவை முக்கிய மதிப்பு ஜோடிகளில் சேமிக்கிறது. ஜாவாவில் இந்தப் பணிக்கான குறியீடு:
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class SomeDuplicates {
private static void findDuplicates(List<Integer> elements) {
HashMap <Integer, Integer> duplicates = new HashMap <>();
// Use the following rule to populate the Map duplicates:
// the key is the element value, and the value is the number of times it occurs
elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
// Remove any elements that don't occur more than once from the Map duplicates
// and store the result as a list (to make it easy to work with in the next step)
List <Map.Entry <Integer, Integer> >
result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
// Write the results for all elements to the result list
result.forEach(e -> System.out.println(String.format("Element %d occurs %d times", e.getKey(), e.getValue())));
}
public static void main(String[] args) {
List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
elements.set(97, 23);
elements.set(27, 51);
elements.set(99, 23);
findDuplicates(elements);
}
}
முடிவுரை
பல்வேறு வகையான நடைமுறை ஜாவா பணிகள் உள்ளன, மேலும் நேர்காணல் செய்பவர் என்ன வகையான புதிர்களைத் தீர்க்கச் சொல்வார் என்பது உங்களுக்குத் தெரியாது. ஆனால், உங்களின் தந்திரக் கேள்விகளைத் தீர்க்கும் திறனை விட, வேலையில் நீங்கள் சந்திக்கும் செயல்களைப் போன்ற உண்மையான நடைமுறைப் பணிகளை முடிப்பதற்கான உங்கள் திறன் மிகவும் முக்கியமானது என்பதை எந்த விவேகமான முதலாளியும் புரிந்துகொள்கிறார் . எனவே முடிந்தவரை இவற்றைச் செய்யுங்கள். அதனால்தான் CodeGym ஐ உருவாக்கினோம். இந்தக் கட்டுரையை உருவாக்க geeksforgeeks இன் பொருள் பயன்படுத்தப்பட்டது.
GO TO FULL VERSION