जैसा कि प्रोग्रामर कहते हैं: आलसी होने के लिए प्रयास करें

25

कहानी

क्या आपने इस पोस्ट को 9gag से देखा है ? हो सकता है कि आपको अपने वाक्य बनाने का अहसास हो। लेकिन तब आपको पता चलता है कि आप आधे घंटे में सिर्फ एक स्क्रिप्ट को गोल्फ कर सकते हैं, और आपको इसके साथ समय नहीं देना होगा।

प्रस्तुत

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

इनपुट के नियम

  • इनपुट में केवल मुद्रण योग्य ASCII वर्ण हैं।
  • इनपुट में रिक्त स्थान हो सकते हैं। शब्द उनके साथ निर्धारित होते हैं।
  • यह गारंटी है कि एक स्थान का दूसरे स्थान से अनुसरण नहीं किया जाएगा।
  • कोई इनपुट या खाली स्ट्रिंग का मामला मायने नहीं रखता।

आउटपुट के नियम

यदि एक शब्द दिया जाता है, तो प्रोग्राम को उद्धरण चिह्नों के बीच स्ट्रिंग वापस करना होगा।

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

सामान्य तौर पर, प्रोग्राम को कई लाइनों के रूप में वापस लौटना पड़ता है क्योंकि इनपुट में शब्द होते हैं।

उदाहरण:

test -> "test"

This is codegolf -> "This" is codegolf
                    This "is" codegolf
                    This is "codegolf"

This is a significantly longer, but not the longest testcase -> "This" is a significantly longer, but not the longest testcase
                                                                This "is" a significantly longer, but not the longest testcase
                                                                This is "a" significantly longer, but not the longest testcase
                                                                This is a "significantly" longer, but not the longest testcase
                                                                This is a significantly "longer," but not the longest testcase
                                                                This is a significantly longer, "but" not the longest testcase
                                                                This is a significantly longer, but "not" the longest testcase
                                                                This is a significantly longer, but not "the" longest testcase
                                                                This is a significantly longer, but not the "longest" testcase
                                                                This is a significantly longer, but not the longest "testcase"

Here is an another one -> "Here" is an another one
                          Here "is" an another one
                          Here is "an" another one
                          Here is an "another" one
                          Here is an another "one"

यह कोड-गोल्फ है , इसलिए कम से कम बाइट उत्तर जीतता है!

code-golf  string 
— krinistof
स्रोत
7
क्या डुप्लीकेट शब्द होंगे?
— अज्ञानता का प्रतीक
10
क्या हम मान सकते हैं कि इनपुट स्ट्रिंग में "वर्ण नहीं होंगे ?
— दरवाज़े
1
पुन : "आलसी होने के लिए कठोर" : मुझे लगता है कि यह लैरी वॉल ने जो कहा है, वह एक गलत बयानी है। - " अधिकांश लोग आलस को आलसी या सोफे आलू के पर्याय के रूप में देखते हैं, लेकिन वॉल की परिभाषा दक्षता के बारे में है। "
— पीटर मोर्टेंसन
14
यह "समस्या" "गोल्फ" के लिए "मज़ेदार" होनी चाहिए।
— जोनो 2906
3
हम अलग अलग उद्धरण, की तरह उपयोग कर सकते हैं '', ‘’या “”के बजाय ""?
— ग्यूसेप

जवाबों:

10

vim, 38 बाइट्स

:s/"/<C-d>/g
qqysW"Ypds"W@qq@qdk:%s/<C-d>/"/g

इसे ऑनलाइन आज़माएं!

आवश्यक vim-चारों ओर प्लगइन ।

यदि इनपुट में "वर्ण नहीं हैं , तो यह 19 बाइट्स में किया जा सकता है :

qqysW"Ypds"W@qq@qdk

यहां, हम एक पुनरावर्ती मैक्रो ( qq ... @qq@q) रिकॉर्ड करते हैं, जो उद्धरण चिह्नों ( ysW") के साथ एक शब्द को घेरता है , रेखा को दोहराता है ( ), उद्धरण चिह्नों ( ) Ypको हटाता है ds", और Wखुद को पुनरावर्ती कहने से पहले अगले शब्द ( ) में चला जाता है। इसे समाप्त करने के बाद, दो बाहरी रेखाएं होती हैं, जिन्हें हटा दिया जाता है dk।

पूर्ण समाधान बस :s/"/<C-d>/gशुरुआत में इसे लपेटता है , जो मौजूदा "वर्णों को एक अप्राप्य चरित्र के साथ बदल देता है , और :%s/<C-d>/"/gअंत में, जो प्रतिस्थापन को पूर्ववत करता है।

— Doorknob
स्रोत
2
मैंने वास्तव में एक ही विधि के साथ उदाहरण बनाए: D
— krinistof
8

हास्केल, 65 बाइट्स

([]#).words
a#(b:c)=unwords(a++('"':b++"\""):c):(a++[b])#c
_#_=[]

लाइनों की एक सूची देता है।

इसे ऑनलाइन आज़माएं!

— nimi
स्रोत
यह तब विफल होता है जब इनपुट में उद्धरण चिह्नों, newlines या अन्य बच गए चार्जर्स होते हैं।
— गेहूं जादूगर
— गेहूं जादूगर
@ श्रीकोटिलिज्म'ओज़िक: फिक्स्ड। इशारा करने के लिए धन्यवाद। छोटे संस्करण के बारे में: xnor ने पहले ही इसे उत्तर के रूप में पोस्ट कर दिया है ।
— nimi
काफी हद तक तय नहीं है, क्योंकि शब्द \nव्हॉट्सएप को ऐसा मानते हैं जब यह मौजूद होता है।
— गेहूं जादूगर
@ SriotchilismO'Zaic: "इनपुट में केवल मुद्रण योग्य ASCII वर्ण शामिल हैं", जो अंतरिक्ष के लिए है ~। "इनपुट में स्थान हो सकता है" - "व्हाट्सएप" नहीं।
— शाम
7

रेटिना 0.8.2 , 17 बाइट्स

 
" $'¶$` "
^|$
"

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। स्पष्टीकरण:

 
" $'¶$` "

पंक्ति को डुप्लिकेट करके और फिर उद्धरण चिह्नों को सम्मिलित करके प्रत्येक स्थान का विस्तार करें।

^|$
"

पहली और आखिरी पंक्तियों को ठीक करें।

— नील
स्रोत
7

जेली ,  15  14 बाइट्स

Ḳ⁾""j$€⁹¦K¥ⱮJ$

इसे ऑनलाइन आज़माएं!

कैसे?

Ḳ⁾""j$€⁹¦K¥ⱮJ$ - Link: list of characters, S
Ḳ              - split (S) at spaces -> A
             $ - last two links as a monad:
           Ɱ   -   map...
            J  -   ...across: range of length -> I = [1,2,...len(A)]
          ¥    -   ...doing: last two links as a dyad: i.e. f(A, i) for i in I
      € ¦      -     sparse application...
       ⁹       -     ...to indices: chain's right argument, i
     $         -     ...action: last two links as a monad:
 ⁾""           -       literal list of characters = ['"', '"']
    j          -       join (with A[i]) -> (e.g. with ['i','s']) ['"','i','s','"']
         K     -     join with spaces
— जोनाथन एलन
स्रोत
आराम से बचाओ । (यहां टिप्पणी करने का निर्णय लिया गया क्योंकि आप समान कोड पोस्ट करने वाले पहले व्यक्ति थे। पी)
— द एग्रीग्राफर
@EriktheOutgolfer धन्यवाद, खुद एक समान सुधार पोस्ट करने के लिए वापस आया।
— जोनाथन एलन
6

जावास्क्रिप्ट (ईएस 6),  43 42 41  38 बाइट्स

@Mazzy के लिए 3 बाइट्स सहेजे गए

गैर-मानक लेकिन व्यापक रूप से समर्थित RegExp.left​Contextऔर का उपयोग करता है RegExp.rightContext। यह बहुत अलग उद्धरण है ...

s=>s.replace(/(\S+) ?/g,`$\`"$1" $'
`)

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
होशियार! लेकिन परीक्षण मामले में अल्पविराम पर देखThis is a significantly "longer,"...
— Mazzy
/(\S+)/gकाम नहीं करेगा ?
— झबरा
1
@mazzy ओह, धन्यवाद। मैंने वास्तव में इसे इस तरह से किया था क्योंकि मैंने परीक्षण मामले को अल्पविराम के साथ गलत किया था। अब तय हो गया।
— Arnauld
@ मुझे लगता है कि हमें अंतरिक्ष पर कब्जा करने की आवश्यकता है ताकि यह अगले शब्द के बाएं संदर्भ में प्रकट न हो।
— Arnauld
1
@ mazzy मुझे लगता है कि यह वास्तव में ठीक है। धन्यवाद!
— Arnauld
6

जावा, 235 183 132 बाइट्स

s->{String a[]=s.split(" "),r="",t;for(int l=a.length,i=0,j;i<l;i++,r+="\n")for(j=0;j<l;)r+=(t=i==j?"\"":"")+a[j++]+t+" ";return r;}

-52 बाइट्स विभिन्न प्रकार की चीजों का दुरुपयोग करके (स्थिर पहुंच, सूची बनाम सरणी, वापसी के बजाय प्रिंट, आदि। धन्यवाद @VueueInk!)
-51 बाइट्स आलसी द्वारा और @KevinCruijssen मेरे द्वारा यह काम करने की
कोशिश करें।

— बेंजामिन अर्कहार्ट
स्रोत
यह कुछ पागल उपरि आप के लिए की जरूरत है java.util.Arrays.copyOfRange। यदि आप उपयोग java.util.Listकरते हैं तो आप subListछोटे के लिए उपयोग कर सकते हैं , और सरणी बनाने के बजाय STDOUT पर प्रिंट कर सकते हैं । मुझे उन विचारों के साथ 193 बाइट्स मिलीं, और साथ ही साथ वेरी कीवर्ड का भी दुरुपयोग हुआ।
— मूल्य इंक
@ValueInk धन्यवाद! मैंने उन अतिरिक्त IDE चेतावनियों (और -10 बाइट्स) के लिए भी प्रतिस्थापित String.joinकिया s.join।
— बेंजामिन यूरेखर्ट
1
@ ओलिवियरग्रेगायर नो थैंक्यू: ^)
— बेंजामिन
2
@ ओलिवियरग्रेयर चैलेंज स्वीकार किया और पीटा, सर! ; पी 71 बाइट्स
— केविन क्रूज़सेन
1
@KevinCruijssen अच्छा लगा! मैंने सोचा भी नहीं है कि रेगेक्स काम करेगा। अच्छी तरह से ;-)
— ओलिवियर ग्रेजायर
5

पहला कोड गोल्फ प्रयास उम्मीद है कि यह भयानक नहीं है और उम्मीद है कि यह नियम तोड़ने वाला नहीं है

कोटलिन, 105 112 147 117 बाइट्स / चार्ट

fun main(a:Array<String>){val q=a[0].split(" ")
q.forEach{println(q.fold(""){i,n->i+if(it==n)"\"$n\" " else n+" "})}}

इसे ऑनलाइन आज़माएं!

— क्विन
स्रोत
4

05AB1E , 14 बाइट्स

ð¡©ε®y…"ÿ"Nǝ}»

इसे ऑनलाइन आज़माएं!

+1 बाइट (और यह किनारे के मामले के लिए काम करता है) एमिग्ना के लिए धन्यवाद। -1 बाइट केविन को धन्यवाद!

— जादू ऑक्टोपस Urn
स्रोत
1
दुर्भाग्य से आपको ð¡इनपुट को संभालने के लिए उपयोग करने की आवश्यकता है जैसे कि test।
— Emigna
1
— केविन क्रूज़सेन
4

जावास्क्रिप्ट, 91 97 75 78 बाइट्स

f= 

t=>t.split` `.map((c,i,a)=>[...a.slice(0,i),`"${c}"`,...a.slice(i+1)].join` `)

// and test
console.log(f("Hello folks and world").join('\n'));
स्निपेट का विस्तार करें

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

19 बाइट्स और कोई अग्रणी स्थान के लिए झबरा के लिए धन्यवाद - जब सरणी संचालक एक सरणी शाब्दिक को आरंभीकृत करने के लिए खाली सरणी पर उपयोग किया जाता है, तो प्रसार ऑपरेटर द्वारा उत्पादित सरणी में कोई स्लॉट नहीं बनाया जाता है:

let empty = [];
let array = [...empty, value]
//  produces an array of length 1 containing value

(91 बाइट संस्करण में पहली पंक्ति में एक अग्रणी स्थान था, 97 बाइट संस्करण ने इसे हटाने के लिए 6 बाइट्स लिए थे)।

— traktor53
स्रोत
2
— झबरा
1
स्निपेट नहीं चलता है क्योंकि आपने fफ़ंक्शन को परिभाषित किया है। अन्यथा सत्यापित है। बहुत बढ़िया!
— क्रिनिस्टोफ
@krinistof ने इसे ठीक किया, thx!
— traktor53
उद्धृत शब्दों के बाद शब्द रिक्त स्थान के बजाय अल्पविराम से अलग हो जाते हैं (फ़ायरफ़ॉक्स, यह निश्चित नहीं है कि क्या यह ब्राउज़र का मुद्दा है)
— wastl
1
@wastl ने बहुत सी 3 बाइट की और धुंधली आँखों के कारण कॉमा को नहीं देखा। दूसरे प्रसार ऑपरेटर को वापस लाना (जैसा कि शैगी के लिंक में है) कॉमा को हटा देता है। स्वयं पर ध्यान दें ... अगली बार मेरा चश्मा लगाएं ।-(
— traktor53
4

पायथन 3 , 79 , 69 , 65 बाइट्स

w,i=input(),0
while~i:m=w.split();m[i]='"%s"'%m[i];print(*m);i+=1

इसे ऑनलाइन आज़माएं!

मुंडा के लिए 10 बाइट्स का धन्यवाद। और अब यह 65 बाइट्स के अनुसार एरिक आउटगोल्फर समाधान है। IndexError के साथ प्रोग्राम समाप्त होता है लेकिन यह ठीक है।

— Андрей Ломакин
स्रोत
2
कार्यक्रमों के लिए त्रुटि के साथ समाप्ति ठीक है । एक आसान ट्रिक: आप इसकी print(*l)जगह पायथन 3 का उपयोग कर सकते हैं print(" ".join(l))।
— xnor
और भी बेहतर, विस्तारित Iterable अनपैकिंग का उपयोग करें ।
— xnor
2
65 बाइट्स : इसके बजाय देने की wकरने के लिए input().split(), यह करने के लिए आवंटित input()है, तो, में while, पाश असाइन mकरने के लिए w.split()है, जो से बचने के संदर्भ मुद्दों के लिए प्रत्येक यात्रा पर एक नई सूची बनाने, फिर सेट m[i]करने के लिए '"%s"'%m[i]और print(*m)।
— बजे एरिक आउटफोलर
4

जावा 8, 72 71 67 62 बाइट्स

s->s.replaceAll("(?<=(^.*))(\\S+) ?(?=(.*$))","$1\"$2\" $3\n")

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

s->                    // Method with String as both parameter and return-type
  s.replaceAll("...",  //  Replace all matches in this regex
               "...")  //  With this
                       //  And then return the result

रेगेक्स स्पष्टीकरण:

(?<=(^.*))(\\S+) ?(?=(.*$))   # === MATCH ===
(?<=     )                    # A positive look-behind to:
     ^.*                      #  The optional leading portion of the string
    (   )                     #  (which is captured in capture group 1)
           \\S+               # Followed by one or more non-space characters,
                              # so the next word in line
          (    )              # (which is captured in capture group 2)
                 ?            # Followed by an optional space
                  (?=     )   # Followed by a positive look-ahead to:
                      .*$     #  The trailing optional portion of the string
                     (   )    #  (which is captured in capture group 3)

$1\"$2\" $3\n                 # === REPLACEMENT ===
$1                            # The match of capture group 1
                              # (the leading portion)
    $2                        # Followed by the match of capture group 2
                              # (the current word in the 'iteration'),
  \"  \"                      # surrounded by quotation marks
                              # Followed by a space character
         $3                   # Followed by the match of capture group 3
                              # (the trailing portion)
           \n                 # Followed by a trailing newline
— केविन क्रूज़सेन
स्रोत
2
आपने अभी-अभी रेगेक्स उत्तरों की भीड़ के लिए मार्ग प्रशस्त किया है। बहुत बढ़िया।
— बेंजामिन उरक्हार्ट
मैंने इसे पायथन में पोर्ट करने की कोशिश की। कभी-कभी मुझे लगता है कि रेगेक्स पार्सर भाषाओं के अनुरूप थे।
— बेंजामिन उर्क्हार्ट
1
@BenjaminUrquhart दुर्भाग्य से वे नहीं हैं .. जावा regex C # regex से अलग है, पायथन फिर से अलग है, पर्ल फिर से अलग है, आदि। वास्तव में थोड़ा कष्टप्रद है।
— केविन क्रूज़सेन
3

रूबी , 98 वर्ण।

पहले सबमिशन। यह निश्चित रूप से छोटा किया जा सकता है। मैं बस जल्दी से उत्तर प्राप्त करना चाहता था।

a=->s{s.split.each_index{|i|puts s.split.each_with_index.map{|a,j|i==j ? "\"#{a}\"":a}.join(" ")}}

इसे ऑनलाइन आज़माएं!

— Snowe
स्रोत
PPCG में आपका स्वागत है! मेरा सुझाव प्रत्येक अनुक्रमणिका के लिए होगा, s.splitएक चर के रूप में सहेजें और उस अनुक्रमणिका को संपादित करें, जिसके बारे में आप उद्धरण चाहते हैं, इसके बजाय अति क्रिया का उपयोग करें each_with_index.map। इसके अलावा, आप अनाम लैम्ब्डा को बिना नाम दिए सबमिट कर सकते हैं, और ज्वाइन कर सकते हैं और इसे *ऑपरेटर से बदल सकते हैं । यह आपकी बाइट काउंट को 64 बाइट्स तक गिरा देता है।
— मूल्य स्याही
बहुत खुबस! मुझे पता था कि जॉइन करने का एक छोटा तरीका था, लेकिन मैं कार्यालय से बाहर निकलने की कोशिश कर रहा था और एक्सडी छोड़ने से पहले कुछ जमा करना चाहता था। मुझे इस तरह अनाम लंबोधों के लिए अनुमति नियमों का एहसास नहीं था।
— बर्फ
3

पर्ल 6 , 43 40 बाइट्स

{m:ex/^(.*?<<)(\S+)(>>.*)$/>>.join('"')}

इसे ऑनलाइन आज़माएं!

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

स्पष्टीकरण:

{                                      }  # Anonymous code block
 m:ex/^                  $/               # Match all strings
       (.*?)         (.*)                 # Match before and after sections
            <<(\S+)>>                     # And the actual word (with no spaces)
                           >>.join('"')   # And join each line by "s
— मजाक कर रहा है
स्रोत
3

प्रतिबिंब , 229 बाइट्स

  _1 +\ /\/(3\  /(0\
/+_:   # \#_: v1=2#_ \
\     /_+/:3; / 1/\:1)
/v(3(2/ \3)(3 ;\#@ \ /
   /:#_(0\:_ / (0*  /0  \
 0 >~    <>~   <0 \  *#_/
 \       /     /\/ v/ 
   \=2#_1/\2#_>  (0~
                 \ ^\
\                   /

झसे आज़माओ!

मैंने इसे "मज़ेदार" "गोल्फिंग" भाषा में "जल्दी" "गोल्फ" किया।

उस सभी व्हाट्सएप को देखते हुए, यह शायद कम हो सकता है।

— wastl
स्रोत
3

हास्केल , 64 बाइट्स

map unwords.g.words
g(h:t)=(('"':h++"\""):t):map(h:)(g t)
g _=[]

इसे ऑनलाइन आज़माएं!

तार की एक सूची आउटपुट करता है। निम्मी के उत्तर के आधार पर ।

— XNOR
स्रोत
Nimi की तरह इस उत्तर ठीक से काम नहीं करता है जब इनपुट जैसे पात्रों भाग निकले होता \nया "।
— गेहूं जादूगर
2

स्टैक्स , 10 बाइट्स

▓¼MY@≈╢∞◙╗

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

jY      split on spaces and store in y register
m       for each word, run the rest of the program and implicitly output
  '"|S  surround with double quotes
  yia&  start with register y, and replace the ith element, where i is the iteration index
  J     join with spaces

इसको चलाओ

— पुनरावर्ती
स्रोत
2

सी (जीसीसी) , 136 133 बाइट्स

जैसा कि सी के टोकनिंग फ़ंक्शन भविष्य के रीड्स पर स्ट्रिंग को गड़बड़ कर देंगे, मैं इसके बजाय प्रत्येक शब्द के लिए संख्या और ऑफसेट की गणना करता हूं और तब समाप्त होता है जब बाहरी लूप के पुनरावृत्तियों की कुल संख्या शब्दों की संख्या से मेल खाती है।

i,j=1;f(s,c,t)char*s,*c,*t;{for(i=0;i++<j;puts(""))for(j=0,c=t=s;t;t=c+!!c)printf("%3$s%.*s%s ",(c=index(t,32))-t,t,"\""+!!(i-++j));}

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
अदला-बदली "\""+!!(i-++j)के लिए i-++j?"":"\""आप एक बाइट बचाता है।
— गैस्ट्रोपनर
2

पॉवरशेल , 60 40 36 बाइट्स

-20 से प्रेरित बाइट Arnauld

$args-replace'(\S+) ?','$`"$1" $''
'

इसे ऑनलाइन आज़माएं!

परिणाम में पूंछ में एक अतिरिक्त जगह और एक खाली लाइन होती है।

पॉवर्सशेल, रेगेक्सप, 60 बाइट्स

($w=-split$args)|%{$p=++$c
"$($w|%{$q='"'*!--$p
"$q$_$q"})"}

इसे ऑनलाइन आज़माएं!

कम गोल्फ वाला:

$words=-split $args                     # split by whitespaces
$words|%{
    $position=++$counter
    $array=$words|%{
        $quotation='"'*!--$position     # empty string or quotation char
        "$quotation$_$quotation"
    }
    "$($array)"                         # equivalent to $array-join' '
}
— Mazzy
स्रोत
यदि इनपुट शब्दों में टैब या अन्य व्हाट्सएप हो तो न तो काम करता है। चुनौती से, केवल रिक्त स्थान शब्दों का परिसीमन करते हैं।
— AdmBorkBork
आप निश्चित रूप से सही कह रहे हैं। लेकिन नियम हैं: 1. The input only contains printable ASCII characters., 2 The input may contain spaces.। टैब और अन्य व्हाट्सएप मुद्रण योग्य ASCII नहीं है, है ना? :)
— माज़ी
1
मैं यह सच है लगता है - मैं केवल ओपी की टिप्पणी से दूर अपना बयान आधारित था यहाँ है, लेकिन वह चुनौती में संपादित नहीं किया गया है ... इसलिए मुझे लगता है कि आपके सबमिशन ठीक है के रूप में यह वर्तमान में है।
— AdmBorkBork
2

जावास्क्रिप्ट, 62 बाइट्स

10 बाइट्स बंद करने के लिए धन्यवाद @ शगुन

f=
x=>x.split` `.map((c,i,a)=>(s=[...a],s[i]=`"${c}"`,s.join` `))

console.log(f("Hello folks and world").join('\n'));
स्निपेट का विस्तार करें

व्याख्या

  • फ़ंक्शन प्रत्येक स्थान पर स्ट्रिंग को विभाजित करता है (x.split` `)
  • परिणामी सरणी में प्रत्येक तत्व के लिए निम्न कार्य करते हैं
  • सरणी की उथली प्रतिलिपि बनाएँ (s = [...])
  • Nth तत्व को उद्धरण चिह्नों (s [i] = `" $ {c} "") से घिरे हुए सरणी में बदलें
  • उथली प्रतिलिपि को रिक्त स्थान (s.join` `) के साथ मिला दें
— fənɛtɪk
स्रोत
— झबरा
2

आर , 94 76 बाइट्स

-18 बाइट्स ग्यूसेप के लिए धन्यवाद

m=matrix(s<-scan(,a<-'"'),n<-length(s),n);diag(m)=paste0(a,s,a);write(m,1,n)

इसे ऑनलाइन आज़माएं!

ठीक से TIO की स्थापना के लिए digEmAll का धन्यवाद। यह उदाहरण के लिए This is codegolfऔर सही ढंग से आउटपुट लेता है

"This" is codegolf 
 This "is" codegolf 
 This is "codegolf"

यह बार- nबार वाक्य के साथ एक मैट्रिक्स प्रारूप का उपयोग करता है ; फिर हमें केवल विकर्ण प्रविष्टियों को बदलने की आवश्यकता है। ध्यान दें कि आमतौर पर, आर कोड-गोल्फ में, स्ट्रिंग्स के साथ पढ़ा जाता है scan(,""), लेकिन किसी भी स्ट्रिंग का उपयोग खाली स्ट्रिंग के बजाय what(या) के रूप में किया जा सकता हैw ) पैरामीटर के ।

पुराने ungolfed संस्करण की व्याख्या: 

s <- scan(t=scan(,''),w=t)    # read in input and separate by spaces
n <- length(s)                # number of words
m = matrix(s, n, n)           # fill a matrix, one word per entry, each column corresponds to the whole sentence. The sentence is repeated n times.
diag(m) = paste0('"', s, '"') # replace diagonal entries with the corresponding word surrounded by quotes
cat(rbind(m,"\n"))        # add a \n at the end of each column, then print column-wise
— रॉबिन राइडर
स्रोत
— ग्यूसेप
@Giuseppe धन्यवाद! मैंने कैसे नहीं देखा कि मुझे दो कॉल की आवश्यकता नहीं है scan??
— रॉबिन राइडर
कभी-कभी आप सिर्फ एक गोल्फ ग्रूव में जाते हैं। यदि हम अन्य उद्धरणों का उपयोग कर सकते हैं "", तो हम 68 बाइट्स का उपयोग करके कम कर सकते हैं sQuote।
— ग्यूसेप
2

यह मेरा पहला कोड गोल्फ है। उम्मीद है कि यह बकवास नहीं है।

संपादित करें: यह बेहतर नियमित अभिव्यक्ति के साथ 54 बाइट्स के नीचे हो गया।

** संपादित 2: प्रति सुझाव, एक बग तय किया और इसे छोटा कर दिया **

जावास्क्रिप्ट (V8) , 46 बाइट्स

t=>t.split(' ').map(v=>t.replace(v,'"'+v+'"'))

इसे ऑनलाइन आज़माएं!

— r3wt
स्रोत
5
यदि इनपुट में डुप्लिकेट शब्द हैं, तो बाद की प्रतियां कभी भी उद्धृत नहीं होती हैं।
— पुनरावर्ती
रिक्त स्थान पर विभाजन कम होगा।
— शैगी
@recursive तय होना चाहिए।
— r3wt
@ धन्यवाद धन्यवाद, मैंने आपका सुझाव शामिल किया
— r3wt
1
अभी भी डुप्लिकेट शब्दों के लिए काम नहीं करता है
— जो राजा
2

/u:System.Text.RegularExpressions.Regexफ्लैग के साथ C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 59 40 बाइट्स

s=>Replace(s,"(\\S+) ?","$`\"$1\" $'\n")

मेरे जावा 8 उत्तर का पोर्ट , इसलिए स्पष्टीकरण के लिए वहां देखें।
पोर्टिंग द्वारा -19 बाइट्स @Arnauld के regex , के बाद से $`और$' सी # .NET में समर्थित हैं।

इसे ऑनलाइन आज़माएं।

— केविन क्रूज़सेन
स्रोत
2

एल्म पुनरावृत्ति का उपयोग करना, 132,130,121,111,100 99 बाइट्स

केविन क्रूज़सेन तकनीक की बदौलत 9 बाइट्स नीचे गिर गई और एक और 22 बाइट्स फटा ASCII ही । गोल्फ के दौरान गैर-पूंछ पुनरावृत्ति में बदल गया।

f b a=case a of
 c::r->String.join" "(b++("\""++c++"\"")::r)::f(b++[c])r
 _->[]
u=f[]<<String.words

इसे ऑनलाइन आज़माएं

उजागर करने के बाद 85 बाइट्स Stringमौजूदा कार्य के लिए कार्यों को करने के

f b a=case a of
 c::r->join" "(b++("""++c++""")::r)::f(b++[c])r
 _->[]
u=f[]<<words

Ungolfed संस्करण (पूंछ पुनरावृत्ति का उपयोग करके)

push : List a -> a -> List a
push list el =
    list ++ [ el ]

zip : (List a -> a -> List a -> b) -> List a -> List a -> List b -> List b
zip transform before after mapped =
    case after of
        [] ->
            mapped

        current :: rest ->
            transform before current rest
                |> push mapped
                |> zip transform (push before current) rest

wrap : appendable -> appendable -> appendable
wrap v str =
    v ++ str ++ v

cb : List String -> String -> List String -> String
cb before current rest =
    before ++ wrap "\"" current :: rest
        |> String.join " "

result : List String
result =
    zip cb [] (String.words "This is code golf") []

अदम्य प्रयास करें

— एवगेनी माल्युटिन
स्रोत
2

जाप , 14 12 बाइट्स

¸£¸hYQ²i1X)¸

कोशिश करो

2 बाइट्स ने ओलिवर को धन्यवाद दिया।

¸£¸hYQ²i1X)¸     :Implicit input of string
¸                :Split on spaces
 £               :Map each X at index Y
  ¸              :  Split input on spaces
   hY            :  Set the element at index Y to
     Q           :    Quotation mark
      ²          :    Repeat twice
       i1X       :    Insert X at 0-based index 1
— झबरा
स्रोत
— ओलिवर
डी 'ओह! बेशक! धन्यवाद, @ ऑलिवर
— झबरा
1

पॉवरशेल , 70 65 बाइट्स

param($a)$a.Split()|%{$a-replace[regex]"( |^)$_( |$)"," ""$_"" "}

इसे ऑनलाइन आज़माएं!

परीक्षण में परीक्षण सूट है। पहली पंक्ति में 1 अग्रणी स्थान है, और अंतिम पंक्ति पर 1 अनुगामी स्थान है। रिफलेक्टर लगाने का प्रयास।

— KGlasier
स्रोत
4
यदि आपके पास परीक्षण स्ट्रिंग में डुप्लिकेट शब्द है तो यह काम नहीं करता है।
— स्नो
1

चारकोल , 19 बाइट्स

Ｅ⪪θ ⪫Ｅ⪪θ ⎇⁼κμ⪫""λλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अनुगामी स्थान। स्पष्टीकरण:

  θ                     Input string
 ⪪                      Split on literal space
Ｅ                       Map over words
       θ                Input string
      ⪪                 Split on literal space
     Ｅ                  Map over words
            μ           Inner index
          ⁼             Equals
           κ            Outer index
         ⎇             If true then
               ""       Literal string `""`
              ⪫         Joined i.e. wrapping
                 λ      Current word
                  λ     Otherwise current word
    ⪫                  Joined with literal space
                        Implicitly print each result on its own line
— नील
स्रोत
1

अटैची , 34 बाइट्स

Join&sp=>{On&_&Repr=>Iota@_}@Split

इसे ऑनलाइन आज़माएं! बेनामी फ़ंक्शन लाइनों की सूची लौटाता है।

व्याख्या

Join&sp=>{On&_&Repr=>Iota@_}@Split
                             Split      Splits the input on whitespace
         {         =>Iota@_}            Over each number K, 0 to #words - 1
          On  &Repr                     Apply the Repr (quoting) function
            &_                          on the Kth element in the input
Join&sp=>                               then rejoin the words of each inner sentence
— कोनोर ओ ब्रायन
स्रोत
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 123 बाइट्स

मुझे आश्चर्य है कि अगर इसे नियमित अभिव्यक्तियों के साथ छोटा किया जा सकता है। 

s=>(r=s.Split(' ')).Select((a,i)=>(string.Join(" ",r.Take(i))+" \""+a+"\" "+string.Join(" ",r.Skip(i+1))).Trim());string[]r

इसे ऑनलाइन आज़माएं!

— मेरा सर्वनाम monicareinstate है
स्रोत
— Innat3
— दाना
जावा उत्तर का पोर्ट - 104 :)
— दाना
1
— केविन क्रूज़सेन
@KevinCruijssen - मैंने देखा कि आपको वह regex पहले मिला था :) यह पता लगाया कि यह एक पूरी तरह से अलग तरीका था इसलिए मैंने इसे पोर्ट करने की कोशिश नहीं की, लेकिन हाँ यह एक अच्छा उपाय है!
— दाना
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.