Göreviniz bir bilgisayar programı yazmak, böylece satırlara kesildiğinde (satırsonu karakterine bölünmüş), satırların her düzenlemesi 1 ve n arasında farklı bir sayı verecektir ! (burada n , toplam satır sayısıdır). Hiçbir sayı iki farklı düzenleme ile verilmemeli ve her düzenleme bu aralıkta bir sayı vermelidir. Yana vardır n! bir programın satırlarını düzenlemenin yolları, her sayının bir yeniden düzenleme tarafından çıkarılması gerektiği anlamına gelir.

Örneğin python programı

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

İki düzenlemesi var

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

ve

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

İlk çıkışlar 1ve ikinci çıkışlar 2.

Kullandığınız dilde standart olan çıktı biçimlerini kullanabilirsiniz. Herhangi bir kazan plakası kabul edemezsiniz. Dilin ısrar ettiği biçimler üzerinde çalışmak zorunda kalırsanız, bu zorluğun daha ilginç olduğunu düşünüyorum.

puanlama

Puanınız, programınızdaki satır sayısı olacak ve daha yüksek puan daha iyi olacaktır. İsterseniz 0 ile n! -1 arasındaki sayıları çıkarmayı seçebilirsiniz .

CJam , skor: ∞

Her satır şu şekildedir

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

burada xarasında bir sayıdır 0için n-1. Sonuç aralığındadır 0için n!-1.

Çevrimiçi deneyin! (İçin n=3.)

Gerçek permütasyon endeksini hesaplayan kod için jimmy23013'e verilen krediler . Ben sadece bir ];Lx+:Lönceki satırdan sonucu atar ve daha sonra L(ilk olarak boş bir dizi olan) değişkenine geçerli satırın dizin ekler girişi okuyan bit değiştirdim .

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/}

İstediğiniz herhangi bir uzunluğa genişletin

Bellek kullanımı O (n ^ n) gibi olduğundan bellekte hızla yer kalmaz. Ancak permütasyon indeksleyicisini O (n) koduyla değiştirmek daha kolay olacaktır. Sadece END{}perl'de bu görev için nasıl kullanabileceğinizi gösteriyorum . Tüm END{}nedeniyle denilen olsun çıkış zamanda çalıştırmak bloklar, ama sadece ilki (kodda bir son) çıktısı şey /A/tek gerçek kez testten

$mSayacın bir dize olarak sayılması gerektiğine dikkat edin, çünkü bir sayı olarak taşacaktır (evrenin sonundan daha geç ama önemli olan prensiptir). Aynı nedenle Abu taşma daha sonra gerçekleşecek olsa da, gerçek bir sayaç kullanmak yerine s dizesi oluşturarak satır sayısını "sayıyorum" .

Bunu perl'de yapmanın başka bir yolu:

@{$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),

Gerçek şu ki o bu kullanımlar foo = bar barsonra yürütülür foo. Bu arada bu sürüm zaman ve mekanda çıldırmıyor ancak bu da kodu daha uzun yapıyor

Yine başka bir fikir, DESTROYsadece bir tanesinin idam edilme avantajına sahip kullanmaktır . Zaten iki örnek verdiğim permütasyon indeksleme kodunu tekrarlamayacağım.

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" }

Veya şunu kullanarak 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;

Jöle , ∞

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

(İle örnek n=3.)

Çevrimiçi deneyin!

23 13 satır başına 11 bayt.

nSatırları olan bir program için satırlar

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

burada <i>numara, hazır temsil ive her çizgi için farklı bir değere sahiptir iarasında değişen 1için n. (Değerleri iaslında bu belirli sayılar olmak zorunda değildir, sadece benzersiz pozitif değerlere sahip olmak zorundadır.) Bu program artık nçizgi yapısında kullanılmamaktadır.

Nasıl?

• Tartışma olmadan Jelly ile başlar 0.
• ;1ekler 1için 0ya da aktif liste.
• ⁼Q$?list öğelerinin benzersiz olup olmadığını kontrol eden if ifadesi ( ) için koşullu monaddır . Öyleyse, yukarıdaki bağlantı ( Ç) çağrılır ve listeye başka bir numara eklenir. Eğer benzersiz değilse, bu ilk bağlantıya sarıldığımız anlamına gelir. Yinelenen öğe listeden ( Q) kaldırılır ve permütasyonun dizini bulunur ( Œ¿). Not bir olduğunu 0ne zaman listenin başında Œ¿alınır ancak değerleri beri çıkışını etkilemez itüm olumludur.

Yeni Jelly özelliği

Yeni eklenen ile ƑÇabuk, azaltabilir ⁼Q$için QƑbir bayt tasarruf.

10 bayt / satır (tek hane için)

;1ÇQŒ¿$QƑ?

Çevrimiçi deneyin!

Beyin Flak , 3

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

Çevrimiçi deneyin!

Bunu daha önce sohbette yayınladım, ancak umarım buraya göndererek insanlar bundan kurtulabilir.

açıklama

Temel programla başlıyoruz

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

Bu kendi başına 2 puan alır. Bir sonraki seviyeye geçmek için yeni bir satır eklemek istiyorum. Başlangıç ​​tahminim

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

Bu, TOS'u 2sıfır ise ve başka bir şey yapmazsa ayarlar . Bu aslında iyi bir başlangıç. Diğer iki satırla 1, 6hariç tüm sayıları alabiliriz 4, çünkü 2çıktı almanın yolları vardır 2:

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

ve

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

Bu sorunu çözmek için bizim hattı da set yapmak 2olmak 4. Bu ile yapılabilir

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

Açıklık için bu temel olarak Haskell işlevini uygular

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

Bu, sorunumuzu düzeltir, çünkü daha önce çıktısı verilen programlardan biri 2artık 4başka bir program değişmeden çıktı.

Java 7, puan: ∞

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));}}

Çevrimiçi deneyin!

Bu 0 ila n! -1 çıktısını alabilir . Ek hatları aşağıdaki biçimde olarak (DİZİN bir sayı ila 1 için n -1! ):

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

Bu yöntem, içinde listelenen sipariş sınıflarını belirlemek için kendi kaynağını okuyarak çalışır. Ne yazık ki derlenmiş dosyayı ayrıştırarak veya java nasıl JIT derleme yaptığı sayesinde özel bir ClassLoader oluşturarak bulabildiğim serin bir yöntem yoktu. Her ek sınıf sadece statik olarak tanımlanmış bir sayı yazdırmak olabilir sanırım ama bu daha eğlenceli görünüyordu. Bu ayrıca Barayüzü kaldırabileceğim, ancak puanlama baytlara dayanmadığı için bunu eğlence için bırakacağım.

Nasıl çalışır (yüksek seviye):

Kendi kaynak kodunu satır satır okur. Her satır yeni bir sınıf ilan ettiğinden, yeni sınıfın bir örneğini oluşturmak için yansımayı kullanırız ave Barayüzünü uyguladığı için olması gereken yöntemi çağırırız .

Ruby , skor: ∞

(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))

Çevrimiçi deneyin!

Bu program satır başına 61 bayta sahiptir (n <10 için). Dylnan'ın çözümü ile aynı temel formata sahiptir ; her satırdaki ilk sayı ve arasında farklı bir değer olur 1ve nher satırdaki ikinci sayı olur n.

nPrograma dahil edilmekten kaçınmanın bir yolunu bulmayı umuyordum , ama bir tane bulamadım.

Brain-Flak , 2 (ile -d)

{}(@ltN)

Çevrimiçi deneyin!

05AB1E , puan: 1.114.112

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

Çevrimiçi deneyin! 0 endeksli. Her satırın başındaki ˆ, ayrı karakterleri genel diziye iter. Kodun geri kalanı, değerleri bir dizeye birleştirdiği ve ardından permütasyon dizinini bulduğu son satır dışında işe yaramaz bir şekilde yürütülür. 1,114,112 yazma sırasındaki olası Unicode karakterlerin sayısıdır (kod noktaları 48-57 elbette göstermesi en kolay olanıdır).