O COBOL é uma linguagem muito antiga, no momento da escrita, tem 58 anos. É tão antigo, de fato, que tem uma peculiaridade muito interessante: os seis primeiros caracteres de cada linha são comentários.

Por que isso, você pergunta? Bem, esses 6 caracteres foram criados para serem usados ​​como números de linha, no dia em que os programas não eram completamente digitais e digitados em um computador.

Além disso, o sétimo caractere só pode fazer parte de um conjunto muito pequeno (geralmente é *para comentar a linha ou um espaço para separar o número da linha do código)

Mas e se você estiver em um sistema mais digital e quiser apenas o programa bruto?

O sistema de comentários

Existem dois tipos de comentários no COBOL: comentários de linha e os comentários "número da linha" mencionados acima.

Não é necessário comentar números de linhas: basta retirar os sete primeiros (seis mais um espaço) de cada linha.

000000 apple
000001 banana
celery donuts

se tornaria:

apple
banana
donuts

Os comentários de linha tornam um pouco mais difícil. Um comentário de linha é iniciado com um asterisco *colocado na posição de sétimo caractere na linha, da seguinte forma:

000323* this is a comment

Este não é um comentário de linha:

*00000 this isn't a comment

Para remover o comentário de uma linha, remova a linha inteira.

Um exemplo comentou "programa":

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

A versão não comentada:

blah blah
oranges?
love me some oranges

Em outras palavras, para descomentar uma sequência, remova os seis primeiros caracteres de cada linha e retorne todos, exceto o primeiro caractere de cada linha que não começa com uma estrela.

O desafio

Crie um programa ou função que pega um programa comentado e retorna sua variante não comentada.

Esclarecimentos

• Asteriscos ( *) nunca serão encontrados em nenhum lugar fora dos sete primeiros caracteres de uma linha (não estamos solicitando que você verifique a sintaxe)
• Cada linha sempre terá pelo menos 7 caracteres.
• Você pode assumir que o sétimo caractere é sempre um asterisco ou um espaço.
• Entrada ou saída pode ser uma matriz ou lista.
• Somente caracteres ASCII imprimíveis (mais nova linha) devem ser manipulados.
• Você pode imprimir com uma nova linha à direita. Você também pode assumir que a entrada terá uma nova linha à direita, se assim desejar.

Pontuação

Como se trata de código-golfe , a resposta com o mínimo de bytes vence!

_{AVISO LEGAL: Na verdade, eu não conheço COBOL e não reivindico. Se alguma das reivindicações sobre COBOL que fiz nesta pergunta estiver incorreta, não me responsabilizo.}

COBOL (GnuCOBOL), 191 + 17 = 208 bytes

Eu "aprendi" o COBOL para esta resposta, portanto provavelmente não está totalmente preparado para o golfe.

Este é um programa completo, tendo como base o que eu presumo ser uma entrada padrão e escrevendo como o que eu presumo ser uma saída padrão. Talvez um dia eu volte a isso e (1) determine se COBOL tem funções e, se houver, (2) veja se uma solução de função seria mais curta.

A contagem de bytes inclui sinalizadores de programa e compilador ( -freee -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).

Experimente Online

Programa ungolfed

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).

Limitações

Tecnicamente, a saída não está correta. Da minha pesquisa superficial, parece que a única maneira prática de armazenar uma string no COBOL é em um buffer de tamanho fixo. Eu escolhi um tamanho de buffer de 80 caracteres, pois esse é o limite de comprimento de linha para programas de formato fixo. Isso apresenta duas limitações:

• Linhas com mais de 80 caracteres são truncadas.
• Linhas menores que 80 caracteres são preenchidas à direita com espaços.

Eu acho que isso é aceitável, pois, bem, é COBOL. Caso contrário, eu estaria disposto a procurar alternativas.

Agradecimentos

• -166 bytes graças a Edward H
• -2 bytes graças a hornj

Python 2 , 39 38 37 bytes

-1 byte graças ao LyricLy. -1 byte graças ao Mego.

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

Experimente online!

E / S como listas de cadeias.

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

-4 bytes com as sugestões de Pavel

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

Experimente online!

V , 13 11 10 bytes

Î6x<<
çª/d

Experimente online!

Explicação

Î       ' 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

Paradoc (v0.2.8 +), 8 bytes (CP-1252)

µ6>(7#;x

Pega uma lista de linhas e resulta em uma lista de linhas não comentadas.

Explicação:

μ        .. 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)

Oi, eu escrevi uma linguagem de programação de golfe. :)

Ainda estou desenvolvendo isso e adicionei / aprimorei um monte de built-ins depois de tentar escrever isso para que haja maneiras mais razoáveis ​​de diferenciar entre um espaço e um asterisco do que " 7#", mas acho que isso tornaria isso não-competitivo. É uma sorte que ainda funcionou (isso usa apenas os recursos da v0.2.8, que comprometi há três dias).

Oitava, 23 bytes

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

Experimente online!

Geléia , 11 9 bytes

ṫ€7Ḣ⁼¥Ðf⁶

Experimente online!

Entradas e saídas como uma lista de linhas.

-2 bytes graças a @EriktheOutgolfer e @JonathanAllan

Como funciona

ṫ€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 bytes

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

Experimente online!

A entrada do pipeline é fornecida como uma matriz de cadeias, -replacefunciona em todas as cadeias e -ne ''(não é igual à cadeia vazia) aplicada a uma matriz, atua para filtrar as linhas em branco.

C, 63 59 55 48 47 46 bytes

Obrigado a " um usuário anônimo " por se livrar de mais um byte.

Agradeço a Felix Palmen por me lembrar de " Você pode assumir que o sétimo caractere é sempre um asterisco ou um espaço. ", Que eliminou mais um byte.

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

Use como:

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

Experimente online!

Na verdade , 13 bytes

⌠6@tp' =*⌡M;░

A entrada e a saída são feitas como uma lista de strings.

Explicação:

⌠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

Experimente online!

Gaia , 9 bytes

6>¦'*«⁈ḥ¦

Uma função que aceita uma lista de cadeias e retorna uma lista de cadeias.

Experimente online!

Explicação

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

Pitão , 9 bytes

Observe que isso só funciona se pelo menos 1 linha não for um comentário e pelo menos 1 linha for um comentário. Todas as outras soluções funcionam em todos os casos.

-2 bytes graças a @pizzakingme !

m>d7.m@b6

Experimente aqui!

Explicação

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.

Pitão , 11 bytes

tMfqhTdm>d6

Experimente aqui!

Explicação

tMfqhTdm> d6 - Programa completo com entrada implícita. Recebe entrada como uma lista de Strings.

       m> d6 - Remova os 6 primeiros caracteres de cada linha.
    hT - Pega o primeiro caractere de cada um.
  fq d - Mantenha aqueles que têm o primeiro caractere em um asterisco.
tM - Remova o primeiro caractere de cada um.
            - Saída implicitamente.

Pitão , 11 bytes

m>d7fqd@T6Q

Experimente aqui!

Explicação

m> d7fq @ T6dQ - Programa completo. Recebe entrada como uma lista de Strings.

      @ T6 - O sexto caractere de cada um.
    fq dQ - Mantenha as linhas que têm um espaço como ^.
m> d7 - Corte os 7 primeiros caracteres.
             - Saída implicitamente.

Pitão , 12 bytes

tMfnhT\*m>d6

Experimente aqui!

Explicação

tMfnhT \ * m> d6 - Programa completo com entrada implícita. Recebe entrada como uma lista de Strings.

        m> d6 - Remova os 6 primeiros caracteres de cada linha.
    hT - Pega o primeiro caractere de cada um.
  fn \ * - filtra aqueles que não são iguais a um asterisco.
tM - Remova o primeiro caractere de cada um.
             - Saída implicitamente.

Pitão , 12 bytes

m>d7fn@T6\*Q

Experimente aqui!

Explicação

m> d7fn @ T6 \ * Q - Programa completo. Recebe entrada como uma lista de Strings.

      @ T6 - Pega o sexto caractere de cada string
    fn \ * Q - E filtre aqueles que não são iguais a um asterisco.
m> d7 - Corte os 7 primeiros caracteres.
              - Saída implicitamente.

GNU Sed, 19 + 2 = 21 caracteres

Requer -Eargumento para sedhabilitar expressões regulares estendidas.

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

Java 8, 40 bytes

Expressões regulares: quase, mas não exatamente, a ferramenta errada para o trabalho. Lambda de Stringpara String(atribuir a Function<String, String>). A entrada deve ter uma nova linha à direita.

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

Experimente Online

Agradecimentos

• -3 bytes graças ao regex de Sven Hohenstein

Haskell , 27 25 bytes

A versão de Laikoni é mais curta que a minha:

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

Experimente online!

Minha versão:

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

Experimente online!

C (gcc) , 53 48 46 bytes

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

Experimente online!

-5 bytes: Foi muito complicado reduzir esse " programa inteiro " para o mesmo tamanho da função de gurka . Agora ele está escrevendo fora dos limites (em ambas as direções) de uma matriz do tipo errado e conta com pequenos endian e inteiros de 4 bytes para encontrar o asterisco ... mas, ei, funciona;)

-2 bytes: Bem, se já escrevemos em algum local "aleatório" .bss, por que se preocupar em declarar uma matriz ! Então aqui vem o programa de manipulação de strings que não usa o chartipo nem uma matriz.

R, 47 45 bytes

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

SNOBOL4 (CSNOBOL4) , 72 70 66 50 bytes

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

Experimente online!

A correspondência de padrões no SNOBOL é bem diferente da regex, mas a idéia aqui ainda é a mesma: se uma linha corresponder a "seis caracteres e depois um asterisco", remova-a, caso contrário, remova os sete primeiros caracteres da linha e imprima o resultado.

Agora, agora, ele tira melhor proveito do operador de atribuição condicional do SNOBOL.

O padrão POS(6) (' ' REM . OUTPUT | '*')é interpretado como:

Começando na posição 6, combine um espaço ou um asterisco e, se você corresponder a um espaço, atribua o restante da linha a OUTPUT.

Vim, 14 bytes

Ctrl-VG5ld:%g/\*/dEnter

Carregando o arquivo de entrada como o buffer a ser editado, digite os comandos acima. Saída é o novo buffer.

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

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

Experimente online!

Usos -p sinalizador.

Explicação:

O -psinalizador adiciona um bloco implícito ao redor do código; portanto, o código que realmente é executado fica assim:

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

    puts $_
end

gets lê uma linha de texto e armazena seu resultado em $_ .

$_[/.../]=''remove a primeira ocorrência do regex ...em$_ .

/.{6}( |.*\n)/corresponde a 6 de qualquer caractere no início de uma linha, seguido por um espaço ou pelo restante da linha. Como o espaço aparece primeiro, ele tentará remover apenas os 6 primeiros caracteres e um espaço antes de tentar remover a linha inteira.

$_ é impresso e esse processo é repetido para cada linha.

Pyke , 9 bytes

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

Experimente aqui!

Legível:

6L>#d.^)mt

Experimente aqui!

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

Retina , 23 15 bytes

5 bytes economizados graças ao nmjcman101
1 byte economizado graças a Neil

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

Experimente online!

JavaScript (ES6), 48 bytes

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

Experimente online!

> <>, 57 53 bytes

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

experimente online

Explicação

>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

Editar: 53 bytes

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

Basicamente, o mesmo material de antes, mas reestruturado ligeiramente

Como nota lateral: estou decepcionado que ninguém tenha feito isso ainda.

C #, 160 145 90 89 bytes

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

Agradecimentos a Pavel & auhmaan por reduzir o tamanho.

Python 3, 71 bytes (sem regexp)

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

Funciona!

>>> 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 bytes

|ʒ6èðQ}ε7F¦

Experimente online!

JavaScript, 44 34 bytes

^{44 riscado ainda é regular 44.}

6 bytes salvos graças ao tsh

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

Experimente online!

C ++ (GCC), 121 112 bytes

Obrigado a @gurka por salvar 9 bytes!

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

Recebe a entrada como uma lista de linhas.

Experimente online!

Java 8, 95 54 53 bytes

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

-42 bytes graças a @ OliverGrégoire , usando a em Stream<String>vez de Stringcomo entrada e saída.

Explicação:

Experimente aqui.

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)