Les parenthèses sur mon clavier sont toutes usées et je veux éviter de les utiliser autant que possible. Votre défi est d'équilibrer une ligne contenant des parenthèses en les ajoutant avant et après chaque ligne.

Ceci est similaire aux parenthèses automatiques et à la fermeture de chaîne de TI-Basic (ie Output(1, 1, "Hello, World!). Il enregistre également de précieux octets d'un programme!

Exemple d'entrée:

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

Exemple de sortie (possible):

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

Spécification:

• Pour chaque ligne d'entrée,

  • Ajoutez autant de parenthèses ouvertes au début et de parenthèses fermées à la fin de la ligne que nécessaire pour équilibrer les parenthèses de la ligne

    • La définition de «l'équilibre» est:

      • Même quantité de (et )dans la ligne

      • Pour chaque sous-chaîne commençant au début de la chaîne, cette sous-chaîne ne doit pas avoir plus de parenthèses fermantes que de parenthèses ouvrantes

        • Par exemple, (foo))(barn'est pas équilibré car (foo))a plus de parenthèses fermantes que de parenthèses ouvrantes

  • Vous pouvez ajouter des parenthèses inutiles supplémentaires si vous le souhaitez, si cela rend votre code plus court

  • Vous n'avez pas à vous soucier des littéraux de chaîne ou quelque chose comme ça, supposez que toutes les parenthèses doivent être équilibrées

• Sortie chaque ligne avec des parenthèses équilibrées

Il s'agit de code-golf , donc le code le plus court en octets gagnera!

GolfScript, 23 octets

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

L'échappatoire que j'exploite est la décision suivante:

Vous pouvez ajouter des parenthèses inutiles supplémentaires si vous le souhaitez, si cela rend votre code plus court

Fondamentalement, pour chaque ligne, ce code compte le nombre de caractères sur la ligne qui n'ouvrent pas de parenthèses, et ajoute autant de parenthèses ouvrantes supplémentaires à la ligne, puis fait de même pour les parenthèses fermantes. Ceci est incroyablement inefficace, mais garantit que toutes les parenthèses sur la ligne de sortie sont équilibrées.

Par exemple, étant donné l'entrée:

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

ce programme affichera:

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

Ps. Vous pouvez également tester ce code en ligne .

Perl, 32 = 31 + 1 ou 73 = 72 + 1 (parenthèses minimisées)

32 = 31 + 1: avec des parenthèses inutiles supplémentaires

Modifications:

• Corrigé, les parenthèses étaient désormais prises en compte y///.
• Variable inutile $asupprimée.

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

Il est utilisé avec le commutateur d'exécution -p(+1 octet).

Fichier de test input.txt:

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

Ligne de commande:

perl -p script.pl <input.txt

ou

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

Résultat:

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

Non golfé:

L'algorithme est simple, il suffit d'ajouter la contrepartie pour chaque parenthèse trouvée.

$_ =                     # $_ 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: ajout d' un nombre minimum de parenthèses

Ce script ajoute uniquement le nombre minimum de parenthèses pour obtenir une sortie équilibrée.

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

Il est utilisé avec le commutateur d'exécution -p(+1 octet).

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

Résultat:

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

Non golfé:

$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: ajout d' un nombre minimum de parenthèses

Il s'agit d'une méthode plus ancienne pour ajouter le nombre minimum de parenthèses pour une sortie équilibrée.

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

Il utilise Perl 5.14 (en raison du modificateur de substitution non destructif) et le commutateur d'exécution -p(+1 octet).

perl -p script.pl <input.txt

Résultat:

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

Non golfé:

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

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

Pas super golfé, mais vous savez. Je pourrais peut-être extraire quelques octets supplémentaires si j'essayais vraiment.

Pour chaque ligne, sort (* le nombre de )dans la ligne, puis la ligne, puis )* le nombre de (dans la ligne. Si je comprends bien les règles, cela fournira toujours une sortie valide.

Quitte en lançant une exception, en raison de la façon dont j'ai entré. (L'entrée est toujours une partie difficile de ces problèmes.) Si ce n'est pas acceptable, cela me coûtera quelques octets à corriger, mais je ne sais pas encore combien.

Exemple de sortie:

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

Pure Bash, 72 octets

Utilise le même algorithme que la réponse de @ undergroundmonorail:

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

Production:

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