Ach, jeszcze jedno z moich samolubnych zastosowań tego Stosu .

Będąc właścicielem Chromebooka, jestem częstym użytkownikiem Ace IDE, edytora używanego przez Cloud9. Ma wiele narzędzi do radzenia sobie z nadmiarem białych znaków, ale brakuje mu jednego: usuwania pustych linii.

Twoja dzisiejsza misja polega na tym, że biorąc pod uwagę dane z miejsca, które mogę skopiować i wkleić do [ ;)], wypisać coś identycznego, zapisać wszystkie spacje i tabulatory na pustych liniach.

Podam kilka przykładów, gdzie #s oznacza białe znaki do usunięcia.

WEJŚCIE 1:

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

WYNIK:

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

WEJŚCIE 2:

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

WYNIK:

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

WEJŚCIE 3:

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

WYNIK:

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

Możesz przetwarzać dane wejściowe w dowolny sposób. Wyjście gdziekolwiek, o ile mogę z niego skopiować i wkleić [ ;)].

Obowiązują standardowe luki, wygrywa najkrótsza odpowiedź w bajtach!

Japt , 10 8 6 5 4 bajtów

mx1R

Wypróbuj online!

Wyjaśnienie

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

Więc mx1Rdzieli ciąg, przez Rktóry jest nowy wiersz, przycina prawą stronę każdej linii za pomocąx1 i ponownie łączy ciągi z nową linią.

Zaoszczędzono 2 bajty dzięki produktom ETH.

Siatkówka , 5 bajtów

%G`\S

Wypróbuj online!

Nie tak oczywiste podejście nagradza nas lepszym wynikiem :)

Wyjaśnienie

Gwskazuje to jako etap Grepa, zachowując tylko te wiersze, w których można znaleźć dopasowanie do podanego wyrażenia regularnego ( \S, pasuje do znaków spacji). Gdyby nie było na początku %, całkowicie usunęłoby to linie zamiast po prostu je „opróżniło”.

%To modyfikator, który odnosi się do stadium po każdym wierszu, a następnie dołącza do wyników z nowymi liniami: W naszym przypadku oznacza to, że pusty ciąg zwracany przez Grep dla białych linii tylko stanie się pusta linia w wyniku.

sed , 6 bajtów

/\S/!g

Wypróbuj 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 bajty

ÇÓ/D

Wypróbuj online!

Wyjaśnienie:

Ç       " 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 bajtów

Nie rozumiem, dlaczego jest tak dużo entuzjastów!

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

Spróbuj

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 bajtów

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

Dane wejściowe i wyjściowe są tablicami ciągów. Dołącz'\n' .

W przypadku oryginalnego programu, który ciągi We / Wy:

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

Wypróbuj online!

Zaoszczędź 8 bajtów dzięki @Rod!
Zaoszczędź 19 bajtów dzięki @LeakyNun!

CJam , 18 16 bajtów

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

Zauważ, że ciąg zawiera 1 spację i 1 tabulator.

Wypróbuj online!

Wyjaśnienie

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

A really pointless challenge. m makes it multiline (ignores newline). \s matches both space and tab.

Try it online!

Vim, 20 18 16 13 10 bytes

I am by no means a Vim expert, but this question needs a Vim answer.

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

<cr> is a carriage return.

Changelog:

• :norm instead of :normal (-2 bytes)
• Switching to * instead of + means we will match already empty lines, but that doesn't matter. And now we can get rid of \v (very magic option) (-2 bytes)
• New approach: Instead of replacing every line that matches with an empty line, we replace every line that doesn't have a no non-whitespace characters with an empty line. (-3 bytes)
• Actually, a normal replacement is shorter (thanks, @DJMcMayhem) (-3 bytes)

AWK, 12 11 bytes

!NF{$0=""}1

Try it online!

I was just feeling like AWK should have an answer too

It works by:

1. Checking if there are no fields in the input. AWK by default uses all whitespace as separator between fields
2. If there are no fields, change the input line to an empty string
3. Print the line. As 1 is a truthy value, it runs the default command which is printing the line

APL (Dyalog), 11 10 bytes

'\s+$'⎕R''

⎕R is an operator which derives a function which replaces stuff. In this case, anything matched by the RegEx is replaced with an empty string.

Ruby, 22 bytes

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

Straightforward regex solution

Java 7, 57 bytes

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

Explanation:

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

Test code:

Try it here.

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

Try it

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

Largely the same as above.

• -p runs the code for every line of input, putting the line into $_ and printing whatever is left in $_.
• s replaces in-place, whereas S returns the result.
• No need for :g/:global as -p takes care of that.

Python 2, 26 bytes

lambda l:map(str.rstrip,l)

Try it online! Inputs and outputs a list of strings.

This takes advantage of the ruling in the comments that trailing whitespace may be removed on non-empty lines.

Vim, 13 9 bytes

:v/\S/le↵

Edits:

• Original answer: :v/\S/d↵ (based on this vim question on SO).
  It deletes empty lines, which isn't the expected behavior.

• Valid answer using vglobal: :v/\S/norm D↵

• Now using the left-align ex command instead of normal 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);}

Detailed

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

See it work online.

QuadR, 5 bytes

\s+$

Try it online!

\s+ replace one or more whitespace chars followed by
$ end of line

 with nothing