Ah, encore une autre de mes utilisations égoïstes de cette pile .

En tant que propriétaire de Chromebook, je suis un utilisateur fréquent de l'Ace IDE, l'éditeur utilisé par Cloud9. Il dispose de nombreux outils pour gérer les espaces blancs excédentaires, mais il en manque notamment un: effacer les lignes vides.

Votre mission aujourd'hui est, étant donné une entrée d'un endroit où je peux copier-coller dans [ ;)], produire quelque chose d'identique, enregistrer tous les espaces et tabulateurs sur des lignes autrement vides.

Je vais donner quelques exemples, avec #s représentant des espaces à supprimer.

ENTRÉE 1:

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

PRODUCTION:

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

ENTRÉE 2:

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

PRODUCTION:

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

ENTRÉE 3:

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

PRODUCTION:

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

Vous pouvez traiter l'entrée comme bon vous semble. Sortez n'importe où, tant que je peux copier-coller à partir de celui-ci [ ;)].

Les lacunes standard s'appliquent, la réponse la plus courte en octets gagne!

Japt , 10 8 6 5 4 octets

mx1R

Essayez-le en ligne!

Explication

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

mx1RDivise donc la chaîne par Rlaquelle se trouve une nouvelle ligne, coupe le côté droit de chaque ligne en utilisant x1et joint à nouveau les chaînes avec une nouvelle ligne.

Sauvegardé 2 octets grâce à ETHproductions.

Rétine , 5 octets

%G`\S

Essayez-le en ligne!

Une approche pas si évidente nous récompense avec un meilleur score :)

Explication

G indique cela comme une étape Grep, ne conservant que les lignes où une correspondance avec l'expression régulière donnée (\S , correspond aux caractères non-espace) peut être trouvée. Si ce n'était pas pour le démarrage, %cela supprimerait complètement les lignes au lieu de simplement les "vider".

Le %est un modificateur qui applique l'étape une fois à chaque ligne et joint ensuite les résultats aux sauts de ligne: dans notre cas, cela signifie que la chaîne vide renvoyée par Grep pour les lignes contenant uniquement des espaces blancs deviendra une ligne vide dans le résultat.

sed , 6 octets

/\S/!g

Essayez-le en ligne!

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

ÇÓ/D

Essayez-le en ligne!

Explication:

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

Je ne comprends pas pourquoi cela fait autant de votes positifs!

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

Essayez-le

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 octets

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

L'entrée et la sortie sont des tableaux de chaînes. Rejoignez-nous'\n' .

Pour le programme d'origine que les chaînes d'E / S:

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

Essayez-le en ligne!

8 octets enregistrés grâce à @Rod!
19 octets enregistrés grâce à @LeakyNun!

CJam , 18 16 octets

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

Notez que la chaîne contient 1 espace et 1 tabulation.

Essayez-le en ligne!

Explication

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)

Rétine , 8 octets

m`^\s+$

Un défi vraiment inutile. mle rend multiligne (ignore la nouvelle ligne). \scorrespond à la fois à l'espace et à la tabulation.

Essayez-le en ligne!

Vim, 20 18 16 13 10 octets

Je ne suis en aucun cas un expert Vim, mais cette question nécessite une réponse Vim.

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

<cr> est un retour chariot.

Journal des modifications:

• :norm au lieu de :normal (-2 octets)
• Passer à la *place de +signifie que nous associerons des lignes déjà vides, mais cela n'a pas d'importance. Et maintenant, nous pouvons nous débarrasser de \v( option très magique ) (-2 octets)
• Nouvelle approche: Au lieu de remplacer chaque ligne qui correspond à une ligne vide, nous remplaçons chaque ligne qui n'a pas de caractères non blancs par une ligne vide. (-3 octets)
• En fait, un remplacement normal est plus court (merci, @DJMcMayhem) (-3 octets)

AWK , 12 11 octets

!NF{$0=""}1

Essayez-le en ligne!

Je me sentais juste comme AWK devrait aussi avoir une réponse

Il fonctionne par:

1. Vérification de l'absence de champs dans l'entrée. AWK utilise par défaut tous les espaces comme séparateur entre les champs
2. S'il n'y a pas de champs, changez la ligne d'entrée en une chaîne vide
3. Imprimez la ligne. Comme 1 est une valeur véridique, il exécute la commande par défaut qui imprime la ligne

APL (Dyalog) , 11 10 octets

'\s+$'⎕R''

⎕Rest un opérateur qui dérive une fonction qui remplace les éléments. Dans ce cas, tout ce qui correspond au RegEx est remplacé par une chaîne vide.

Rubis, 22 octets

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

Solution regex simple

Java 7, 57 octets

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

Explication:

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

Code de test:

Essayez-le ici.

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 octets

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

Perl 6 ,  15  12 octets

15

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

Essayez-le

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

Largement les mêmes que ci-dessus.

• -pexécute le code pour chaque ligne d'entrée, en insérant la ligne $_et en imprimant tout ce qui reste $_.
• sremplace in-place, alors que Srenvoie le résultat.
• Pas besoin de :g/ :globalas s'en -poccupe.

Python 2 , 26 octets

lambda l:map(str.rstrip,l)

Essayez-le en ligne! Entrées et sorties une liste de chaînes.

Cela profite de la décision dans les commentaires que les espaces de fin peuvent être supprimés sur les lignes non vides.

Vim, 13 9 octets

:v/\S/le↵

Modifications:

• Réponse originale: :v/\S/d↵(basée sur cette question vim sur SO ).
  Il supprime les lignes vides, ce qui n'est pas le comportement attendu.

• Réponse valide en utilisant vglobal ::v/\S/norm D↵

• Maintenant, en utilisant la commande ex alignement à gauche au lieu denormal D

C, 168 octets

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

Détaillé

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

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

Voyez-le fonctionner en ligne .

QuadR , 5 octets

\s+$

Essayez-le en ligne!

\s+ remplacer un ou plusieurs caractères d'espacement, suivi de la
$ fin de la ligne

 avec rien