Anfang dieser Woche haben wir gelernt, wie man esoterische Sprachen zum Kommentieren formatiert . Heute machen wir das Gegenteil davon. Sie müssen ein Programm oder eine Funktion schreiben, die gut kommentierten esoterischen Code analysiert und die Kommentare auswertet, wobei nur der Code zurückgegeben wird. Anhand einiger Beispiele aus der vorherigen Herausforderung sehen Sie hier, wie gut kommentierter Code aussieht:

a                #Explanation of what 'a' does
 bc              #Bc
   d             #d
    e            #Explanation of e
     fgh         #foobar
        ij       #hello world
          k      #etc.
           l     #so on
            mn   #and
              op #so forth

Folgendes müssen Sie tun, um den Code zu extrahieren. Entfernen Sie zuerst das Kommentarzeichen ( #), das Leerzeichen davor und alles nach dem Kommentarzeichen.

a               
 bc             
   d            
    e           
     fgh        
        ij      
          k     
           l    
            mn  
              op

Reduzieren Sie dann jede Zeile nach oben in eine einzelne Zeile. Da bes sich zum Beispiel in Zeile zwei in der zweiten Spalte befindet, wird es in Zeile eins in der zweiten Spalte angezeigt, sobald wir es zusammengeklappt haben . Ebenso cwird in die dritte Spalte der ersten Zeile und din die vierte Spalte eingefügt. Wiederholen Sie dies für jeden Charakter und Sie erhalten Folgendes:

abcdefghijklmnop

Wichtiger Hinweis: Es scheint, als ob die einfache Lösung darin besteht, einfach die Kommentare zu entfernen, jedes Leerzeichen zu entfernen und jede Zeile zu verbinden. Dies ist kein gültiger Ansatz! Da der ursprüngliche Code möglicherweise Leerzeichen enthält, werden diese bei diesem Ansatz entfernt. Dies ist zum Beispiel eine absolut gültige Eingabe:

hello         #Line one
              #Line two
       world! #Line three

Und die entsprechende Ausgabe sollte sein:

hello  world!

Die Herausforderung:

Schreiben Sie ein Programm oder eine Funktion, die kommentierten Code als Eingabe verwendet und den Code mit allen darin analysierten Kommentaren ausgibt oder zurückgibt. Sie sollten den Code ohne nachfolgende Leerzeichen ausgeben , obwohl eine nachfolgende Newline zulässig ist. Das Kommentarzeichen wird immer sein #und es wird immer ein zusätzliches Leerzeichen geben, bevor die Kommentare beginnen. #wird nicht im Kommentarbereich der Eingabe angezeigt. Um die Herausforderung einfacher zu gestalten, müssen Sie die folgenden Eingaben nicht bearbeiten:

• Sie können davon ausgehen, dass der Code nicht aus zwei Zeichen in derselben Spalte besteht. Dies ist beispielsweise eine Eingabe, die gegen diese Regel verstößt:

  a  #A character in column one
  bc #Characters in columns one and two
  

• Sie können auch davon ausgehen, dass alle Kommentarzeichen in derselben Spalte erscheinen. Zum Beispiel diese Eingabe:

  short       #this is a short line
        long        #This is a long line
  

  gegen diese Regel verstößt. Dies bedeutet auch, dass #nicht im Codeabschnitt sein wird.

• Und schließlich müssen Sie keine Codeabschnitte mit führenden oder nachfolgenden Leerzeichen behandeln. Beispielsweise,

    Hello,          #
           World!   #
  

Sie können auch davon ausgehen, dass die Eingabe nur druckbare ASCII-Zeichen enthält.

Beispiele:

Input:
hello         #Line one
              #Line two
       world! #Line three

Output:
hello  world!

Input:
E                                                   #This comment intentionally left blank
 ac                                                 #
   h s                                              #
      ecti                                          #
          on is                                     #
                one c                               #
                     haracte                        #
                            r longer                #
                                     than the       #
                                              last! #

Output:
Each section is one character longer than the last!

Input:
4          #This number is 7
 8         #
  15       #That last comment is wrong.
    16     #
      23   #
        42 #

Output:
4815162342

Input:
Hello                     #Comment 1
      world               #Comment 2
           ,              #Comment 3
             how          #Comment 4
                 are      #Comment 5
                     you? #Comment 6

Output:
Hello world, how are you?

Input:
Prepare                               #
        for...                        #
                        extra spaces! #

Output:
Prepare for...          extra spaces!

Sie können Eingaben in einem beliebigen vernünftigen Format vornehmen, z. B. eine Liste von Zeichenfolgen, eine einzelne Zeichenfolge mit Zeilenumbrüchen, eine 2D-Liste von Zeichen usw. Die kürzeste Antwort in Bytes gewinnt!

Gelee , 8 7 Bytes

»/ṣ”#ḢṖ

Probieren Sie es online!

Wie es funktioniert

»/ṣ”#ḢṖ  Main link. Argument: A (array of strings)

»/       Reduce the columns of A by maximum.
         Since the space is the lowest printable ASCII characters, this returns the
         non-space character (if any) of each column.
  ṣ”#    Split the result at occurrences of '#'.
     Ḣ   Head; extract the first chunk, i.e., everything before the (first) '#'.
      Ṗ  Pop; remove the trailing space.

Python 2, 48 43 Bytes

lambda x:`map(max,*x)`[2::5].split(' #')[0]

Vielen Dank an @xnor für das Golfen mit 5 Bytes!

Testen Sie es auf Ideone .

JavaScript (ES6), 97 75 60 Byte

Vielen Dank an @Neil für die Unterstützung beim Golfspielen mit 22 Bytes

a=>a.reduce((p,c)=>p.replace(/ /g,(m,o)=>c[o])).split` #`[0]

Die Eingabe ist ein Array von Zeilen.

• a ist eine Array-Eingabe
• p ist vorheriger Artikel
• c ist aktueller Artikel
• m ist eine Übereinstimmungszeichenfolge
• o versetzt ist

Perl, 35 34 32 Bytes

Beinhaltet +1 für -p

Geben Sie eine Eingabe für STDIN ein

eso.pl

#!/usr/bin/perl -p
y/ /\0/;/.#/;$\|=$`}{$\=~y;\0; 

Beachten Sie, dass nach dem Finale ein Leerzeichen steht ;. Der Code funktioniert wie gezeigt, wird jedoch \0durch das Literalzeichen ersetzt, um die beanspruchte Punktzahl zu erhalten.

Python 2, 187 Bytes

def f(x,o=""):
 l=[i[:i.index("#")-1]for i in x]
 for n in range(len(l[0])):
  c=[x[n]for x in l]
  if sum([1for x in c if x!=" "])<1:o+=" "
  else:o+=[x for x in c if x!=" "][0]
 print o

Ich werde diesmal mehr Golf spielen, morgen habe ich Schule;)

Ruby, 63 Bytes

Im Grunde genommen eine Portierung von Dennis 'Jelly . Nimmt Eingaben als ein Array von Zeichenfolgen.

->a{l,=a
l.gsub(/./){a.map{|m|m[$`.size]||$/}.max}[/(.+) #/,1]}

Sehen Sie es auf eval.in: https://eval.in/640757

CJam , 12 Bytes

Danke an Sp3000 für das Speichern von 2 Bytes.

{:.e>_'##(<}

Ein unbenannter Block, der eine Liste von Zeichenfolgen (eine für jede Zeile) durch eine einzelne Zeichenfolge ersetzt.

Probieren Sie es online!

Erläuterung

:.e>  e# Reduce the list of strings by elementwise maximum. This keeps non-spaces in
      e# favour of spaces. It'll also wreak havoc with the comments, but we'll discard
      e# those anyway.
_'##  e# Duplicate and find the index of '#'.
(<    e# Decrement that index and truncate the string to this length.

J, 30 Bytes

(#~[:<./\'#'~:])@(>./&.(3&u:))

Nimmt eine Liste von Zeichenfolgen als Eingabe. Verwendet im Grunde den gleichen Ansatz wie Dennis in seiner Jelly-Antwort.

Kommentiert und erklärt

ord =: 3 & u:
under =: &.
max =: >./
over =: @
maxes =: max under ord
neq =: ~:
arg =: ]
runningMin =: <./\
magic =: #~ [: runningMin ('#' neq arg)

f =: magic over maxes

Zwischenschritte:

   p
Hello                     #Comment 1
      world               #Comment 2
           ,              #Comment 3
             how          #Comment 4
                 are      #Comment 5
                     you? #Comment 6
   maxes p
Hello world, how are you? #Comment 6
   magic
#~ ([: runningMin '#' neq arg)
   3 neq 4
1
   '#' neq '~'
1
   '#' neq '#'
0
   '#' neq maxes p
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1
   runningMin 5 4 2 5 9 0 _3 4 _10
5 4 2 2 2 0 _3 _3 _10
   runningMin '#' neq maxes p
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
   0 1 0 1 1 0 # 'abcdef'
bde
   'abcdef' #~ 0 1 0 1 1 0
bde
   (maxes p) #~ runningMin '#' neq maxes p
Hello world, how are you? 
   (#~ [: runningMin '#' neq arg) maxes p
Hello world, how are you? 
   ((#~ [: runningMin '#' neq arg) over maxes) p
Hello world, how are you? 
   (magic over maxes) p
Hello world, how are you? 

Testfall

   f =: (#~[:<./\'#'~:])@(>./&.(3&u:))
   a
Hello                     #Comment 1
      world               #Comment 2
           ,              #Comment 3
             how          #Comment 4
                 are      #Comment 5
                     you? #Comment 6
   $a
6 36
   f a
Hello world, how are you?

Javascript (ES6), 63 Byte

a=>a.reduce((p,c)=>p+/(.+?)\s+#/.exec(c)[1].slice(p.length),'')

Nimmt Eingaben als ein Array von Zeichenfolgen.

F=a=>a.reduce((p,c)=>p+/(.+?)\s+#/.exec(c)[1].slice(p.length),'')

input.oninput = update;
update();

function update() {
  try {
    output.innerHTML = F(input.value.trim().split`
`);
  } catch(e) {
    output.innerHTML = 'ERROR: INVALID INPUT';
  }
}

textarea {
  width: 100%;
  box-sizing: border-box;
  font-family: monospace;
}

<h2>Input:</h2>
<textarea id="input" rows="8">
a                #Explanation of what 'a' does
 bc              #Bc
   d             #d
    e            #Explanation of e
     fgh         #foobar
        ij       #hello world
          k      #etc.
           l     #so on
            mn   #and
              op #so forth
</textarea>
<hr />
<h2>Output:</h2>
<pre id="output">
</pre>

Retina , 32 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

Rmr` #.+|(?<=^(?<-1>.)+).+?¶( )+

Probieren Sie es online!

Pyke, 15 10 Bytes

,FSe)s\#ch

Probieren Sie es hier aus!

Port of the Jelly antworten

,          -     transpose()
 FSe)      -    map(min, ^)
     s     -   sum(^)
      \#c  -  ^.split("#")
         h - ^[0]

C # 157 122 Bytes

Dank @milk 35 Bytes Golf gespielt - obwohl ich schwöre, dass ich das früher versucht habe.

Nimmt die Eingabe als 2D-Array von Zeichen an.

string f(char[][]s){int i=0;foreach(var x in s)for(i=0;x[i]!=35;i++)if(x[i]!=32)s[0][i]=x[i];return new string(s[0],0,i);}

157 Bytes:

string g(char[][]s){var o=new char[s[0].Length];foreach(var x in s)for(int i=0;x[i]!=35;i++)if(x[i]!=32|o[i]<1)o[i]=x[i];return new string(o).TrimEnd('\0');}

Pyth, 11 Bytes

PhceCSMCQ\#

Ein Programm, das eine Liste von Zeichenfolgen in STDIN eingibt und eine Zeichenfolge druckt.

Probieren Sie es online aus

Wie es funktioniert

PhceCSMCQ\#  Program. Input: Q
       CQ    Transpose Q
     SM      Sort each element of that lexicographically
    C        Transpose that
   e         Yield the last element of that, giving the program ending with ' #' and some
             parts of the comments
  c      \#  Split that on the character '#'
 h           Yield the first element of that, giving the program with a trailing space
P            All but the last element of that, removing the trailing space
             Implicitly print

sed, 126 bytes

:a;N;$!ba;s,#[^\n]*\n,#,g;s,^,#,;:;/#[^ ]/{/^# /s,^# *,,;t;H;s,#.,#,g}
t;/#[^ ]/!{H;s,#.,#,g};t;g;s,\n#(.)[^\n]*,\1,g;s,...$,,

Erfordert eine neue Zeile am Ende der Eingabe.
Ich bin mir sicher, dass ich ein bisschen mehr Golf spielen kann, aber ich bin nur froh, dass es jetzt funktioniert.

Perl 6 , 39 Bytes

{[Zmax](@_».comb).join.split(' #')[0]}

Übersetzung der Python-Lösung von Dennis .
Nimmt Eingaben als Liste von Zeichenfolgen und gibt eine Zeichenfolge zurück.

( online ausprobieren )

Gelee , 27 Bytes

żḟ€” ;€” Ḣ€
i€”#’©ḣ@"ç/ḣ®ṪṖ

Testen Sie es bei TryItOnline

Verwendet die strengste Spezifikation - das zusätzliche Leerzeichen, bevor das Kommentarzeichen auf Kosten eines Bytes entfernt wird.

Die Eingabe ist eine Liste von Zeichenfolgen.

Ruby, 77 Bytes

puts File.readlines("stack.txt").join('').gsub(/\s{1}#.*\n/,'').gsub(/\s/,'')

TSQL, 216 175 Bytes

Golf gespielt:

DECLARE @ varchar(max)=
'hello         #Line one
              #Line two
       world! #Line three'

DECLARE @i INT=1,@j INT=0WHILE @i<LEN(@)SELECT @=stuff(@,@j+1,len(x),x),@j=iif(x=char(10),0,@j+1),@i+=1FROM(SELECT ltrim(substring(@,@i,1))x)x PRINT LEFT(@,patindex('%_#%',@))

Ungolfed:

DECLARE @ varchar(max)=
'hello         #Line one
              #Line two
       world! #Line three'

DECLARE @i INT=1,@j INT=0
WHILE @i<LEN(@)
  SELECT @=stuff(@,@j+1,len(x),x),@j=iif(x=char(10),0,@j+1),@i+=1
  FROM(SELECT ltrim(substring(@,@i,1))x)x
PRINT LEFT(@,patindex('%_#%',@))

Geige

Javascript, 56 34 Bytes, nicht konkurrierend

q=>q.split(/\n/).map(x=>/ (.?) #./.exec(x)[1]).join()

q=>q.replace(/^ *| *#.*$\n?/gm,'')

Wie @ n̴̖̋h̷͉̃ã̷͉h̷̭̿d̷̰̀ĥ̷̳ betonte, bin ich nicht auf zusätzliche Leerzeichen vorbereitet

Dyalog APL , 22 Bytes

Inspiration .

(⎕UCS¯2↓⍳∘35↑⊢)⌈⌿∘⎕UCS

(

 ⎕UCS Zeichendarstellung von

 ¯2↓ alle bis auf die letzten zwei von

 ⍳∘35↑ bis zur Position der ersten 35 ("#"), die außerhalb der Klammer steht, von

 ⊢ das, was außerhalb der Klammer ist

) nämlich...

⌈⌿ die kolumnaren Maxima

∘ von

⎕UCS die Unicode-Werte

TryAPL online!