อ่าอีกหนึ่งความเห็นแก่ตัวของฉันที่ใช้กับกองนี้

ในฐานะเจ้าของ Chromebook ฉันเป็นผู้ใช้ Ace IDE ตัวแก้ไขที่ใช้โดย Cloud9 บ่อยครั้ง มันมีเครื่องมือมากมายสำหรับจัดการกับช่องว่างส่วนเกิน แต่มันขาดหนึ่ง: การล้างบรรทัดว่าง

ภารกิจของคุณในวันนี้คือรับข้อมูลจากสถานที่ที่ฉันสามารถคัดลอก - วางไปที่ [ ;)] ออกบางสิ่งที่เหมือนกันบันทึกช่องว่างทั้งหมดและตัวสร้างตารางในบรรทัดว่าง

ฉันจะให้ตัวอย่างด้วย#s แทนอักขระช่องว่างที่จะถูกลบออก

อินพุต 1:

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

เอาท์พุท:

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

อินพุต 2:

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

เอาท์พุท:

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

อินพุต 3:

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

เอาท์พุท:

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

คุณสามารถประมวลผลอินพุตได้ตามที่คุณต้องการ เอาท์พุทที่ไหนก็ได้ตราบใดที่ฉันสามารถคัดลอก - วางมันได้ [ ;)]

ใช้ช่องโหว่มาตรฐานตอบสั้นที่สุดเป็นไบต์ชนะ!

Japt , 10 8 6 5 4 ไบต์

mx1R

ลองออนไลน์!

คำอธิบาย

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

ดังนั้นการmx1RแยกสตริงRซึ่งเป็นบรรทัดใหม่ตัดขอบด้านขวาของแต่ละบรรทัดโดยใช้x1และรวมสตริงอีกครั้งด้วยการขึ้นบรรทัดใหม่

บันทึก 2 ไบต์ด้วย ETHproductions

เรติน่า 5 ไบต์

%G`\S

ลองออนไลน์!

วิธีการที่ไม่ชัดเจนทำให้เราได้คะแนนที่ดีกว่า :)

คำอธิบาย

Gบ่งชี้ว่านี่เป็นสเตจ Grep โดยรักษาเฉพาะบรรทัดที่ตรงกับ regex ที่ระบุ (สามารถ\Sจับคู่อักขระที่ไม่ใช่ช่องว่าง) หากไม่ใช่เพื่อเริ่มต้น%สิ่งนี้จะเป็นการลบบรรทัดทั้งหมดแทนที่จะ "ล้าง" พวกเขา

%เป็นตัวปรับแต่งซึ่งใช้เวทีครั้งเพื่อแต่ละบรรทัดและจากนั้นร่วมผลกับการขึ้นบรรทัดใหม่ A: ในกรณีของเราที่นี้หมายถึงว่าสตริงที่ว่างเปล่ากลับโดย Grep สำหรับสายช่องว่างอย่างเดียวจะกลายเป็นบรรทัดว่างในผล

sed , 6 ไบต์

/\S/!g

ลองออนไลน์!

/  /!  # 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 ไบต์

ÇÓ/D

ลองออนไลน์!

คำอธิบาย:

Ç       " 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 ไบต์

ฉันไม่เข้าใจว่าทำไมสิ่งนี้ถึงได้เพิ่มขึ้นมากมาย!

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

ลองมัน

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 ไบต์

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

อินพุตและเอาต์พุตเป็นอาร์เรย์ของสตริง '\n'เข้าร่วมใน

สำหรับโปรแกรมต้นฉบับที่สตริงของ I / O:

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

ลองออนไลน์!

บันทึก 8 ไบต์ขอบคุณ @Rod!
บันทึกแล้ว 19 ไบต์ขอบคุณ @LeakyNun!

CJam , 18 16 ไบต์

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

โปรดทราบว่าสตริงมี 1 ช่องว่างและ 1 แท็บ

ลองออนไลน์!

คำอธิบาย

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)

เรติน่า 8 ไบต์

m`^\s+$

ความท้าทายที่ไม่มีจุดหมายจริงๆ mทำให้มันหลายบรรทัด (ละเว้นบรรทัดใหม่) \sจับคู่ทั้งช่องว่างและแท็บ

ลองออนไลน์!

เป็นกลุ่ม, 20 18 16 13 10 ไบต์

ฉันไม่เคยเป็นผู้เชี่ยวชาญมาก่อน แต่คำถามนี้ต้องการคำตอบเป็นกลุ่ม

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

<cr> คือการคืนสินค้า

การเปลี่ยนแปลง:

• :normแทน:normal(-2 ไบต์)
• เปลี่ยน*เป็น+วิธีที่เราจะจับคู่บรรทัดว่างแล้ว แต่นั่นไม่สำคัญ และตอนนี้เราสามารถกำจัด\v( ตัวเลือกที่วิเศษมาก ) (-2 ไบต์)
• วิธีการใหม่: แทนที่จะแทนที่ทุกบรรทัดที่ตรงกับบรรทัดว่างเราแทนที่ทุกบรรทัดที่ไม่มีตัวอักษรที่ไม่ใช่ช่องว่างด้วยบรรทัดว่าง (-3 ไบต์)
• ที่จริงแล้วการแทนที่ปกติสั้นกว่า (ขอบคุณ @DJMcMayhem) (-3 ไบต์)

AWK , 12 11 ไบต์

!NF{$0=""}1

ลองออนไลน์!

ฉันแค่รู้สึกเหมือน AWK ควรมีคำตอบด้วย

มันทำงานโดย:

1. ตรวจสอบว่าไม่มีฟิลด์ในอินพุตหรือไม่ AWK โดยค่าเริ่มต้นจะใช้ช่องว่างทั้งหมดเป็นตัวคั่นระหว่างเขตข้อมูล
2. หากไม่มีฟิลด์ให้เปลี่ยนบรรทัดอินพุตเป็นสตริงว่าง
3. พิมพ์บรรทัด เนื่องจาก 1 เป็นค่าจริงมันรันคำสั่งเริ่มต้นซึ่งกำลังพิมพ์บรรทัด

APL (Dyalog) , 11 10 ไบต์

'\s+$'⎕R''

⎕Rเป็นโอเปอเรเตอร์ที่ได้รับฟังก์ชั่นที่แทนที่สิ่งต่าง ๆ ในกรณีนี้สิ่งใดที่ตรงกับ RegEx จะถูกแทนที่ด้วยสตริงว่าง

ทับทิมขนาด 22 ไบต์

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

วิธีการแก้ปัญหา regex ตรงไปตรงมา

Java 7, 57 ไบต์

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

คำอธิบาย:

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

รหัสทดสอบ:

ลองที่นี่

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 ไบต์

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

Perl 6 ,  15  12 ไบต์

15

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

ลองมัน

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

ส่วนใหญ่เหมือนกับข้างต้น

• -pทำงานรหัสสำหรับสายของทุกท่านวางสายลงและการพิมพ์สิ่งที่เหลืออยู่ใน$_$_
• sแทนที่ในสถานที่ในขณะที่Sผลตอบแทน
• ไม่จำเป็นต้องมี:g/ :globalตามที่-pดูแล

Python 2 , 26 ไบต์

lambda l:map(str.rstrip,l)

ลองออนไลน์! อินพุตและเอาต์พุตรายการสตริง

นี่ใช้ประโยชน์จากการพิจารณาคดีในความคิดเห็นที่ช่องว่างต่อท้ายอาจถูกลบออกในบรรทัดที่ไม่ว่างเปล่า

เป็นกลุ่ม, 13 9 ไบต์

:v/\S/le↵

การแก้ไข:

• คำตอบเดิม: :v/\S/d↵(ตามคำถามเป็นกลุ่มนี้ใน SO )
  มันลบบรรทัดว่างเปล่าซึ่งไม่ใช่พฤติกรรมที่คาดหวัง

• คำตอบที่ถูกต้องโดยใช้vglobal ::v/\S/norm D↵

• ตอนนี้ใช้คำสั่ง ex -leftอดีตแทนnormal D

C, 168 ไบต์

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

รายละเอียด

#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 ไบต์

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

เห็นมันทำงานแบบออนไลน์

QuadR , 5 ไบต์

\s+$

ลองออนไลน์!

\s+ แทนที่ช่องว่างอย่างน้อยหนึ่งตัวอักษรตามด้วย
$ ท้ายบรรทัด

 ด้วยอะไร