COBOL è una lingua molto antica, al momento in cui scrivo ha 58 anni. È così vecchio, infatti, che ha una stranezza molto interessante: i primi sei caratteri di ogni riga sono commenti.

Perché chiedi questo? Bene, quei 6 personaggi dovevano essere usati come numeri di riga, ai tempi in cui i programmi non erano completamente digitali e digitati su un computer.

Inoltre, il settimo carattere potrebbe far parte solo di un set molto piccolo (di solito è *necessario commentare la riga o uno spazio per separare il numero di riga dal codice)

Ma cosa succede se si utilizza un sistema più digitale e si desidera solo il programma non elaborato?

Il sistema dei commenti

Esistono due tipi di commenti in COBOL: commenti di riga e commenti di "numero di riga" di cui sopra.

I numeri di riga senza commenti sono semplici: basta togliere i primi sette (sei più uno spazio singolo) da ogni riga.

000000 apple
000001 banana
celery donuts

potrebbe diventare:

apple
banana
donuts

I commenti in linea lo rendono un po 'più difficile. Un commento di riga viene avviato con un asterisco *posizionato nella settima posizione del carattere sulla riga, in questo modo:

000323* this is a comment

Questo non è un commento di riga:

*00000 this isn't a comment

Per rimuovere il commento da un commento di riga, basta rimuovere l'intera riga.

Un esempio di "programma" commentato:

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

La versione non commentata:

blah blah
oranges?
love me some oranges

In altre parole, per rimuovere il commento da una stringa, rimuovere i primi sei caratteri di ogni riga, quindi restituire tutti tranne il primo carattere di ogni riga che non inizia con una stella.

La sfida

Creare un programma o una funzione che accetta un programma commentato e restituisce la sua variante non commentata.

chiarimenti

• Gli asterischi ( *) non si troveranno mai al di fuori dei primi sette caratteri di una riga (non ti stiamo chiedendo di verificare la sintassi)
• Ogni riga avrà sempre almeno 7 caratteri.
• Puoi assumere che il settimo carattere sia sempre un asterisco o uno spazio.
• L'input o l'output possono essere una matrice o un elenco.
• Devono essere gestiti solo caratteri ASCII stampabili (più newline).
• È possibile eseguire l'output con una nuova riga finale. Puoi anche supporre che l'input avrà una nuova riga finale, se lo desideri.

punteggio

Dato che si tratta di code-golf , la risposta con il minor numero di byte vince!

_{NOTA BENE: In realtà non conosco COBOL e non pretendo di farlo. Se una delle affermazioni su COBOL che ho formulato in questa domanda sono errate, non mi assumo alcuna responsabilità.}

COBOL (GnuCOBOL), 191 + 17 = 208 byte

Ho "imparato" COBOL per questa risposta, quindi probabilmente non è completamente golfato.

Questo è un programma completo, prendendo input su ciò che presumo sia input standard e scrivendo su ciò che presumo sia output standard. Forse un giorno tornerò su questo e (1) determinerò se COBOL ha funzioni e, in tal caso, (2) vedo se una soluzione di funzione sarebbe più breve.

Il conteggio dei byte include i flag di programma e compilatore ( -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).

Provalo online

Programma non golfato

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

limitazioni

L'output non è, tecnicamente parlando, corretto. Dalla mia rapida ricerca, sembra che l'unico modo pratico per memorizzare una stringa in COBOL sia in un buffer di dimensioni fisse. Ho scelto una dimensione del buffer di 80 caratteri, poiché questo è il limite di lunghezza della linea per i programmi a formato fisso. Ciò presenta due limiti:

• Le righe più lunghe di 80 caratteri vengono troncate.
• Le righe più corte di 80 caratteri sono riempite a destra con spazi.

Immagino che questo sia accettabile poiché, beh, è ​​COBOL. Altrimenti, sarei disposto a cercare alternative.

Ringraziamenti

• -166 byte grazie a Edward H
• -2 byte grazie a hornj

Python 2 , 39 38 37 byte

-1 byte grazie a LyricLy. -1 byte grazie a Mego.

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

Provalo online!

I / O come elenchi di stringhe.

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

-4 byte con i suggerimenti di Pavel

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

Provalo online!

V , 13 11 10 byte

Î6x<<
çª/d

Provalo online!

Spiegazione

Î       ' 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 byte (CP-1252)

µ6>(7#;x

Prende un elenco di righe e genera un elenco di righe non commentate.

Spiegazione:

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

Ciao, ho scritto un linguaggio di programmazione per il golf. :)

Sto ancora sviluppando questo e ho aggiunto / modificato un sacco di incorporati dopo aver provato a scrivere questo in modo che ci siano modi più ragionevoli per distinguere tra uno spazio e un asterisco di " 7#", ma penso che ciò renderebbe questo non competitivo. È una fortuna che abbia funzionato (utilizza solo le funzionalità della versione 2.0.8, che ho eseguito tre giorni fa).

Ottava, 23 byte

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

Provalo online!

Gelatina , 11 9 byte

ṫ€7Ḣ⁼¥Ðf⁶

Provalo online!

Ingressi e uscite come un elenco di linee.

-2 byte grazie a @EriktheOutgolfer e @JonathanAllan

Come funziona

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

Provalo online!

L'input della pipeline arriva come un array di stringhe, -replacefunziona su ogni stringa e -ne ''(non uguale a stringa vuota) applicato a un array, agisce per filtrare le righe vuote.

C, 63 59 55 48 47 46 byte

Grazie a " un utente anonimo " per sbarazzarsi di un altro byte.

Grazie a Felix Palmen per avermi ricordato di " Puoi supporre che il settimo carattere sia sempre un asterisco o uno spazio ", che si è rasato di un altro byte.

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

Usa come:

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

Provalo online!

In realtà , 13 byte

⌠6@tp' =*⌡M;░

L'input e l'output vengono eseguiti come un elenco di stringhe.

Spiegazione:

⌠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

Provalo online!

Gaia , 9 byte

6>¦'*«⁈ḥ¦

Una funzione che accetta un elenco di stringhe e restituisce un elenco di stringhe.

Provalo online!

Spiegazione

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

Pyth , 9 byte

Nota che questo funziona solo se almeno 1 riga non è un commento e almeno 1 riga è un commento. Tutte le altre soluzioni funzionano in tutti i casi.

-2 byte grazie a @pizzakingme !

m>d7.m@b6

Provalo qui!

Spiegazione

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 byte

tMfqhTdm>d6

Provalo qui!

Spiegazione

tMfqhTdm> d6 - Programma completo con input implicito. Accetta input come un elenco di stringhe.

       m> d6: rimuove i primi 6 caratteri di ogni riga.
    hT - Ottieni il primo personaggio di ciascuno.
  fq d - Mantieni un asterisco a quelli che hanno il primo carattere.
tM: rimuove il primo carattere di ciascuno.
            - Uscita implicita.

Pyth , 11 byte

m>d7fqd@T6Q

Provalo qui!

Spiegazione

m> d7fq @ T6dQ - Programma completo. Accetta input come un elenco di stringhe.

      @ T6 - Il sesto carattere di ciascuno.
    fq dQ - Mantiene le linee che hanno uno spazio come ^.
m> d7 - Ritaglia i primi 7 caratteri.
             - Uscita implicita.

Pyth , 12 byte

tMfnhT\*m>d6

Provalo qui!

Spiegazione

tMfnhT \ * m> d6 - Programma completo con input implicito. Accetta input come un elenco di stringhe.

        m> d6: rimuove i primi 6 caratteri di ogni riga.
    hT - Ottieni il primo personaggio di ciascuno.
  fn \ * - Filtra quelli che non sono uguali a un asterisco.
tM: rimuove il primo carattere di ciascuno.
             - Uscita implicita.

Pyth , 12 byte

m>d7fn@T6\*Q

Provalo qui!

Spiegazione

m> d7fn @ T6 \ * Q - Programma completo. Accetta input come un elenco di stringhe.

      @ T6 - Ottieni il sesto carattere di ogni stringa
    fn \ * Q - E filtra quelli che non sono uguali a un asterisco.
m> d7 - Ritaglia i primi 7 caratteri.
              - Uscita implicita.

GNU Sed, 19 + 2 = 21 caratteri

Richiede -Eargomento per sedabilitare espressioni regolari estese.

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

Java 8, 40 byte

Espressioni regolari: quasi, ma non del tutto, lo strumento sbagliato per il lavoro. Lambda da Stringa String(assegnare a Function<String, String>). L'input deve avere una nuova riga finale.

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

Provalo online

Ringraziamenti

• -3 byte grazie alla regex di Sven Hohenstein

Haskell , 27 25 byte

La versione di Laikoni è più corta della mia:

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

Provalo online!

La mia versione:

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

Provalo online!

C (gcc) , 53 48 46 byte

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

Provalo online!

-5 byte: è stato molto complicato ridurre questo " intero programma " alle stesse dimensioni della funzione di gurka . Ora sta scrivendo fuori dai limiti (in entrambe le direzioni) di una matrice di tipo errato e si basa su piccoli endian e numeri interi a 4 byte per trovare l'asterisco ... ma hey, funziona;)

-2 byte: bene, se scriviamo già in una posizione "casuale" .bss, perché preoccuparsi di dichiarare un array ! Quindi ecco che arriva il programma di gestione delle stringhe che non utilizza né il chartipo né un array.

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

Provalo online!

La corrispondenza dei motivi in ​​SNOBOL è abbastanza diversa da regex ma l'idea qui è sempre la stessa: se una riga corrisponde a "sei caratteri e quindi un asterisco", rimuovila, altrimenti rimuovi i primi sette caratteri della riga e stampa il risultato.

Questo ora sfrutta al meglio l'operatore di assegnazione condizionale di SNOBOL.

Lo schema POS(6) (' ' REM . OUTPUT | '*')è interpretato come:

A partire dalla posizione 6, abbina uno spazio o un asterisco e, se abbini uno spazio, assegna il resto della linea a OUTPUT.

Vim, 14 byte

Ctrl-VG5ld:%g/\*/dEnter

Caricamento del file di input come buffer da modificare, quindi immettere i comandi sopra. L'output è il nuovo buffer.

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

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

Provalo online!

Usa la -pbandiera.

Spiegazione:

Il -pflag aggiunge un blocco implicito attorno al codice, quindi il codice che viene effettivamente eseguito è simile al seguente:

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

    puts $_
end

getslegge una riga di testo e ne memorizza il risultato $_.

$_[/.../]=''rimuove la prima occorrenza del regex ...in $_.

/.{6}( |.*\n)/corrisponde a 6 di qualsiasi carattere all'inizio di una riga, seguito da uno spazio o dal resto della riga. Poiché lo spazio viene visualizzato per primo, tenterà di rimuovere solo i primi 6 caratteri e uno spazio prima di tentare di rimuovere l'intera riga.

$_ viene quindi stampato e questo processo viene ripetuto per ogni riga.

Pyke , 9 byte

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

Provalo qui!

Leggibile:

6L>#d.^)mt

Provalo qui!

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

Retina , 23 15 byte

5 byte salvati grazie a nmjcman101
1 byte salvato grazie a Neil

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

Provalo online!

JavaScript (ES6), 48 byte

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

Provalo online!

> <>, 57 53 byte

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

provalo online

Spiegazione

>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

Modifica: 53 byte

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

Sostanzialmente le stesse cose di prima, ma leggermente ristrutturate

Come nota a margine: sono deluso che nessuno l'abbia ancora fatto in 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;}

Grazie a Pavel & auhmaan per la riduzione delle dimensioni.

Python 3, 71 byte (nessuna regexp)

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

Funziona!

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

Provalo online!

JavaScript, 44 34 byte

^{Il barrato 44 è ancora regolare 44.}

6 byte salvati grazie a tsh

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

Provalo online!

C ++ (GCC), 121 112 byte

Grazie a @gurka per aver salvato 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());}

Accetta input come un elenco di righe.

Provalo online!

Java 8, 95 54 53 byte

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

-42 byte grazie a @ OliverGrégoire , usando un Stream<String>invece di Stringcome in e output.

Spiegazione:

Provalo qui.

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)