Ti viene data una stringa. Emette la stringa con uno spazio per parole.

Sfida

L'input sarà una stringa (non nullo vuota), racchiusa tra virgolette ( ") inviate tramite stdin. Rimuovi gli spazi iniziali e finali da esso. Inoltre, se ci sono più di uno spazio tra due parole (o simboli o altro), taglialo in un solo spazio. Emette la stringa modificata con le virgolette.

Regole

• La stringa non sarà più lunga di 100 caratteri e conterrà solo caratteri ASCII nell'intervallo (spazio) da ~(tilde) (codici carattere da 0x20 a 0x7E, inclusi) tranne ", ad esempio, la stringa non conterrà virgolette ( ") e altri caratteri al di fuori del intervallo sopra specificato. Vedere la tabella ASCII per riferimento.
• Devi prendere input dalla stdin(o alternativa più vicina).
• L'output deve contenere virgolette ( ").
• È possibile scrivere un programma completo o una funzione che accetta input (da stdin) e genera la stringa finale

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

punteggio

Questo è il golf del codice, quindi vince l'invio più breve (in byte).

CJam, 7 byte

q~S%S*p

Spiegazione del codice

CJam ha riservato tutte le lettere maiuscole come variabili integrate. Quindi Sha un valore di uno spazio qui.

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.

Questo rimuove anche gli spazi iniziali e finali

Provalo online qui

/// : 18 caratteri

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

Esecuzione di esempio:

(Usando l'interprete di Faubiguy dalla sua risposta in Perl per Interpret /// (pronunciato 'barre') .)

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

Perl, 22

(20 byte di codice, più 2 opzioni della riga di comando)

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

Deve essere eseguito con l' -npinterruttore in modo che $_venga automaticamente riempito tramite stdin e stampato su stdout. Presumo che questo aggiunge 2 al conteggio dei byte.

Rubino, 31 29 25 23 byte

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

Spiegazione del codice:

• pgenera una stringa tra virgolette doppie STDOUT( C'è di più però ...)
• $*è un array di STDINinput, $*[0]prende il primo
• strip rimuove gli spazi iniziali e finali
• squeeze ' ' sostituisce> 1 caratteri spazio con un singolo spazio

Casi test:

Pyth, 17 15 11 10 byte

(grazie a Ypnypn e FryAmTheEggman )

pjd-cQdkNN

Probabilmente potrebbe essere più giocato a golf.

Se l'output può essere utilizzato 'invece di "allora ho bisogno solo di 8 byte:

`jd-cQdk

Bash, 36 32 byte

Come funzione, programma o semplicemente in una pipe:

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

Spiegazione

Il primo xargsrimuove le virgolette.

Il secondo xargstaglia il lato sinistro e sostituisce più spazi adiacenti nel mezzo della stringa con uno spazio prendendo ogni "parola" e separandoli con uno spazio.

La xargs -i echo '"{}"'taglia il lato destro e riavvolge la stringa risultante tra virgolette.

Haskell, 31 25 byte

fmap(unwords.words)readLn

wordsdivide la stringa in un elenco di stringhe con spazi come delimitatori e unwordsunisce l'elenco di stringhe con un singolo spazio in mezzo. Le virgolette "vengono rimosse e ripristinate dalle funzioni di Haskell reade show(implicitamente tramite REPL) sulle stringhe.

L'output della funzione stessa è più lungo di tre byte, ovvero 28 byte:

print.unwords.words=<<readLn

Modifica: @Mauris ha indicato la readLnfunzione, che ha salvato alcuni byte.

R, 45 byte

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

La readline()funzione legge da STDIN, eliminando automaticamente qualsiasi spazio bianco iniziale e finale. Lo spazio in eccesso tra le parole viene rimosso usando gsub(). Infine, le doppie virgolette vengono anteposte e aggiunte e il risultato viene stampato su STDOUT.

Esempi:

> 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

Ridotto di 1 byte grazie a @ygramul.

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

Versione originale:

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

Casi test:

JavaScript (ES6), 49 52 58

Modifica 6 byte in meno, grazie a @Optimizer

Modifica 2-3, grazie a @nderscore

Ingresso / uscita tramite popup. Utilizzo della stringa di modello per tagliare 1 byte nella concatenazione di stringhe.

Esegui lo snippet per testare in Firefox.

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

05AB1E , 9 byte

#õKðý'".ø

Provalo online!

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

Mathematica, 75 byte

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

KDB (Q), 28 byte

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

Spiegazione

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

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

Spiegazione:

Provalo qui.

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)

Ottava , 44 byte

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

Provalo online!

Perl 5 , 17 byte

16 byte di codice + 1 per -p

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

Provalo online!

Jq 1,5 , 42 byte

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

Esecuzione del campione

$ 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

Provalo online

Tcl , 69 byte

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

Provalo online!

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

Provalo online!

Japt -Q , 10 4 byte

¸f ¸

Provalo

golfua, 42 byte

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

Semplice sostituzione della corrispondenza del modello: trova le doppie virgolette ( \") racchiuse tra 0 o più spazi ( %s*) e restituisce la virgoletta singola, quindi sostituisci tutti gli 1 o più spazi ( %s+) con un singolo spazio.

Un equivalente di Lua sarebbe

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

Cobra - 68

Come una funzione anonima:

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

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

Versione non compressa:

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

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

Powershell, 40 byte

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

Abbastanza diretto e non molto impressionante.

Spiegazione

Prendi il parametro di input tramite args (predeterminato) variabile, sostituisci tutti gli spazi multipli con uno, taglia gli spazi iniziali e finali usando il metodo trim (), aggiungi virgolette. Powershell stamperà le stringhe per la console come comportamento predefinito.

k4, 23 byte

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

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

Provalo online!

La stringa di input contiene virgolette incorporate. Rimuovi Qper 14 byte se la stringa di input non contiene virgolette incorporate, come avviene in alcune delle altre risposte qui.

QFlag di espansione dei parametri: dequote, quindi si zdivide in parole come fa la shell. Le parole sono quindi implicitamente unite da spazi.

Wren , 56 byte

Aspettare. La sostituzione lo fa solo una volta ? Ora devo usare la combinazione split-join.

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

Provalo online!

Spiegazione

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 byte

' '%' '*

Provalo online!

Spiegazione

La logica è abbastanza semplice:

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

Python2, 28 byte

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

Spiegazione

lambda s

Funzione anonima che accetta come input s.

s.split()

Restituisce un elenco delle parole (che sono separate da stringhe arbitrarie di caratteri bianchi) della stringa s.

" ".join(...)

Elenco dei join in una stringa, con ogni parola separata da uno spazio ("").