Te dan una cuerda. Salida de la cadena con un espacio por palabra.

Desafío

La entrada será una cadena (no nullo vacía), rodeada de comillas ( ") enviadas a través de stdin. Elimine los espacios iniciales y finales de él. Además, si hay más de un espacio entre dos palabras (o símbolos o lo que sea), recórtelo a un solo espacio. Salida de la cadena modificada con las comillas.

Reglas

• La cadena no tendrá más de 100 caracteres y solo contendrá caracteres ASCII en el rango (espacio) a ~(tilde) (códigos de caracteres 0x20 a 0x7E, inclusive) excepto ", es decir, la cadena no contendrá comillas ( ") y otros caracteres fuera del rango especificado anteriormente. Consulte la tabla ASCII para referencia.
• Debe tomar la entrada de stdin(o la alternativa más cercana).
• La salida debe contener comillas ( ").
• Puede escribir un programa completo, o una función que toma la entrada (desde stdin) y emite la cadena final

Casos de prueba

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

Puntuación

Este es el código de golf, por lo que gana el envío más corto (en bytes).

CJam, 7 bytes

q~S%S*p

Explicación del código

CJam ha reservado todas las letras mayúsculas como variables incorporadas. Entonces Stiene un valor de un espacio aquí.

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.

Esto elimina los espacios iniciales y finales también

Pruébalo en línea aquí

/// : 18 caracteres

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

Ejecución de muestra:

(Usando el intérprete de faubiguy de su respuesta Perl para Interpretar /// (pronunciado 'barras') .)

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

Perl, 22

(20 bytes de código, más 2 interruptores de línea de comando)

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

Debe ejecutarse con el -npinterruptor para que $_se llene automáticamente mediante stdin y se imprima en stdout. Voy a suponer que esto agrega 2 al recuento de bytes.

Rubí, 31 29 25 23 Bytes

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

Explicación del código:

• pemite una cadena entre comillas dobles para STDOUT( Sin embargo, hay más ...)
• $*es una matriz de STDINentradas, $*[0]toma la primera
• strip elimina espacios iniciales y finales
• squeeze ' ' reemplaza> 1 espacio de caracteres con un solo espacio

Casos de prueba:

Pyth, 17 15 11 10 bytes

(gracias a Ypnypn y FryAmTheEggman )

pjd-cQdkNN

Probablemente podría jugar más golf.

Si la salida puede usarse en 'lugar de "eso, solo necesito 8 bytes:

`jd-cQdk

Bash, 36 32 bytes

Como una función, un programa o simplemente en una tubería:

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

Explicación

El primero xargselimina las comillas.

El segundo xargsrecorta el lado izquierdo y reemplaza múltiples espacios adyacentes en el medio de la cadena con un espacio tomando cada "palabra" y separando cada uno con un espacio.

El xargs -i echo '"{}"'recorta el lado derecho y rewraps la cadena resultante entre comillas dobles.

Haskell, 31 25 bytes

fmap(unwords.words)readLn

wordsdivide la cadena en una lista de cadenas con espacios como delimitadores y se unwordsune a la lista de cadenas con espacios individuales en el medio. Las comillas "son eliminadas y puestas de nuevo por las funciones de Haskell ready show(implícitamente a través de REPL) en las cadenas.

La salida de la función en sí es tres bytes más larga, es decir, 28 bytes:

print.unwords.words=<<readLn

Editar: @Mauris señaló la readLnfunción, que ahorró algunos bytes.

R, 45 bytes

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

La readline()función lee desde STDIN, eliminando automáticamente cualquier espacio en blanco inicial y final. El exceso de espacio entre palabras se elimina con gsub(). Finalmente, las comillas dobles se anteponen y anexan y el resultado se imprime en STDOUT.

Ejemplos:

> 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

Reducido en 1 byte gracias a @ygramul.

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

Versión original:

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

Casos de prueba:

JavaScript (ES6), 49 52 58

Editar 6 bytes más cortos, gracias a @Optimizer

Editar 2 -3, gracias a @nderscore

Entrada / salida a través de una ventana emergente. Usando cadena de plantilla para cortar 1 byte en concatenación de cadena.

Ejecute el fragmento para probar en Firefox.

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

05AB1E , 9 bytes

#õKðý'".ø

Pruébalo en línea!

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

Explicación

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

Prueba

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

Explicación:

Pruébalo aquí.

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)

Octava , 44 bytes

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

Pruébalo en línea!

Perl 5 , 17 bytes

16 bytes de código + 1 para -p

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

Pruébalo en línea!

Jq 1.5 , 42 bytes

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

Ejecución de muestra

$ 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

Pruébalo en línea

Tcl , 69 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Japt -Q , 10 4 bytes

¸f ¸

Intentalo

golfua, 42 bytes

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

Reemplazo simple de coincidencia de patrones: encuentre comillas dobles (\" ) rodeadas por 0 o más espacios ( %s*) y devuelva la comilla simple, luego reemplace los 1 o más espacios ( %s+) con un solo espacio.

Un equivalente de Lua sería

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

Cobra - 68

Como una función 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];}

Versión sin comprimir:

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

Bastante sencillo y no muy impresionante.

Explicación

Tome el parámetro de entrada a través de la variable args (predefinida), reemplace todos los espacios múltiples con uno, recorte los espacios iniciales y finales utilizando el método trim (), agregue comillas. Powershell imprimirá cadenas a la consola como comportamiento predeterminado.

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

Pruébalo en línea!

La cadena de entrada contiene comillas incrustadas. Elimine los Qde 14 bytes si la cadena de entrada no contiene comillas incrustadas, como se hace en algunas de las otras respuestas aquí.

QIndicadores de expansión de parámetros: se indican con comillas, luego se zdividen en palabras como lo hace el shell. Las palabras se unen implícitamente por espacios.

Wren , 56 bytes

Espere. El reemplazo solo lo hace una vez ? Ahora tengo que usar el combo split-join.

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

Pruébalo en línea!

Explicación

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

' '%' '*

Pruébalo en línea!

Explicación

La lógica es bastante simple:

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

Python2, 28 bytes

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

Explicación

lambda s

Función anónima que toma como entrada s.

s.split()

Devuelve una lista de las palabras (que están separadas por cadenas arbitrarias de caracteres de espacios en blanco) de la cadena s.

" ".join(...)

Une la lista nuevamente en una cadena, con cada palabra separada por un espacio ("").