COBOL es un idioma muy antiguo, al momento de escribirlo tiene 58 años. Es tan viejo, de hecho, que tiene una peculiaridad muy interesante: los primeros seis caracteres de cada línea son comentarios.

¿Por qué es esto, preguntas? Bueno, esos 6 caracteres estaban destinados a ser utilizados como números de línea, en aquellos días en que los programas no eran completamente digitales y se escribían en una computadora.

Además, el séptimo carácter solo podría ser parte de un conjunto muy pequeño (generalmente es *comentar la línea o un espacio para separar el número de línea del código)

Pero, ¿qué pasa si estás en un sistema más digital y solo quieres el programa en bruto?

El sistema de comentarios

Hay dos tipos de comentarios en COBOL: comentarios de línea y los comentarios de "número de línea" antes mencionados.

Descomentar los números de línea es simple: simplemente quite los primeros siete caracteres (seis más un espacio) de cada línea.

000000 apple
000001 banana
celery donuts

se convertiría:

apple
banana
donuts

Los comentarios de línea lo hacen un poco más difícil. Se inicia un comentario de línea con un asterisco *colocado en la posición del séptimo carácter en la línea, así:

000323* this is a comment

Este no es un comentario de línea:

*00000 this isn't a comment

Para descomentar un comentario de línea, simplemente elimine toda la línea.

Un ejemplo comentado "programa":

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

La versión no comentada:

blah blah
oranges?
love me some oranges

En otras palabras, para descomentar una cadena, elimine los primeros seis caracteres de cada línea, luego devuelva todos menos el primer carácter de cada línea que no comience con una estrella.

El reto

Cree un programa o función que tome un programa comentado y devuelva su variante no comentada.

Aclaraciones

• Los asteriscos ( *) nunca se encontrarán en ningún lugar fuera de los primeros siete caracteres de una línea (no le pedimos que verifique la sintaxis)
• Cada línea siempre tendrá al menos 7 caracteres.
• Puede suponer que el séptimo carácter es siempre un asterisco o un espacio.
• La entrada o salida puede ser una matriz o una lista.
• Solo se deben manejar los caracteres ASCII imprimibles (más la nueva línea).
• Puede generar una nueva línea final. También puede suponer que la entrada tendrá una nueva línea final, si así lo desea.

Puntuación

Como se trata de código de golf , ¡la respuesta con la menor cantidad de bytes gana!

_{DESCARGO DE RESPONSABILIDAD: en realidad no conozco COBOL y no pretendo hacerlo. Si alguna de las afirmaciones sobre COBOL que he hecho en esta pregunta es incorrecta, no me hago responsable.}

COBOL (GnuCOBOL), 191 + 17 = 208 bytes

"Aprendí" COBOL para esta respuesta, por lo que probablemente no esté totalmente golfizado.

Este es un programa completo, que toma información sobre lo que presumo que es entrada estándar y escribe sobre lo que presumo que es salida estándar. Quizás algún día volveré a esto y (1) determinaré si COBOL tiene funciones y, de ser así, (2) veré si una solución de función sería más corta.

El recuento de bytes incluye indicadores de programa y compilador ( -freey -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).

Pruébalo en línea

Programa sin golf

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

Limitaciones

La salida es, técnicamente hablando, no correcta. De mi investigación superficial, parece que la única forma práctica de almacenar una cadena en COBOL es en un búfer de tamaño fijo. Elegí un tamaño de búfer de 80 caracteres, ya que este es el límite de longitud de línea para programas de formato fijo. Esto presenta dos limitaciones:

• Las líneas de más de 80 caracteres se truncan.
• Las líneas de menos de 80 caracteres se rellenan con espacios a la derecha.

Supongo que esto es aceptable ya que, bueno, es COBOL. Si no, estaría dispuesto a buscar alternativas.

Expresiones de gratitud

• -166 bytes gracias a Edward H
• -2 bytes gracias a hornj

Python 2 , 39 38 37 bytes

-1 byte gracias a LyricLy. -1 byte gracias a Mego.

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

Pruébalo en línea!

E / S como listas de cadenas.

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

-4 bytes con las sugerencias de Pavel

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

Pruébalo en línea!

V , 13 11 10 bytes

Î6x<<
çª/d

Pruébalo en línea!

Explicación

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

Toma una lista de líneas y da como resultado una lista de líneas no comentadas.

Explicación:

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

Hola, escribí un lenguaje de programación de golf. :)

Todavía estoy desarrollando esto y agregué / modifiqué un montón de elementos incorporados después de intentar escribir esto para que haya formas más razonables de diferenciar entre un espacio y un asterisco que " 7#", pero siento que eso haría que esto no sea competitivo. Es una suerte que todavía funcionó (esto solo usa características de v0.2.8, que cometí hace tres días).

Octava, 23 bytes

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

Pruébalo en línea!

Jalea , 11 9 bytes

ṫ€7Ḣ⁼¥Ðf⁶

Pruébalo en línea!

Entradas y salidas como una lista de líneas.

-2 bytes gracias a @EriktheOutgolfer y @JonathanAllan

Cómo 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''

Pruébalo en línea!

La entrada de canalización viene como una matriz de cadenas, -replacefunciona en cada cadena y -ne ''(no es igual a una cadena vacía) aplicada a una matriz, actúa para filtrar las líneas en blanco.

C, 63 59 55 48 47 46 bytes

Gracias a " un usuario anónimo " por deshacerse de otro byte.

Gracias a Felix Palmen por recordarme " Puede suponer que el séptimo carácter es siempre un asterisco o un espacio ", lo que redujo un byte más.

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

Usar como:

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

Pruébalo en línea!

En realidad , 13 bytes

⌠6@tp' =*⌡M;░

La entrada y salida se realiza como una lista de cadenas.

Explicación:

⌠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

Pruébalo en línea!

Gaia , 9 bytes

6>¦'*«⁈ḥ¦

Una función que acepta una lista de cadenas y devuelve una lista de cadenas.

Pruébalo en línea!

Explicación

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

Pyth , 9 bytes

Tenga en cuenta que esto solo funciona si al menos 1 línea no es un comentario y al menos 1 línea es un comentario. Todas las demás soluciones funcionan en todos los casos.

-2 bytes gracias a @pizzakingme !

m>d7.m@b6

Pruébalo aquí!

Explicación

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.

Pyth , 11 bytes

tMfqhTdm>d6

Pruébalo aquí!

Explicación

tMfqhTdm> d6 - Programa completo con entrada implícita. Toma la entrada como una lista de cadenas.

       m> d6: elimina los primeros 6 caracteres de cada línea.
    hT: obtén el primer personaje de cada uno.
  fq d - Mantenga los que tienen el primer carácter con un asterisco.
tM: elimina el primer carácter de cada uno.
            - Salida implícita.

Pyth , 11 bytes

m>d7fqd@T6Q

Pruébalo aquí!

Explicación

m> d7fq @ T6dQ - Programa completo. Toma la entrada como una lista de cadenas.

      @ T6: el sexto personaje de cada uno.
    fq dQ - Mantenga las líneas que tienen un espacio como ^.
m> d7: recorta los primeros 7 caracteres.
             - Salida implícita.

Pyth , 12 bytes

tMfnhT\*m>d6

Pruébalo aquí!

Explicación

tMfnhT \ * m> d6 - Programa completo con entrada implícita. Toma la entrada como una lista de cadenas.

        m> d6: elimina los primeros 6 caracteres de cada línea.
    hT: obtén el primer personaje de cada uno.
  fn \ * - Filtra aquellos que no son iguales a un asterisco.
tM: elimina el primer carácter de cada uno.
             - Salida implícita.

Pyth , 12 bytes

m>d7fn@T6\*Q

Pruébalo aquí!

Explicación

m> d7fn @ T6 \ * Q - Programa completo. Toma la entrada como una lista de cadenas.

      @ T6: obtén el sexto carácter de cada cadena
    fn \ * Q - Y filtra aquellos que no son iguales a un asterisco.
m> d7: recorta los primeros 7 caracteres.
              - Salida implícita.

GNU Sed, 19 + 2 = 21 caracteres

Requiere -Eargumento para sedhabilitar expresiones regulares extendidas.

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

Java 8, 40 bytes

Expresiones regulares: casi, pero no del todo, la herramienta incorrecta para el trabajo. Lambda de Stringa String(asignar a Function<String, String>). La entrada debe tener una nueva línea final.

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

Pruébalo en línea

Expresiones de gratitud

• -3 bytes gracias a la expresión regular de Sven Hohenstein

Haskell , 27 25 bytes

La versión de Laikoni es más corta que la mía:

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

Pruébalo en línea!

Mi version:

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

Pruébalo en línea!

C (gcc) , 53 48 46 bytes

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

Pruébalo en línea!

-5 bytes: fue muy difícil reducir este " programa completo " al mismo tamaño que la función de gurka . Ahora está escribiendo fuera de los límites (en ambas direcciones) de una serie de tipos incorrectos y se basa en pequeños endianos y enteros de 4 bytes para encontrar el asterisco ... pero bueno, funciona;)

-2 bytes: Bueno, si ya escribimos en alguna .bssubicación "aleatoria" , ¿por qué molestarse en declarar una matriz ? Así que aquí viene el programa de manejo de cadenas que no usa ni el chartipo ni una 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

Pruébalo en línea!

La coincidencia de patrones en SNOBOL es bastante diferente de la expresión regular, pero la idea aquí sigue siendo la misma: si una línea coincide con "seis caracteres y luego un asterisco", elimínela; de lo contrario, elimine los primeros siete caracteres de la línea e imprima el resultado.

Esto ahora aprovecha mejor el operador de asignación condicional de SNOBOL.

El patrón es el POS(6) (' ' REM . OUTPUT | '*')que se interpreta como:

Comenzando en la posición 6, haga coincidir un espacio o un asterisco, y si coincide con un espacio, asigne el resto de la línea a OUTPUT.

Vim, 14 bytes

Ctrl-VG5ld:%g/\*/dEnter

Cargue el archivo de entrada como el búfer para editar, luego ingrese los comandos anteriores. La salida es el nuevo búfer.

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

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

Pruébalo en línea!

Usa -pbandera.

Explicación:

El -pindicador agrega un bloque implícito alrededor del código, por lo que el código que realmente se ejecuta se ve así:

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

    puts $_
end

getslee una línea de texto y almacena su resultado en $_.

$_[/.../]=''elimina la primera aparición de la expresión regular ...en $_.

/.{6}( |.*\n)/coincide con 6 de cualquier carácter al comienzo de una línea, seguido de un espacio o el resto de la línea. Debido a que el espacio aparece primero, intentará eliminar solo los primeros 6 caracteres y un espacio antes de intentar eliminar la línea completa.

$_ se imprime y este proceso se repite para cada línea.

Pyke , 9 bytes

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

Pruébalo aquí!

Legible:

6L>#d.^)mt

Pruébalo aquí!

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 guardados gracias a nmjcman101
1 byte guardado gracias a Neil

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

Pruébalo en línea!

JavaScript (ES6), 48 bytes

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

Pruébalo en línea!

> <>, 57 53 bytes

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

pruébalo en línea

Explicación

>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<
~   \~/

Básicamente lo mismo que antes, pero reestructurado ligeramente

Como nota al margen: estoy decepcionado de que nadie haya hecho esto en cobol todavía.

C #, 160145 90 89 bytes

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

Gracias a Pavel & auhmaan por reducir el tamaño.

Python 3, 71 bytes (sin expresión regular)

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¦

Pruébalo en línea!

JavaScript, 44 34 bytes

^{Tachado 44 sigue siendo regular 44.}

6 bytes guardados gracias a tsh

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

Pruébalo en línea!

C ++ (GCC), 121 112 bytes

¡Gracias a @gurka por guardar 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());}

Toma la entrada como una lista de líneas.

Pruébalo en línea!

Java 8, 95 54 53 bytes

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

-42 bytes gracias a @ OliverGrégoire , utilizando un en Stream<String>lugar de Stringcomo entrada y salida.

Explicación:

Pruébalo aquí.

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)