उलटे वाक्य

Question

इस चुनौती का लक्ष्य एक इनपुट और आउटपुट प्राप्त करना है जो कि इनपुट है लेकिन वाक्य क्रम के साथ उलट है। उदाहरण इनपुट:

Hello friend. What are you doing? I bet it is something I want to do too!

उदाहरण आउटपुट:

I bet it is something I want to do too! What are you doing? Hello friend.

जैसा कि आप उदाहरणों से बता सकते हैं, आपके कार्यक्रम को प्रश्न चिह्न, विस्मयादिबोधक बिंदु और अवधि से निपटना है। आप मान सकते हैं कि प्रत्येक वाक्य में अगले वाक्य से पहले एक विराम चिह्न और एक स्थान है। ट्रेलिंग स्पेस / न्यूलाइन्स ठीक हैं, जब तक यह पढ़ने योग्य है। सबसे छोटा कोड जीतता है।

सौभाग्य!

संपादित करें: आप मान सकते हैं कि वाक्यों का कोई उद्धरण या कोष्ठक नहीं है, लेकिन यदि आप अपना कोड उन दोनों से निपटने में सक्षम हैं, तो आपको -5 बाइट्स मिलते हैं उदाहरण पार्न्स / उद्धरण के लिए आउटपुट:

"Hello, " she said. (I didn't know what she was talking about.) --> (I didn't know what she was talking about.) "Hello, " she said.

Comments

क्या हम मान सकते हैं कि कोई उद्धरण या कोष्ठक नहीं हैं? यदि नहीं, तो हम उन्हें कैसे संभालेंगे?

— ब्रेनसैट

पोस्ट को क्लीयर करने के लिए एडिट किया।

क्या आप कृपया उद्धरण या परेंस वाले वाक्य के लिए अपेक्षित आउटपुट का उदाहरण दे सकते हैं?

— mbomb007

यदि किसी वाक्य में उद्धरण या परेंस के भीतर विराम चिह्न है, तो हमें उससे कैसे निपटना चाहिए?

— isaacg

@Scimonster आपका मतलब है "अर्थात", आदि, सही है? ओह, और कृपया मेरे परीक्षण के मामले में संशोधन करें:"Hello!" she said. (I hesitated. How should I respond? This is too much!) I responded, "Hi there. How are you? What is your cat's name?" without thinking any more about it.

— ऐसा नहीं है कि चार्ल्स

Answer 1

जूलिया, 45 42 बाइट्स - 5 बोनस = 37

s->join(reverse(split(s,r"[.?!]\K "))," ")

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को इनपुट के रूप में स्वीकार करता है और स्ट्रिंग को इसके वाक्यों के साथ वापस लौटाता है। यह उचित रूप से किसी भी विशेष चरित्र को संभालता है, हालांकि दोहरे उद्धरण और डॉलर के संकेत से बच जाना चाहिए, अन्यथा वे जूलिया में मान्य तार नहीं हैं।

असंगठित + स्पष्टीकरण:

function f(s)
    # Get individual sentences by splitting on the spaces that
    # separate them. Spaces are identified by matching punctuation
    # then moving the position beyond that match and matching a
    # space. This is accomplished using \K.

    sentences = split(s, r"[.?!]\K ")

    # Reverse the order of the array of sentences.

    reversed_order = reverse(sentences)

    # Join the array elements into a string, separated by a space.

    join(reversed_order, " ")
end

उदाहरण:

julia> f("Hello friend. What are you doing? I bet it is something I want to do too!")
"I bet it is something I want to do too! What are you doing? Hello friend."

julia> f("\"Hello, \" she said. (I didn't know what she was talking about.)")
"(I didn't know what she was talking about.) \"Hello, \" she said."

और अगर आप आउटपुट में बच गए उद्धरणों को देखना पसंद नहीं करते हैं:

julia> println(f("\"Hello, \" she said. (I didn't know what she was talking about.)"))
(I didn't know what she was talking about.) "Hello, " she said.

मार्टिन ब्यूटनर के लिए नियमित अभिव्यक्ति पर 3 बाइट्स सहेजे गए! इससे पहले यह एक lookbehind प्रयोग किया है: (?<=[.?!])।

Comments

मुझे नहीं लगता कि यह बोनस के लिए योग्य है ...

— ऑप्टिमाइज़र

@Optimizer: यह कैसे नहीं होता है? यह पोस्ट में दिए गए कोष्ठक, उद्धरण आदि के साथ अपेक्षित रूप से काम करता है।

— एलेक्स ए

क्या आप परीक्षण के लिए एक ऑनलाइन लिंक प्रदान कर सकते हैं, उदाहरण के लिए प्रश्न के बोनस अनुभाग से।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र: जूलिया के हालिया संस्करण को चलाने का एकमात्र तरीका पंजीकरण की आवश्यकता है और यह अनुमति नहीं देता है। क्या यहां पोस्ट में केवल इनपुट और आउटपुट को शामिल करना पर्याप्त होगा?

— एलेक्स ए

ज़रूर, मुझे लगता है ..

— ऑप्टिमाइज़र

Answer 2

CJam, 23 22 बाइट्स

मुझे यकीन नहीं है कि यह बोनस के लिए योग्य है या नहीं, लेकिन यहां समाधान है:

Sq{1$".?!"-{])[}|}%]W%

कोड विस्तार (थोड़ा पुराना) :

Sq+                      e# Read the input and prepend with a space
   {            }%       e# For each input character
    _".?!"&              e# Copy and check if its one of ., ? and !
           {][}&         e# If it is one of the above, wrap everything till now in an array
                         e# and start a new array to be wrapped next time we get one of those
                         e# three characters. We now have an array of strings, each having
                         e# a single sentence
                  W%     e# Reverse the ordering of these sentences
                    s(   e# Convert to string and remove the first space

इसे यहाँ ऑनलाइन आज़माएँ

Comments

आह, आपने इस पोस्ट को ठीक उसी तरह बनाया है जब मैंने इसे पहली बार संपादित किया था। अब आपको एक -5 बोनस मिलेगा (बस इसे थोड़ा कठिन बनाने के लिए) तो आप को ५ बोनस! 18 बाइट्स, वाह, यकीन नहीं होता है, तो दैट्स

Answer 3

जे, ३५ ३२

यह लगभग बोनस इनपुट को संभालता है, सिवाय इसके कि मुझे एकल एपोस्ट्रोफिस से बचना है, इसलिए मुझे लगता है कि इसकी गिनती नहीं है। (इसके अलावा, मेरा पहला सबमिशन यहाँ)

f=.;@|.@(]<;.2~'.?!'e.~])@,~&' '

उपयोग:

f 'Hello friend. What are you doing? I bet it is something I want to do too!'

Answer 4

पर्ल, 27/25

#!perl -n
print reverse/ |[^.!?]*./g

या कमांड लाइन से:

$perl -nE'say reverse/ |[^.!?]*./g'

Comments

अच्छा! आप के साथ -5 बोनस प्राप्त कर सकते हैं perl -nE 'say reverse/ |[^.?!]*.\)?/g'करने के लिए 23. कुल संख्या लाने,

— ThisSuitIsBlackNot

Answer 5

PHP, 60

echo join(' ',array_reverse(preg_split('/(?<=[?!.])/',$s)));

Comments

क्या आप [?!.]\Kइसके बजाय रेगेक्स का उपयोग कर सकते हैं ?

— मार्टिन एंडर

इसके अलावा यह स्ट्रिंग में अतिरिक्त स्थान नहीं जोड़ता है जब तक कि आप पैटर्न को विभाजित करने के लिए स्थान शामिल नहीं करते हैं?

— मार्टिन एंडर

@ मार्टिनबटनर, नहीं, मैं डेटा वापस शामिल होने पर उचित संकेत को पुनर्स्थापित करने में सक्षम नहीं होगा, इसलिए हमें कुछ ऐसी चीज की आवश्यकता है जो चरित्र का उपभोग नहीं करेगी।

— रोमनिंश

Answer 6

बैश + कोरुटिल्स, 40 बाइट्स

sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \ 

यह एसटीडीआईएन से पढ़ता है इसलिए इनपुट मुझे फ़ाइल से पुनर्निर्देशित किया जा सकता है, या बस इसमें पाइप किया जा सकता है, जैसे:

$ printf 'Hello friend. What are you doing? I bet it is something I want to do too!' | sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \ 
I bet it is something I want to do too! What are you doing? Hello friend. 
$ 

Comments

क्या यह वास्तव में इस अर्थ में कोष्ठक के लिए काम करता है, कि (foo bar.)एक इकाई के रूप में बदली जाती है?

— मार्टिन एंडर

@ मार्टिनबटनर लगता है कि प्रश्न संपादित हो गया, इसलिए मैं अब बोनस का दावा नहीं कर सकता :(

— डिजिटल ट्रॉमा

Answer 7

पिप , 25 बाइट्स

a.:sRV(a^@2+$ALa@*^".?!")

इनपुट स्ट्रिंग के लिए एक स्थान जोड़कर के बाद, हम के सभी सूचकांकों लगता है ., ?है, और !, 2 जोड़ने के लिए, और प्रयोग ^@वाक्य में स्ट्रिंग (ट्रेलिंग स्थान के साथ प्रत्येक) को तोड़ने के लिए ऑपरेटर पर विभाजित। सूची को उल्टा करें, और यह कार्यक्रम के अंत में ऑटो-मुद्रित है। देखा!

उदाहरण इनपुट के साथ मुख्य संगणना के चरणों को दिखा रहा है A! B? C. D!:

              ^".?!"     ["." "?" "!"]
           a@*           [[7] [4] [1 10]]
        $AL              [7 4 1 10]
      2+                 [9 6 3 12]
   a^@                   ["A! " "B? " "C. " "D! "]
RV(                 )    ["D! " "C. " "B? " "A! "]

                         D! C. B? A! 

Comments

नहीं आप नहीं :)

— ऑप्टिमाइज़र

Answer 8

रेटिना , 61 34 33 30 बाइट्स

24 बाइट्स में कटौती के लिए नटकी को श्रेय।

^
#
+`(#.*[.!?]) (.+)
$2 $1
#
<empty>

जहां <empty>एक खाली लाइन के लिए खड़ा है। यह मानता है कि #इनपुट का हिस्सा नहीं है, लेकिन अगर यह वैध नहीं है, तो मैं इसे किसी भी अन्य चरित्र के लिए स्वैप कर सकता हूं, जिसमें "(जिसमें मुझे केवल बोनस के लिए संभालना होगा) या कुछ अनपेक्षित है। आप एक एकल फ़ाइल में कोड का उपयोग -sकर सकते हैं यदि आप ध्वज का उपयोग करते हैं , या आप प्रत्येक पंक्ति को एक अलग फ़ाइल में रख सकते हैं और उन सभी को रेटिना को पास कर सकते हैं।

एक एकल रेगेक्स प्रतिस्थापन के साथ इसे उल्टा करना संभव है, लेकिन वास्तव में बोझिल है। .NET बैलेंसिंग समूहों के साथ भी मुझे लगभग 90 बाइट्स की आवश्यकता थी, इसलिए इसके बजाय मैंने इसे कई चरणों में करने की कोशिश की।

रेटिना में, प्रत्येक जोड़ी लाइनें एक प्रतिस्थापन चरण है, जहां पहली पंक्ति पैटर्न है और दूसरी पंक्ति प्रतिस्थापन है।

^
#

यह चरण बस आगे की प्रक्रिया के लिए स्ट्रिंग तैयार करता है। यह #मार्कर के रूप में प्रीपेंड करता है। यह मार्कर इंगित करता है कि इसके सामने सब कुछ पहले से ही सही जगह पर रखा गया है, और इसके बाद की सभी चीजों को अभी भी संसाधित करने की आवश्यकता है।

+`(#.*[.!?]) (.+)
$2 $1

यह चरण पिछले वाक्य को बार-बार आगे ले जाकर #(जो प्रक्रिया में स्ट्रिंग के माध्यम से आगे बढ़ता है) , वाक्यों को स्वैप करता है । +`जब तक उत्पादन बदल रहा बंद हो जाता है इस स्तर को दोहराने के लिए रेटिना निर्देश देता है। एक उदाहरण के रूप में, यहां बताया गया है कि इनपुट foo. bar! blah?को कैसे संसाधित किया जाएगा:

#foo. bar! blah?
blah? #foo. bar!
blah? bar! #foo.

और अंत में हम केवल मार्कर निकालते हैं:

#
<empty>

Comments

सिर्फ .+=> $0 #और दोहराया (.*?[.!?] )(.*#)=> क्यों नहीं $2$1?

— नटकी

@ कुटकी ओह, यह बहुत अच्छा है, धन्यवाद। :)

— मार्टिन एंडर

Answer 9

जावा, 113

s->{String t[]=s.split("(?<=[\\.?!]) "),u="";for(int i=t.length;i-->0;)u+=t[i]+" ";return u.replaceAll(".$","");}

Answer 10

जावास्क्रिप्ट (ईएस 6) 47 45

जैसा कि कहा गया है, यह एक सरल रेगेक्स व्यायाम है। जावास्क्रिप्ट में:

// ES6 - FireFox only
F=t=>t.match(/\S[^.!?]+./g).reverse().join(' ')

// ES5 - so much longer
function G(t){return t.match(/\S[^.!?]+./g).reverse().join(' ')}

// TEST

alert(G("Hello friend. What are you doing? I bet it is something I want to do too!"))
 

Comments

मैं जावास्क्रिप्ट करने जा रहा था, लेकिन आपने मुझे हरा दिया।

— BobTheAwesome

यह सब से पहले अतिरिक्त स्थान बनाता है लेकिन अंतिम वाक्य (मूल रूप से पहला)। निश्चित नहीं है कि यह ठीक है, क्योंकि कार्य बहुत अच्छी तरह से परिभाषित नहीं है।

— नटकी

@ कुटकी हाँ, मैं सहमत हूँ। निश्चित

— edc65

Answer 11

अजगर 2, 62

बोनस के लिए सुधार करने के लिए नहीं जा रहा है, क्योंकि यह शायद बाइट लागत के लायक नहीं है।

import re
print' '.join(re.split('(?<=[?!.]).',input())[::-1])

Comments

यह बोनस के लिए योग्य नहीं है। प्रश्न में बोनस उदाहरण देखें

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र प्रश्न इतिहास में देखें। जिस समय मैंने बोनस जोड़ने के लिए अपने प्रश्न को अपडेट किया, मेरे आउटपुट ने उदाहरण से मिलान किया। कुछ भी संकेत नहीं दे रहा था कि कोष्ठक एक अवधि के बाहर हो सकता है।

— mbomb007

मुझे लगता है कि इरादे शुरुआत से ही यही थे। एक ठोस उदाहरण हालांकि बाद में आया। इसका मतलब यह नहीं है कि आपको अभी भी बोनस मिलता है :) (मैंने अपना भी निकाल दिया)

— ऑप्टिमाइज़र

Answer 12

मतलाब (93 बाइट्स)

y=[32 input('','s')];y=sortrows([cumsum(ismember(y,'?!.'),'reverse');y]',1)';disp(y(4:2:end))

• यह मानता है कि इनपुट में प्रमुख या अनुगामी स्थान नहीं हैं
• मानक इनपुट और आउटपुट का उपयोग करता है
• Matlab 2014b में परीक्षण किया गया

Answer 13

रूबी ४१

अन्य रूबी के जवाब में पर्याप्त डब्ल्यूटीएफ नहीं है।

#!ruby -apF(?<=[.!?])\s
$_=$F.reverse*" "

यह कम से कम रूबी 2 में काम करता है। यदि 1.8.7 में काम करता है aऔर Fस्विच करता है, तो मुझे लगता है कि आप $_=तीन पात्रों को बचाने के लिए छोड़ सकते हैं ।

स्टड पर हर लाइन को उलट देता है और स्टडआउट को प्रिंट करता है:

$ ruby foo.rb <<< "Hello. Hi. How are you? Good, you? fine, thanks."
fine, thanks. Good, you? How are you? Hi. Hello.

Comments

क्या आप कृपया इसका उत्तर बता सकते हैं।

— Mhmd

Answer 14

रूबी, 48 (पुट्स के बिना 42) बाइट्स

reverse_sentence.rb

puts $*[0].scan(/\S[^.!?]+./).reverse.join(" ")

उपयोग:

ruby reverse_sentence.rb 'Hello friend. What are you doing? I bet it is something I want to do too!'

आउटपुट:

I bet it is something I want to do too! What are you doing? Hello friend.

स्वागत से अधिक आलोचना।

Comments

आलोचना: आपने "वाक्य" को गलत तरीके से लिखा।

— एलेक्स ए

6 पात्रों को बचाएं: .join(" ")=>*" "

— daniero

@AlexA। सर्वश्रेष्ठ प्रतिक्रिया कभी!

— डिकिएबॉय

@daniero धन्यवाद, पता करने के लिए अच्छा है

— डिक्कीबॉय

Answer 15

के, ३१

{1_,/|(0,1+&x in"?!.")_x:" ",x}

।

k){1_,/|(0,1+&x in"?!.")_x:" ",x} "Hello friend. What are you doing? I bet it is something I want to do too!"
"I bet it is something I want to do too! What are you doing? Hello friend."

Answer 16

C # - LINQPAD - 93 - 5 = 88 बाइट्स

void Main(){string.Join(" ",Regex.Split(Console.ReadLine(),"(?<=[.?!]) ").Reverse()).Dump();}

C # कंसोल ऐप 189 - 5 = 184 बाइट्स

using System;using System.Linq;using System.Text.RegularExpressions;class P{static void Main(){Console.WriteLine(string.Join(" ",Regex.Split(Console.ReadLine(), "(?<=[.?!]) ").Reverse()));}}

regex बेशर्मी से एलेक्स ए :)

Comments

आप namespace Systemउस using Linq;usingText.RegularExpressionsबचत 2x के भीतर अपना आवेदन डालकर 7 बाइट्स बचा सकते हैं system।

— ldam

मुझे नहीं लगता कि यह बोनस के लिए योग्य है। प्रश्न में बोनस उदाहरण देखें

— ऑप्टिमाइज़र

Answer 17

क्लोजर - 44 71 वर्ण

(defn rs[s](reverse(re-seq #"\S.+?[.!?]"s)))

बेहतर और सरलीकृत आरई, अनावश्यक व्हाट्सएप को समाप्त कर दिया।

आउटपुट मूल स्ट्रिंग में दिए गए वाक्यों के क्रम के साथ वाक्यों का एक क्रम है:

इनपुट: "हेलो फ्रेंड। तुम क्या कर रहे हो? मुझे यकीन है यह कुछ ऐसा है जो मैं भी करना चाहता हूं!" आउटपुट: ("मुझे यकीन है कि यह कुछ ऐसा है जो मैं भी करना चाहता हूं!" "आप क्या कर रहे हैं?" "हैलो दोस्त।"

Answer 18

रूबी, ४,

$><<gets.strip.split(/(?<=[.?!]) /).reverse*' '

कुछ पात्रों को बचाने के लिए मार्टिन ब्यूटनर को श्रेय दिया गया ।

Comments

आप getsएक बाइट को बचाने के लिए एसटीडीआईएन से इनपुट पढ़ सकते हैं , इसे $><<बाइट को बचाने के लिए प्रिंट कर सकते हैं (कोई स्थान की आवश्यकता नहीं है) और *''दो बाइट को बचाने के लिए स्ट्रिंग के साथ जुड़ें ।

— मार्टिन एंडर

@ मार्टिनबटनर सुझाव के लिए धन्यवाद, मैं एसटीडीआईएन से इनपुट के साथ पढ़ने के साथ नहीं जाऊंगा, हालांकि। बस, क्योंकि वहाँ एक अनुगामी नई लाइन होगी।

— Mhmd

दरअसल, मुझे लगता है कि वर्तमान में आपका कोड एक अग्रणी स्थान पर परिणाम देगा।

— मार्टिन एंडर

मिमी, तुम सही हो। मैं देखूंगा कि मुझे क्या करना चाहिए।

— Mhmd

Answer 19

सीजेएम, 21 बाइट्स

1q{1?_"!.?"-}%1a/W%S*

के बाद रिक्त स्थान बदल कर यह काम करता है !है, .और ?नंबर 1 (नहीं में रों चरित्र 1 नहीं और न ही कोड बिंदु 1 के साथ वर्ण, इसलिए इनपुट में अभी भी वे शामिल हो सकते हैं), 1 पर बंटवारा, जिसके परिणामस्वरूप विखंडू के क्रम को उलट कर शामिल हो सकते हैं रिक्त स्थान द्वारा।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

1                     e# B := 1
 q                    e# Q := input()
  {         }%        e# for each C in Q (map):
   1?                 e#   C := B ? C : 1
     _"!.?"-          e#   B := string(C).strip("!.?")
              1a/     e# Q := Q.split([1])
                 W%   e# Q := reverse(Q)
                   S* e# Q := Q.join(" ")
                      e# print(Q)