Zakończ leniwe nawiasy

17

Nawiasy na klawiaturze są zużyte i chcę unikać ich używania w jak największym stopniu. Twoim zadaniem jest zrównoważyć linię zawierającą nawiasy, dodając je przed i po każdej linii.

Jest to podobne do automatycznego nawiasu i zamykania łańcucha TI-Basic (tj Output(1, 1, "Hello, World!.). Oszczędza również cenne bajty z programu!

Przykładowe dane wejściowe:

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

Przykład (możliwy) wynik:

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

Specyfikacja:

  • Dla każdego wiersza danych wejściowych

    • Dodaj tyle otwartych nawiasów na początku i zamknij nawiasy na końcu linii, ile potrzeba, aby zrównoważyć nawiasy w linii

      • Definicja „równowagi” jest następująca:

        • Ta sama ilość (i )na linii

        • Dla każdego podłańcucha rozpoczynającego się od początku łańcucha podłańcuch ten nie może zawierać więcej nawiasów zamykających niż nawiasów otwierających

          • Na przykład (foo))(barnie jest zrównoważony, ponieważ (foo))ma więcej nawiasów zamykających niż nawiasów otwierających
    • Jeśli chcesz, możesz dodać dodatkowe niepotrzebne nawiasy, jeśli spowoduje to skrócenie kodu

    • Nie musisz się martwić literałami łańcuchowymi ani nic podobnego, zakładając, że wszystkie nawiasy wymagają równoważenia

  • Wypisz każdą linię ze zrównoważonymi nawiasami

To jest , więc wygra najkrótszy kod w bajtach!

Klamka
źródło
Są po prostu dotyczy ()parens, czy inne wsporniki {}, [], <>itp trzeba uznać za dobrze?
Digital Trauma
@DigitalTrauma Nie, tylko (i ).
Klamka
Czy masz jakieś przypadki testowe?
Peter Taylor
1
@Peter Tak, są tam na poczcie ...
Klamka

Odpowiedzi:

21

GolfScript, 23 bajty

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

Wykorzystuję lukę, że:

Jeśli chcesz, możesz dodać dodatkowe niepotrzebne nawiasy, jeśli spowoduje to skrócenie kodu

Zasadniczo dla każdego wiersza ten kod liczy liczbę znaków w wierszu, które nie otwierają nawiasów, i przygotowuje tyle dodatkowych nawiasów otwierających do linii, a następnie robi to samo dla zamykania nawiasów. Jest to niezwykle nieefektywne, ale zapewnia zrównoważenie wszystkich nawiasów w linii wyjściowej.

Na przykład, biorąc pod uwagę dane wejściowe:

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

ten program wyświetli:

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

Ps. Możesz również przetestować ten kod online .

Ilmari Karonen
źródło
4
To przypomina mi, kiedy programowałem w Lisp ... Kilka fragmentów kodu zaginęło w morzu nawiasów.
Taconut
7

Perl, 32 = 31 + 1 lub 73 = 72 + 1 (zminimalizowane nawiasy)

32 = 31 + 1: z dodatkowymi niepotrzebnymi nawiasami

Edycje:

  • Napraw, nawiasy są teraz liczone y///.
  • $aUsunięto niepotrzebną zmienną .
$_="("x y/)//.s|$|")"x y/(//|er

Jest używany z przełącznikiem czasu działania -p(+1 bajt).

Plik testowy input.txt:

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

Wiersz poleceń:

perl -p script.pl <input.txt

lub

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

Wynik:

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

Nie golfowany:

Algorytm jest prosty, wystarczy dodać odpowiednik dla każdego znalezionego nawiasu.

$_ =                     # $_ 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: dodanie minimalnej liczby nawiasów

Ten skrypt dodaje tylko minimalną liczbę nawiasów, aby uzyskać zrównoważone wyjście.

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

Jest używany z przełącznikiem czasu pracy -p(+1 bajt).

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

Wynik:

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

Nie golfowany:

$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: dodanie minimalnej liczby nawiasów

Jest to starsza metoda dodawania minimalnej liczby nawiasów dla zrównoważonego wyjścia.

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

Używa Perla 5.14 (z powodu nieniszczącego modyfikatora podstawienia) i przełącznika czasu działania -p(+1 bajt).

perl -p script.pl <input.txt

Wynik:

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

Nie golfowany:

# 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";
}
Heiko Oberdiek
źródło
2
Wow, to prawie wygląda jak golfscript ;-)
Digital Trauma
@HeikoOberdiek Jakiego perla używasz w pierwszej wersji? Wygląda na to, że nie działa na 18.1 ze względu na '('x/\)/gzawsze równe ”(„ ...
Mouq
@Mouq: Dzięki, naprawiono teraz używanie y///zamiast m//gliczenia nawiasów.
Heiko Oberdiek
4

Python 2.7 3: 62 60 58 bajtów

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

Nie super golfa, ale wiesz. Może naprawdę będę w stanie wycisnąć więcej bajtów, jeśli naprawdę spróbuję.

Dla każdej linii wyprowadza (* liczbę )w linii, następnie linię, a następnie )* liczbę( w linii. Jeśli poprawnie zrozumiem reguły, zawsze zapewni to prawidłowe wyniki.

Wychodzi przez zgłoszenie wyjątku w wyniku sposobu, w jaki wprowadziłem dane. (Dane wejściowe są zawsze trudną częścią tych problemów.) Jeśli nie jest to akceptowalne, naprawienie go kosztuje kilka bajtów, choć nie jestem jeszcze pewien, ile.

Przykładowe dane wyjściowe:

This line has no parentheses
alert(Math.max(1, 2))
(((1+1)*2).toString())
(((function() { alert('Hello, World!'); })()))
podziemny monorail
źródło
Wydaje się, że nie wymaga to wprowadzania danych wielowierszowych, tzn. Wydruki są przeplatane liniami wprowadzania. Ale fajny pomysł na algorytm, nie myślałem o tym;)
Klamka
python2 balanced_parenthesis.py < input.txt 2>/dev/nullpobiera dane wyjściowe, które napisałem, ale jeśli chcesz wejść wielowierszowych podczas wykonywania tego interaktywnie, będzie mnie to kosztować kilka bajtów. Daj mi chwilkę, coś wymyślę ...
metro
Ach, dobrze, nieważne. To zadziała!
Klamka
zapisz 2 znaki:while 1:s=raw_input();c=s.count;print'('*c(')')+s+')'*c('(')
Justin
@qui Oh, wow. Tak blisko doszedłem do tego, ale nie zdawałem sobie sprawy, że możesz to zrobić c=s.count. Myślałem, że trzeba było zrobić c=s, s.c(). Dzięki!
undergroundmonorail
1

Pure Bash, 72 bajty

Używa tego samego algorytmu, co odpowiedź @ undergroundmonorail:

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

Wynik:

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