Twoim zadaniem jest napisanie programu komputerowego, który po podzieleniu na linie (podział na znak nowego wiersza) w każdym układzie wierszy wyświetli inną liczbę od 1 do n! (gdzie n jest całkowitą liczbą linii). Żadne liczby nie powinny być wyprowadzane przez dwa różne układy, a każdy układ powinien wypisywać liczbę w tym zakresie. Ponieważ istnieje n! sposoby ułożenia linii programu oznacza, że ​​każda liczba powinna być wyprowadzana przez jedną zmianę układu.

Na przykład program python

print 1;"""
print 2;"""

Ma dwa ustalenia

print 1;"""
print 2;"""

i

print 2;"""
print 1;"""

Pierwsze wyjścia 1i drugie wyjścia 2.

Możesz używać formatów wyjściowych standardowych w języku, którego używasz. Nie możesz zakładać żadnego rodzaju bojlera. Myślę, że to wyzwanie jest bardziej interesujące, jeśli musisz obejść formaty, na które nalega ten język.

Punktacja

Twój wynik będzie liczbą linii w twoim programie, przy czym wyższy wynik będzie lepszy. Możesz wybrać wyświetlanie liczb od 0 do n! -1, jeśli chcesz.

CJam , wynik: ∞

Każda linia ma formę

];Lx+:L{__(f<0+:+\,,(;1+:**\(;}h]:+

gdzie xjest liczba od 0do n-1. Wynik mieści się w zakresie 0od n!-1.

Wypróbuj online! (Dla n=3.)

Podziękowania dla jimmy23013 dla kodu, który oblicza aktualny indeks permutacji. Zastąpiłem tylko bit, który odczytuje dane wejściowe, ];Lx+:Lktóre odrzucają wynik z poprzedniego wiersza, a następnie dodaje indeks bieżącego wiersza do zmiennej L(która początkowo jest pustą tablicą).

Perl: ∞

$z.="-1,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-2,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-3,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}

Rozciągnij na dowolną długość

Szybko zabraknie pamięci, ponieważ użycie pamięci jest jak O (n ^ n). Łatwo byłoby jednak zastąpić indeksator permutacji kodem O (n), tylko dłużej. Właśnie ilustruję sposób, w jaki możesz użyć END{}tego zadania w Perlu. Wszystkie END{}bloki działają w momencie wyjścia, ale tylko pierwszy, który zostanie wywołany (ostatni w kodzie), wyświetli cokolwiek z powodu /A/testu, który jest prawdziwy tylko raz

Zauważ, że $mlicznik musi się liczyć jako ciąg, ponieważ jako liczba przelałaby się (później niż koniec wszechświata, ale liczy się zasada). Z tego samego powodu „liczę” liczbę wierszy, konstruując ciąg As zamiast prawdziwego licznika, chociaż to przepełnienie nastąpiłoby nawet później.

Inny sposób, aby to zrobić w Perlu:

@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"1".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"2".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"3".!($a.=A),

Wykorzystuje to fakt, że in foo = bar barjest wykonywany później foo. Nawiasem mówiąc, ta wersja nie oszaleje w czasie i przestrzeni, ale wydłuża kod

Jeszcze innym pomysłem jest użycie, DESTROYktóre ma tę zaletę, że tylko jeden z nich zostanie wykonany. Nie zamierzam powtarzać kodu indeksującego permutację, którego już podałem dwa przykłady.

push@F,"1";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"2";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"3";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }

Lub używając BEGIN:

BEGIN{push@F,"1"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"2"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"3"} print"Work out permutation index of @F\n"; exit;

Galaretka , ∞

;3ÇQŒ¿$⁼Q$?
;2ÇQŒ¿$⁼Q$?
;1ÇQŒ¿$⁼Q$?

(Przykład z n=3.)

Wypróbuj online!

23 13 11 bajtów na linię.

W przypadku programu z nliniami linie będą miały format

; <i> ÇQŒ¿$⁼Q$?

gdzie <i>reprezentuje literał liczbowy, ia każda linia ma inną wartość w izakresie od 1do n. (Wartości dlai rzeczywistości nie muszą być tymi konkretnymi liczbami, muszą po prostu mieć unikalne wartości dodatnie.) Ten program nie używa już nw strukturze linii.

W jaki sposób?

• Bez kłótni zaczyna się Jelly 0 .
• ;1dołącza 1do0 lub aktywnej listy.
• ⁼Q$jest monadą warunkową dla instrukcji if ( ?), która sprawdza, czy elementy listy są unikalne. Jeśli tak, powyższy link nazywa się ( Ç), a do listy dołączany jest inny numer. Jeśli nie są unikalne, oznacza to, że obejrzeliśmy pierwszy link. Powtarzany element jest usuwany z list ( Q) i znajduje się indeks permutacji ( Œ¿). Zauważ, że 0kiedy Œ¿jest pobierana, na początku listy znajduje się, ale nie wpływa to na wynik, ponieważ wszystkie wartości isą dodatnie.

Nowa funkcja galaretki

Dzięki nowo dodanemu Ƒszybkiemu możemy zredukować ⁼Q$do QƑ, oszczędzając bajt.

10 bajtów / linię (dla pojedynczych cyfr)

;1ÇQŒ¿$QƑ?

Wypróbuj online!

Brain-Flak , 3

(({}){})
({}())
(()(){([()()]{})()(){[()()](<{}>)}}{})

Wypróbuj online!

Wcześniej opublikowałem to na czacie, ale mam nadzieję, że zamieszczając je tutaj, ludzie mogą to wykorzystać.

Wyjaśnienie

Zaczynamy od programu podstawowego

(({}){})
({}())

To samo daje 2 punkty. Aby przejść do następnego poziomu, chcę dodać nową linię. Moje początkowe przypuszczenie było

(()(){[()()]{}(<()>)}{})

To ustawia TOS na, 2jeśli wynosi zero i nie robi nic innego. To właściwie dobry początek. Za pomocą dwóch pozostałych linii możemy uzyskać wszystkie liczby od 1do6 oprócz 4, ponieważ istnieją 2sposoby na wyjście 2:

({}())
(({}){})
(()(){[()()]{}(<()>)}{})

i

({}())
(()(){[()()]{}(<()>)}{})
(({}){})

Aby temu zaradzić, ustawiamy również naszą linię 2 być 4. Można to zrobić za pomocą

(()(){([()()]{})()(){[()()](<{}>)}}{})

Dla przejrzystości w zasadzie implementuje ona funkcję Haskell

f 0 = 2
f 2 = 4
f x = x

To rozwiązuje nasz problem, ponieważ jeden z programów, który poprzednio wyświetlał dane 2wyjściowe, teraz wyświetla wyjście 4bez zmiany innych programów.

Java 7, wynik: ∞

public class DerangedRearrangements implements B{public void a(){System.out.println("0");}public static void main(String[]a)throws Exception{java.util.regex.Pattern p=java.util.regex.Pattern.compile("^(?:public )?class ([\\w]+).*");java.io.BufferedReader r=new java.io.BufferedReader(new java.io.FileReader("./DerangedRearrangements.java"));String line; while((line=r.readLine())!=null){java.util.regex.Matcher m=p.matcher(line);if(m.matches()){((B)Class.forName(m.group(1)).getDeclaredConstructor().newInstance()).a();}}}}interface B{void a();}
class b1 implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Wypróbuj online!

Można to wydrukować od 0 do n! -1 . Dodatkowe wiersze mają następujący format (gdzie INDEKS jest liczbą od 1 do n! -1 ):

class b<INDEX> implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Ta metoda działa poprzez czytanie własnego źródła w celu ustalenia, że ​​klasy zamówień są w nim wymienione. Niestety nie było fajniejszej metody, którą mogłem znaleźć, analizując skompilowany plik lub tworząc niestandardowy ClassLoader dzięki temu, jak Java kompiluje JIT. Przypuszczam, że mógłbym kazać każdej dodatkowej klasie wydrukować statycznie określoną liczbę, ale wydawało się to bardziej zabawne. To również sprawiłoby, żebym mógł usunąć Binterfejs, ale ocena nie jest oparta na bajtach, więc zostawię to dla zabawy.

Jak to działa (wysoki poziom):

Czyta swój własny kod źródłowy wiersz po wierszu. Ponieważ każda linia deklaruje nową klasę, używamy refleksji, aby utworzyć instancję nowej klasy i wywołać jej ametodę, którą musi mieć, ponieważ implementuje Binterfejs.

Ruby , wynik: ∞

(a||=[])<<2;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<1;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<3;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))

Wypróbuj online!

Ten program ma 61 bajtów na linię (dla n <10). Ma ten sam podstawowy format, co rozwiązanie dylnana ; pierwsza liczba w każdym wierszu będzie miała inną wartość między 1i n, a druga liczba w każdym wierszu będzie n.

Miałem nadzieję znaleźć sposób na uniknięcie włączenia ndo programu, ale nie mogłem go znaleźć.

Brain-Flak , 2 (z -d)

{}(@ltN)

Wypróbuj online!

05AB1E , wynik: 1114112

0ˆ¯JD{œsk
1ˆ¯JD{œsk
2ˆ¯JD{œsk

Wypróbuj online! 0-indeksowane. ˆ na początku każdej linii wypycha różne znaki do globalnej tablicy. Reszta kodu jest bezużytecznie wykonywana, z wyjątkiem ostatniego wiersza, w którym konkatenuje wartości w łańcuch, a następnie znajduje swój indeks permutacji. 1114112 to liczba możliwych znaków Unicode w momencie pisania (oczywiście punkty kodowe 48-57 są najłatwiejsze do wykazania).