Ne commentez pas un programme COBOL!

65

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 , 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é.

LyricLy
la source
23
Les numéros de ligne ne sont pas des commentaires. Ils sont une colonne. Terminologie s'il vous plaît.
user207421
2
Vos exemples ont tous un espace après le *. Est-ce une coïncidence?
Neil
1
@ Neil Oui, c'est ça. Le huitième caractère peut être n'importe quoi.
LyricLy
6
Vieux n'implique pas automatiquement mauvais. J'ai travaillé dans un magasin Agile COBOL. Ils pourraient faire des choses sur l'AS / 400 que nous ne pouvions pas faire en Java.
Thorbjørn Ravn Andersen
4
Peut-il y avoir un espace dans les 6 premiers caractères?

Réponses:

104

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
Jakob
la source
10
Les astérisques (*) ne seront jamais trouvés en dehors des sept premiers caractères d'une ligne ... et pourtant ...;)
Cœur
@ Cœur Haha oui ... mais ma solution n'utilise pas cette hypothèse, alors c'est peut-être approprié!
Jakob
8
Vous gagnez un internet.
Joshua
@ Cœur sauf dans une déclaration COMPUTE.
ClickRick
1
Félicitations pour votre badge en or!
Caird coinheringaahing
20

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.

totalement humain
la source
2
Enregistrez un octet en le remplaçant !=par <, car le point de code d'un espace est inférieur à celui d'un astérisque, et le septième caractère sera toujours un espace ou un astérisque.
LyricLy
Donc, le 7ème caractère sera toujours un espace ou un astérisque?
totalement humain
Oui. You may assume the seventh character is always an asterisk or a space.
LyricLy
1
Économisez 1 octet avecif'*'!=i[6]
Mego
13

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

-4 octets avec les suggestions de Pavel

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

Essayez-le en ligne!

Xcali
la source
2
Vous pouvez économiser trois octets si vous remplacez (\*.*$| )par( |.*)
Pavel
Pas aussi court que le commentaire de Pavel, mais / /;$_=/\* /?$,:$'une autre alternative
Dom Hastings
Vous n'avez pas non plus besoin du ^.
Pavel
11

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
nmjcman101
la source
Ne pourriez-vous pas faire 7xau lieu de 6x<<?
DJMcMayhem
1
Ensuite, il supprime le*
nmjcman101
Est-ce que ça marche de supprimer les lins avec d' *abord et ensuite de le faire Î7x? (en supposant qu'un * ne peut pas ne pas être dans les caractères 0-5)
12431234123412341234123
@ 12431234123412341234123 malheureusement non, car il peut y avoir un *dans les 6 premiers caractères.
nmjcman101
9

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

betaveros
la source
"Bonjour, j'ai écrit un langage de programmation pour le golf." La version que vous utilisez a-t-elle été publiée avant ou après la publication de ce défi?
Mât
1
Cela fonctionne sur cette version d'il y a trois jours: github.com/betaveros/paradoc/releases/tag/v0.2.8
betaveros
A droite, vous avez mentionné, mais en quelque sorte il n'a pas inscrit explicitement ...
Mast
7

Octave, 23 octets

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

Essayez-le en ligne!

rahnema1
la source
4
Je n'ai jamais su qu'Octave pouvait faire des ficelles comme ça ... Prends ça, MATLAB. xD
Sanchises
Depuis l'introduction de tableaux de chaînes par R2016b , je suis à peu près sûr que cela fonctionnerait aussi dans MATLAB @Sanchises! Je n'ai actuellement accès qu'à la R2015b, je ne peux donc pas confirmer. MATLAB peut le faire en 74 octets, probablement moins @(s)cellfun(@(r)r(8:end),s(cellfun(@(r)r(7)~=42,s)),'uniformoutput',false), où se strouve un tableau de cellules, pas un tableau de chaînes. Utiliser une expression rationnelle ou autre serait probablement plus court, mais la méthode que j'ai écrite est comparable à la méthodologie décrite dans cette réponse, rien que pour l'ancien MATLAB
Wolfie
6

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
fireflame241
la source
7$€can be€7
Erik the Outgolfer
réduisez-le à 9 comme suit:ṫ€7Ḣ⁼¥Ðf⁶
Jonathan Allan
5

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.

TessellatingHeckler
la source
4

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!

Simon
la source
3

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!

Mego
la source
3

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
Chat d'affaires
la source
Je compte dix caractères, et comme trois ne sont pas ASCII, ne prennent-ils pas plus d'un octet?
WGroleau
@WGroleau et «sont tous deux 1 caractère. Les langues de golf utilisant des caractères non-ascii (peut-être sauf Neim) utilisent des codages personnalisés qui permettent à tous ces non-ASCII d'être comptés comme un seul octet. Voici la page de code de Gaia .
M. Xcoder
@ Mr.Xcoder Neim a aussi un encodage.
Erik the Outgolfer
3

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.
M. Xcoder
la source
" Gardez ceux qui ont le premier caractère d'un astérisque. " Je pense que vous vouliez dire "Gardez ceux dont le premier caractère n'est PAS un astérisque."
Kevin Cruijssen
m>d7.m@b6devrait fonctionner à 9 octets, en abusant *après l'espace dans l'ordre lexicographique
Dave
Je peux l'éditer avec un lien explication / test si vous voulez!
Dave
@pizzakingme Je serais heureux si vous pouviez éditer, car je suis sur mobile. Merci beaucoup et n'oubliez pas de créditer la nouvelle solution!
M. Xcoder
Cela fonctionne-t-il si toutes les lignes sont des commentaires de ligne? (Je ne sais pas si vous devez gérer ce cas)
betaveros
3

GNU Sed, 19 + 2 = 21 caractères

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

/^.{6}\*/d;s/^.{7}/
Daniel Schepler
la source
vous pouvez faire la même chose que le type perl,s/^.{6}( |.*)//g
markasoftware
3

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

Jakob
la source
Le bon outil! :)
Olivier Grégoire Le
3

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!

jferard
la source
25 octets: f n=[x|' ':x<-drop 6<$>n].
Laikoni
@ Laikoni C'est gentil !! Je ne savais pas qu'il était possible de faire correspondre des modèles dans un générateur de compréhension de liste.
jferard
3

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.

Felix Palmen
la source
Agréable! Et cela *x&2m'a rappelé: "Vous pouvez supposer que le septième caractère est toujours un astérisque ou un espace.", Je devrais donc être en mesure de réduire de quelques octets ma réponse :-)
simon
@gurka merci: D -2, héhé
Felix Palmen
3

R, 47 45 octets

function(x)gsub("(?m)^.{6}( |.*\\n)","",x,,T)
Sven Hohenstein
la source
Si vous prenez l'entrée comme une liste de chaînes, je pense que vous pouvez raccourcir l'expression rationnelle à "^. {6} (|. * ​​$)" Pour -6.
CriminallyVulgar
@CiminelyVulgar Correct. Dans ce cas, je pourrais aussi laisser tomber l' pe=Targument. Cependant, je ne sais pas si l'entrée sous forme de liste de chaînes est autorisée.
Sven Hohenstein
Depuis l'OP:Input or output may be a matrix or list.
totalement humain
@CriminallyVulgar Le problème est la présence de chaînes vides dans la sortie.
Sven Hohenstein
@SvenHohenstein Ah bien sûr, je n'y avais pas pensé.
CriminallyVulgar
3

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.

Giuseppe
la source
3

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.

David Heyman
la source
2

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.

Pavel
la source
1
Les appels de méthode en Ruby n’ont pas besoin de parenthèses, les supprimer vous évitera de perdre un octet.
m-chrzan
2

JavaScript (ES6), 48 octets

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

Essayez-le en ligne!

sgtdck
la source
1
Ce n'est ni une fonction, ni un programme complet, car cela suppose que l'entrée est stockée dans z, ce qui n'est pas autorisé ici. Vous pouvez toutefois le transformer en une fonction de flèche anonyme, afin de le rendre valide.
Caird coinheringaahing
1
@cairdcoinheringaahing vous avez absolument raison. Mise à jour de la solution - ne pas savoir quelles sont les règles concernant le (et )autour du fn, les a ajoutées pour en être sûr.
samedi
1
Vous n'avez pas besoin de la ()fonction, mais sinon, ça a l'air bien.
Caird coinheringaahing
2

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

Sasha
la source
2

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.

ronflement
la source
Bienvenue chez PPCG! Je suggérerais d’ajouter un lien d’ essai en ligne à votre réponse afin que d’autres personnes puissent tester votre code. En plus de ça, super première (enfin, deuxième) réponse!
LyricLy
Vous pouvez raccourcir cette étape en écrivant un lambda sous la formet=>{...}
Pavel
@ LyyLy j'ai essayé de le faire, en fait, mais pour une raison quelconque, cela ne fonctionne pas là-bas. Cela fonctionne parfaitement dans une application de console VS, cependant.
Snorepion
@Pavel Comme si? Je ne sais pas si je l'ai fait complètement correctement; Je n'ai jamais eu besoin d'utiliser une expression lambda auparavant.
Snorepion
Oui, exactement. Vous pouvez le tester en l’attribuant à un fichier func<string, string>.
Pavel
2

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
Sagittaire
la source
1

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!


la source
s=>s.replace(/^.{6}( |\*.*\s)?/mg,'')
tsh
s.match(/(?<=^.{6} ).*/mg) ESNext (Non standard, Stage3) Chrome62 +
tsh
@th. Jusqu'à ce qu'il y ait un interprète stable qui le permette, je suppose que cela ne compte pas comme langage de programmation valide.
Il ne semble pas que cela donne le bon résultat si la dernière ligne est une ligne de commentaire.
LyricLy
@LyricLy. C'est parce que j'ai supposé que l'entrée contiendra toujours une nouvelle ligne. Vous pouvez voir que cela fonctionne s'il y a une ligne vide après l'entrée. Si je ne devais pas l'assumer, alors la réparation coûtera 1 octet (en ajoutant ?après \n).
1

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!

Steadybox
la source
#import? De plus, je pense qu'il est correct d'omettre les inclusions standard.
simon
#importCe n'est pas le standard C ++, mais au moins GCC et MSVC le supportent. Omettre certains inclus fonctionne avec C, mais pas avec C ++. Le code ne fonctionne pas sans les inclus, ils doivent donc être comptés dans le total des sous-comptes.
Steadybox
Aha, je pensais que vous pouviez ignorer les inclus, car vous ne voyez aucune importréponse en python ni usingen réponse C #. Aussi, ne serait-il pas #include <bits/stdc++.h>plus court pour votre réponse?
simon
@gurka Oui, ce serait plus court. Merci!
Steadybox
@gurka les importations sont comptées dans les réponses Python, c'est juste que Python a beaucoup de fonctions qui n'ont pas besoin d'importation. C # a tendance à ne pas utiliser statement car il est généralement plus court à écrire system.foo()queusing system;foo()
Pavel
1

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)
Kevin Cruijssen
la source
On dirait que vous pouvez utiliser un String[]ou List<String>comme entrée pour -12 octets.
Jakob
Ou Stream<String>si cela peut aider. Exemple:s->s.map(x->x.charAt(6)!=42?x.substring(7):"")
Olivier Grégoire
1
Oh, il faut filtrer ... alors s->s.filter(x->x.charAt(6)!=42).map(x->x.substring(7))pour 54 octets.
Olivier Grégoire
1
Utilisez <42plutôt que !=42parce que "vous pouvez supposer que le septième caractère est toujours un astérisque ou un espace".
Olivier Grégoire
1
@ OlivierGrégoire Ah, j'ai raté cette règle, sinon je l'aurais fait moi-même. Merci pour la correction.
Kevin Cruijssen