COBOL là một ngôn ngữ rất cũ, tại thời điểm viết nó đã 58 tuổi. Trên thực tế, nó quá cũ đến nỗi nó có một cách giải quyết rất thú vị: sáu ký tự đầu tiên của mỗi dòng là các bình luận.

Tại sao điều này lại hỏi thế? Chà, 6 ký tự đó được dự định sẽ được sử dụng làm số dòng, trở lại vào ngày mà các chương trình không hoàn toàn là kỹ thuật số và được gõ trên máy tính.

Ngoài ra, ký tự thứ bảy chỉ có thể là một phần của một tập hợp rất nhỏ (thường là *để nhận xét dòng hoặc khoảng trắng để tách số dòng khỏi mã)

Nhưng nếu bạn đang ở trên một hệ thống kỹ thuật số hơn và bạn chỉ muốn chương trình thô thì sao?

Hệ thống bình luận

Có hai loại nhận xét trong COBOL: nhận xét dòng và nhận xét "số dòng" đã nói ở trên.

Số dòng không ghi chú rất đơn giản: chỉ cần lấy bảy ký tự đầu tiên (sáu cộng một dấu cách) trên mỗi dòng.

000000 apple
000001 banana
celery donuts

sẽ trở thành:

apple
banana
donuts

Dòng ý kiến ​​làm cho nó một chút khó khăn hơn. Một nhận xét dòng được bắt đầu với một dấu sao *được đặt ở vị trí ký tự thứ bảy trên dòng, như vậy:

000323* this is a comment

Đây không phải là một bình luận dòng:

*00000 this isn't a comment

Để bỏ ghi chú một dòng, chỉ cần xóa toàn bộ dòng.

Một ví dụ nhận xét "chương trình":

000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges

Phiên bản chưa hoàn thành:

blah blah
oranges?
love me some oranges

Nói cách khác, để bỏ ghi chú một chuỗi, hãy xóa sáu ký tự đầu tiên của mỗi dòng, sau đó trả lại tất cả trừ ký tự đầu tiên của mỗi dòng không bắt đầu bằng một ngôi sao.

Các thách thức

Tạo một chương trình hoặc chức năng có một chương trình nhận xét và trả về biến thể không bị lỗi của nó.

Làm rõ

• Dấu hoa thị ( *) sẽ không bao giờ được tìm thấy ở bất cứ đâu ngoài bảy ký tự đầu tiên trên một dòng (chúng tôi không yêu cầu bạn xác minh cú pháp)
• Mỗi dòng sẽ luôn có ít nhất 7 ký tự.
• Bạn có thể cho rằng nhân vật thứ bảy luôn là dấu hoa thị hoặc dấu cách.
• Đầu vào hoặc đầu ra có thể là một ma trận hoặc danh sách.
• Chỉ các ký tự ASCII có thể in (cộng với dòng mới) phải được xử lý.
• Bạn có thể xuất ra với một dòng mới. Bạn cũng có thể cho rằng đầu vào sẽ có một dòng mới, nếu bạn chọn.

Chấm điểm

Vì đây là môn đánh gôn , câu trả lời có ít byte nhất sẽ thắng!

_{TUYÊN BỐ TỪ CHỐI: Tôi thực sự không biết về COBOL và không yêu cầu. Nếu bất kỳ khiếu nại nào về COBOL tôi đã đưa ra trong câu hỏi này là không chính xác, tôi không chịu trách nhiệm.}

COBOL (GnuCOBOL), 191 + 17 = 208 byte

Tôi đã "học" COBOL cho câu trả lời này, vì vậy có lẽ nó không được đánh gôn hoàn toàn.

Đây là một chương trình đầy đủ, lấy đầu vào của cái mà tôi cho là đầu vào tiêu chuẩn và ghi vào cái mà tôi cho là đầu ra tiêu chuẩn. Có lẽ một ngày nào đó tôi sẽ quay lại vấn đề này và (1) xác định xem liệu COBOL có chức năng hay không và nếu có, (2) hãy xem liệu một giải pháp chức năng có ngắn hơn không.

Số byte bao gồm các cờ chương trình và trình biên dịch ( -freevà -frelax-syntax).

program-id.c.select i assign keyboard line sequential.fd i. 1 l pic X(80). 88 e value 0.open input i perform until e read i end set e to true end-read if not e and l(7:1)<>'*'display l(8:73).

Dùng thử trực tuyến

Chương trình phản đối

program-id. c.

select i assign to keyboard organization line sequential.

fd i.
    1 l pic X(80).
    88 e value 0.

open input i
perform until e
    read i
        end set e to true
    end-read
    if not e and l(7:1) <> '*'
        display l(8:73).

Hạn chế

Đầu ra là, về mặt kỹ thuật, không chính xác. Từ nghiên cứu chữ thảo của tôi, có vẻ như cách thực tế duy nhất để lưu trữ một chuỗi trong COBOL là trong một bộ đệm có kích thước cố định. Tôi đã chọn kích thước bộ đệm là 80 ký tự, vì đây là giới hạn độ dài dòng cho các chương trình định dạng cố định. Điều này trình bày hai hạn chế:

• Các dòng dài hơn 80 ký tự được cắt ngắn.
• Các dòng ngắn hơn 80 ký tự được đệm đúng với khoảng trắng.

Tôi đoán điều này có thể chấp nhận được, vì, đó là COBOL. Nếu không, tôi sẵn sàng xem xét các lựa chọn thay thế.

Sự nhìn nhận

• -166 byte nhờ Edward H
• -2 byte nhờ hornj

Python 2 , 39 38 37 byte

-1 byte nhờ LyricLy. -1 byte nhờ Mego.

lambda s:[i[7:]for i in s if'*'>i[6]]

Hãy thử trực tuyến!

I / O là danh sách các chuỗi.

Perl 5 , 19 + 1 (-p) = 20 16 byte

-4 byte với đề xuất của Pavel

s/.{6}( |.*)//s

Hãy thử trực tuyến!

V , 13 11 10 byte

Î6x<<
çª/d

Hãy thử trực tuyến!

Giải trình

Î       ' On every line
  x     ' delete the first...
 6      ' 6 characters
   <<   ' and unindent the line (removes the leading space)
ç /     ' on every line
 ª      ' matching \*
   d    ' delete the line

Hexdump:

00000000: ce36 783c 3c0a e7aa 2f64                 .6x<<.../d

Nghịch lý (v0.2.8 +), 8 byte (CP-1252)

µ6>(7#;x

Đưa ra một danh sách các dòng và kết quả là một danh sách các dòng không bị thiếu.

Giải trình:

μ        .. Map the following block over each line (the block is terminated
         .. by }, but that doesn't exist, so it's until EOF)
 6>      .. Slice everything after the first six characters
   (     .. Uncons, so now the stack has the 6th character on top
         .. and the rest of the line second
    7#   .. Count the multiplicity of factors of 7 in the character
         .. (treated as an integer, so '*' is 42 and ' ' is 32)
      ;  .. Pop the top element of the stack (the rest of the line)...
       x .. ...that many times (so, don't pop if the 6th character was a
         .. space, and do pop if it was an asterisk)

Xin chào, tôi đã viết một ngôn ngữ lập trình golf. :)

Tôi vẫn đang phát triển điều này và đã thêm / điều chỉnh một loạt các tích hợp sau khi cố gắng viết nó để có nhiều cách hợp lý hơn để phân biệt giữa một không gian và dấu hoa thị so với " 7#", nhưng tôi cảm thấy như thế sẽ khiến nó không bị xóa. Thật may là nó vẫn hoạt động được (điều này chỉ sử dụng các tính năng từ v0.2.8, mà tôi đã cam kết ba ngày trước).

Octave, 23 byte

@(s)s(s(:,7)~=42,8:end)

Hãy thử trực tuyến!

Thạch , 11 9 byte

ṫ€7Ḣ⁼¥Ðf⁶

Hãy thử trực tuyến!

Đầu vào và đầu ra như một danh sách các dòng.

-2 byte nhờ @EriktheOutgolfer và @Jonathan ALLan

Làm thế nào nó hoạt động

ṫ€7Ḣ=¥Ðf⁶
 €           On each line:
ṫ 7            Replace the line with line[7:]
      Ðf     Keep all lines that meet condition:
     ¥         Dyad:
   Ḣ             First Element (modifies line)
    =            Equals
        ⁶    Space

PowerShell , 32 byte

$input-replace'^.{6}( |.*)'-ne''

Hãy thử trực tuyến!

Đầu vào đường ống đi vào dưới dạng một chuỗi các chuỗi, -replacehoạt động trên mọi chuỗi và -ne ''(không bằng chuỗi trống) được áp dụng cho một mảng, hoạt động để lọc ra các dòng trống.

C, 63 59 55 48 47 46 byte

Cảm ơn " một người dùng ẩn danh " đã thoát khỏi một byte khác.

Cảm ơn Felix Palmen đã nhắc nhở tôi về " Bạn có thể cho rằng nhân vật thứ bảy luôn là dấu hoa thị hoặc dấu cách. ", Nó đã loại bỏ thêm một byte.

f(char**a){for(;*a;++a)(*a)[6]&2||puts(*a+7);}

Sử dụng như:

char** program = { "000000 apple", "000001 banana", "celery donuts", 0 };
f(program);

Hãy thử trực tuyến!

Trên thực tế , 13 byte

⌠6@tp' =*⌡M;░

Đầu vào và đầu ra được thực hiện dưới dạng một danh sách các chuỗi.

Giải trình:

⌠6@tp' =*⌡M;░
⌠6@tp' =*⌡M    for each line:
 6@t             discard the first 6 characters
    p            pop the first character of the remainder
     ' =         is it a space?
        *        multiply the string by the boolean - returns the string if true, and an empty string if false
           ;░  filter out empty strings

Hãy thử trực tuyến!

Gaia , 9 byte

6>¦'*«⁈ḥ¦

Hàm chấp nhận danh sách các chuỗi và trả về danh sách các chuỗi.

Hãy thử trực tuyến!

Giải trình

6>¦        Remove the first 6 characters of each string
   '*«⁈    Filter out ones that start with *
       ḥ¦  Remove the initial space from each

Bình thường , 9 byte

Lưu ý rằng điều này chỉ hoạt động nếu ít nhất 1 dòng không phải là một nhận xét và ít nhất 1 dòng là một bình luận. Tất cả các giải pháp khác hoạt động trong mọi trường hợp.

-2 byte nhờ @pizzakingme !

m>d7.m@b6

Hãy thử nó ở đây!

Giải trình

m>d7.m@b6     - Full program with implicit input. Takes input as a list of Strings.

m>d7          - All but the first 7 letters of 
    .m   (Q)  - The input, filtered for its minimal value using the < operator on
      @b6     - the 7th character -- note that "*" is greater than " "
              - Implicitly Output the result.

Bình thường , 11 byte

tMfqhTdm>d6

Hãy thử nó ở đây!

Giải trình

tMfqhTdm> d6 - Chương trình đầy đủ với đầu vào ẩn. Lấy đầu vào là một danh sách các Chuỗi.

       m> d6 - Xóa 6 ký tự đầu tiên của mỗi dòng.
    hT - Lấy ký tự đầu tiên của mỗi.
  fq d - Giữ những ký tự đầu tiên có dấu hoa thị.
tM - Xóa ký tự đầu tiên của mỗi ký tự.
            - Đầu ra ngầm.

Bình thường , 11 byte

m>d7fqd@T6Q

Hãy thử nó ở đây!

Giải trình

m> d7fq @ T6dQ - Chương trình đầy đủ. Lấy đầu vào là một danh sách các Chuỗi.

      @ T6 - Nhân vật thứ sáu của mỗi.
    fq dQ - Giữ các dòng có khoảng trắng là ^.
m> d7 - Cắt 7 ký tự đầu tiên.
             - Đầu ra ngầm.

Bình thường , 12 byte

tMfnhT\*m>d6

Hãy thử nó ở đây!

Giải trình

tMfnhT \ * m> d6 - Chương trình đầy đủ với đầu vào ẩn. Lấy đầu vào là một danh sách các Chuỗi.

        m> d6 - Xóa 6 ký tự đầu tiên của mỗi dòng.
    hT - Lấy ký tự đầu tiên của mỗi.
  fn \ * - Lọc những cái không bằng dấu hoa thị.
tM - Xóa ký tự đầu tiên của mỗi ký tự.
             - Đầu ra ngầm.

Bình thường , 12 byte

m>d7fn@T6\*Q

Hãy thử nó ở đây!

Giải trình

m> d7fn @ T6 \ * Q - Chương trình đầy đủ. Lấy đầu vào là một danh sách các Chuỗi.

      @ T6 - Nhận ký tự thứ sáu của mỗi chuỗi
    fn \ * Q - Và lọc những cái không bằng dấu hoa thị.
m> d7 - Cắt 7 ký tự đầu tiên.
              - Đầu ra ngầm.

GNU Sed, 19 + 2 = 21 ký tự

Yêu cầu -Eđối số để sedkích hoạt biểu thức chính quy mở rộng.

/^.{6}\*/d;s/^.{7}/

Java 8, 40 byte

Biểu thức thông thường: chỉ về, nhưng không hoàn toàn, công cụ sai cho công việc. Lambda từ Stringđến String(gán cho Function<String, String>). Đầu vào phải có một dòng mới.

s->s.replaceAll("(?m)^.{6}( |.*\\n)","")

Dùng thử trực tuyến

Sự nhìn nhận

• -3 byte nhờ regex của Sven Hohenstein

Haskell , 27 25 byte

Phiên bản của Laikoni ngắn hơn phiên bản của tôi:

f n=[x|' ':x<-drop 6<$>n]

Hãy thử trực tuyến!

Phiên bản của tôi:

f n=[drop 7x|x<-n,x!!6<'*']

Hãy thử trực tuyến!

C (gcc) , 53 48 46 byte

x;main(y){for(y=&x;gets(y-6);x&2||puts(y+1));}

Hãy thử trực tuyến!

-5 byte: Rất khó để đưa " toàn bộ chương trình " này xuống cùng kích thước với chức năng của gurka . Bây giờ, nó viết ra các giới hạn (theo cả hai hướng) của một mảng sai loại và dựa vào các số nguyên nhỏ và 4 byte để tìm dấu hoa thị ... nhưng này, nó hoạt động;)

-2 byte: Chà, nếu chúng ta đã ghi vào một .bssvị trí "ngẫu nhiên" , tại sao lại phải khai báo một mảng ! Vì vậy, ở đây có các chuỗi chương trình xử lý sử dụng không phải là charloại hay một mảng.

R, 47 45 byte

function(x)gsub("(?m)^.{6}( |.*\\n)","",x,,T)

SNOBOL4 (CSNOBOL4) , 72 70 66 50 byte

R	INPUT POS(6) (' '  REM . OUTPUT | '*') :S(R)
END

Hãy thử trực tuyến!

Khớp mẫu trong SNOBOL khá khác so với regex nhưng ý tưởng ở đây vẫn giống nhau: Nếu một dòng khớp với "sáu ký tự và sau đó là dấu hoa thị", hãy xóa nó, nếu không, hãy xóa bảy ký tự đầu tiên của dòng và in kết quả.

Điều này thực sự tận dụng lợi thế tốt hơn của toán tử gán điều kiện của SNOBOL.

Mẫu POS(6) (' ' REM . OUTPUT | '*')được hiểu là:

Bắt đầu từ vị trí 6, khớp với một khoảng trắng hoặc dấu hoa thị và nếu bạn khớp với một khoảng trắng, gán phần còn lại của dòng cho OUTPUT.

Vim, 14 byte

Ctrl-VG5ld:%g/\*/dEnter

Tải tập tin đầu vào dưới dạng bộ đệm để chỉnh sửa, sau đó nhập các lệnh trên. Đầu ra là bộ đệm mới.

Ruby , 39 38 36 29 23 22 20 + 1 = 21 byte

$_[/.{6}( |.*
)/]=''

Hãy thử trực tuyến!

Sử dụng -pcờ.

Giải trình:

Các -plá cờ cho biết thêm một khối tiềm ẩn xung quanh mã, vì vậy mã mà thực sự được chạy trông như thế này:

while gets
    $_[/.{6}( |.*
)/]=''

    puts $_
end

getsđọc một dòng văn bản và lưu trữ kết quả của nó trong $_.

$_[/.../]=''loại bỏ sự xuất hiện đầu tiên của regex ...trong $_.

/.{6}( |.*\n)/khớp với 6 của bất kỳ ký tự nào ở đầu một dòng, theo sau là khoảng trắng hoặc phần còn lại của dòng. Bởi vì không gian xuất hiện đầu tiên, nó sẽ cố gắng chỉ xóa 6 ký tự đầu tiên và một khoảng trắng trước khi cố gắng xóa toàn bộ dòng.

$_ sau đó được in ra và quá trình này được lặp lại cho mỗi dòng.

Pyke , 9 byte

36 4C 3E 23 64 DE 29 6D 74

Hãy thử nó ở đây!

Có thể đọc được

6L>#d.^)mt

Hãy thử nó ở đây!

6L>        -   [i[6:] for i in input]
   #d.^)   -  filter(i.startswith(" ") for  i in ^)
        mt - [i[-1:] for i in ^]

Võng mạc , 23 15 byte

5 byte được lưu nhờ vào nmjcman101 Lưu
1 byte nhờ Neil

m`^.{6}( |.*¶)

Hãy thử trực tuyến!

JavaScript (ES6), 48 byte

s=>s.map(c=>c[6]<"*"?console.log(c.substr(7)):1)

Hãy thử trực tuyến!

> <>, 57 53 byte

>i~i~i~i~i~i~i67*=\
<o$/?:$/?=a:;?(0:i<
\~$/~\ $
/  <o\?/

thử trực tuyến

Giải trình

>i~i~i~i~i~i~i67*=    Read in the first seven bytes of the line
 i~i~i~i~i~i~         Read, and discard 6 characters
             i        Read the seventh
              67*=    Check if the seventh character was an 
                      asterisk (and leave that value on the stack );

<o$/?:$/?=a:;?(0:i<    Read characters until a newline or eof
                 i     Read the next character of the line
            ;?(0:      If it's a -1, terminate the program
       /?=a:           If it's a newline, break out of the loop
   /?:$                If the seventh character was not an asterisk
<o$                    Output this character
\~$/                   otherwise discard it

   /~\ $    Having reached the end of the line, output
/  <o\?/    the newline only if it was not a comment

Chỉnh sửa: 53 byte

>   i~i~i~i~i~i~i67*=\
/?=a<o/?$@:$@:$;?(0:i<
~   \~/

Về cơ bản các công cụ như trước đây, nhưng cấu trúc lại một chút

Như một lưu ý phụ: Tôi thất vọng vì chưa có ai thực hiện điều này trong cobol.

C #, 160 145 90 89 byte

t=>{var o="";foreach(var s in i.Split('\n'))if(s[6]!=42)o+=s.Substring(7)+"\n";return o;}

Cảm ơn Pavel & auhmaan vì đã giảm kích thước.

Python 3, 71 byte (không có biểu thức chính quy)

def f(s):
 for w in s.split('\n'):
  t=w[6:]
  if t[0]!='*':print(t[1:])

Nó hoạt động!

>>> s="""000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges"""
>>> f(s)
blah blah
oranges?
love me some oranges

05AB1E , 11 byte

|ʒ6èðQ}ε7F¦

Hãy thử trực tuyến!

JavaScript, 44 34 byte

^{Crossed-out 44 vẫn là 44 thường xuyên.}

6 byte được lưu nhờ vào tsh

a=>a.replace(/^.{6}( |.*\n)/gm,'')

Hãy thử trực tuyến!

C ++ (GCC), 121 112 byte

Cảm ơn @gurka vì đã tiết kiệm 9 byte!

#import<bits/stdc++.h>
void f(std::list<std::string>l){for(auto s:l)if(s[6]-42)std::cout<<s.substr(7,s.size());}

Lấy đầu vào là một danh sách các dòng.

Hãy thử trực tuyến!

Java 8, 95 54 53 byte

s->s.filter(x->x.charAt(6)<33).map(x->x.substring(7))

-42 byte nhờ @ OliverGrégoire , bằng cách sử dụng Stream<String>thay vì Stringnhư trong và đầu ra.

Giải trình:

Hãy thử nó ở đây.

s->                          // Method with Stream<String> as parameter and return-type
  s.filter(x->x.charAt(6)<33)//  Filter out all lines containing an asterisk as 7th char
   .map(x->x.substring(7))   //  And remove the first 7 characters from the remaining lines
                             // End of method (implicit / single-line body)