25
\$\begingroup\$

Story

Have you seen this post from 9gag? Maybe you got the feeling to make your own sentences. But then you realize that you could just golf a script in half an hour, and you will never have to deal time with that.

The submission

Your program will get an input string which it will return with added quotation marks as explained below. Standard loopholes are forbidden. Output as a list of lines is allowed. Trailing spaces and empty lines that don't break the output are allowed.

The rules of input

  • The input only contains printable ASCII characters.
  • The input may contain spaces. The words are determined with them.
  • It's guaranteed that a space will never be followed by another space.
  • The case of no input or empty string doesn't matter.

The rules of output

If one word is given then the program has to return the string between quotation marks.

If the input string has 2 or more words, it first returns the initial input, but the first word is in quotation marks. Then on the next line, it returns the initial input, but with the second word in quotes. And so on for the remaining words.

In general, the program has to return as many lines as there are words in the input.

Examples:

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"

This is , so the least byte answer wins!

\$\endgroup\$

40 Answers 40

10
\$\begingroup\$

vim, 38 bytes

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

Try it online!

Requires the vim-surround plugin.

If the input does not contain " characters, this can be done in 19 bytes:

qqysW"Ypds"W@qq@qdk

Here, we record a recursive macro (qq ... @qq@q) that surrounds a word with quotation marks (ysW"), duplicates the line (Yp), deletes the quotation marks (ds"), and moves to the next word (W) before calling itself recursively. After it terminates, there are two extraneous lines, which are deleted with dk.

The full solution simply wraps this with :s/"/<C-d>/g at the beginning, which replaces existing " characters with an unprintable character, and :%s/<C-d>/"/g at the end, which undoes the replacement.

\$\endgroup\$
  • 2
    \$\begingroup\$ I actually made the examples with the same method :D \$\endgroup\$ – krinistof May 11 at 11:41
8
\$\begingroup\$

Haskell, 65 bytes

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

Returns a list of lines.

Try it online!

\$\endgroup\$
  • \$\begingroup\$ This seems to fail when the input contains quotation marks, newlines or other escaped charcters. \$\endgroup\$ – Sriotchilism O'Zaic May 12 at 15:14
  • \$\begingroup\$ @SriotchilismO'Zaic: fixed. Thanks for pointing out. Regarding the shorter version: xnor already posted this as an answer. \$\endgroup\$ – nimi May 13 at 19:17
  • \$\begingroup\$ Not quite fixed, since words considers \n to be whitespace it behaves inproperly when it is present. \$\endgroup\$ – Sriotchilism O'Zaic May 14 at 3:19
  • \$\begingroup\$ @SriotchilismO'Zaic: "The input only contains printable ASCII characters", which is Space to ~. "The input may contain spaces" - not "whitespace". \$\endgroup\$ – nimi May 14 at 5:08
7
\$\begingroup\$

Retina 0.8.2, 17 bytes

 
" $'¶$` "
^|$
"

Try it online! Link includes test suite. Explanation:

 
" $'¶$` "

Expand each space by duplicating the line and then inserting quotation marks.

^|$
"

Fix the first and last lines.

\$\endgroup\$
7
\$\begingroup\$

Jelly,  15  14 bytes

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

Try it online!

How?

Ḳ⁾""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
\$\endgroup\$
  • \$\begingroup\$ Easy save. (Decided to comment here because you were the first to post similar code. :P) \$\endgroup\$ – Erik the Outgolfer May 11 at 15:31
  • \$\begingroup\$ @EriktheOutgolfer thanks, came back to post a similar improvement myself. \$\endgroup\$ – Jonathan Allan May 11 at 16:26
6
\$\begingroup\$

JavaScript (ES6),  43 42 41  38 bytes

Saved 3 bytes thanks to @mazzy

Uses the non-standard but widely supported RegExp.left​Context and RegExp.rightContext. That's a lot of different quotes...

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Smart! But see on the comma in the test case This is a significantly "longer,"... \$\endgroup\$ – mazzy May 12 at 8:20
  • \$\begingroup\$ Wouldn't /(\S+)/g work? \$\endgroup\$ – Shaggy May 12 at 10:50
  • 1
    \$\begingroup\$ @mazzy Oh, thanks. I actually did it that way on purpose because I misread the test case with a comma. Now fixed. \$\endgroup\$ – Arnauld May 12 at 11:00
  • \$\begingroup\$ @Shaggy I think we need to capture the space so that it doesn't appear in the left context of the next word. \$\endgroup\$ – Arnauld May 12 at 11:01
  • 1
    \$\begingroup\$ @mazzy I guess that's fine indeed. Thanks! \$\endgroup\$ – Arnauld May 12 at 12:39
6
\$\begingroup\$

Java, 235 183 132 bytes

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 bytes by abusing a variety of things (static access, list vs array, print instead of returning, etc. Thanks @ValueInk!)
-51 bytes by beung lazy and letting @KevinCruijssen do the work for me
Try it online

\$\endgroup\$
  • \$\begingroup\$ That's some crazy overhead you need for the java.util.Arrays.copyOfRange. If you utilize java.util.List you can use subList for shorter, and print to STDOUT instead of building an array. I got 193 bytes with those ideas, and also abusing the var keyword. \$\endgroup\$ – Value Ink May 11 at 1:17
  • \$\begingroup\$ @ValueInk thanks! I also replaced String.join with s.join for those extra IDE warnings (and -10 bytes). \$\endgroup\$ – Benjamin Urquhart May 11 at 17:44
  • 1
    \$\begingroup\$ @OlivierGrégoire no thank you :^) \$\endgroup\$ – Benjamin Urquhart May 13 at 13:01
  • 2
    \$\begingroup\$ @OlivierGrégoire Challenge accepted and beaten, sir! ;p 71 bytes \$\endgroup\$ – Kevin Cruijssen May 14 at 15:55
  • 1
    \$\begingroup\$ @KevinCruijssen Nice! I haven't even thought regex would do the job. Well done ;-) \$\endgroup\$ – Olivier Grégoire May 14 at 16:26
5
\$\begingroup\$

First code golf attempt hopefully it's not terrible and hopefully it's not rule breaking

Kotlin, 105 112 147 117 bytes/chars

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

Try it online!

\$\endgroup\$
4
\$\begingroup\$

05AB1E, 14 bytes

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

Try it online!


+1 byte (and it works for the edge case) thanks to Emigna. -1 byte thanks to Kevin!

\$\endgroup\$
4
\$\begingroup\$

JavaScript, 91 97 75 78 bytes

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'));

Outputs a list of lines as a JavaScript array. The last entry has a trailing space as allowed in the question. The test code writes each entry to the console on a separate line for demonstration purposes.

Thanks to Shaggy for 19 bytes off and no leading spaces - when the spread operator is used on an empty array to initialize an array literal, no slots are created in the array produced by the spread operator:

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

(The 91 byte version had a leading space on the first line, the 97 byte version took 6 bytes to remove it.)

\$\endgroup\$
  • 2
    \$\begingroup\$ 78 bytes \$\endgroup\$ – Shaggy May 11 at 7:22
  • 1
    \$\begingroup\$ The snippet doesn't run because you defined the f function. Otherwise verified. Good job! \$\endgroup\$ – krinistof May 13 at 10:24
  • \$\begingroup\$ @krinistof fixed it, thx! \$\endgroup\$ – traktor53 May 13 at 14:16
  • \$\begingroup\$ Words after the quoted word are separated by commas instead of spaces (Firefox, not sure if that's a browser issue) \$\endgroup\$ – wastl May 13 at 15:16
  • 1
    \$\begingroup\$ @wastl Golfed 3 bytes too many and didn't see the commas due to blurry eyes. Putting back the second spread operator (as in Shaggy"s link) removes the commas . Note to self... put my glasses on next time ;-( \$\endgroup\$ – traktor53 May 13 at 15:36
4
\$\begingroup\$

Python 3, 79, 69, 65 bytes

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

Try it online!

Shaved 10 bytes thanks to xnor. And now this is 65 bytes as per Erik the Outgolfer solution. Program ends with IndexError but this is fine.

\$\endgroup\$
  • 2
    \$\begingroup\$ Terminating with error is fine for programs. A handy trick: you can use print(*l) in Python 3 in place of print(" ".join(l)). \$\endgroup\$ – xnor May 11 at 6:43
  • \$\begingroup\$ Even better, use Extended Iterable Unpacking. \$\endgroup\$ – xnor May 11 at 6:52
  • 2
    \$\begingroup\$ 65 bytes: Instead of assigning w to input().split(), assign it to input(), then, in the while loop, assign m to w.split(), which will create a new list at each iteration to avoid reference issues, then set m[i] to '"%s"'%m[i] and print(*m). \$\endgroup\$ – Erik the Outgolfer May 11 at 15:18
4
\$\begingroup\$

Java 8, 72 71 67 62 bytes

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

Try it online.

Explanation:

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

Regex explanation:

(?<=(^.*))(\\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
\$\endgroup\$
  • 2
    \$\begingroup\$ You have just paved the way for a multitude of regex answers. Well done. \$\endgroup\$ – Benjamin Urquhart May 14 at 17:17
  • \$\begingroup\$ I tried to port this to Python. Sometimes I wish regex parsers were consistent across languages. \$\endgroup\$ – Benjamin Urquhart May 15 at 17:00
  • 1
    \$\begingroup\$ @BenjaminUrquhart Unfortunately they aren't.. Java regex is different than C# regex, Python is different again, Perl is different again, etc. Indeed a bit annoying. \$\endgroup\$ – Kevin Cruijssen May 15 at 17:09
4
\$\begingroup\$

Ruby with -an, 53 bytes

The flags -an are read each line and split to $F.

$F.size.times{|i|a=$F.dup;a[i]=?"+a[i]+?";puts a*' '}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Ruby, 98 chars.

First submission ever. This can definitely be shortened. I just wanted to get an answer in quickly.

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! My suggestion would be for each index, save s.split as a variable and edit the index you want to have the quotes around it, instead of using the overly verbose each_with_index.map. Also, you can submit the anonymous lambda without naming it, and join can be replaced with a * operator. This drops your byte count to 64 bytes. \$\endgroup\$ – Value Ink May 11 at 0:04
  • \$\begingroup\$ Fantastic! I knew there was a shorter way to do the join, but I was trying to get out of the office and wanted to submit something before leaving XD. I didn't realize the rules allowed for anonymous lambdas like that. \$\endgroup\$ – snowe May 11 at 0:17
3
\$\begingroup\$

Perl 6, 43 40 bytes

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

Try it online!

Matches all possible words, then joins each list by quotes. This could be one byte shorter if we could output lines in reverse order.

Explanation:

{                                      }  # 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
\$\endgroup\$
3
\$\begingroup\$

Reflections, 229 bytes

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

Test it!

I "quickly" "golfed" this in a "funny" "golfing" language.

Looking at all that whitespace, it could probably be shorter.

\$\endgroup\$
3
\$\begingroup\$

Haskell, 64 bytes

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

Try it online!

Outputs a list of strings. Based on nimi's answer.

\$\endgroup\$
  • \$\begingroup\$ This answer like nimi's doesn't work properly when the input contains escaped characters like \n or ". \$\endgroup\$ – Sriotchilism O'Zaic May 14 at 3:18
2
\$\begingroup\$

Stax, 10 bytes

▓¼MY@≈╢∞◙╗

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

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

Run this one

\$\endgroup\$
2
\$\begingroup\$

C (gcc), 136 133 bytes

As C's tokenizing functions would mess up the string on future reads, I instead calculate the number and offsets for each word and then finish when the total number of iterations of the outer loop matches the number of words.

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));}

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Swapping "\""+!!(i-++j) for i-++j?"":"\"" saves you a byte. \$\endgroup\$ – gastropner May 16 at 20:53
2
\$\begingroup\$

PowerShell, 60 40 36 bytes

-20 bytes inspired by Arnauld

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

Try it online!

The result has one extra space and one empty line in the tail.


Powershell, no regexp, 60 bytes

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

Try it online!

Less golfed:

$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' '
}
\$\endgroup\$
  • \$\begingroup\$ Neither works if the input words contain tabs or other whitespace. From the challenge, only spaces delimit words. \$\endgroup\$ – AdmBorkBork May 13 at 20:31
  • \$\begingroup\$ you are right, of course. But rules are: 1. The input only contains printable ASCII characters., 2. The input may contain spaces. Tabs and other whitespace is not printable ASCII, is not it? :) \$\endgroup\$ – mazzy May 13 at 20:54
  • 1
    \$\begingroup\$ I suppose that's true - I was only basing my statement off of the OP's comment here, but that hasn't been edited into the challenge ... so I suppose your submission is fine as it currently is. \$\endgroup\$ – AdmBorkBork May 14 at 12:26
2
\$\begingroup\$

JavaScript, 62 bytes

Thanks @Shaggy for golfing off 10 bytes

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

console.log(f("Hello folks and world").join('\n'));

Explanation

  • The function splits the string at each space (x.split` `)
  • For each element in the resulting array perform the following function
  • Create a shallow copy of the array (s=[...a])
  • Replace the nth element in the array with itself surrounded with quotation marks (s[i]=`"${c}"`)
  • return the shallow copy joined with spaces (s.join` `)
\$\endgroup\$
2
\$\begingroup\$

Java (JDK), 104 bytes

t->{var w=t.split(" ");int i=0;for(var s:w){w[i]='"'+s+'"';System.out.println(s.join(" ",w));w[i++]=s;}}

Try it online!

\$\endgroup\$
2
\$\begingroup\$

R, 94 76 bytes

-18 bytes thanks to Giuseppe

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

Try it online!

Thanks to digEmAll for setting up the TIO properly. It takes in e.g. This is codegolf and outputs correctly

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

It uses a matrix format with the sentence repeated n times; then we only need to change the diagonal entries. Note that usually, in R code-golf, strings are read in with scan(,""), but any string can be used instead of the empty string as the what (or w) parameter.

Explanation of old ungolfed version:

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
\$\endgroup\$
  • \$\begingroup\$ 76 bytes \$\endgroup\$ – Giuseppe May 13 at 15:16
  • \$\begingroup\$ @Giuseppe Thanks! How did I not see that I didn't need two calls to scan?? \$\endgroup\$ – Robin Ryder May 13 at 16:47
  • \$\begingroup\$ Sometimes you just get into a golfing groove. If we can use other quotes than "", we can reduce to 68 bytes using sQuote. \$\endgroup\$ – Giuseppe May 13 at 18:01
2
\$\begingroup\$

This is my first code golf. hopefully its not shit.

EDIT: got it down to 54 bytes with a better regular expression.

**EDIT 2: per suggestions, fixed a bug and made it shorter **

JavaScript (V8), 46 bytes

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

Try it online!

\$\endgroup\$
  • 5
    \$\begingroup\$ If the input contains duplicate words, subsequent copies never get quoted. \$\endgroup\$ – recursive May 12 at 0:08
  • \$\begingroup\$ Splitting on spaces would be shorter. \$\endgroup\$ – Shaggy May 12 at 8:56
  • \$\begingroup\$ @recursive should be fixed. \$\endgroup\$ – r3wt May 13 at 18:05
  • \$\begingroup\$ @Shaggy thanks, i incorporated your suggestion \$\endgroup\$ – r3wt May 13 at 18:06
  • 1
    \$\begingroup\$ Still doesn't work for duplicate words \$\endgroup\$ – Jo King May 14 at 22:14
2
\$\begingroup\$

C# (Visual C# Interactive Compiler) with /u:System.Text.RegularExpressions.Regex flag, 59 40 bytes

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

Port of my Java 8 answer, so look there for an explanation.
-19 bytes by porting @Arnauld's regex, since the $` and $' are supported in C# .NET.

Try it online.

\$\endgroup\$
2
\$\begingroup\$

Elm Using recursion, 132,130,121,111,100 99 bytes

Golfed down 9 bytes thanks to Kevin Cruijssen technique and another 22 bytes were cracked by ASCII-only. Turned to non-tail recursion during the golf.

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

Try it online

85 bytes after exposing String functions to the current scope

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

Ungolfed version (Using tail recursion)

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") []

Try ungolfed

\$\endgroup\$
2
\$\begingroup\$

Japt, 14 12 bytes

¸£¸hYQ²i1X)¸

Try it

2 bytes saved thanks to Oliver.

¸£¸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
\$\endgroup\$
  • \$\begingroup\$ 12 bytes \$\endgroup\$ – Oliver May 15 at 13:26
  • \$\begingroup\$ D'oh! Of course! Thanks, @Oliver. \$\endgroup\$ – Shaggy May 15 at 17:30
1
\$\begingroup\$

PowerShell, 70 65 bytes

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

Try it online!

Has test suite in trial. Has 1 leading space on first row, and 1 trailing space on last row. Attempting to refactor.

\$\endgroup\$
  • 4
    \$\begingroup\$ This doesn't work if you have a duplicate word in the test string. \$\endgroup\$ – snowe May 10 at 23:14
1
\$\begingroup\$

Charcoal, 19 bytes

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

Try it online! Link is to verbose version of code. Note: Trailing space. Explanation:

  θ                     Input string
 ⪪                      Split on literal space
E                       Map over words
       θ                Input string
      ⪪                 Split on literal space
     E                  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
\$\endgroup\$
1
\$\begingroup\$

Attache, 34 bytes

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

Try it online! Anonymous function returning a list of lines.

Explanation

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
\$\endgroup\$
1
\$\begingroup\$

C# (Visual C# Interactive Compiler), 123 bytes

I wonder if can this be shortened with regular expressions.

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ 118 bytes \$\endgroup\$ – Innat3 May 13 at 16:43
  • \$\begingroup\$ 110 bytes \$\endgroup\$ – dana May 15 at 3:48
  • \$\begingroup\$ Port of Java answer - 104 :) \$\endgroup\$ – dana May 15 at 4:05
  • 1
    \$\begingroup\$ @dana My port is shorter, though ;) \$\endgroup\$ – Kevin Cruijssen May 15 at 12:06
  • \$\begingroup\$ @KevinCruijssen - I saw you got that regex earlier :) Figured that was a totally different approach so I didn't try porting it over, but yeah that is a good solution! \$\endgroup\$ – dana May 15 at 12:20

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.