मैं, एबीएपी में, एक स्ट्रिंग को एन भागों में कैसे विभाजित कर सकता हूं और यह निर्धारित कर सकता हूं कि कौन सा सबसे बड़ा तत्व है? मेरे समाधान में मुझे यह जानना होगा कि कितने तत्व हैं, लेकिन मैं इसे तत्वों की संख्या के लिए हल करना चाहता हूं।

मैंने नीचे दिए गए कोड की कोशिश की। और मैंने वेब खोजा।

DATA: string TYPE string VALUE 'this is a string'.
DATA: part1 TYPE c LENGTH 20.
DATA: part2 TYPE c LENGTH 20.
DATA: part3 TYPE c LENGTH 20.
DATA: part4 TYPE c LENGTH 20.
DATA: del TYPE c VALUE ' '.
DATA: bigger TYPE c LENGTH 20.


split: string AT del INTO part1 part2 part3 part4.

bigger = part1.

IF bigger > part2.
  bigger = part1.
ELSEIF bigger > part3.
  bigger = part2.
ELSE.
  bigger = part4.
ENDIF.
WRITE: bigger.

अपेक्षित परिणाम: एक स्ट्रिंग में तत्वों की किसी भी संख्या के साथ काम करता है और निर्धारित करता है कि कौन सा सबसे बड़ा है।

वास्तविक परिणाम: मुझे यह जानने की जरूरत है कि कितने तत्व हैं

1
J. T. Random 14 अगस्त 2019, 17:04
2
आप "सबसे बड़ा" शब्द का उपयोग कर रहे हैं जो लोगों को भ्रमित कर सकता है (वर्तमान में, वे "सबसे लंबे समय तक" समझते हैं) लेकिन आपका एल्गोरिदम कहता है कि आप वर्णानुक्रम में क्रमबद्ध करना चाहते हैं (एक पहले, जेड आखिरी) और क्रम में अंतिम शब्द आउटपुट करना चाहते हैं ("यह" आपके में उदाहरण के लिए, क्योंकि "t" "i", "a" और "s" के बाद है)। क्या आप कृपया "सबसे बड़ा" अर्थ स्पष्ट करने के लिए अपना प्रश्न संपादित कर सकते हैं?
 – 
Sandra Rossi
14 अगस्त 2019, 22:31
आप इसे किस आधार पर विभाजित करेंगे? शब्द-वार? चरित्र के अनुसार? वाक्य-वार?क्या होगा यदि इसमें कोई स्थान नहीं है?
 – 
Suncatcher
15 अगस्त 2019, 02:49

4 जवाब

सबसे बढ़िया उत्तर

इसे हल करने का एक तरीका यहां दिया गया है:

DATA: string TYPE string VALUE 'this is a string'.
TYPES: BEGIN OF ty_words,
         word   TYPE string,
         length TYPE i,
       END OF ty_words.
DATA: ls_words TYPE ty_words.
DATA: gt_words TYPE STANDARD TABLE OF ty_words.

START-OF-SELECTION.
  WHILE string IS NOT INITIAL.
    SPLIT string AT space INTO ls_words-word string.
    ls_words-length = strlen( ls_words-word ).
    APPEND ls_words TO gt_words.
  ENDWHILE.
  SORT gt_words BY length DESCENDING.
  READ TABLE gt_words
       ASSIGNING FIELD-SYMBOL(<ls_longest_word>)
       INDEX 1.
  IF sy-subrc EQ 0.
    WRITE: 'The longest word is:', <ls_longest_word>-word.
  ENDIF.

कृपया ध्यान दें, यह मामले को कवर नहीं करता है यदि समान लंबाई वाले अधिक लंबे शब्द हैं, तो यह उनमें से केवल एक को दिखाएगा।

2
József Szikszai 14 अगस्त 2019, 17:31
कृपया ध्यान दें कि READ TABLE gt_words ASSIGNING FIELD-SYMBOL(<ls_longest_word>) INDEX 1. केवल उस सिस्टम में काम करेगा जो इनलाइन डिक्लेरेशन सिंटैक्स का समर्थन करता है। यदि "J. T. Random" में एक पुराना सिस्टम है, तो उन्हें इसे पहले FIELD-SYMBOLS <ls_longest_word> TYPE ty_words. के साथ घोषित करना होगा और फिर इसके बजाय READ TABLE gt_words ASSIGNING <ls_longest_word> INDEX 1. का उपयोग करना होगा।
 – 
Legxis
14 अगस्त 2019, 18:06

यदि आप स्ट्रिंग को एक सरणी में विभाजित करते हैं, तो आपको विभाजित भागों की संख्या जानने की आवश्यकता नहीं है। फिर आप सरणी पर LOOP करते हैं और सबसे लंबी लंबाई खोजने के लिए स्ट्रिंग की लंबाई की जांच करते हैं।

जबकि József Szikszai का समाधान काम करता है, यह आपके लिए आवश्यक कार्यक्षमता के लिए बहुत जटिल हो सकता है। यह ठीक उसी तरह काम करेगा: (उसी सीमा के साथ भी कि यह केवल पहले सबसे लंबे शब्द का उत्पादन करेगा और समान लंबाई के किसी अन्य शब्द का उत्पादन नहीं करेगा)

DATA string TYPE string VALUE 'this is a string'.
DATA parts TYPE STANDARD TABLE OF string.
DATA biggest TYPE string.
FIELD-SYMBOLS <part> TYPE string.

SPLIT string AT space INTO TABLE parts.

LOOP AT parts ASSIGNING <part>.

  IF STRLEN( <part> ) > STRLEN( biggest ).
    biggest = <part>.
  ENDIF.

ENDLOOP.

WRITE biggest.

संपादित करें: मैंने माना कि 'सबसे बड़ा' का अर्थ सबसे लंबा है, लेकिन यदि आप वास्तव में वह शब्द चाहते हैं जो वर्णमाला में अंतिम होगा, तो आप सरणी को अवरोही क्रम में क्रमबद्ध कर सकते हैं और इस तरह पहली प्रविष्टि को आउटपुट कर सकते हैं:

DATA string TYPE string VALUE 'this is a string'.
DATA parts TYPE STANDARD TABLE OF string.
DATA biggest TYPE string.

SPLIT string AT space INTO TABLE parts.
SORT parts DESCENDING.
READ TABLE parts INDEX 1 INTO biggest.

WRITE biggest.
2
Legxis 15 अगस्त 2019, 11:01
आपका कोड भी तेज़ है, SORT एक LOOP से धीमा है
 – 
András
15 अगस्त 2019, 15:41

ABAP 740 के साथ, आप इसे छोटा भी कर सकते हैं:

SPLIT lv_s AT space INTO TABLE DATA(lt_word).
DATA(lv_longest)    = REDUCE string( INIT longest = `` FOR <word> IN lt_word NEXT longest = COND #( WHEN strlen( <word> ) > strlen( longest ) THEN <word> ELSE longest ) ).
DATA(lv_alphabetic) = REDUCE string( INIT alph = ``    FOR <word> IN lt_word NEXT alph    = COND #( WHEN <word> > alph THEN <word> ELSE alph ) ).
2
peterulb 23 अगस्त 2019, 16:30

यदि "सबसे बड़ा" का अर्थ "सबसे लंबा" शब्द है तो ऐसा करने का रेगेक्स तरीका है:

FIND ALL OCCURRENCES OF REGEX '\w+' IN string RESULTS DATA(words).
SORT words BY length DESCENDING.
WRITE substring( val = string off = words[ 1 ]-offset len = words[ 1 ]-length ).
0
Suncatcher 21 अक्टूबर 2020, 17:48