Sie erhalten eine Zeichenfolge. Geben Sie die Zeichenfolge mit einem Leerzeichen pro Wort aus.

Herausforderung

Die Eingabe ist eine Zeichenfolge (nicht nulloder leer), die von Anführungszeichen ( ") umgeben ist, die über das Symbol gesendet werden stdin. Entfernen Sie führende und nachfolgende Leerzeichen. Wenn sich zwischen zwei Wörtern (oder Symbolen oder was auch immer) mehr als ein Leerzeichen befindet, kürzen Sie es auf nur ein Leerzeichen. Geben Sie den geänderten String mit den Anführungszeichen aus.

Regeln

• Die Zeichenfolge darf nicht länger als 100 Zeichen sein und enthält nur ASCII-Zeichen im Bereich (Leerzeichen) bis ~(Tilde) (Zeichencodes 0x20 bis 0x7E, einschließlich), mit der Ausnahme ", dass die Zeichenfolge keine Anführungszeichen ( ") und andere Zeichen außerhalb von enthält Bereich oben angegeben. Siehe ASCII-Tabelle als Referenz.
• Sie müssen Eingaben von der stdin(oder der nächstgelegenen) Alternative nehmen.
• Die Ausgabe muss Anführungszeichen ( ") enthalten.
• Sie können ein vollständiges Programm oder eine Funktion schreiben, die Eingaben (von stdin) entgegennimmt und die endgültige Zeichenfolge ausgibt

Testfälle

"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 -" 

Wertung

Dies ist Codegolf, daher gewinnt die kürzeste Übermittlung (in Byte).

CJam, 7 Bytes

q~S%S*p

Code Erklärung

CJam hat alle Großbuchstaben als eingebaute Variablen reserviert. Hat also Shier den Wert eines Raumes.

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.

Dadurch werden auch die nachgestellten und führenden Leerzeichen entfernt

Probieren Sie es hier online aus

/// : 18 Zeichen

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

Probelauf:

(Verwenden des Interpreters von faubiguy aus seiner Perl-Antwort für Interpret /// (ausgesprochene 'Schrägstriche') .)

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

Perl, 22

(20 Byte Code plus 2 Befehlszeilenoptionen)

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

Muss mit dem -npSwitch ausgeführt werden, $_damit er automatisch über stdin gefüllt und auf stdout gedruckt wird. Ich gehe davon aus, dass dies die Byteanzahl um 2 erhöht.

Ruby, 31 29 25 23 Bytes

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

Code Erklärung:

• pgibt einen String in doppelten Anführungszeichen aus zu STDOUT( es steckt aber noch mehr dahinter ...)
• $*ist ein Array von STDINEingaben, $*[0]nimmt die erste
• strip Entfernt Start- und End-Leerzeichen
• squeeze ' ' ersetzt> 1 Leerzeichen durch ein einzelnes Leerzeichen

Testfälle:

Pyth, 17 15 11 10 Bytes

(Dank an Ypnypn und FryAmTheEggman )

pjd-cQdkNN

Könnte wahrscheinlich mehr Golf gespielt werden.

Wenn die Ausgabe 'statt "dann verwenden kann, benötige ich nur 8 Bytes:

`jd-cQdk

Bash, 36 32 Bytes

Als eine Funktion, ein Programm oder einfach in einer Pipe:

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

Erläuterung

Der Erste xargs die Anführungszeichen.

Der Zweite xargs Option schneidet die linke Seite ab und ersetzt mehrere benachbarte Leerzeichen in der Mitte der Zeichenfolge durch ein Leerzeichen, indem jedes "Wort" durch ein Leerzeichen getrennt wird.

Das xargs -i echo '"{}"'schneidet die rechte Seite und fügt die resultierende Zeichenfolge in doppelte Anführungszeichen ein.

Haskell, 31 25 Bytes

fmap(unwords.words)readLn

wordsTeilt die Zeichenfolge in eine Liste von Zeichenfolgen mit Leerzeichen als Trennzeichen auf und unwordsfügt der Liste der Zeichenfolgen ein einzelnes Leerzeichen dazwischen hinzu. Die Anführungszeichen "werden von Haskells readund show(implizit über die REPL) -Funktionen für Zeichenfolgen entfernt und zurückgesetzt.

Die Ausgabe durch die Funktion selbst ist drei Bytes länger, dh 28 Bytes:

print.unwords.words=<<readLn

Edit: @ Mauris zeigte auf die readLnFunktion, die einige Bytes sparte.

R, 45 Bytes

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

Die readline()Funktion liest aus STDIN und entfernt automatisch alle führenden und nachfolgenden Leerzeichen. Überschüssiger Abstand zwischen Wörtern wird mit entferntgsub() . Schließlich werden doppelte Anführungszeichen vorangestellt und angehängt, und das Ergebnis wird an STDOUT ausgegeben.

Beispiele:

> 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

Reduziert um 1 Byte dank @ygramul.

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

Originalfassung:

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

Testfälle:

JavaScript (ES6), 49 52 58

Bearbeiten Sie dank @Optimizer 6 Bytes kürzer

Bearbeite 2 -3, danke an @nderscore

Eingabe / Ausgabe über Popup. Verwenden der Vorlagenzeichenfolge zum Ausschneiden von 1 Byte in der Zeichenfolgenverkettung.

Führen Sie das Snippet aus, um es in Firefox zu testen.

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

05AB1E , 9 Bytes

#õKðý'".ø

Probieren Sie es online!

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

Mathematica, 75 Bytes

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

KDB (Q), 28 Bytes

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

Erläuterung

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

Prüfung

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

Java 8, 43 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

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)

Oktave , 44 Bytes

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

Probieren Sie es online!

Perl 5 , 17 Bytes

16 Byte Code + 1 für -p

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

Probieren Sie es online!

Jq 1,5 , 42 Bytes

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

Probelauf

$ 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

Probieren Sie es online aus

Tcl , 69 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Japt -Q , 10 4 Bytes

¸f ¸

Versuch es

Golfua, 42 Bytes

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

Einfache Ersetzung durch Mustererkennung: Suchen Sie nach doppelten Anführungszeichen ( \"), die von 0 oder mehr Leerzeichen ( %s*) umgeben sind, und geben Sie das einfache Anführungszeichen zurück. Ersetzen Sie dann alle 1 oder mehr Leerzeichen (%s+ ) durch ein einzelnes Leerzeichen.

Ein Lua-Äquivalent wäre

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

Cobra - 68

Als anonyme Funktion:

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

Ziel-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];}

Unkomprimierte Version:

-(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 Bytes

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

Powershell, 40 Bytes

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

Ziemlich direkt und nicht sehr beeindruckend.

Erläuterung

Eingabeparameter über (vordefinierte) args-Variable übernehmen, alle mehreren Leerzeichen durch eins ersetzen, führende und nachfolgende Leerzeichen mit trim () - Methode abschneiden, Anführungszeichen hinzufügen. Powershell druckt als Standardverhalten Zeichenfolgen an die Konsole.

k4, 23 Bytes

" "/: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 Bytes

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

Probieren Sie es online!

Eingabezeichenfolge enthält eingebettete Anführungszeichen. Entfernen Sie die Qfür 14 Bytes wenn die Eingabezeichenfolge keine eingebetteten Anführungszeichen enthält, wie dies in einigen anderen Antworten hier der Fall ist.

Parametererweiterungsflags: QEntzieht Anführungszeichen und zteilt sich dann wie die Shell in Wörter auf. Die Wörter werden dann implizit durch Leerzeichen verbunden.

Zaunkönig , 56 Bytes

Warten. Das Ersetzen macht es nur einmal ? Jetzt muss ich die Split-Join-Kombination verwenden.

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

Probieren Sie es online!

Erläuterung

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 Bytes

' '%' '*

Probieren Sie es online!

Erläuterung

Die Logik ist ganz einfach:

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

Python2, 28 Bytes

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

Erläuterung

lambda s

Anonyme Funktion, die als Eingabe s nimmt.

s.split()

Gibt eine Liste der Wörter (die durch beliebige Zeichenfolgen mit Leerzeichen getrennt sind) der Zeichenfolge s zurück.

" ".join(...)

Verknüpft die Liste wieder zu einer Zeichenfolge, wobei jedes Wort durch ein Leerzeichen ("") getrennt ist.