Ah, ancora un altro dei miei usi egoistici di questa pila .

Essendo un proprietario di Chromebook, sono un utente frequente dell'IDE IDE, l'editor utilizzato da Cloud9. Ha molti strumenti per gestire gli spazi bianchi in eccesso, ma in particolare ne manca uno: eliminare le linee vuote.

La tua missione oggi è, dato un input da un posto in cui posso copiare e incollare in [ ;)], produrre qualcosa di identico, salvare tutti gli spazi e i tabulatori su righe altrimenti vuote.

Fornirò alcuni esempi, con #s che rappresentano i caratteri degli spazi bianchi da rimuovere.

INGRESSO 1:

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

PRODUZIONE:

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

INGRESSO 2:

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

PRODUZIONE:

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

INGRESSO 3:

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

PRODUZIONE:

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

È possibile elaborare l'input nel modo desiderato. Uscita ovunque, purché io possa copiare e incollare da esso [ ;)].

Si applicano scappatoie standard, vince la risposta più breve in byte!

Japt , 10 8 6 5 4 byte

mx1R

Provalo online!

Spiegazione

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

Quindi mx1Rdivide la stringa con la Rquale è una nuova riga, taglia il lato destro di ogni riga usando x1e unisce nuovamente le stringhe con una nuova riga.

Risparmiato 2 byte grazie a ETHproductions.

Retina , 5 byte

%G`\S

Provalo online!

Un approccio non così ovvio ci premia con un punteggio migliore :)

Spiegazione

Gindica questo come uno stadio Grep, mantenendo solo quelle linee in cui è possibile trovare una corrispondenza con la regex ( \S, corrisponde a caratteri non spaziali). Se non fosse per l'inizio, %questo rimuove completamente le linee invece di "svuotarle".

La %è un modificatore che si applica la fase una volta per ogni riga e quindi unisce i risultati con newlines: nel nostro caso questo significa che la stringa vuota restituita da Grep per linee da spazi solo diventerà una riga vuota nel risultato.

sed , 6 byte

/\S/!g

Provalo 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 byte

ÇÓ/D

Provalo online!

Spiegazione:

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

Non capisco perché questo ottenga così tanti voti!

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

Provalo

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 byte

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

Input e output sono matrici di stringhe. Unisciti '\n'.

Per il programma originale che le stringhe di I / O:

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

Provalo online!

8 byte salvati grazie a @Rod!
Risparmiato 19 byte grazie a @LeakyNun!

CJam , 18 16 byte

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

Nota che la stringa contiene 1 spazio e 1 scheda.

Provalo online!

Spiegazione

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 byte

m`^\s+$

Una sfida davvero inutile. mlo rende multilinea (ignora la nuova riga). \scorrisponde sia allo spazio che alla scheda.

Provalo online!

Vim, 20 18 16 13 10 byte

Non sono affatto un esperto di Vim, ma questa domanda ha bisogno di una risposta Vim.

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

<cr> è un ritorno a capo.

changelog:

• :normanziché :normal(-2 byte)
• Passare a *invece di +significa che abbineremo linee già vuote, ma non importa. E ora possiamo sbarazzarci di \v( opzione molto magica ) (-2 byte)
• Nuovo approccio: invece di sostituire ogni riga che corrisponde a una riga vuota, sostituiamo ogni riga che non ha caratteri non bianchi con una riga vuota. (-3 byte)
• In realtà, una sostituzione normale è più breve (grazie, @DJMcMayhem) (-3 byte)

AWK , 12 11 byte

!NF{$0=""}1

Provalo online!

Mi sentivo come se anche AWK dovesse avere una risposta

Funziona da:

1. Verifica se non ci sono campi nell'input. AWK per impostazione predefinita utilizza tutti gli spazi bianchi come separatore tra i campi
2. Se non ci sono campi, cambia la riga di input in una stringa vuota
3. Stampa la linea. Poiché 1 è un valore veritiero, esegue il comando predefinito che sta stampando la linea

APL (Dyalog) , 11 10 byte

'\s+$'⎕R''

⎕Rè un operatore che deriva una funzione che sostituisce roba. In questo caso, tutto ciò che corrisponde a RegEx viene sostituito con una stringa vuota.

Rubino, 22 byte

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

Soluzione regex semplice

Java 7, 57 byte

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

Spiegazione:

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

Codice di prova:

Provalo qui.

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 byte

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

Perl 6 ,  15  12 byte

15

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

Provalo

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

In gran parte uguale a sopra.

• -pesegue il codice per ogni riga di input, inserendo la riga $_e stampando tutto ciò che rimane$_ .
• ssostituisce sul posto, mentre Srestituisce il risultato.
• Non c'è bisogno di :g/ :globalcome se -pne occupa.

Python 2 , 26 byte

lambda l:map(str.rstrip,l)

Provalo online!Inserisce ed emette un elenco di stringhe.

Ciò sfrutta la sentenza nei commenti secondo cui gli spazi bianchi finali possono essere rimossi su righe non vuote.

Vim, 13 9 byte

:v/\S/le↵

modifiche:

• Risposta originale: :v/\S/d↵(basato su questa domanda vim su SO ).
  Elimina le righe vuote, che non è il comportamento previsto.

• Risposta valida utilizzando vglobal ::v/\S/norm D↵

• Ora usa il comando ex -allineamento a sinistra invece dinormal D

C, 168 byte

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

dettagliata

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

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

Guardalo funzionare online .

QuadR , 5 byte

\s+$

Provalo online!

\s+ sostituire uno o più caratteri di spazi bianchi seguiti da
$ fine riga

 con niente