On vous donne une chaîne. Sortez la chaîne avec un espace par mot.

Défi

L'entrée sera une chaîne (non nullou vide), entourée de guillemets ( ") envoyés via le stdin. Supprimez-y les espaces de début et de fin. De plus, s'il y a plus d'un espace entre deux mots (ou symboles ou autre), coupez-le à un seul espace. Sortez la chaîne modifiée avec les guillemets.

Règles

• La chaîne ne dépassera pas 100 caractères et ne contiendra que des caractères ASCII dans la plage (espace) à ~(tilde) (codes de caractères 0x20 à 0x7E, inclus) sauf ", c'est-à-dire que la chaîne ne contiendra pas de guillemets ( ") et d'autres caractères en dehors de la plage spécifiée ci-dessus. Voir le tableau ASCII pour référence.
• Vous devez prendre connaissance de stdin(ou de l'alternative la plus proche).
• La sortie doit contenir des guillemets ( ").
• Vous pouvez écrire un programme complet ou une fonction qui prend une entrée (de stdin) et produit la chaîne finale

Cas de test

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

Notation

Il s'agit du code golf, donc la soumission la plus courte (en octets) l'emporte.

CJam, 7 octets

q~S%S*p

Explication du code

CJam a réservé toutes les majuscules en tant que variables intégrées. A donc Sla valeur d'un espace ici.

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.

Cela supprime également les espaces de fin et de début

Essayez-le en ligne ici

/// : 18 caractères

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

Exemple d'exécution:

(Utilisation de l 'interprète de faubiguy à partir de sa réponse Perl pour Interpréter /// (prononcé «slashes») .)

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

Perl, 22

(20 octets de code, plus 2 commutateurs de ligne de commande)

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

Doit être exécuté avec le -npcommutateur afin qu'il $_soit automatiquement rempli via stdin et imprimé sur stdout. Je vais supposer que cela ajoute 2 au nombre d'octets.

Rubis, 31 29 25 23 octets

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

Explication du code:

• paffiche une chaîne entre guillemets doubles STDOUT(il y a plus que ça ...)
• $*est un tableau d' STDINentrées, $*[0]prend la première
• strip supprime les espaces de début et de fin
• squeeze ' ' remplace> 1 espace par un seul espace

Cas de test:

Pyth, 17 15 11 10 octets

(merci à Ypnypn et FryAmTheEggman )

pjd-cQdkNN

Pourrait probablement être plus joué au golf.

Si la sortie peut utiliser à la 'place, "je n'ai besoin que de 8 octets:

`jd-cQdk

Bash, 36 32 octets

En tant que fonction, programme ou simplement dans un tube:

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

Explication

Le premier xargssupprime les guillemets.

Le second xargscoupe le côté gauche et remplace plusieurs espaces adjacents au milieu de la chaîne par un espace en prenant chaque "mot" et en les séparant chacun par un espace.

Le xargs -i echo '"{}"'coupe le côté droit et rembobine la chaîne résultante entre guillemets.

Haskell, 31 25 octets

fmap(unwords.words)readLn

wordsdivise la chaîne en une liste de chaînes avec des espaces comme délimiteurs et unwordsjoint la liste des chaînes avec un seul espace entre les deux. Les guillemets "sont supprimés et remis par les fonctions de Haskell readet show(implicitement via le REPL) sur les chaînes.

La sortie par la fonction elle-même est plus longue de trois octets, soit 28 octets:

print.unwords.words=<<readLn

Edit: @Mauris a souligné la readLnfonction, qui a enregistré quelques octets.

R, 45 octets

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

La readline()fonction lit à partir de STDIN, supprimant automatiquement tous les espaces blancs de début et de fin. L'excès d'espace entre les mots est supprimé à l'aide de gsub(). Enfin, les guillemets doubles sont ajoutés et ajoutés avant et le résultat est imprimé dans STDOUT.

Exemples:

> 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

Réduit de 1 octet grâce à @ygramul.

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

Version originale:

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

Cas de test:

JavaScript (ES6), 49 52 58

Éditez 6 octets plus court, grâce à @Optimizer

Edit 2 -3, grâce à @nderscore

Entrée / sortie via popup. Utilisation d'une chaîne de modèle pour couper 1 octet dans la concaténation de chaînes.

Exécutez l'extrait de code pour tester dans Firefox.

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

05AB1E , 9 octets

#õKðý'".ø

Essayez-le en ligne!

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

Mathematica, 75 octets

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

KDB (Q), 28 octets

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

Explication

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

Tester

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

Java 8, 43 octets

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

Explication:

Essayez-le ici.

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)

Octave , 44 octets

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

Essayez-le en ligne!

Perl 5 , 17 octets

16 octets de code + 1 pour -p

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

Essayez-le en ligne!

Jq 1,5 , 42 octets

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

Sample Run

$ 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

Essayez-le en ligne

Tcl , 69 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Japt -Q , 10 4 octets

¸f ¸

Essayez-le

golfua, 42 octets

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

Remplacement de correspondance de modèle simple: recherchez les guillemets doubles ( \") entourés de 0 ou plusieurs espaces ( %s*) et renvoyez le guillemet simple, puis remplacez tous les 1 ou plusieurs espaces ( %s+) par un seul espace.

Un équivalent Lua serait

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

Cobra - 68

En tant que fonction anonyme:

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

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

Version non compressée:

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

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

Powershell, 40 octets

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

Assez simple et pas très impressionnant.

Explication

Prendre le paramètre d'entrée via la variable args (prédéfinie), remplacer tous les espaces multiples par un, couper les espaces de début et de fin en utilisant la méthode trim (), ajouter des guillemets. Powershell imprimera les chaînes sur la console comme comportement par défaut.

k4, 23 octets

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

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

Essayez-le en ligne!

La chaîne d'entrée contient des guillemets incorporés. Supprimez le Qpour 14 octets si la chaîne d'entrée ne contient pas de guillemets incorporés, comme cela est fait dans certaines des autres réponses ici.

QIndicateurs d' expansion des paramètres: déquote, puis zse divise en mots comme le fait le shell. Les mots sont alors implicitement joints par des espaces.

Troglodyte , 56 octets

Attendez. Le remplacement ne fait-il qu'une seule fois ? Maintenant, je dois utiliser le combo split-join.

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

Essayez-le en ligne!

Explication

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 octets

' '%' '*

Essayez-le en ligne!

Explication

La logique est assez simple:

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

Python2, 28 octets

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

Explication

lambda s

Fonction anonyme qui prend en entrée s.

s.split()

Renvoie une liste des mots (qui sont séparés par des chaînes arbitraires de caractères blancs) de la chaîne s.

" ".join(...)

Rejoint la liste dans une chaîne, chaque mot étant séparé par un espace ("").