मैं एक प्रोग्राम लिखने की कोशिश कर रहा हूं जो 2 चीजें करता है, उपयोगकर्ता द्वारा उत्पन्न स्ट्रिंग में सबसे लंबा शब्द ढूंढता है और वर्णमाला क्रम में उच्चतम शब्द ढूंढता है। मेरे पास सबसे लंबा शब्द ठीक काम कर रहा है, लेकिन मैं अपने जीवन को बचाने के लिए वर्णमाला की समस्या का पता नहीं लगा सकता। जिस समस्या में मैं चल रहा हूं वह यह है कि यह लूप के लिए चल रहे शब्दों की तुलना कैसे कर रहा है। किसी भी सहायता की सराहना की जाएगी!

/*
CSC 190
Hw7
Ryan Burchfield
10/19/17
Purpose: Take a string and return both the Longest and largest words in the String.
 */
package hw7;
import java.util.Scanner;
class MyString{
    String s;

    MyString( String s1 ){
        s=s1;

    }
    void setString(String s1){
        s=s1;

    }
    String getLongest(String s1){
        s1 = s1 +" ";
        int length = s1.length();
        String temp="", longestw="";
        char ltr;
        int templ, longest=0;

        for(int i=0; i<length;i++){

            ltr = s1.charAt(i);
            if(ltr!=' ' && ltr!=',' && ltr!='.'){
                temp=temp+ltr;
            }
            else{
                templ=temp.length();

                if(templ>longest){
                    longest=templ;
                    longestw=temp;
                }
                temp="";
            }
        }
        return longestw;
    }
    String getLargest(String s1){
        s1= s1 + " ";
        String temp="", curWord="",largestW="";
        char ltr;
        for(int i=0; i<s1.length(); i++){
            ltr = s1.charAt(i);
            if(ltr!=' ' && ltr!=',' && ltr!='.'){
                temp= temp + ltr; 

            }else{


                char ltr1;    
                for(int j=0; j<s1.length(); j++){
                    ltr1 = s1.charAt(j);
                    if(ltr1!=' ' && ltr1!=',' && ltr1!='.'){
                        curWord= curWord + ltr1; 
                    }
                    else{   

                        int largest = temp.compareToIgnoreCase(curWord);
                        System.out.println(temp+","+curWord+","+temp.compareToIgnoreCase(curWord));
                        System.out.println(largest);
                        if(largest > 0){

                            largestW=curWord;
                        }else{
                            largestW=temp;
                        }
                        curWord="";    
                        temp="";  
                    }
                }
            }
        }
        return largestW;
    }

}


public class Hw7 {


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Please enter a series of words: ");
        String s = in.nextLine();
        MyString s1 = new MyString(s);
        System.out.println("The longest word is: " + s1.getLongest(s));
        System.out.println("The largest word is: " + s1.getLargest(s));
    }

}
1
Wigginton 21 अक्टूबर 2017, 05:56
सबसे पहले, वर्णानुक्रम में "उच्चतम" से आपका क्या मतलब है? "सेब" और "ज़ेबरा" को देखते हुए, "सेब" उच्चतम है - या "ज़ेबरा" है? इसे अनदेखा करते हुए, मान लें कि पहला शब्द "उच्चतम" है - प्रत्येक बाद के शब्द के लिए "उच्चतम" की तुलना करें, iff वर्तमान शब्द वर्तमान "उच्चतम" अद्यतन से "उच्च" है "उच्चतम" - तब तक जारी रखें जब तक कि और शब्द न हों। वर्तमान उच्चतम लौटाएं, जो कि उच्चतम होना चाहिए क्योंकि हमने इसकी तुलना प्रत्येक शब्द से की है।
 – 
Elliott Frisch
21 अक्टूबर 2017, 06:06
सेब और ज़ेबरा को देखते हुए, ज़ेबरा आउटपुट होगा।
 – 
Wigginton
21 अक्टूबर 2017, 06:29

4 जवाब

if(largest > 0){
    largestW=curWord;
}else{
    largestW=temp;
}

यहीं पर कार्यक्रम गलत हो जाता है। आपने currWord / temp की तुलना largestW से नहीं की

getLargest() लिखने का एक बेहतर तरीका है getLongest() की तरह ही इस्तेमाल करना, यानी एक लूप का इस्तेमाल करना, और हर बार largestW की तुलना temp से करना (अगर largestW खाली है तो बस largestW = temp सेट करें)

0
Dabiuteef 21 अक्टूबर 2017, 06:07

मैं इसे एक एकल विधि से हल करूंगा जिसमें एक Comparator<String> और इनपुट String; Scanner का निर्माण करें ="nofollow noreferrer">Scanner(String) कंस्ट्रक्टर और Scanner#useDelimiter(String) सफेद स्थान, अल्पविराम और शाब्दिक '.' का उपभोग करने के लिए। फिर Scanner के माध्यम से उपलब्ध टोकन की तुलना करने के लिए आपूर्ति किए गए Comparator का उपयोग करें। पसंद,

static String findWord(Comparator<String> comp, String s1) {
    Scanner sc = new Scanner(s1);
    sc.useDelimiter("[\\s,\\.]+");
    String max = null;
    while (sc.hasNext()) {
        String token = sc.next();
        if (max == null || comp.compare(max, token) < 0) {
            max = token;
        }
    }
    return max;
}

फिर, यह मानते हुए कि आप Java 8+ का उपयोग कर रहे हैं, main को पहले से उपलब्ध Comparator का उपयोग करके लिखा जा सकता है जैसे -

Comparator<String> stringLengthComparator = Comparator.comparingInt(
        String::length);
Comparator<String> stringAlphaComparator = Comparator.naturalOrder();
Scanner in = new Scanner(System.in);
System.out.println("Please enter a series of words: ");
String sentence = in.nextLine();
System.out.printf("Longest: %s%n", findWord(stringLengthComparator, sentence));
System.out.printf("Lexically: %s%n", findWord(stringAlphaComparator, sentence));

लेकिन, यदि आप किसी पुराने संस्करण का उपयोग कर रहे हैं - या आप बेहतर ढंग से समझना चाहते हैं कि यह क्या करता है, तो ठीक वही कोड काम करेगा यदि आप दो Comparator को समान कोड से बदलते हैं - जैसे

Comparator<String> stringLengthComparator = new Comparator<String>() {
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
};
Comparator<String> stringAlphaComparator = new Comparator<String>() {
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
};
0
Elliott Frisch 21 अक्टूबर 2017, 06:50

वहां बहुत सारे कोड हैं, जिनमें से लगभग सभी अनावश्यक हैं।

ये कोशिश करें:

String longest = Arrays.stream(s.split(" +")).sort(comparing(String::length).reversed()).findFirst().get();
String highest = Arrays.stream(s.split(" +")).sort().reduce((a,b) -> b).get();

नोट: अपना असाइनमेंट सबमिट करने से पहले कोड को अच्छी तरह पढ़ और समझ लें।

अस्वीकरण: कोड संकलित नहीं हो सकता है या यहां तक ​​​​कि काम भी नहीं कर सकता है क्योंकि यह मेरे फोन पर था (लेकिन एक उचित मौका है कि यह काम करेगा)

0
Bohemian 21 अक्टूबर 2017, 07:34
1
ओपी सरणियों का उपयोग नहीं करना चाहता था :)
 – 
achAmháin
21 अक्टूबर 2017, 10:37

आपकी पोस्ट के रूप में आप सबसे लंबा शब्द प्राप्त कर सकते हैं। मैं आपको दिखाऊंगा कि सबसे लंबे शब्द के वर्णानुक्रम में उच्चतम अक्षर कैसे प्राप्त करें।

  • एक विधि कॉल toCharArray() है, आप दिए गए शब्द के अक्षर सरणी बनाने के लिए इस पद्धति का उपयोग कर सकते हैं।

  • दिए गए चार मान का पूर्णांक मान प्राप्त करने के लिए आप कास्टिंग का उपयोग कर सकते हैं

  • फिर आप उच्चतम पूर्णांक मान प्राप्त करने के लिए उस पूर्णांक मान की तुलना कर सकते हैं

  • एक बार जब आपके पास उच्चतम पूर्णांक मान कास्ट हो जाता है तो अक्षर को लेने के लिए int मान को char पर डाल दिया जाता है

अधिक जानकारी के लिए निम्नलिखित लिंक्स

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#toCharArray()

http://javaseeeedu.blogspot.com/2015/12/casting-part-1.html

मैंने आपका कोड बदल दिया है इसे आजमाएं

import java.util.Scanner;
class MyString{
    String s;

    MyString( String s1 ){
        s=s1;

    }
    void setString(String s1){
        s=s1;

    }
    String getLongest(String s1){
        s1 = s1 +" ";
        int length = s1.length();
        String temp="", longestw="";
        char ltr;
        int templ, longest=0;

        for(int i=0; i<length;i++){

            ltr = s1.charAt(i);
            if(ltr!=' ' && ltr!=',' && ltr!='.'){
                temp=temp+ltr;
            }
            else{
                templ=temp.length();

                if(templ>longest){
                    longest=templ;
                    longestw=temp;
                }
                temp="";
            }
        }
        return longestw;
    }
    char getLargest(String s1){

        int max = 0;

        char []arr = s1.toCharArray();

        int temp[] = new int[arr.length];

        for(int i=0;i<arr.length;i++){  

            temp[i] = (int)arr[i];
            if(i!=0){

                if(temp[i-1] < temp[i]){
                        max = temp[i];
                }else{

                 max = temp[i-1];   

                }
            }                   
        }   

        return (char)max;
    }

}


class Demo {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Please enter a series of words: ");
        String s = in.nextLine();
        MyString s1 = new MyString(s);
        System.out.println("The longest word is: " + s1.getLongest(s));
        System.out.println("The largest letter is: " + s1.getLargest(s1.getLongest(s)));
    }
}

enter image description here

0
Nisal Edu 21 अक्टूबर 2017, 11:43
खैर यह स्पष्ट रूप से एक होमवर्क है, और आपने ओपी के लिए होमवर्क किया है बजाय उसे बताए कि क्या गलत हो रहा है ...
 – 
Dabiuteef
21 अक्टूबर 2017, 06:59