Ah, yine de bu Stack'i bencilce kullanıyorum .

Chromebook sahibi olarak, Cloud9 tarafından kullanılan editör Ace IDE'nin sık kullanıcısıyım. Fazla boşlukla uğraşmak için birçok araç var, ancak özellikle bir tane yok: boş satırları temizlemek.

Bugünkü göreviniz, kopyalayıp yapıştırabileceğim bir yerden bir girdi verildiğinde [;) ] ' , aynı şeyi çıktılamak, tüm boşlukları ve tabloları aksi takdirde boş satırlara kaydetmek.

#Silinecek boşluk karakterlerini temsil eden bazı örnekler vereceğim .

GİRİŞ 1:

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

ÇIKTI:

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

GİRİŞ 2:

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

ÇIKTI:

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

GİRİŞ 3:

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

ÇIKTI:

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

Girişi istediğiniz gibi işleyebilirsiniz. Buradan kopyalayıp yapıştırabildiğim sürece çıktı alın [;) ].

Standart boşluklar uygulanır, baytlarda en kısa cevap kazanır!

Japt , 10 8 6 5 4 bayt

mx1R

Çevrimiçi deneyin!

açıklama

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

Böylece yeni satır olan mx1Rdizeyi böler, Rher satırın sağ tarafını kullanarak x1keser ve dizeleri yeni satırla yeniden birleştirir.

ETHproductions sayesinde 2 bayt tasarruf etti.

Retina , 5 bayt

%G`\S

Çevrimiçi deneyin!

Çok açık olmayan bir yaklaşım bizi daha iyi bir puanla ödüllendiriyor :)

açıklama

Gbunu Grep aşaması olarak belirtir ve yalnızca verilen normal ifadeyle eşleşmenin ( \S, boşluk olmayan karakterlerle eşleşmesinin) bulunduğu satırları tutar . Başlangıç ​​için %olmasaydı , bu satırları yalnızca "boşaltmak" yerine tamamen kaldıracaktır.

%Boşluk okunur hatları için Grep tarafından döndürülen boş dize sonucu boş bir satır haline gelecek bizim durumumuzda bu araç, her satıra bir kez sahne uygular ve ardından yenisatırlar sonuçları birleştiren bir değiştirici olduğunu.

sed , 6 bayt

/\S/!g

Çevrimiçi deneyin!

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

ÇÓ/D

Çevrimiçi deneyin!

Açıklama:

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

I don't understand why this is getting so many upvotes!

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

Try It

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]

Input and output are arrays of strings. Join on '\n'.

For the original program that I/O's strings:

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

Try it online!

Saved 8 bytes thanks to @Rod!
Saved 19 bytes thanks to @LeakyNun!

CJam, 18 16 bytes

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

Note that the string contains 1 space and 1 tab.

Try it online!

Explanation

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