Ah, mais um dos meus usos egoístas dessa pilha .

Como proprietário de um Chromebook, sou um usuário frequente do Ace IDE, o editor usado pelo Cloud9. Ele tem muitas ferramentas para lidar com o excesso de espaço em branco, mas notavelmente falta uma: limpar linhas vazias.

Sua missão hoje é, dada a entrada de um lugar para onde eu posso copiar e colar [ ;)], produzir algo idêntico, salvar todos os espaços e tabuladores em linhas vazias.

Vou dar alguns exemplos, com #s representando caracteres de espaço em branco a serem removidos.

ENTRADA 1:

if (this.Color !== 'blue') {
##
  this.Color = 'blue';
}

RESULTADO:

if (this.Color !== 'blue') {
[empty line]
  this.Color = 'blue';
}

ENTRADA 2:

function outputSomething(times) {
  for (var iter = 0; iter < times; iter++) {
    console.log('"# # " represents a tabulator');
    // This is a comment
# # 
}}

RESULTADO:

function outputSomething(times) {
  for (var iter = 0; iter < times; iter++) {
    console.log('"# # " represents a tabulator');
    // This is a comment
[empty line]
}}

ENTRADA 3:

var x = 'Do you prefer spaces or tabs?';
var y = 'I\'m using both here. Sue me.';
# # ####
console.log(x + ' ' + y);

RESULTADO:

var x = 'Do you prefer spaces or tabs?';
var y = 'I\'m using both here. Sue me.';
[empty line]
console.log(x + ' ' + y);

Você pode processar a entrada como quiser. Saída em qualquer lugar, desde que eu possa copiar e colar a partir dele [ ;)].

As brechas padrão se aplicam, a resposta mais curta em bytes ganha!

Japonês , 10 8 6 5 4 bytes

mx1R

Experimente online!

Explicação

(from the Japt docs)
.m(f,s=""):
Splits this with s, maps each item by f, then rejoins with s.

Então, mx1Rdivide a string pela Rqual é uma nova linha, corta o lado direito de cada linha usando x1e junta as strings novamente com uma nova linha.

Economizou 2 bytes graças ao ETHproductions.

Retina , 5 bytes

%G`\S

Experimente online!

Uma abordagem não tão óbvia nos recompensa com uma pontuação melhor :)

Explicação

Gindica isso como um estágio Grep, mantendo apenas as linhas em que uma correspondência com a expressão regular fornecida ( \S, corresponde a caracteres não espaciais) pode ser encontrada. Se não fosse o começo, %isso removeria completamente as linhas em vez de apenas "esvaziá-las".

O %é um modificador que aplica o estágio uma vez a cada linha e, em seguida, junta os resultados com novas linhas: no nosso caso, isso significa que a string vazia retornada pelo Grep para linhas somente em espaço em branco se tornará uma linha vazia no resultado.

sed , 6 bytes

/\S/!g

Experimente online!

/  /!  # If the line doesn't contain...
 \S    # anything non-whitespace (i.e. the entire line is whitespace)
     g #   replace the pattern space with the hold space which is empty

V , 5 , 4 bytes

ÇÓ/D

Experimente online!

Explicação:

Ç       " On every line not matching the following regex:
 Ó/     "   a non-whitespace character...
   D    "   Delete the whole line

Hexdump:

00000000: c7d3 2f44                                ../D

JavaScript (ES6), 26 bytes

Não entendo por que isso está recebendo tantos votos positivos!

s=>s.replace(/^\s+$/gm,``)

Tente

f=
s=>s.replace(/^\s+$/gm,``)
i.addEventListener("input",_=>o.innerText=f(i.value))

<textarea id=i></textarea><pre id=o>

Python 3 , 63 55 36 bytes

lambda s:[x.strip()and x for x in s]

Entrada e saída são matrizes de strings. Participe '\n'.

Para o programa original que as cadeias de E / S:

lambda s:'\n'.join(x.strip()and x for x in s.split('\n'))

Experimente online!

Economizou 8 bytes graças a @Rod!
Guardou 19 bytes graças a @LeakyNun!

CJam , 18 16 bytes

qN/{_" 	"-\e&N}%

Observe que a sequência contém 1 espaço e 1 guia.

Experimente online!

Explicação

q                 e# Read the input
 N/               e# Split it on newlines
   {              e# Apply this block to each line:
    _             e#  Copy the line
     "  "-        e#  Remove all spaces and tabs from the copy
          \       e#  Bring the original to the top of the stack
           e&     e#  Logical AND; returns the original line if the copy is truthy 
                  e#    (non-empty), otherwise returns the copy line
             N    e#  Push a newline after the line
              }%  e# (end of block)

Retina , 8 bytes

m`^\s+$

Um desafio realmente inútil. mtorna a multilinha (ignora a nova linha). \scorresponde ao espaço e à guia.

Experimente online!

Vim, 20 18 16 13 10 bytes

Eu não sou um especialista em Vim, mas essa pergunta precisa de uma resposta em Vim.

:%s/^\s*$<cr>

<cr> é um retorno de carro.

Changelog:

• :norm ao invés de :normal (-2 bytes)
• Mudar para em *vez de +significa que já corresponderemos a linhas vazias, mas isso não importa. E agora podemos nos livrar de \v( opção muito mágica ) (-2 bytes)
• Nova abordagem: em vez de substituir todas as linhas correspondentes a uma linha vazia, substituímos todas as linhas que não possuem caracteres que não sejam espaços em branco por uma linha vazia. (-3 bytes)
• Na verdade, uma substituição normal é mais curta (obrigado, @DJMcMayhem) (-3 bytes)

AWK , 12 11 bytes

!NF{$0=""}1

Experimente online!

Eu estava apenas sentindo que o AWK deveria ter uma resposta também

Funciona por:

1. Verificando se não há campos na entrada. Por padrão, o AWK usa todo o espaço em branco como separador entre os campos
2. Se não houver campos, altere a linha de entrada para uma sequência vazia
3. Imprima a linha. Como 1 é um valor verdadeiro, ele executa o comando padrão que está imprimindo a linha

APL (Dyalog) , 11 10 bytes

'\s+$'⎕R''

⎕Ré um operador que deriva uma função que substitui coisas. Nesse caso, qualquer coisa correspondida pelo RegEx é substituída por uma sequência vazia.

Ruby, 22 bytes

->s{s.gsub /^\s+$/,''}

Solução simples de regex

Java 7, 57 bytes

String c(String s){return s.replaceAll("(?m)^\\s+$","");}

Explicação:

String c(String s){     // Method with String parameter and String return-type
  return s.replaceAll(  //  Return the input String after we've replaced
    "(?m)^\\s+$",       //  all lines only containing whitespaces
    "");                //  with empty Strings
                        //    (NOTE: `(?m)` enables multiline regex)
}                       // End of method

Código do teste:

Experimente aqui.

class M{
  static String c(String s){return s.replaceAll("(?m)^\\s+$","");}

  public static void main(String[]a){
    System.out.println(c("if (this.Color !== 'blue') {\n \t\n  this.Color = 'blue';\n}"));
    System.out.println();
    System.out.println(c("function outputSomething(times) {\n  for (var iter = 0; iter < times; iter++) {\n    console.log('\"# # \" represents a tabulator');\n    // This is a comment\n  \t\n}}"));
    System.out.println();
    System.out.println(c("var x = 'Do you prefer spaces or tabs?';\nvar y = 'I\'m using both here. Sue me.';\n    \t\t\t \nconsole.log(x + ' ' + y);"));
  }
}

Groovy, 31 bytes

{it.replaceAll(/\n\s+\n/,"\n")}

Perl 6 ,  15  12 bytes

15

{S:g/^^\h+$$//}

Tente

{         # bare block lambda with implicit parameter ｢$_｣

  S       # string replace (implicitly against ｢$_｣)
  :global # globally
  /
    ^^    # match beginning of line
      \h+ # match at least one horizontal whitespace
    $$    # match end of line

  //      # replace with nothing
}

11 + 1

perl6 -pe 's/^^\h+$$//'

Principalmente o mesmo que acima.

• -pexecuta o código para cada linha de entrada, colocando a linha $_e imprimindo o que resta $_.
• ssubstitui no local, enquanto Sretorna o resultado.
• Não há necessidade de :g/ :globalcomo -pcuida disso.

Python 2 , 26 bytes

lambda l:map(str.rstrip,l)

Experimente online! Insere e gera uma lista de strings.

Isso tira proveito da decisão nos comentários de que o espaço em branco à direita pode ser removido em linhas não vazias.

Vim, 13 9 bytes

:v/\S/le↵

Editar% s:

• Resposta original: :v/\S/d↵(com base nesta pergunta do vim no SO ).
  Exclui linhas vazias, que não são o comportamento esperado.

• Resposta válida usando vglobal ::v/\S/norm D↵

• Agora, usando o comando ex de alinhamento à esquerda em vez denormal D

C, 168 bytes

#define P putchar(*t++)
s;e(char*t){s=0;while(*t>10)if(*t!=32|*t!=9)return 0;else t++,s++;return s;}
r(char*t){while(*t==10)P;if(!*t)return;if(!e(t))while(*t)P;t+=e(t);}

Detalhado

#include <stdio.h>

int e (char * t)
{
    int s = 0;

    // till the end of the line
    while (*t!='\0' && *t!='\n')
        // if it's not a space
        if (*t!=' ' || *t!='    ')
            // ignore the line
            return 0;
        else
            // count the space
            t++, s++;

    // return number of spaces
    return s;
}

void r (char * t)
{
    // skip to empty lines
    while (*t != '\0' && *t == '\n') putchar('\n'), t++;

    // stop at end of string
    if (*t == '\0') return;

    // if there is contnet print it
    if (!e(t)) while(*t != '\0') putchar(*t), t++;

    // skip to the end of line
    t += e(t);
}

int main (int argc, char**argv)
{
    if (argc > 1) r(argv[1]);
    putchar('\n');
    return 0;
}

C, 100 bytes

c,i,j;f(char*s){for(i=j=c=0;s[i];s[++j]^10?c=s[j]^32:(printf(!c?"\n":"%.*s",j-i+1,s+i),c=0,i=j+1));}

Veja como funciona online .

QuadR , 5 bytes

\s+$

Experimente online!

\s+ substitua um ou mais caracteres de espaço em branco seguidos por
$  final da linha

 com nada