Otrzymałeś ciąg. Wypisuj ciąg z jedną spacją na słowo.

Wyzwanie

Wejście będzie ciąg (nie nulllub pusta), otoczony z cytatami ( ") wysyłane za pośrednictwem stdin. Usuń z niego początkowe i końcowe spacje. Ponadto, jeśli pomiędzy dwoma słowami (lub symbolami lub czymkolwiek) jest więcej niż jedna spacja, przycinaj ją do tylko jednej spacji. Wyjście zmodyfikowanego ciągu z cudzysłowami.

Zasady

• Ciąg nie będzie dłuższy niż 100 znaków i będzie zawierać tylko znaki ASCII w zakresie (spacja) do ~(tylda) (kody znaków od 0x20 do 0x7E włącznie), z wyjątkiem ", tzn. Ciąg nie będzie zawierał cudzysłowów ( ") i innych znaków poza zakres określony powyżej. Zobacz tabelę ASCII w celach informacyjnych.
• Musisz wziąć dane wejściowe z stdin(lub najbliższej alternatywy).
• Dane wyjściowe muszą zawierać quotes ( ").
• Możesz napisać pełny program lub funkcję, która pobiera dane wejściowe (z stdin) i generuje końcowy ciąg znaków

Przypadki testowe

"this  is  a    string   "         --> "this is a string"

"  blah blah    blah "             --> "blah blah blah"

"abcdefg"                          --> "abcdefg"

"           "                      --> ""

"12 34  ~5 6   (7, 8) - 9 -  "     --> "12 34 ~5 6 (7, 8) - 9 -" 

Punktacja

To jest kod golfowy, więc wygrywa najkrótsze przesłanie (w bajtach).

CJam, 7 bajtów

q~S%S*p

Objaśnienie kodu

CJam zastrzegł wszystkie duże litery jako zmienne wbudowane. Więc Sma wartość przestrzeni tutaj.

q~          e# Read the input (using q) and evaluate (~) to get the string
  S%        e# Split on running lengths (%) of space
    S*      e# Join (*) the splitted parts by single space
      p     e# Print the stringified form (p) of the string.

Usuwa to również spacje końcowe i wiodące

Wypróbuj online tutaj

/// : 18 znaków

/  / //" /"// "/"/

Przykładowy przebieg:

(Użycie interpretera faubiguy z jego odpowiedzi Perla na Interpretacja /// (wymawiane „ukośniki”) .)

bash-4.3$ ( echo -n '/  / //" /"// "/"/'; echo '"   foo  *  bar   "'; ) | slashes.pl
"foo * bar"

Perl, 22

(20 bajtów kodu plus 2 przełączniki wiersza poleceń)

s/ +/ /g;s/" | "/"/g

Musi być uruchamiany za pomocą -npprzełącznika, aby $_był automatycznie napełniany przez standardowe wejście i drukowany na standardowe wyjście. Zakładam, że to dodaje 2 do liczby bajtów.

Ruby, 31 29 25 23 bajtów

p$*[0].strip.squeeze' '

Objaśnienie kodu:

• pwypisuje ciąg znaków w podwójnych cudzysłowach do STDOUT( jest jednak coś więcej ...)
• $*jest tablicą danych STDINwejściowych, $*[0]bierze pierwszą
• strip usuwa początkowe i końcowe spacje
• squeeze ' ' zastępuje> 1 znak spacji jednym spacją

Przypadki testowe:

Pyth, 17 15 11 10 bajtów

(dzięki Ypnypn i FryAmTheEggman )

pjd-cQdkNN

Prawdopodobnie można by grać w golfa więcej.

Jeśli 'zamiast tego można użyć danych wyjściowych, "potrzebuję tylko 8 bajtów:

`jd-cQdk

Bash, 36 32 bajtów

Jako funkcja, program lub po prostu w potoku:

xargs|xargs|xargs -i echo '"{}"'

Wyjaśnienie

Pierwszy xargsusuwa znaki cudzysłowu.

Drugi xargsprzycina lewą stronę i zastępuje wiele sąsiednich spacji w środku łańcucha jedną spacją, biorąc każde „słowo” i oddzielając je spacją.

xargs -i echo '"{}"'Przycina prawą stronę i rewraps wynikowy ciąg w cudzysłowach.

Haskell, 31 25 bajtów

fmap(unwords.words)readLn

wordsdzieli ciąg na listę ciągów ze spacjami jako ogranicznikami i unwordsłączy listę ciągów z pojedynczymi spacjami pomiędzy nimi. Cytaty "są usuwane i odkładane przez funkcje Haskell readi show(domyślnie przez REPL) na łańcuchach.

Wyprowadzanie przez samą funkcję jest trzy bajty dłuższe, tj. 28 bajtów:

print.unwords.words=<<readLn

Edycja: @ Mauris wskazał na readLnfunkcję, która zapisała niektóre bajty.

R, 45 bajtów

cat('"',gsub(" +"," ",readline()),'"',sep="")

The readline()Funkcja czyta ze standardowego wejścia, automatyczne usuwanie jakichkolwiek początkowe i końcowe spacje. Nadmiar spacji między słowami usuwa się za pomocą gsub(). Wreszcie, cudzysłowy są dodawane i dołączane, a wynik jest drukowany do STDOUT.

Przykłady:

> cat('"',gsub(" +"," ",readline()),'"',sep="")
    This   is     a   string  
"This is a string"

> cat('"',gsub(" +"," ",readline()),'"',sep="")
12 34  ~5 6   (7, 8) - 9 -  
"12 34 ~5 6 (7, 8) - 9 -"

Python2, 37

Zmniejszony o 1 bajt dzięki @ygramul.

print'"%s"'%' '.join(input().split())

Orginalna wersja:

print'"'+' '.join(input().split())+'"'

Przypadki testowe:

JavaScript (ES6), 49 52 58

Edytuj 6 bajtów krócej dzięki @Optimizer

Edytuj 2 2-3, dzięki @nderscore

Wejście / wyjście przez wyskakujące okienko. Używanie ciągu szablonu do wycięcia 1 bajtu w łączeniu ciągu.

Uruchom fragment kodu, aby przetestować w przeglądarce Firefox.

alert(`"${prompt().match(/[^ "]+/g).join(" ")}"`)

05AB1E , 9 bajtów

#õKðý'".ø

Wypróbuj online!

#         | Split on spaces.
 õK       | Remove empty Strings.
   ðý     | Join with spaces.
     '".ø | Surround with quotes.

Mathematica, 75 bajtów

a=" ";b=a...;Print[InputString[]~StringReplace~{b~~"\""~~b->"\"",a..->a}]

KDB (Q), 28 bajtów

" "sv except[;enlist""]" "vs

Wyjaśnienie

                       " "vs    / cut string by space
      except[;enlist""]         / clear empty strings
" "sv                           / join back with space

Test

q)" "sv except[;enlist""]" "vs"12 34  ~5 6   (7, 8) - 9 -  "
"12 34 ~5 6 (7, 8) - 9 -"

Java 8, 43 bajty

s->'"'+s.replaceAll(" +|\""," ").trim()+'"'

Wyjaśnienie:

Wypróbuj tutaj.

s->                           // Method with String as parameter and return-type
  '"'                         //  Return a leading quote
  +s.replaceAll(" +           //  + Replace all occurrences of multiple spaces
                   |\"",      //     and all quotes
                        " ")  //    with a single space
    .trim()                   //  And remove all leading and trailing spaces
  +'"'                        //  And add the trailing quote
                              // End of method (implicit / single-line return statement)

Oktawa , 44 bajty

@(x)[34 strjoin(regexp(x,'\S+','match')) 34]

Wypróbuj online!

Perl 5 , 17 bajtów

16 bajtów kodu + 1 dla -p

s/ *("| ) */$1/g

Wypróbuj online!

Jq 1,5 , 42 bajty

split(" ")|map(select(length>0))|join(" ")

Przykładowy przebieg

$ jq -M 'split(" ")|map(select(length>0))|join(" ")' < data
"this is a string"
"blah blah blah"
"abcdefg"
""
"12 34 ~5 6 (7, 8) - 9 -"

$ echo -n 'split(" ")|map(select(length>0))|join(" ")' | wc -c
  42

Wypróbuj online

Tcl , 69 bajtów

puts [string map {{ "} \" {" } \"} [regsub -all \ + [gets stdin] \ ]]

Wypróbuj online!

puts \"[string trim [regsub -all \ + [string range [gets stdin] 1 end-1] \ ]]\"

Wypróbuj online!

Japt -Q , 10 4 bajtów

¸f ¸

Spróbuj

golfua, 42 bajty

L=I.r():g('%s*\"%s*','"'):g('%s+',' ')w(L)

Prosta zamiana pasujących wzorów: znajdź dowolne cudzysłowy ( \") otoczone 0 lub więcej spacjami ( %s*) i zwróć pojedynczy cudzysłów, a następnie zamień wszystkie 1 lub więcej spacji ( %s+) na jedną spację.

Byłby to odpowiednik Lua

Line = io.read()
NoSpaceQuotes = Line:gsub('%s*\"%s*', '"')
NoExtraSpaces = NoSpaceQuotes:gsub('%s+', ' ')
print(NoExtraSpaces)

Kobra - 68

Jako funkcja anonimowa:

do
    print'"[(for s in Console.readLine.split where''<s).join(' ')]"'

Cel C 215

-(NSString*)q:(NSString*)s{NSArray*a=[s componentsSeparatedByString:@" "];NSMutableString*m=[NSMutableString new];for(NSString*w in a){if(w.length){[m appendFormat:@"%@ ",w];}}return[m substringToIndex:m.length-1];}

Wersja nieskompresowana:

-(NSString*)q:(NSString*)s{
    NSArray *a=[s componentsSeparatedByString:@" "];
    NSMutableString *m=[NSMutableString new];
    for (NSString *w in a) {
        if (w.length) {
            [m appendFormat:@"%@ ",w];
        }
    }
    return[m substringToIndex:m.length-1];
}

Bash, 14 bajtów

read f;echo $f       # assume f="this  is  a    string   "

PowerShell, 40 bajtów

"`"$(($args-Replace' +'," ").trim())`""

Całkiem prosto i niezbyt imponująco.

Wyjaśnienie

Weź parametr wejściowy za pomocą (predefiniowanej) zmiennej args, zamień wszystkie wiele spacji na jeden, przycinaj spacje wiodące i końcowe za pomocą metody trim () - dodaj cudzysłowy. Program PowerShell wypisze ciągi do konsoli jako zachowanie domyślne.

k4, 23 bajty

" "/:x@&~~#:'x:" "\:0:0

                    0:0  / read from stdin
             x:" "\:     / split string on spaces and assign to x
        ~~#:'            / boolean true where string len>0, bool false otherwise
     x@&                 / x at indices where true
" "/:                    / join with spaces

Zsh , 15 bajtów

<<<\"${(Qz)1}\"

Wypróbuj online!

Ciąg wejściowy zawiera osadzone cudzysłowy. Wyjąć Qdla 14 bajtów , jeśli ciąg wejściowy nie zawiera osadzone cytaty, jak to ma miejsce w niektórych innych odpowiedzi tutaj.

Flagi ekspansji parametrów: Qusuwają cudzysłowy, a następnie zdzielą się na słowa, tak jak robi to powłoka. Słowa są następnie domyślnie łączone spacjami.

Strzyżyk , 56 bajtów

Czekać. Zamiennik robi to tylko raz ? Teraz muszę użyć kombinacji split-join.

Fn.new{|x|x.trim().split(" ").where{|i|i!=""}.join(" ")}

Wypróbuj online!

Wyjaśnienie

Fn.new{|x|                                             } // New anonymous function with the operand x
          x.trim()                                       // Trim out whitespace from both sides of the string
                  .split(" ")                            // Split the string into space-separated chunks
                             .where{|i|i!=""}            // Keep all of those that aren't the null string (due to two consecutive spaces)
                                             .join(" ")  // Join the replaced list together

GolfScript , 8 bajtów

' '%' '*

Wypróbuj online!

Wyjaśnienie

Logika jest dość prosta:

' '%     # Split on spaces, remove empty results
    ' '* # Join on spaces

Python2, 28 bajtów

lambda s:" ".join(s.split())

Wyjaśnienie

lambda s

Anonimowa funkcja, która przyjmuje jako dane wejściowe.

s.split()

Zwraca listę słów (oddzielonych dowolnymi ciągami znaków spacji) ciągu s.

" ".join(...)

Łączy listę z powrotem w ciąg, a każde słowo jest oddzielone spacją („”).