Die Klammern auf meiner Tastatur sind alle abgenutzt, und ich möchte vermeiden, sie so oft wie möglich zu verwenden. Ihre Herausforderung besteht darin, eine Zeile mit Klammern auszugleichen, indem Sie sie vor und nach jeder Zeile einfügen.

Dies ist vergleichbar mit den automatischen Klammern und dem Schließen von Zeichenfolgen von TI-Basic Output(1, 1, "Hello, World!. Es speichert auch wertvolle Bytes aus einem Programm!

Beispiel Eingabe:

This line has no parentheses
alert(Math.max(1, 2
1+1)*2).toString()
function() { alert('Hello, World!'); })(

Beispiel (mögliche) Ausgabe:

This line has no parentheses
alert(Math.max(1, 2))
((1+1)*2).toString()
(function() { alert('Hello, World!'); })()

Spezifikation:

• Für jede Eingabezeile

  • Fügen Sie am Anfang so viele offene Klammern hinzu, und schließen Sie die Klammern am Ende der Zeile, wie erforderlich, um die Klammern in der Zeile auszugleichen

    • Die Definition von "Gleichgewicht" ist:

      • Gleiche Menge (und )in der Leitung

      • Für jede Teilzeichenfolge, die am Anfang der Zeichenfolge beginnt, darf diese Teilzeichenfolge nicht mehr schließende Klammern als öffnende Klammern enthalten

        • Zum Beispiel (foo))(barist nicht ausgeglichen, weil (foo))es mehr schließende Klammern als öffnende Klammern gibt

  • Sie können zusätzliche unnötige Klammern hinzufügen, wenn Sie möchten, wenn dies Ihren Code verkürzt

  • Sie müssen sich keine Gedanken über String-Literale oder ähnliches machen, vorausgesetzt, alle Klammern müssen ausgeglichen werden

• Geben Sie jede Zeile mit ausgeglichenen Klammern aus

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

GolfScript, 23 Bytes

n/{"()"1/{.2$\-,*}%*n}/

Die Lücke, die ich ausnütze, ist die Entscheidung, dass:

Sie können zusätzliche unnötige Klammern hinzufügen, wenn Sie möchten, wenn dies Ihren Code verkürzt

Grundsätzlich zählt dieser Code für jede Zeile die Anzahl der Zeichen in der Zeile, die keine öffnenden Klammern sind, und stellt der Zeile viele zusätzliche öffnende Klammern voran. Das Gleiche gilt dann für das Schließen von Klammern. Dies ist unglaublich ineffizient, stellt jedoch sicher, dass alle Klammern in der Ausgabezeile ausgeglichen sind.

Zum Beispiel bei der Eingabe:

This line has no parentheses
alert(Math.max(1, 2
1+1)*2).toString()
function() { alert('Hello, World!'); })(

Dieses Programm gibt aus:

((((((((((((((((((((((((((((This line has no parentheses))))))))))))))))))))))))))))
(((((((((((((((((alert(Math.max(1, 2)))))))))))))))))))
(((((((((((((((((1+1)*2).toString())))))))))))))))
(((((((((((((((((((((((((((((((((((((function() { alert('Hello, World!'); })()))))))))))))))))))))))))))))))))))))

Ps. Sie können diesen Code auch online testen .

Perl, 32 = 31 + 1 oder 73 = 72 + 1 (minimierte Klammern)

32 = 31 + 1: mit zusätzlichen unnötigen Klammern

Bearbeitungen:

• Fix, Klammern zählen jetzt mit y///.
• Unnötige Variable $aentfernt.

$_="("x y/)//.s|$|")"x y/(//|er

Es wird mit dem Laufzeitschalter -p(+1 Byte) verwendet.

Testdatei input.txt:

This line has no parentheses
alert(Math.max(1, 2
1+1)*2).toString()
function() { alert('Hello, World!'); })(
(foo))(bar
)))(((
((
))

Befehlszeile:

perl -p script.pl <input.txt

oder

perl -pe '$_="("x y/)//.s|$|")"x y/(//|er' <input.txt

Ergebnis:

This line has no parentheses
alert(Math.max(1, 2))
(((1+1)*2).toString())
(((function() { alert('Hello, World!'); })()))
(((foo))(bar))
((()))((()))
(())
(())

Ungolfed:

Der Algorithmus ist einfach, fügen Sie einfach das Gegenstück für jede gefundene Klammer hinzu.

$_ =                     # $_ is provided as input by switch `-p` and
                         # it is printed afterwards as output.
                         # y/X// is used to count the character 'X' in $_
    '(' x y/)//          # add opening parentheses for each closing parentheses
    . s|$|')' x y/(//|er # go right before the end of line and insert
                         # closing parentheses for each opening parentheses
                         # in the original string

73 = 72 + 1: Hinzufügen einer Mindestanzahl von Klammern

Dieses Skript fügt nur die Mindestanzahl von Klammern hinzu, um eine ausgeglichene Ausgabe zu erhalten.

$a=y/()//cdr;1while$a=~s/\(\)//g;$_=$a=~y/)(/(/dr.$_;s|$|$a=~y/()/)/dr|e

Es wird mit dem Laufzeitschalter -p(+1 Byte) verwendet.

perl -pe "$a=y/()//cdr;1while$a=~s/\(\)//g;$_=$a=~y/)(/(/dr.$_;s|$|$a=~y/()/)/dr|e" <input.txt

Ergebnis:

This line has no parentheses
alert(Math.max(1, 2))
((1+1)*2).toString()
(function() { alert('Hello, World!'); })()
((foo))(bar)
((()))((()))
(())
(())

Ungolfed:

$a = y/()//cdr;            # filter parentheses and store in $a
1 while $a =~ s/\(\)//g;   # remove matching parentheses
$_ = $a =~ y/)(/(/dr . $_; # add missing opening parentheses at start of string
s|$|$a=~y/()/)/dr|e        # insert missing closing parentheses at end of string

81 = 80 + 1: Hinzufügen einer Mindestanzahl von Klammern

Dies ist eine ältere Methode zum Hinzufügen der Mindestanzahl von Klammern für eine ausgeglichene Ausgabe.

my($l,$r);s/[()]/($&eq")"&&($r&&$r--||++$l))||$r++/ger;$_="("x$l.$_;s/$/")"x$r/e

Es verwendet Perl 5.14 (wegen des zerstörungsfreien Substitutionsmodifikators) und den Laufzeitschalter -p(+1 Byte).

perl -p script.pl <input.txt

Ergebnis:

This line has no parentheses
alert(Math.max(1, 2))
((1+1)*2).toString()
(function() { alert('Hello, World!'); })()
((foo))(bar)
((()))((()))
(())
(())

Ungolfed:

# The while loop is added by option "-p".
LINE:
while (<>) {

    # $_ contains the current line
    my ($l, $r); # initializes $l and $r (to undef/kind of indirect 0)
    # Modifiers for the following substitution of $_:
    # /g: process all parentheses
    # /e: evaluate code
    # /r: does not change the original input string $_ (Perl 5.14)
    s/[()]/
        # $& contains the matched parentheses
        # $r is a balance level counter; at the end $r contains
        #    the number of needed closing parentheses
        # $l is the number of needed opening parentheses;
        #    if $r would go negative, then an opening parentheses
        #    is missing and $l is increases and $r remains zero.
        (  
            $& eq ")" &&   # case ")"
            ($r && $r--    # close a parentheses group and update balance counter
                || ++$l)   # or update $l if an opening parentheses is needed
        )
        || $r++            # case "(": increase balance counter
    /ger;
    $_ = "(" x $l . $_;    # add opening parentheses at the begin of line
    s/$/")" x $r/e         # add closing parentheses before the line end

# the remainder is added by run-time switch "-p"
} continue {
    print or die "-p destination: $!\n";
}

Python 2.7 3: 62 60 58 Bytes

while 1:s=input();c=s.count;print('('*c(')')+s+')'*c('('))

Nicht super golfen, aber du weißt schon. Ich könnte in der Lage sein, mehr Bytes herauszuquetschen, wenn ich es wirklich versuche.

Gibt für jede Zeile (* die Nummer )in der Zeile, dann die Zeile und )* die Nummer (in der Zeile aus. Wenn ich die Regeln richtig verstehe, wird dies immer eine gültige Ausgabe liefern.

Verlässt das Programm, indem ich eine Ausnahme auslöse, die auf meine Eingabe zurückzuführen ist. (Eingaben sind immer ein schwieriger Teil dieser Probleme.) Wenn dies nicht akzeptabel ist, kostet es mich ein paar Bytes, sie zu beheben, obwohl ich noch nicht sicher bin, wie viele.

Beispielausgabe:

This line has no parentheses
alert(Math.max(1, 2))
(((1+1)*2).toString())
(((function() { alert('Hello, World!'); })()))

Pure Bash, 72 Bytes

Verwendet den gleichen Algorithmus wie die Antwort von @ undergroundmonorail:

while read a;do
o=${a//[!(]}
c=${a//[!)]}
echo ${c//)/(}$a${o//(/)}
done

Ausgabe:

$ ./lazyparens.sh < input.txt
This line has no parentheses
alert(Math.max(1, 2))
(((1+1)*2).toString())
(((function() { alert('Hello, World!'); })()))
$