Le COBOL est une langue très ancienne. Au moment de la rédaction de cet article, il a 58 ans. Il est si vieux, en fait, qu’il a une bizarrerie très intéressante: les six premiers caractères de chaque ligne sont des commentaires.

Pourquoi est-ce que vous demandez? Eh bien, ces 6 caractères étaient destinés à être utilisés comme numéros de ligne, à l’époque où les programmes n’étaient pas entièrement numériques et tapés sur un ordinateur.

De plus, le septième caractère ne peut faire partie que d'un très petit ensemble (il s'agit généralement *de commenter la ligne ou d'un espace pour séparer le numéro de ligne du code).

Mais que se passe-t-il si vous utilisez un système plus numérique et que vous souhaitez uniquement le programme brut?

Le système de commentaires

Il existe deux types de commentaires dans COBOL: les commentaires de ligne et les commentaires "numéro de ligne" susmentionnés.

Décommenter les numéros de ligne est simple: il suffit de prendre les sept premiers caractères (six plus un seul espace) de chaque ligne.

000000 apple
000001 banana
celery donuts

deviendrait:

apple
banana
donuts

Les commentaires de ligne rendent les choses un peu plus difficiles. Un commentaire de ligne commence par un astérisque *placé au septième caractère de la ligne, comme suit:

000323* this is a comment

Ce n'est pas un commentaire de ligne:

*00000 this isn't a comment

Pour supprimer un commentaire de ligne, supprimez simplement la ligne entière.

Un exemple commenté "programme":

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

La version non commentée:

blah blah
oranges?
love me some oranges

En d'autres termes, pour supprimer la mise en commentaire d'une chaîne, supprimez les six premiers caractères de chaque ligne, puis renvoyez tous les caractères sauf le premier caractère de chaque ligne qui ne commence pas par une étoile.

Le défi

Créez un programme ou une fonction qui prend un programme commenté et renvoie sa variante non commentée.

Des clarifications

• Les astérisques ( *) ne seront jamais trouvés en dehors des sept premiers caractères d'une ligne (nous ne vous demandons pas de vérifier la syntaxe)
• Chaque ligne aura toujours au moins 7 caractères.
• Vous pouvez supposer que le septième caractère est toujours un astérisque ou un espace.
• L'entrée ou la sortie peut être une matrice ou une liste.
• Seuls les caractères ASCII imprimables (plus la nouvelle ligne) doivent être gérés.
• Vous pouvez sortir avec une nouvelle ligne. Vous pouvez également supposer que l'entrée aura un retour à la ligne de fin, si vous le souhaitez.

Notation

Puisqu'il s'agit de code-golf , la réponse avec le moins d'octets gagne!

_{DISCLAIMER: Je ne connais pas réellement COBOL et ne prétends pas le faire. Si l'une des affirmations que j'ai faites à propos de COBOL dans cette question est inexacte, je décline toute responsabilité.}

COBOL (GnuCOBOL), 191 + 17 = 208 octets

J'ai "appris" en COBOL pour cette réponse, donc ce n'est probablement pas complètement joué au golf.

Ceci est un programme complet, prenant en entrée ce que je présume être une entrée standard et en écrivant dans ce que je présume être une sortie standard. Peut-être qu'un jour, j'y reviendrai pour (1) déterminer si COBOL a des fonctions et, dans l'affirmative, (2) voir si une solution de fonction serait plus courte.

Le nombre d'octets inclut les indicateurs de programme et de compilateur ( -freeet -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).

Essayez-le en ligne

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

Limites

La sortie est techniquement pas correcte. De mes recherches superficielles, il semble que le seul moyen pratique de stocker une chaîne en COBOL est dans un tampon de taille fixe. J'ai choisi une taille de tampon de 80 caractères, car il s'agit de la limite de longueur de ligne pour les programmes au format fixe. Cela présente deux limitations:

• Les lignes de plus de 80 caractères sont tronquées.
• Les lignes de moins de 80 caractères sont complétées à droite par des espaces.

J'imagine que c'est acceptable car, bon, c'est du COBOL. Sinon, je serais prêt à chercher des solutions de rechange.

Remerciements

• -166 octets grâce à Edward H
• -2 octets grâce à hornj

Python 2 , 39 38 37 octets

-1 octet grâce à LyricLy. -1 octet grâce à Mego.

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

Essayez-le en ligne!

I / O en tant que listes de chaînes.

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

-4 octets avec les suggestions de Pavel

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

Essayez-le en ligne!

V , 13 11 10 octets

Î6x<<
çª/d

Essayez-le en ligne!

Explication

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

µ6>(7#;x

Prend une liste de lignes et génère une liste de lignes non commentées.

Explication:

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

Bonjour, j'ai écrit un langage de programmation pour le golf. :)

Je développe toujours ceci et a ajouté / peaufiné un tas de fonctions intégrées après avoir essayé de l'écrire afin qu'il y ait plus de façons raisonnables de différencier un espace et un astérisque que " 7#", mais je pense que cela rendrait cela non compétitif. Heureusement que cela fonctionne toujours (cela utilise uniquement les fonctionnalités de la v0.2.8, que j'ai validées il y a trois jours).

Octave, 23 octets

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

Essayez-le en ligne!

Gelée , 11 à 9 octets

ṫ€7Ḣ⁼¥Ðf⁶

Essayez-le en ligne!

Entrées et sorties sous forme de liste de lignes.

-2 octets grâce à @EriktheOutgolfer et @JonathanAllan

Comment ça fonctionne

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

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

Essayez-le en ligne!

L'entrée de pipeline se présente sous la forme d'un tableau de chaînes, -replacefonctionne sur toutes les chaînes et, -ne ''(différente de la chaîne vide) appliquée à un tableau, agit pour filtrer les lignes vides.

C, 63 59 55 48 47 46 octets

Merci à " un utilisateur anonyme " de se débarrasser d’un octet supplémentaire.

Merci à Felix Palmen de me rappeler " Vous pouvez supposer que le septième caractère est toujours un astérisque ou un espace ", ce qui a supprimé un octet de plus.

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

Utilisez comme:

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

Essayez-le en ligne!

En fait , 13 octets

⌠6@tp' =*⌡M;░

L'entrée et la sortie se font sous la forme d'une liste de chaînes.

Explication:

⌠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

Essayez-le en ligne!

Gaia , 9 octets

6>¦'*«⁈ḥ¦

Fonction acceptant une liste de chaînes et renvoyant une liste de chaînes.

Essayez-le en ligne!

Explication

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

Pyth , 9 octets

Notez que cela ne fonctionne que si au moins 1 ligne n'est pas un commentaire et au moins 1 ligne est un commentaire. Toutes les autres solutions fonctionnent dans tous les cas.

-2 octets grâce à @pizzakingme !

m>d7.m@b6

Essayez-le ici!

Explication

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 octets

tMfqhTdm>d6

Essayez-le ici!

Explication

tMfqhTdm> d6 - Programme complet avec entrée implicite. Prend l'entrée en tant que liste de chaînes.

       m> d6 - Supprime les 6 premiers caractères de chaque ligne.
    hT - Récupère le premier caractère de chacun.
  fq d - Conservez les astérisques des premiers caractères.
tM - Supprime le premier caractère de chacun.
            - Sortie implicite.

Pyth , 11 octets

m>d7fqd@T6Q

Essayez-le ici!

Explication

m> d7fq @ T6dQ - Programme complet. Prend l'entrée en tant que liste de chaînes.

      @ T6 - Le sixième caractère de chacun.
    fq dQ - Conserve les lignes qui ont un espace comme ^.
m> d7 - Recadrer les 7 premiers caractères.
             - Sortie implicite.

Pyth , 12 octets

tMfnhT\*m>d6

Essayez-le ici!

Explication

tMfnhT \ * m> d6 - Programme complet avec entrée implicite. Prend l'entrée en tant que liste de chaînes.

        m> d6 - Supprime les 6 premiers caractères de chaque ligne.
    hT - Récupère le premier caractère de chacun.
  fn \ * - Filtrez ceux qui ne sont pas égaux à un astérisque.
tM - Supprime le premier caractère de chacun.
             - Sortie implicite.

Pyth , 12 octets

m>d7fn@T6\*Q

Essayez-le ici!

Explication

m> d7fn @ T6 \ * Q - Programme complet. Prend l'entrée en tant que liste de chaînes.

      @ T6 - Récupère le sixième caractère de chaque chaîne
    fn \ * Q - Et filtrez ceux qui ne sont pas égaux à un astérisque.
m> d7 - Recadrer les 7 premiers caractères.
              - Sortie implicite.

GNU Sed, 19 + 2 = 21 caractères

Requiert un -Eargument pour sedactiver les expressions régulières étendues.

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

Java 8, 40 octets

Expressions régulières: à peu près, mais pas tout à fait, le mauvais outil pour le travail. Lambda de Stringà String(attribuer à Function<String, String>). L'entrée doit avoir une fin de ligne.

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

Essayez-le en ligne

Remerciements

• -3 octets grâce aux regex de Sven Hohenstein

Haskell , 27 à 25 octets

La version de Laikoni est plus courte que la mienne:

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

Essayez-le en ligne!

Ma version:

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

Essayez-le en ligne!

C (gcc) , 53 48 46 octets

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

Essayez-le en ligne!

-5 octets: Il était très difficile d'obtenir ce " programme entier " à la même taille que la fonction de gurka . Il écrit maintenant en dehors des limites (dans les deux sens) d'un tableau de type incorrect et s'appuie sur des entiers little endian et 4 octets pour trouver l'astérisque ... mais bon, ça marche;)

-2 octets: Eh bien, si nous écrivons déjà dans un .bssemplacement "aléatoire" , pourquoi se donner la peine de déclarer un tableau ? Voici donc le programme de traitement de chaîne qui n’utilise ni le chartype ni un tableau.

R, 47 45 octets

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

SNOBOL4 (CSNOBOL4) , 72 70 66 50 octets

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

Essayez-le en ligne!

La recherche de motifs dans SNOBOL est assez différente de regex mais l’idée est la même: si une ligne correspond à "six caractères, puis à un astérisque", supprimez-la, sinon, supprimez les sept premiers caractères de la ligne et imprimez le résultat.

En fait, cela profite maintenant mieux de l’opérateur d’affectation conditionnel de SNOBOL.

Le motif est POS(6) (' ' REM . OUTPUT | '*')ce qui est interprété comme:

En partant de la position 6, faites correspondre un espace ou un astérisque et, si vous correspondez à un espace, affectez le reste de la ligne à OUTPUT.

Vim, 14 octets

Ctrl-VG5ld:%g/\*/dEnter

Chargement du fichier d'entrée en tant que tampon à modifier, puis entrez les commandes ci-dessus. La sortie est le nouveau tampon.

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

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

Essayez-le en ligne!

Utilise le -pdrapeau.

Explication:

L' -pindicateur ajoute un bloc implicite autour du code, de sorte que le code réellement exécuté se présente comme suit:

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

    puts $_
end

getslit une ligne de texte et stocke son résultat dans $_.

$_[/.../]=''supprime la première occurrence de la regex ...dans $_.

/.{6}( |.*\n)/correspond à 6 de n'importe quel caractère au début d'une ligne, suivi d'un espace ou du reste de la ligne. Étant donné que l'espace apparaît en premier, il essaiera de supprimer uniquement les 6 premiers caractères et un espace avant d'essayer de supprimer la ligne entière.

$_ est ensuite imprimé et ce processus est répété pour chaque ligne.

Pyke , 9 octets

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

Essayez-le ici!

Lisible:

6L>#d.^)mt

Essayez-le ici!

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

Retina , 23 15 octets

5 octets enregistrés grâce à nmjcman101
1 octet enregistrés grâce à Neil

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

Essayez-le en ligne!

JavaScript (ES6), 48 octets

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

Essayez-le en ligne!

> <>, 57 53 octets

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

essayez-le en ligne

Explication

>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

Edit: 53 octets

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

Fondamentalement les mêmes choses qu'avant, mais légèrement restructuré

En note de côté: je suis déçu que personne ne l'ait encore fait en cobol.

C #, 160 145 90 89 octets

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

Merci à Pavel & auhmaan pour avoir réduit la taille.

Python 3, 71 octets (pas d'expressions rationnelles)

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

Ça marche!

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

|ʒ6èðQ}ε7F¦

Essayez-le en ligne!

JavaScript, 44 34 octets

^{44 barré est toujours régulier 44.}

6 octets sauvés grâce à tsh

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

Essayez-le en ligne!

C ++ (GCC), 121 112 octets

Merci à @gurka pour la sauvegarde de 9 octets!

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

Prend les entrées sous forme de liste de lignes.

Essayez-le en ligne!

Java 8, 95 54 53 octets

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

-42 octets grâce à @ OliverGrégoire , en utilisant un Stream<String>au lieu de Stringcomme entrée et sortie.

Explication:

Essayez-le ici.

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)