Retirando espaços extras de uma sequência

12

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.

Spikatrix
fonte
1
Você diz must take input from stdin, e depois você diz ...or a function which takes input, and outputs the final string. Isso significa que a função também deve receber informações stdin?
Blotange
@blutorange, Sim. Editado para esclarecer.
Spikatrix
2
" "aa" "-> ""aa""(são citações válidas dentro da cadeia de entrada?)
edc65
@ edc65, bom argumento. A resposta para isso é não. Editado para esclarecer.
Spikatrix
Por favor, veja o comentário do MickeyT na minha resposta. O que ele propõe é válido? Em R, os resultados retornados são impressos implicitamente, mas na minha resposta eu imprimi explicitamente no stdout.
Alex A.

Respostas:

12

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

Optimizer
fonte
10

/// : 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"
homem a trabalhar
fonte
Tecnicamente, você não está aceitando informações. ;) Existe essa linguagem, mas a leitura de entrada ainda é uma dor, eu acho.
Martin Ender
6

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.

r3mainer
fonte
1
mesma solução:sed -E 's/ +/ /g;s/" | "/"/g'
izabera 20/05
3
O mesmo ocorre com 12 bytes na Retina . :)
Martin Ender
-pimplica -nque você só precisa aplicar uma penalidade de +1 aqui (supondo que você não mude apenas para um idioma diferente, como sugerem os outros comentaristas).
4

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:

insira a descrição da imagem aqui

Sheharyar
fonte
1
Você pode substituir ARGVpor $*salvar dois bytes. gsub /\s+/, ' 'pode ser substituído com squeeze ' 'por mais 4 bytes
DickieBoy
@ RickieBoy, obrigado por $*, eu não sabia disso. Mas não podemos substituir gsub /\s+/, ' 'por, squeezeporque eles não são os mesmos .
Sheharyar
O que você quer dizer com "não é o mesmo"? As saídas são as mesmas.
22715 DickieBoy
1
squeeze ' 'apenas espremerá espaços. "yellow moon".squeeze "l" => "yelow moon"
22715 DickieBoy
2
Pessoalmente eu sou. E alguns outros respondedores também. Mas, a meu ver, nem você está sozinho com sua interpretação ... Um esclarecimento do proprietário da pergunta seria bem-vindo. A propósito, tanto o espaço entre pcomo seu parâmetro squeezee seu parâmetro são desnecessários.
Manatwork
4

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
Tyilo
fonte
Você pode usar em Nvez de\"
Ypnypn
Bem-vindo ao Pyth, Tylio. O segundo programa pode ser limitado pelo uso de d.
Isaacg
@isaacg Eu já não usei dtudo o que pode ser usado?
Tyilo
@ Tyilo Acho que você fez uma edição na mesma época que comentei. Está tudo bem agora.
Isaacg 22/05
Você pode usar ppara salvar alguns bytes na concatenação de cadeias, em vez de muitas +es. pjd-cQdkNN
FryAmTheEggman
3

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.

Deltik
fonte
2
Uau! Isso é complicado. Infelizmente, não lida com o caso de teste 4, mas ainda é impressionante.
manatwork
Sim, esse código atende ao quarto caso de teste e é mais curto.
Deltik
Você pode fazer algo assim? x=xargs;$x|$x|$x -i echo '"{}"'
Cyoce 01/09/19
@Cyoce: Você realmente poderia fazer isso para economizar um byte ao custo de perder a funcionalidade do pipe. Ainda não é tão curto quanto esta solução e ainda não satisfaz o quarto caso de teste.
Deltik 01/09/17
3

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.

nimi
fonte
Estou recebendo Parse error: naked expression at top levelquando testei os dois códigos aqui
Spikatrix
@CoolGuy: rextester.com espera programas inteiros, não funções, então tente main=interact$show.unwords.words.read. Há um REPL on-line na fachada do haskell.org (requer cookies ativados) onde você pode tentar fmap(unwords.words.read)getLine.
nimi
1
fmap(unwords.words)readLne print.unwords.words=<<readLnsão um pouco mais curtos.
Lynn
@Mauris: obrigado por apontar readLn.
nimi 23/05
2

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 -"
Alex A.
fonte
Não tenho certeza se ele cumpre totalmente as regras, mas o gato pode não ser totalmente necessário, apenas o gsub. A saída disso é[1] "This is a string"
MickyT 20/05
@MickyT: Obrigado pela sugestão. Minha interpretação com base no comentário do OP (primeiro no post) foi que ele tinha que ser impresso em stdout. Vou pedir esclarecimentos.
Alex A.
Ahhh ... não vi esse comentário ou requisito #
MickyT
2

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:

Captura de tela de casos de teste

user12205
fonte
Eu realmente queria usar print" ".join(raw_input().split()), mas teria um espaço à direita no interior da última aspa se houvesse espaços após a última palavra ...
mbomb007
Você pode cortar um byte extra usando% de formatação: print '"% s"'% '' .join (input (). Split ())
ygramul
2

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

edc65
fonte
alert(`"${eval(prompt()).match(/\S+/g).join(" ")}"`) - 52
Otimizador
@Optimizer thx. Observe que isso só funciona após o último esclarecimento sobre as aspas: eval ('"" "')
falharia
Quando testei o quarto caso de teste (usando o chrome), nenhum pop-up (que mostra o resultado) é visto. Por quê?
Spikatrix # 21/15
@CoolGuy talvez porque o Chrome não execute o ES6? Eu nunca testei o ES6 com o Chrome. Enfim, eu tentei agora no meu Chrome (42.0.2311.152) e funciona para mim.
edc65
-3:alert(`"${prompt().match(/[^ "]+/g).join(" ")}"`)
nderscore 23/05
2

05AB1E , 9 bytes

#õKðý'".ø

Experimente online!


#         | Split on spaces.
 õK       | Remove empty Strings.
   ðý     | Join with spaces.
     '".ø | Surround with quotes.
Urna de polvo mágico
fonte
1

Mathematica, 75 bytes

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

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 -"
WooiKent Lee
fonte
1

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)
Kevin Cruijssen
fonte
1

Perl 5 , 17 bytes

16 bytes de código + 1 para -p

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

Experimente online!

Xcali
fonte
1

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

jq170727
fonte
Eu peguei o problema de saída anteriormente (consulte a edição 5), mas não percebi o problema de entrada. O comando está corrigido agora. Obrigado!
precisa saber é o seguinte
1

Tcl , 69 bytes

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

Experimente online!

Tcl , 79 bytes

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

Experimente online!

sergiol
fonte
@KevinCruijssen Fixed. infelizmente, à custa de muitos bytes. Tks por me dizer.
sergiol 22/09
0

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)
Kyle Kanos
fonte
0

Cobra - 68

Como uma função anônima:

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

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];
}
Fennelouski
fonte
0

Bash, 14 bytes

read f;echo $f       # assume f="this  is  a    string   "
michael501
fonte
1
Que tal assumir "foo * bar" ou qualquer outra coisa com um caractere curinga?
manatwork 23/05
0

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.

tanto faz
fonte
0

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
rabisco
fonte
0

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.

GammaFunction
fonte
0

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

fonte
0

GolfScript , 8 bytes

' '%' '*

Experimente online!

Explicação

A lógica é bastante simples:

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

fonte
-1

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

Triggernometria
fonte
2
Isso parece dar resultados incorretos em relação aos espaços iniciais e finais. Observe que no estado de desafio você deve pegar a entrada com aspas duplas e também produzi-las com aspas duplas. Eu também errei no começo, até reler o desafio.
Kevin Cruijssen