Ah, noch eine meiner egoistischen Verwendungen dieses Stapels .

Als Chromebook-Besitzer benutze ich häufig die Ace IDE, den von Cloud9 verwendeten Editor. Es verfügt über viele Tools für den Umgang mit übermäßigem Leerraum, aber es fehlt vor allem eines: das Löschen von Leerzeilen.

Ihre heutige Mission ist es, eine Eingabe von einem Ort zu erhalten, an den ich kopieren und einfügen kann ;), etwas Identisches auszugeben, alle Leerzeichen und Tabulatoren in ansonsten leeren Zeilen zu speichern.

Ich werde einige Beispiele geben, wobei #s für zu entfernende Leerzeichen steht.

EINGANG 1:

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

AUSGABE:

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

EINGANG 2:

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

AUSGABE:

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

EINGANG 3:

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

AUSGABE:

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

Sie können die Eingabe beliebig weiterverarbeiten. Ausgabe überall, solange ich sie kopieren und einfügen kann [ ;)].

Es gelten Standardlücken, die kürzeste Antwort in Bytes gewinnt!

Japt , 10 8 6 5 4 Bytes

mx1R

Probieren Sie es online!

Erläuterung

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

Zerlegt also mx1Rdie Zeichenkette, Rdie eine neue Zeile ist, schneidet die rechte Seite jeder Zeile mit x1und verbindet die Zeichenketten erneut mit einer neuen Zeile.

2 Bytes gespart dank ETHproductions.

Retina , 5 Bytes

%G`\S

Probieren Sie es online!

Ein nicht so offensichtlicher Ansatz belohnt uns mit einer besseren Punktzahl :)

Erläuterung

GGibt dies als Grep-Stufe an, wobei nur die Zeilen beibehalten werden, in denen eine Übereinstimmung mit dem angegebenen regulären Ausdruck ( \Sentspricht nicht-Leerzeichen) gefunden werden kann. Wenn es nicht für den Start %wäre, würde dies Linien vollständig entfernen, anstatt sie nur zu "leeren".

Das %ist ein Modifikator, der die Bühne gilt einmal für jede Zeile und schließt sich dann die Ergebnisse mit Zeilenumbrüchen: in unserem Fall bedeutet dies , dass die leere Zeichenkette von Grep für die nur aus Leerzeichen Zeilen zurückgegeben wird eine leere Zeile im Ergebnis werden.

sed , 6 bytes

/\S/!g

Probieren Sie es 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

Probieren Sie es online!

Erläuterung:

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

Ich verstehe nicht, warum das so viele positive Stimmen bekommt!

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

Versuch es

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 und Output sind Arrays von Strings. Mach mit '\n'.

Für das ursprüngliche Programm der I / O-Zeichenfolgen:

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

Probieren Sie es online!

8 Bytes gespart dank @Rod!
Dank @LeakyNun 19 Bytes gespart!

CJam , 18 16 Bytes

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

Beachten Sie, dass die Zeichenfolge 1 Leerzeichen und 1 Tabulator enthält.

Probieren Sie es online!

Erläuterung

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

Eine wirklich sinnlose Herausforderung. mmacht es mehrzeilig (ignoriert Zeilenvorschub). \sEntspricht sowohl dem Leerzeichen als auch dem Tabulator.

Probieren Sie es online!

Vim, 20 18 16 13 10 Bytes

Ich bin kein Vim-Experte, aber diese Frage muss von Vim beantwortet werden.

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

<cr> ist ein Wagenrücklauf.

Änderungsprotokoll:

• :normstatt :normal(-2 Bytes)
• Wechseln zu *statt +bedeutet, dass wir bereits leere Zeilen abgleichen, aber das spielt keine Rolle. Und jetzt können wir loswerden \v( sehr magische Option) (-2 Bytes)
• Neuer Ansatz: Anstatt jede Zeile, die mit einer Leerzeile übereinstimmt, zu ersetzen, ersetzen wir jede Zeile, die keine Nicht-Leerzeichen enthält, durch eine Leerzeile. (-3 Bytes)
• Eigentlich ist ein normaler Ersatz kürzer (danke, @DJMcMayhem) (-3 Bytes)

AWK , 12 11 Bytes

!NF{$0=""}1

Probieren Sie es online!

Ich hatte nur das Gefühl, dass AWK auch eine Antwort haben sollte

Es funktioniert durch:

1. Überprüfung, ob die Eingabe keine Felder enthält. AWK verwendet standardmäßig alle Leerzeichen als Trennzeichen zwischen den Feldern
2. Wenn keine Felder vorhanden sind, ändern Sie die Eingabezeile in eine leere Zeichenfolge
3. Drucken Sie die Zeile. Da 1 ein wahrer Wert ist, wird der Standardbefehl ausgeführt, mit dem die Zeile gedruckt wird

APL (Dyalog) , 11 10 Bytes

'\s+$'⎕R''

⎕Rist ein Operator, der eine Funktion ableitet, die Sachen ersetzt. In diesem Fall wird alles, was mit der RegEx übereinstimmt, durch eine leere Zeichenfolge ersetzt.

Ruby, 22 Bytes

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

Einfache Regex-Lösung

Java 7, 57 Bytes

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

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Versuch es

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

Weitgehend das gleiche wie oben.

• -pFührt den Code für jede Eingabezeile aus, fügt die Zeile ein $_und druckt alles, was noch übrig ist $_.
• swird an Ort und Stelle ersetzt, während Sdas Ergebnis zurückgegeben wird.
• Dafür braucht :g/ kümmert sich :globalas nicht -p.

Python 2 , 26 Bytes

lambda l:map(str.rstrip,l)

Probieren Sie es online! Gibt eine Liste von Zeichenfolgen ein und aus.

Dies nutzt die Regel in den Kommentaren, dass nachfolgende Leerzeichen in nicht leeren Zeilen entfernt werden können.

Vim, 13 9 Bytes

:v/\S/le↵

Bearbeitungen:

• Ursprüngliche Antwort: :v/\S/d↵(basierend auf dieser vim Frage zu SO ).
  Es löscht leere Zeilen, was nicht das erwartete Verhalten ist.

• Gültige Antwort mit vglobal ::v/\S/norm D↵

• Verwenden Sie jetzt den Befehl left-align ex anstelle vonnormal 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);}

Detailliert

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

Sehen Sie , wie es online funktioniert .

QuadR , 5 Bytes

\s+$

Probieren Sie es online!

\s+ Ersetzen Sie ein oder mehrere Whitespace-Zeichen, gefolgt vom
$ Zeilenende

 mit nichts