Ah, otro de mis usos egoístas de esta pila .

Como propietario de un Chromebook, soy un usuario frecuente de Ace IDE, el editor utilizado por Cloud9. Tiene muchas herramientas para lidiar con el exceso de espacios en blanco, pero carece notablemente de una: borrar líneas vacías.

Su misión hoy es, dada una entrada desde un lugar donde puedo copiar y pegar en [ ;)], generar algo idéntico, guardar todos los espacios y tabuladores en líneas vacías.

Daré algunos ejemplos, con #s que representan caracteres de espacios en blanco que se eliminarán.

ENTRADA 1:

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

SALIDA:

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

SALIDA:

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);

SALIDA:

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

Puede procesar la entrada como quiera. Salida donde sea, siempre que pueda copiar y pegar de él [ ;)].

Se aplican lagunas estándar, gana la respuesta más corta en bytes.

Japt , 10 8 6 5 4 bytes

mx1R

Pruébalo en línea!

Explicación

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

Entonces mx1Rdivide la cadena por la Rcual es una nueva línea, recorta el lado derecho de cada línea usando x1y une las cadenas nuevamente con una nueva línea.

Ahorró 2 bytes gracias a ETHproductions.

Retina , 5 bytes

%G`\S

Pruébalo en línea!

Un enfoque no tan obvio nos recompensa con una mejor puntuación :)

Explicación

Gindica esto como una etapa Grep, manteniendo solo aquellas líneas donde se puede encontrar una coincidencia con la expresión regular dada ( \S, coincide con caracteres que no son espacios). Si no fuera por el comienzo, %esto eliminaría completamente las líneas en lugar de simplemente "vaciarlas".

El %es un modificador que aplica la etapa una vez a cada línea y luego une los resultados con nuevas líneas: en nuestro caso, esto significa que la cadena vacía devuelta por Grep para líneas de espacio en blanco se convertirá en una línea vacía en el resultado.

sed , 6 bytes

/\S/!g

Pruébalo en línea!

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

Pruébalo en línea!

Explicación:

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

¡No entiendo por qué esto está recibiendo tantos votos positivos!

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

Intentalo

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]

La entrada y la salida son matrices de cadenas. Unete'\n' .

Para el programa original que encadena las E / S:

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

Pruébalo en línea!

¡Guardado 8 bytes gracias a @Rod!
¡Ahorró 19 bytes gracias a @LeakyNun!

CJam , 18 16 bytes

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

Tenga en cuenta que la cadena contiene 1 espacio y 1 pestaña.

Pruébalo en línea!

Explicación

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+$

Un desafío realmente inútil. mlo hace multilínea (ignora la nueva línea). \scoincide con el espacio y la pestaña.

Pruébalo en línea!

Vim, 20 18 16 13 10 bytes

De ninguna manera soy un experto de Vim, pero esta pregunta necesita una respuesta de Vim.

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

<cr> Es un retorno de carro.

Registro de cambios:

• :norm en lugar de :normal (-2 bytes)
• Cambiar a en *lugar de +significa que haremos coincidir las líneas ya vacías, pero eso no importa. Y ahora podemos deshacernos de \v( muy mágico opción ) (-2 bytes)
• Nuevo enfoque: en lugar de reemplazar cada línea que coincide con una línea vacía, reemplazamos cada línea que no tiene caracteres que no son espacios en blanco con una línea vacía. (-3 bytes)
• En realidad, un reemplazo normal es más corto (gracias, @DJMcMayhem) (-3 bytes)

AWK , 12 11 bytes

!NF{$0=""}1

Pruébalo en línea!

Solo sentía que AWK debería tener una respuesta también

Funciona por:

1. Comprobando si no hay campos en la entrada. AWK por defecto usa todos los espacios en blanco como separador entre campos
2. Si no hay campos, cambie la línea de entrada a una cadena vacía
3. Imprime la línea. Como 1 es un valor verdadero, ejecuta el comando predeterminado que imprime la línea

APL (Dyalog) , 11 10 bytes

'\s+$'⎕R''

⎕Res un operador que deriva una función que reemplaza cosas. En este caso, todo lo que coincida con el RegEx se reemplaza con una cadena vacía.

Ruby, 22 bytes

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

Solución directa de expresiones regulares

Java 7, 57 bytes

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

Explicación:

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 de prueba:

Pruébalo aquí

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+$$//}

Intentalo

{         # 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+$$//'

En gran medida lo mismo que arriba.

• -pejecuta el código para cada línea de entrada, coloca la línea $_e imprime lo que queda en$_ .
• s reemplaza en el lugar, mientras que S devuelve el resultado.
• No hay necesidad de :g/ :globalas -pse encarga de eso.

Python 2 , 26 bytes

lambda l:map(str.rstrip,l)

Pruébalo en línea!Entradas y salidas de una lista de cadenas.

Esto aprovecha la decisión en los comentarios de que los espacios en blanco finales pueden eliminarse en líneas no vacías.

Vim, 13 9 bytes

:v/\S/le↵

Ediciones:

• Respuesta original: :v/\S/d↵(basada en esta pregunta vim sobre SO ).
  Elimina líneas vacías, que no es el comportamiento esperado.

• Respuesta válida con vglobal ::v/\S/norm D↵

• Ahora usando el comando ex alinear a la izquierda en lugar 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);}

Detallado

#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));}

Véalo trabajar en línea .

QuadR , 5 bytes

\s+$

Pruébalo en línea!

\s+ reemplazar uno o más espacios en blanco seguidos de
$  final de la línea

 sin nada