Você recebe uma string. Produza a sequência com um espaço por palavras.

Desafio

A entrada será uma string (não nullou vazia), cercada por aspas ( ") enviadas via stdin. Remova espaços à esquerda e à direita. Além disso, se houver mais de um espaço entre duas palavras (ou símbolos ou o que for), apare-o em apenas um espaço. Saída a string modificada com as aspas.

Regras

• A string não terá mais de 100 caracteres e conterá apenas caracteres ASCII no intervalo (espaço) a ~(til) (códigos de caracteres 0x20 a 0x7E, inclusive) ", exceto , por exemplo, que a string não conterá aspas ( ") e outros caracteres fora do intervalo especificado acima. Consulte a tabela ASCII para referência.
• Você deve receber informações da stdin(ou alternativa mais próxima).
• A saída deve conter aspas ( ").
• Você pode escrever um programa completo ou uma função que recebe entrada (de stdin) e gera a sequência final

Casos de teste

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

Pontuação

Isso é código de golfe, então a submissão mais curta (em bytes) vence.

CJam, 7 bytes

q~S%S*p

Código Explicação

O CJam reservou todas as letras maiúsculas como variáveis ​​embutidas. Então, Stem o valor de um espaço aqui.

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.

Isso remove também os espaços à direita e à direita

Experimente online aqui

/// : 18 caracteres

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

Exemplo de execução:

(Usando o intérprete de faubiguy de sua resposta Perl para Interpretar /// (pronunciado 'barras') .)

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

Perl, 22

(20 bytes de código, mais 2 opções de linha de comando)

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

Precisa ser executado com o -npcomutador para que $_seja preenchido automaticamente via stdin e impresso em stdout. Vou assumir que isso adiciona 2 à contagem de bytes.

Ruby, 31 29 25 23 Bytes

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

Código Explicação:

• pgera string entre aspas duplas para STDOUT( Há mais do que isso ...)
• $*é uma matriz de STDINentradas, $*[0]pega a primeira
• strip remove os espaços inicial e final
• squeeze ' ' substitui> 1 caracteres de espaço por um único espaço

Casos de teste:

Pitão, 17 15 11 10 bytes

(obrigado a Ypnypn e FryAmTheEggman )

pjd-cQdkNN

Provavelmente poderia ser jogado mais.

Se a saída puder ser usada em 'vez de ", só preciso de 8 bytes:

`jd-cQdk

Bash, 36 32 bytes

Como uma função, um programa ou apenas em um pipe:

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

Explicação

O primeiro xargsretira as aspas.

O segundo xargsapara o lado esquerdo e substitui vários espaços adjacentes no meio da cadeia por um espaço, pegando cada "palavra" e separando cada um com um espaço.

A xargs -i echo '"{}"'apara o lado direito e rewraps a string resultante entre aspas duplas.

Haskell, 31 25 bytes

fmap(unwords.words)readLn

wordsdivide a string em uma lista de strings com espaços como delimitadores e unwordsune a lista de strings com um único espaço no meio. As aspas "são retiradas e recolocadas pelas funções de Haskell reade show(implicitamente via REPL) nas strings.

A saída pela própria função é três bytes mais longa, ou seja, 28 bytes:

print.unwords.words=<<readLn

Edit: @Mauris apontou para a readLnfunção, que salvou alguns bytes.

R, 45 bytes

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

A readline()função lê STDIN, eliminando automaticamente qualquer espaço em branco à esquerda e à direita. O excesso de espaço entre as palavras é removido usando gsub(). Finalmente, aspas duplas são anexadas e anexadas e o resultado é impresso em STDOUT.

Exemplos:

> 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

Reduzido em 1 byte graças a @ygramul.

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

Versão original:

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

Casos de teste:

JavaScript (ES6), 49 52 58

Edite 6 bytes mais curtos, graças ao @Optimizer

Editar 2 -3, graças a @nderscore

Entrada / saída via pop-up. Usando a sequência de modelo para cortar 1 byte na concatenação de sequência.

Execute o snippet para testar no Firefox.

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

05AB1E , 9 bytes

#õKðý'".ø

Experimente 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

Explicação

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

Teste

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()+'"'

Explicação:

Experimente aqui.

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)

Oitava , 44 bytes

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

Experimente online!

Perl 5 , 17 bytes

16 bytes de código + 1 para -p

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

Experimente online!

Jq 1.5 , 42 bytes

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

Experimente online

Tcl , 69 bytes

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

Experimente online!

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

Experimente online!

Japonês -Q , 10 4 bytes

¸f ¸

Tente

golfua, 42 bytes

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

Substituição simples da correspondência de padrões: encontre aspas duplas ( \") cercadas por 0 ou mais espaços ( %s*) e retorne a aspas simples e substitua todos os 1 ou mais espaços ( %s+) por um único espaço.

Um equivalente Lua seria

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

Cobra - 68

Como uma função anônima:

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

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

Versão não compactada:

-(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())`""

Bem direto e não muito impressionante.

Explicação

Pegue o parâmetro de entrada através da variável args (predefinida), substitua todos os espaços múltiplos por um, apare os espaços iniciais e finais usando o método trim () -, adicione aspas. O Powershell imprimirá seqüências de caracteres no console como comportamento padrão.

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

Experimente online!

A sequência de entrada contém aspas incorporadas. Remova o Qpara 14 bytes se a cadeia de entrada não contém citações embutidas, como é feito em alguns dos outros respostas aqui.

Sinalizadores de expansão de parâmetro: Qdequotes, depois se zdividem em palavras como o shell. As palavras são então implicitamente unidas por espaços.

Carriça , 56 bytes

Esperar. A substituição faz apenas uma vez ? Agora eu tenho que usar o combo split-join.

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

Experimente online!

Explicação

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

' '%' '*

Experimente online!

Explicação

A lógica é bastante simples:

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

Python2, 28 bytes

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

Explicação

lambda s

Função anônima que recebe como entrada s.

s.split()

Retorna uma lista das palavras (que são separadas por seqüências arbitrárias de caracteres de espaço em branco) da sequência s.

" ".join(...)

Junta a lista novamente a uma sequência, com cada palavra separada por um espaço ("").