51

Bir tamsayı dizisi verildiğinde, artan düzende sıralanıp sıralanmadığını belirleyen bir program yazın.

Bunun bir kod trolling sorusu olduğunu unutmayın.

İnsanların geldiği en ilginç yöntemleri arıyorum.

En çok oy alan cevap, kazanır.

Bu soru, bir adayın röportajda bana verdiği 'yaratıcı' bir çözümden ilham alıyor :)

'Yaratıcı' çözüm şunun gibi bir şeydi:

Çünkü sıralı bir dizi için

Herhangi bir öğenin sol tarafındaki tüm öğeler daha küçük olmalıdır

Herhangi bir elemanın sağ tarafındaki tüm elemanlar daha büyük olmalıdır

Bu nedenle, tüm elemanlar için bir ana döngü çalıştırın ve ana biri içerisinde (biri sol taraf, diğeri sağ taraf) olmak üzere iki iç içe döngü çalıştırarak yukarıdaki iki koşulu kontrol edin.

Şok olmuştum!!.

popularity-contest code-trolling

— microbian
kaynak

58

Bu bir kopya değil. Bazı moderatörler, her soruyu okumadan başkalarına kopyalamayı işaretlemenin gerekli olduğunu düşünüyor. Bu bir sıralama sorusu değil. Oku onu.

— microbian

3

Yarışmanın sonunda ben de "yaratıcı" çözümü bilmek istiyorum! :)

— Vereos

16

@micro Diamond moderatörleri topluluk seçildi. Denetleyicileri ayrıcalık sistemi ile karıştırıyorsunuz.

— Doorknob

3

@microbian Yani o adamı işe aldın mı?

— VisioN

3

Yalnızca StackExchange API'sının yazma erişimine izin verdiyse, "Bu dizi sıralanıyor mu?" Sorusunu sorarım. ve olumlu / olumsuz cevaplar üzerinde olumlu oylar ..

— Michael Foukarakis

77

Yakut

Herkes bilir: sıralama çok yavaştır ve birçok döngü gerektirir (yapabileceğiniz en iyi şey bir şeydir n log(n)). Böylece dizinin sıralanıp sıralanmadığını kontrol etmek oldukça kolaydır. Tek yapmanız gereken, diziyi sıralama ve sıralanmış diziyi sıralama çalışma zamanını karşılaştırmaktır.

array = [1, 5, 4, 2, 3]

## measure the time needed to sort the array 1m times
tstart = Time.now
1000000.times {
  array.sort
}
trun = Time.now - tstart

## now do a reference measurement on a sorted array
array.sort!
tstart = Time.now
1000000.times {
  array.sort
}
treference = Time.now - tstart

## compare run times
if trun > treference
  print "array was not sorted"
else
  print "array was sorted"
end

— Howard
kaynak

19

Bu olsa da sıralama algoritmasına bağlı. Birleştirme sıralaması veya yığın sıralaması, dizinin zaten sıralanıp sıralanmadığından bağımsız olarak hiçbir farklılık göstermez.

— Niklas B.

4

@NiklasB. Ruby hızlı bağlantı kullanır . Yani bu yöntem zor olsun ve giriş dizisi ne zaman yanlış pozitif verebilir neredeyse sıralanabilir veya dizi zaman, daha büyük olasılıkla, yanlış negatifler edilir sıralanmış (onun için çok olası olacaktır treference <= trunsadece sebebiyle nondeterministic başka şeyler, her sıralanmış durumda) . Teoride, sıralanan durum için yaklaşık% 50 yanlış negatif alırsınız gibi görünüyor?

— Jason C,

6

İlginç düşünce ancak deterministik değil. Biri on şınav ve ardından on şınav çekebilecek kadar iyi ve ilk dizinin sıralanıp sıralanmayacağına karar veriyor, çünkü ikinci push-up'larda daha fazla terliyordu. Unutmuştuk, çoklu görev makinelerinde kod çalıştırdık mı? Ayrıca çok küçük dizilerde, zaman dilimi yeterince doğru değildir. Yine de vahşi bir girişim için +1!

— LMSingh

1

@NiklasB. Timsort (mergesort'un bir çeşidi) sıralanmış (ve ayrıca kısmen sıralanmış) dizilerde lineer zamanda çalışır.

— Bakuriu

3

@JasonC - bunun yukarıdaki uygulamayı daha da şüpheli hale getirdiğine dikkat etmek önemlidir: sadece yakutun iç sıralama algoritmasının hızlı olduğu (kendi başına belgelenmemiş olduğu ve bu nedenle de dayanılacak şüpheli bir şey olduğu) değil, aynı zamanda belirli bir uygulamanın da olduğu bilgisine dayanır. zaten sıralanan veriler için optimize edilmiştir (varsayılan olarak varsayılan bağlantı noktası değildir: hızlı bağlantı ortalama durumda yalnızca O (n log n) ... en kötü durum performansı O (n ^ 2) ve saf bir uygulamada En kötü durum aslında sıralanmış verilerden çağrılıyor).

— Jules

52

JavaScript

array = prompt("Give the array");
while (true) {
    sorted = prompt("Is it sorted?");
    if (/yes|Yes/.test(sorted)) {
        alert("The array is sorted.");
        break;
    } else if (/no|No/.test(sorted)) {
        alert("The array is not sorted.");
        break;
    } else {
        alert("Dear user:\n\nPlease refer to the manual (RTFM) to observe how to use the system accordingly to the defined business rules.\nNow, try again.");
    }
}

— Victor Stafusa
kaynak

55

-1 yeterli değil JQuery.

— Pierre Arlaud,

3

Diziyi soracak benzer bir fikrim vardı ve sonra birer birer "bu bundan daha büyük mü?" Ve eğer hepsi doğruysa, dizi sıralanır

— Zach Thacker

41

Java - Özyinelemeli Alt kümeler

Yığın Taşmasına Hoş Geldiniz! Bazı mükemmel kıdemli kodlayıcıları bile tıkadığı için bu mükemmel bir ilk soru. Kodu vermeden önce size biraz arka plan bilgisi vereyim:

Sıralamanın belirlenmesi ilk bakışta zor bir görev olabilir. Herhangi bir uzunluk n kümesi için, n var! sipariş etmenin olası yolları. Bunlara permütasyon denir . Dizinizin farklı öğeleri varsa, bu olasılıklardan yalnızca biri sıralanır! Sıralananı bulmak için, diğerlerini atarak, doğru olanı (muhtemelen sadece) bulana kadar hepsini elemek zorundasınız.

Ne? Elbette o kadar da zor değil ...

N ile algoritmalar! karmaşıklık, daha büyük girdiler için uzun zaman alıyor, ancak biraz çalışarak bunun üstesinden gelebilir ve tüm karmaşıklık düzenini aşağıya çekebiliriz. Bu hala üssel bir zaman, ama faktörlü olmaktan çok daha iyi .

Bunu yapmak için, yalnızca aşağıdaki matematiksel gerçeği göz önünde bulundurmamız gerekir: Bir dizi sıralanırsa, o zaman (nispeten sıralı) alt kümelerinin her biri de sıralanır . Uzmanlardan Matematik'teki uzmanlardan resmi bir kanıt isteyebilirsiniz , ancak bu sezgisel olarak doğrudur. Örneğin, set 123için uygun altkümelerdir 1 2 3 12 13 23. Hepsinin sipariş edildiğini görebilirsiniz. Şimdi eğer orijinal 213olsaydı, olurdu 2 1 3 21 23 13ve hemen bunun düzensiz olduğunu görebilirsiniz 21.

Bunun önemli olmasının nedeni n'den çok daha az olmasıdır! alt kümeleri. Aslında, bakmamız gereken sadece 2 ^n- 2 altkümesi var. Tüm orijinal sayı dizisini içeren seti ve boş seti hariç tutabiliriz.

Yine de, 2 ⁿ -2 çok fazla iş olabilir. Polinom zamanını aşan birçok şeyde olduğu gibi, bir böl ve ele geçir yaklaşımı burada da işe yarar . En basit yaklaşım? Özyineleme !

Temel adımlar basit. Girişinizin her alt kümesi için daha küçük alt kümeler oluşturursunuz . Sonra bunların her biri için aynı şeyi yaparsınız. Alt kümeleriniz boyut 2'ye düştüğünde, hangisinin daha büyük olduğunu kontrol edin. Her seferinde alt grupların boyutunu küçültdüğünüzden, aslında beklediğinizden daha hızlı gider.

Burada anahtar Gerçek şu ki olmasıdır erken çıkmak bir bulur bulmaz, tek bozuk alt kümesini. Sen yok olması hepsini arama yapmak. Eğer biri kötüyse, tüm grup kötüdür. Bu, bu diğer cevapların çoğunda görmediğiniz bir hız meselesidir.

Yeterince konuşma, kodunu alalım!

Bunu popüler bir dil olduğundan ve okuması kolay olduğundan Java'da yaptım . Özyinelemenin zarafeti açıkça görülmelidir:

import java.util.ArrayList;

public class SortChecker {

    static final Integer[] input = {1, 2, 3, 4, 5};

    public static void main(String[] args) {
        if(isSorted(input))
            System.out.println("The array is sorted properly.");
        else
            System.out.println("The array was not sorted properly.");
    }

    public static boolean isSorted(Integer[] in){
        if(in.length == 1)
            return true;
        if(in.length == 2)
            return (in[0] <= in[1]);
        ArrayList<Integer[]> subsets = getSubsets(in);
        for(Integer[] next : subsets){
            if(!isSorted(next))
                return false;
        }
        return true;
    }

    public static ArrayList<Integer[]> getSubsets(Integer[] in){
        ArrayList<Integer[]> subsets = new ArrayList<Integer[]>();
        int bitmasks = (1 << in.length) - 1;
        for (int i = 1; i < bitmasks; i++){
            ArrayList<Integer> subset = new ArrayList<Integer>(); 
            for (int j = 0; j < in.length; j++)
                if ((i & (1 << j)) > 0) 
                    subset.add(in[j]);          
            subsets.add(subset.toArray(new Integer[1]));
        }
        return subsets;
    }
}

Kayıt için, sıkıldım ve dizilmiş 12 elemanlı bir dizi için 15 dakika bekledikten sonra onu öldürdüm. Yaklaşık 45 saniyede 11 element yapacaktır. Tabii ki, bu gerçekten yapar asortisiz için erken çıkmak, böylece iyi, um, bu.

Güncelleme: Yeni bir yeniden başlatmada, 13 dakikada 12 element yapar. 13 neredeyse 3 saat sürüyor ve 14 saat 20'de ve sayıyor.

— Geobits
kaynak

8

+1 bu muhtemelen şimdiye kadar gördüğüm en az verimli algoritma. O civarında olmalı (n! * 2 ^ (n!)) - Karmaşıklık (muhtemelen daha da kötü).

— Ral Zarek

6

Ben kötü gördüm eminim, ama bir o kadar kötü. İçtenlikle karmaşıklığı belirlemeye çalıştım ama vazgeçtim ve aradım O(big).

— Geobits

1

Daha az verimli bir çözüm sunmak, o zaman seyahat eden satıcı probleminin naif denemesinden bile etkileyicidir!

— recursion.ninja

3

12 element dizisinin dizilme şansı 479 milyonda sadece 1 olduğundan, kesinlikle kesin olarak kesinleşmesi biraz zaman alması önemli değil. Asla gerçek dünyada birini görmeyeceksiniz ...

— Jules

2

@ Geobits Sorun yok. Victor'un algoritmasını çalıştırın ve ilk satırda "evet" cevabını verin.

— Jason C

29

C ++ - kaba kuvvet yöntemi

Herkes kaba kuvvet yöntemlerinin her zaman en hızlı olduğunu bilir.

bool issorted(std::vector<int>& list)
{
  switch (list.size()) {
    case 0: case 1: return true;
    case 2: return list[0]<=list[1];
    case 3: return list[0]<=list[1] && list[1]<=list[2];
    case 4: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3];
    case 5: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4];
    case 6: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5];
    case 7: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6];
    case 8: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7];
    case 9: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8];
    case 10: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9];
    case 11: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10];
    case 12: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11];
    case 13: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12];
    case 14: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13];
    case 15: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14];
    case 16: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15];
    case 17: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16];
    case 18: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17];
    case 19: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18];
    case 20: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19];
    case 21: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20];
    case 22: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21];
    case 23: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22];
    case 24: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23];
    case 25: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24];
    case 26: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25];
    case 27: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26];
    case 28: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27];
    case 29: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28];
    case 30: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29];
    case 31: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30];
    case 32: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31];
    case 33: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32];
    case 34: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33];
    case 35: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34];
    case 36: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35];
    case 37: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36];
    case 38: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37];
    case 39: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38];
    case 40: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39];
    case 41: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40];
    case 42: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41];
    case 43: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42];
    case 44: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43];
    case 45: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44];
    case 46: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45];
    case 47: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46];
    case 48: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47];
    case 49: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48];
    case 50: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49];
    case 51: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49] && list[49]<=list[50];
    case 52: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49] && list[49]<=list[50] && list[50]<=list[51];
  }
}

Gerçek rutin daha uzundur (std :: npos'a gider), ancak buraya yazarken 30000 karakterle sınırlıyım.

— Bay Lister
kaynak

Bunu gerçekten beğendim.

— Jakob

3

Bu, vaka ifadelerine "bufalo her bölümünü kullanın" yaklaşımı gibidir.

— Jonathan Van Matre

Bu harika. Tüm döngüleri aç!

— McKay

Süper fikir!!!

— bikram990

26

Bilgi vermek

Bilgilendirme, klasik Infocom Z-machine yorumlayıcısı için etkileşimli kurgu oyunları yazmak için kullanılan bir dildir. Bozulmalardan kaçınmak için önce programımın sonuçlarını, sonra kaynak kodunu veriyorum.

Düzenleme: Diziye numara eklenmesine izin vermek için küçük bir revizyon yaptım ve büyüleyici bir oda açıklaması ekledim.

Sorted
An Interactive Fiction by Jonathan Van Matre
Release 1 / Serial number 140301 / Inform 7 build 6G60 (I6/v6.32 lib 6/12N) SD

Sorting Room
You are in the Sorting Room, a sterile expanse of pure white. Translucent
lucite walls leak a lambent clinical light into the spotless room.

You can see a safe (closed), a flask of poison, a radioactive isotope 
attached to a radiation detector that triggers a hammer, an array (empty) 
and Erwin Schrodinger here.

>open safe
You open the safe.

>put flask in safe
(first taking the flask of poison)

You put the flask of poison into the safe.

>put isotope in safe
(first taking the radioactive isotope attached to a radiation detector 
 that triggers a hammer)

You put the isotope detector assembly into the safe, carefully placing 
the hammer next to the fragile glass of the flask of poison.

>get array
Taken.

>put numeral 1 in array
(first taking the numeral 1)

You put the numeral 1 into the array.

>put 2 in array
(first taking the numeral 2)

You put the numeral 2 into the array.

>put 3 in array
(first taking the numeral 3)

You put the numeral 3 into the array.

>examine array
In the array are a numeral 3, a numeral 2 and a numeral 1.

>put array in safe
You put the array into the safe.

>ask Erwin about whether the array is sorted
Erwin grumbles and complains, "You haven't finished the experiment" 

>close safe
You close the safe.

>ask Erwin about whether the array is sorted
Erwin beams and proudly announces, "Indeterminate!"

Ve kaynak koduyla birlikte:

"Sorted" by Jonathan Van Matre

The Sorting Room is a room. "You are in the Sorting Room, a sterile expanse of pure white. Translucent lucite walls leak a lambent clinical light into the spotless room."
The safe is a container. The safe is in the Sorting Room. The safe is openable. The safe is closed.
There is a flask of poison in the Sorting Room.
There is a radioactive isotope attached to a radiation detector that triggers a hammer in the Sorting Room.
There is an array in the Sorting Room. The array is a container.
There is a numeral 1 in the Sorting Room. The numeral 1 is undescribed.
There is a numeral 2 in the Sorting Room. The numeral 2 is undescribed.
There is a numeral 3 in the Sorting Room. The numeral 3 is undescribed.
There is a numeral 4 in the Sorting Room. The numeral 4 is undescribed.
There is a numeral 5 in the Sorting Room. The numeral 5 is undescribed.
There is a numeral 6 in the Sorting Room. The numeral 6 is undescribed.
There is a numeral 7 in the Sorting Room. The numeral 7 is undescribed.
There is a numeral 8 in the Sorting Room. The numeral 8 is undescribed.
There is a numeral 9 in the Sorting Room. The numeral 9 is undescribed.
In the Sorting Room is a man called Erwin Schrodinger.
Understand the command "ask" as something new.
Understand "ask [someone] about [text]" as asking it about.
After inserting the isotope into the safe:
    If the safe encloses the flask, say "You put the isotope detector assembly into the safe, carefully placing the hammer next to the fragile glass of the flask of poison.";
Instead of asking Erwin about something:
    If the safe is closed and the safe encloses the flask and the safe encloses the array and the safe encloses the isotope, say "Erwin beams and proudly announces, 'Indeterminate!' ";
    Otherwise say "Erwin grumbles and complains, 'You haven't finished the experiment' ";

— Jonathan Van Matre
kaynak

21

Doge Ruby

Öncelikle bu kurulum kodunu çalıştırmalısınız

class Array;alias ruby sort;end
def self.method_missing x,*a;x;end
def very x;$a=x;end
def many x;$b=$a.send x;end
def wow;puts $a==$b;end

Ardından diziyi denilen değişkende saklayın codingve çalıştırın:

  very coding

                 many ruby
so algorithm


      wow

Ve cevabınız basılacak (doğru veya yanlış).

Lütfen en iyi performans için doge kodunu da ekleyin:

#~! SET DOGE=1 PERFORMANCE=OPTIMAL ONERROR=nil PIC=
#                    ***=*                                                       
#                    **===*                                                      
#                    ***=-=&                                   &&**&             
#                    **==--=                                  ***===*            
#                   &***=---*                               $*=------*&          
#                   &***=---=*                             $**=----;;=&          
#                   &**==----=&                           &*===---;;;-*          
#                   &**==----=*                          &**=-==--;;;;=          
#                   ****=-----=*                       &&*==--=---;;;;-          
#                   **===------=&                     $&*==-------;;;;-          
#                   **===-------=*&$$                &*==------;;;;;;;-          
#                   **==----==-====***&&&&&&&&$$    &*==-;;---;;;;;;;;-&         
#                  &*=---=====================*******=---;---;;;;;;;-;;=         
#                  *=======*=========================---;;--;;;;;;;;;;;*         
#                  *===***=======================------;;--;;""""";;;;;=         
#                  *=*****========================;--;;;;--;;""""";;;;;*         
#                &*********====-----===============;;;;;----;"","";-;;-&         
#               ***********====----================-;;;;----;",,";;----          
#             &************===---====================-;;;;;;",,"";----=          
#            &*************===---=====================-;;;;",,,";-----*          
#            ******=*******===--=======================--;",,,"";-----&          
#           &**************==--=========================-;"","";----;-           
#          ****************==---====****=====-===========--;";;-;;;";=           
#         ****************==----==*******===--=============--;----;--=           
#        &*****=;"";==***===----==*******===----=============------;-=$          
#        &&&***;"",,"-**====---==********=====-===============----;;;-&          
#       &&&&&*=-;;";";*==========****=***======--=========***==---;;;-&          
#      $&&&&&&=="",,,-===**=======***==-;-=================**===--;;;;*          
#      &&&&&&&-="",,"==***==***======-",,,";=-===================--";;=          
#      &&&&&**=-""";==****=***===---;"-=-,,,"--===================-;;;=&         
#     &&&&&&***--;=***********=---;,,-*",,,,,"--==================--;--*         
#     &&&&&***=*=*************=-;;","=-,,,,,,"-====================----=$        
#    &&&&&&*******************==--","-;,,,,,"-====*****=============-===&        
#   $&&&&&&******************===---",";"""";=******************=====-===*        
#   &&&&&&&&&*****************======--;;--==********************=========&       
#  &&&&&&&&&&&******=**********===========*==*****&&************=========*       
#  &&&&&&&&*=---;--==**********==============*********************=======*&      
#  &&&&&&&-""""";;"";=**********==**=========*****&&&**************=======*      
# &&&&&&&*,,,,,,,,,,,"-****&************=*******&&&&&&&************========&     
# &&**&&&=,,,,,,,,,,,,;*&&&&***********************&&&&&&***********=======*     
# &&&*&&&*",,,,,,,,,,,;*&&&*************&&**********&**************========*&    
#&&&&&&&&-"",,,,,,,,,,-*&&&**********&**&&&&&&&******************==========**    
#&&&&&&&*=,,,,,,,,,,,"-***************&&&&&&&&&*****************====--======*&   
#&&***&&*=;,,,,,,,,,";=*==*****************&&&***************=======--=======&   
#*&&&&**=-;",,,,,,"";-=*********=**&*********&&**************=======--======**   
#&&&&&**=-""",,,,,"";==**==***===**********************======***===---=======*&  
#&&&&&**=-;"""""","";;=-===*======*********************==******====----======*&  
#*&&&&**=-;""""""""";=-============*****************==*********====---==--===**  
#&&&&&***=",,,,,,"""";--=============*******==****************====----=--====**& 
#&&&&&****"",,,,,,,,,;-=========--===****====******************====--==-======*& 
#&&&&&&&&*-"",,,,,,,,,"--==--;"""";====**===********************======--======** 
#&&&&&&***=-;",,,,,,,,,,,;",,,""";-=======********************===-------=======* 
#&&&&&&&****=;""""""""",,,"""";;--==**====*******************=====--------=====* 
# &&&&&&&***=-;;;;;;;;;"";;;;;---==***====*****************=====--=--------====*$
# &&&&&&*****=-;-----=--------=====*=======****************====-==---------=====&
#  &&&&&******==-==-=============***========*************======----=--------====&
#  &&&&************==========================***********=====----------------===*
#  $&&&&***************====================***********=*======-------------=--==*
#   &&*&************=====================**************======--------------=====*
#   &******************=================**************=========-----------======*
#    &***********=*****================************==========------;-------=====*
#    &*****************================***********=============---------========*
#     &*************===================**********==***========--------========***
#      **************==================********====**===*=====--------=======****
#      &************=============================*****=*=====--------=======*****
#       &****=*******=============================**============--=======*=******
#       $*****=====**===========================***===================**********&
#        &*****=====================-====-====*=*=====*=======--==***************
#         &*****===========---==--===============**=**=*========*****************
#          &*****====---=---------========********======***===*******************
#           *****=======-=-------======*******=**==****==*==*********************
#           $***======================******===**********************************
#            &***===================*******==***=******************************=&
#             &***=========-=========*************==***************************=&
#              ******===*=======*=*****************==*************************==&
#~! END

Bu en kolay yoldur.

(ASCII sanatı, bu görüntüden türetilmiş, yazdığım bir senaryo tarafından oluşturuldu .)

— Kapı kolu
kaynak

7

"Yani algoritmayı" unuttun. Gerçek bir doge örneğinde "vay" dan önce 3 cümle vardır. Ve evet, partilerde çok eğleniyorum.

— Pierre Arlaud,

@ArlaudPierre Heh, tamam, düzeltilmiş: P

— Doorknob

11

Yani yorum, çok gelişme, pek çok yararlı. Vay.

— Pierre Arlaud,

Doge şeklinde ascii bir BF programı yazmalıydın ... yeni bir soru fikri!

— Doktor

19

PHP

Aşağıdaki çözümün kolaylığını ve anlaşılırlığını seversiniz. Genel kodlama ve bu kodlama başyapıtında kullanılan en son fonksiyonlar sizi hemen dünyanın en iyi geliştiricilerinin seçkin listesine götürecektir.

function is_sorted($input) {
    mysql_connect('localhost', 'name', 'password');
    mysql_select_db('database');

    mysql_query('
        CREATE TEMPORARY TABLE sorting_table (
          `value` int NOT NULL
        )');

    foreach ($input as $value) {
        mysql_query('INSERT INTO sorting_table VALUES (' . $value . ')');
    }

    $i = 0;
    $result = 'SORTED';
    $query = mysql_query('SELECT * FROM sorting_table ORDER BY value ASC');
    while ($value = reset(mysql_fetch_row($query))) {
        if ($input[$i++] != $value) {
            $result = 'NOT SORTED';
            break;
        }
    }

    mysql_query('DROP TABLE sorting_table');

    return $result;
}

print is_sorted(array(10, 20, 30, 40, 50));

— Vizyon
kaynak

+1 Çünkü sıralama sorusuna verdiğim cevabın

— Victor Stafusa,

4

Bayan Roberts değerleri girerse bu işe yarar mı?

— user80551

3

Hiçbir tablo olarak adlandırılan öğrencilerin olduğundan @ user80551 evet

— mandalınızı ucube

3

@JonathanVanMatre Kesinlikle güvenlik bu kodun en güçlü yönlerinden biridir.

— Vision

1

Bu, bu web sitesindeki yeni favori cevabım; ama fazladan puanlar için güvenlik için bir PDO kullandığını görmek isterim

— alexandercannon

17

İstatistiğin gücü

Bunu çözmek için gerçekten yapmanız gereken, soruyu çözümü açık bir şekilde yeniden çerçevelemek. Bu temelde "doğru-yanlış" türden bir soru olduğundan, temelde sorduğunuz şey "dizinin sıralandığından nasıl% 100 emin olabilirim?" Bir kelime bu sorudan çıkarsa, "kesin" kelimesidir. Kesinliği ölçmenin en iyi yolu nedir? Anladınız: istatistikler.

Buradaki diğer cevaplar sadece dizinin bir yönde sıralanıp sıralanmadığını kontrol eder . Bu çözüm aynı anda hem artan hem de azalan düzeni test eder. İşin püf noktası, zaten sıralandığını bildiğiniz aynı büyüklükte bir dizi almak (kendiniz yapmak kolaydır) ve sonra her bir dizinin sırasının diğerine göre ne kadar iyi olduğunu bulmaktır. Kendall tau rütbe korelasyon katsayısını hesaplamak, bunu yapmanın en kolay yoludur:

using System;

namespace Homework
{
    class Example
    {
        static void Main(string[] args)
        {
            int[] n1 = { 23, 50, 16, 57, 19, 60, 40, 7, 30, 54 };
            int[] n2 = { 7, 16, 19, 23, 30, 40, 50, 54, 57, 60 };
            int[] n3 = { 60, 57, 54, 50, 40, 30, 23, 19, 16, 7 };

            Console.WriteLine(isSorted(n1));
            Console.WriteLine(isSorted(n2));
            Console.WriteLine(isSorted(n3));
        }

        static string isSorted(int[] a)
        {
            double t = 0;
            int n = a.Length;

            //Build a 'known' sorted array.
            int[] k = new int[n];
            for (int i = 1; i < n; i++)
            {
                k[i] = i;
            }

            //Find the Kendall's tau coefficient.
            //First the numerator...
            for (int i = 1; i < n; i++)
            {
                for (int j = 0; j < i; j++)
                {
                    t += Math.Sign(a[i] - a[j]) * Math.Sign(k[i] - k[j]);
                }
            }
            //...then the denominator.
            int d = n * (n-1) / 2;
            //This gives the correlation coefficient.
            double sortedness = t / d;
            //1 is perfect correlation (ascending), -1 is perfectly non-correlated (descending).
            if (Math.Abs(sortedness) == 1)
            {
                return "Sorted";
            }
            else
            {
                return "Unsorted";
            }
        }
    }
}

Çıktı:

Unsorted
Sorted
Sorted

Bu işlev aynı zamanda "Çoğunlukla sıralanır" ya da "Tamamen sıralanmamış" ya da "Tamamen rasgele" gibi işlevler eklemenin önemsiz olması nedeniyle işlevselliklerini genişletmek için de çok kolaydır.

Düzenle

Neredeyse algoritmanın verimliliğini aşmayı unuttum. Bu şu anda O (7). Yöntem adında bir tane, "for" anahtar kelimelerinin her birinde bir tane, "çift" bildirgesinde bir tane ve "sıralı" değişkeninin kullanımında iki tane vardır. Fonksiyonu yeniden adlandırarak, ikilik ondalık değerine değiştirerek, "sıralama" 'yı "srtdnss" e çevirerek ve for döngülerine dönüştürerek, O (0)' a kadar (gidebileceğiniz kadar düşük) kadar geliştirebilirsiniz. döngüleri

— Komintern
kaynak

2

Karmaşıklığı titizlikle yeniden hesapladım ve O olarak belirledim (8). Etkili olması gerektiğine inandığım çıktıları elden çekiyorsunuz. Gerçekten O (7) bir karmaşıklığa sahip olmak için, "sıralanmış" / "sıralanmamış" yerine "artan" / "rasgele" döndürmeyi düşünebilirsiniz.

— Geobits

@Geobits - Tekrar baktım ve elbette haklısın. Sanırım bu, dizeleri döndürürken asgari bir O (1) karmaşıklığı olduğunu gösteriyor. Bu küçük bir bedel olsa da, çünkü bir boole döndürmek iki kat daha kötü.

— Komintern

1

O () hesaplama için +1. -1 aynı zamanda bir Spearman rho hesaplayamadığı için, çünkü iki korelasyon bir taneden daha iyi değil mi? Ve C # istatistikleri için +1, istatistikçilerin kanıtlanmış favorisi.

— Jonathan Van Matre

Lütfen bana O(7)şakanın bir şey olduğunu söyle

— mbatchkarov

@mbatchkarov - Bu küçük O notasyonu. :-)

— Comintern

16

Yakut

Bir dizi sıralanırsa aşağıdaki strateji eninde sonunda ortaya çıkacaktır:

A bir dizi olabilir (sıralı veya sıralanmamış, örneğin [1,2,3] veya [1,3,2])
P , A'nın tüm permütasyonlarını tutan bir dizi olmalıdır.
Eğer bir sıralanır, maksimum veya minimum ya olan P (temelde bir sıralı versiyonlarını olan A Ruby)

Test için çevrimiçi versiyon .

class Array
   def is_sorted?
      permutations = permutation.to_a
      self == permutations.max || self == permutations.min
   end
end

— David Herrmann
kaynak

1

Açıklamayı anladığımı sanmıyorum. Dizi, mesela, [1, 9, 100] ise, min. 10019 ve maks. 91100, fakat sıralanan numara 19100'dür. [1,9,100]. Hiçbir şeyin "sayı ile temsil edildiğini" anlamıyorum; diziler sadece sözlüksel olarak sıralanıyor gibi görünüyor. Bu aynı olurdu, sanırım tüm sayılar sadece bir rakamsa.

— Joshua Taylor

“... ya maksimum ya da minimum…” onu sevdi.

— microbian

@JoshuaTaylor: Heads-up için teşekkürler! Ben açıklama ... düzeltilmiş); düz yanlış olduğunu belirten sona erdi - Ben kolay anlaşılabilir bir şekilde açıklamak istedim

— David Herrmann

2

@JoshuaTaylor yakut yöntemleri Array # max ve #min, <ve> işleçleri bakımından en büyük ve en küçük elemanı seçer. Dizilerde <ve> sözlükbilimsel sıralama uygular. [1,9,100], sözlükbilim sırasındaki 1, 9 ve 100 numaralı sıralı tüm izinlerin asgarisidir.

— Karl Damgaard Asmussen,

Bu neredeyse üretim kalitesi.

— primo

12

Deterministik olmayan çözüm

Bu kod muhtemelen çalışıyor.

static bool isSorted(int[] s)
{
    var rnd = new Random();
    for (var i = 0; i < s.Length * s.Length * s.Length; i++)
    {
        var i1 = rnd.Next(0, s.Length);
        var i2 = rnd.Next(0, s.Length);
        if (i1 < i2 && s[i1] > s[i2] || i1 > i2 && s[i1] < s[i2])
            return false; // definitely not sorted
    }
    return true; // probably sorted
}

— fejesjoco
kaynak

8

Yineleme sayısını -n ^ 2 * ln (1-p) olarak ayarlarsanız, tüm kombinasyonların kontrol edileceğini p olasılığından emin olabilirsiniz!

— Hannesh

Ve bu çözümün "çalışma kodu fakat trolling" olarak kabul edilmesi için hangi p değerleri geçerlidir? :)

— fejesjoco

2

Gönderen stackoverflow.com/questions/2580933 nedeniyle kozmik ışınlar bir karşılaştırmanın yanlış hesap şans 0,0000018 (1.8e-6) her saniye olacaktır. Öyleyse: 1) bir yinelemenin ne kadar süreceğini anlayabilir, 2) Olasılığı hesaplamak için @Hannesh formülü kullanabiliriz ve sonra çözümünüzü ayırt edilemez hale getiren yinelemelerin sayısını bulmak için denklem sistemini çözebiliriz. standart, sıralı yöntemdir.

— Xantix

11

piton

Liste sıralanırsa, her sayı bir sonraki sayıya eşit veya daha küçüktür. Bu nedenle en soldaki sayıyı kaldırmak ortalama değeri yükseltir, aksi halde liste sıralanmaz. Her sayıyı kontrol etmek için bunu bir döngüye koyacağız

def is_sorted(lst):
    def _avg(lst):
        return sum(lst)/(1.0*len(lst))
    for i in range(len(lst)-1):
        if _avg(lst[i:]) > _avg(lst[i+1:]):
            return False
    return True

sıralı ([1,2,3]) #True
sıralı ([3,2,1]) # Yanlış, beyaz
((1,4,3,2,0,3,4,5)) #False

Gözlemci okuyucu tam olarak böyle çalışmadığını fark edecektir.
Sıralı ([1,4,3,2,0,3,4,11]) # Yanlış Sıralı
([1,4,3,2,0,3,4,12]) #True
sıralı ([1,2 , 1,2,1,2,1,2,99]) #True

— VBCPP
kaynak

9

darbe

mkdir -p nums
mynums=(1 2 3 4)
for i in "${mynums[@]}"
do
     touch "nums/$i"
done

result=`ls -v nums`
resultarray=(${result})
for i in "${!resultarray[@]}"
do
    if [ ${resultarray[$i]} != ${mynums[$i]} ]; then
        echo "not sorted!"
        rm -rf nums/*
        exit 1
    fi
done
echo "sorted!"
rm -rf nums/*

Dizideki her eleman için bir dosyaya dokunun, dizinin ls'si ve ls sonucunu orjinal diziyle karşılaştırın.

Bash ile pek iyi değilim, sadece denemek istedim :)

— Zach Thacker
kaynak

Güzel olan, bu "./nums" dizininin zaten var olduğunu varsayar. Belki bir yerlerde bir "mkdir -p nums"?

— camelthemammel

Ah, evet, mantıklı: P

— Zach Thacker

8

C #

“Daha küçük” veya “daha büyük” kavramları çok fazla 2013 . Gerçek programcılar sadece modulooperatörü kullanır !

private static void Main()
{
    List<int> list = new List<int> { 1, 5, 7, 15, 22};
    List<int> list2 = new List<int> { 1, 5, 15, 7, 22 };

    bool a = IsSorted(list); // true
    bool b = IsSorted(list2); // false
}

private static bool IsSorted(List<int> list)
{
    for(int i = 0; i % list.Count != list.Count() - 1; i++)
    {
        if (list[i] % list[i + 1] != list[i] &&
            list[i] != list[i + 1])
        {
            return false;
        }
    }
    return true;
}

— Pierre-Luc Pineault
kaynak

Ya aynı numara iki kez belirirse? Ardından [i]% list [i + 1] == 0 listesi

— Simon

@Simon Oh ho! Aslında, iki özdeş sayının sıralandığını tahmin ediyorum. Bu kenar durum için bir karşılaştırma eklendi. Güzel buldum.

— Pierre-Luc Pineault,

5

{0, -1, 2} 'nin sıralanmış bir liste olduğunu bilmek sevindim.

— Pierre Arlaud,

9

@ArlaudPierre Gerçek bir 2014 programcısı olmak istiyorsanız, negatif olan her şeyi bir kenara koymak zorundasınız. Dünya pozitif, dünya mutlak, dünya modulo!

— Pierre-Luc Pineault,

1

"Daha büyük" ve "daha küçük" kavramlarından hoşlanmadığınız için, işaretlerden daha küçük ve daha büyük olanları dahil etmeniz çok yazık. Listeleri yerine dizileri kullanmalıydın.

— Bay Lister

8

Scala

Bir dizinin sıralanıp düzenlenmediğini kontrol etmek kolaydır! İlk öğenin ikinciden daha az olup olmadığını kontrol edin. Sonra gerisini sıralayın ve eşit olup olmadıklarına bakın.

Ne yazık ki, sıralama zor bir sorundur. Bir diziyi sıralamak için çok iyi bilinen ya da etkili algoritmalar yoktur; Aslında bilgisayar bilimi bilgisinin şu anki durumunda büyük bir kör nokta. Bu yüzden basit bir algoritma öneririm: diziyi karıştırın ve daha önce belirtildiği gibi kolay olduğunu sıraladı mı kontrol edin! Sıralanıncaya kadar karıştırmaya devam edin.

object Random {
  def isSorted(list: List[Int]): Boolean = {
    if (list.size <= 1) {
      true
    } else {
      sort(list.tail) == list.tail && list.head <= list.tail.head
    }
  }

  def sort(list: List[Int]): List[Int] = {
    val rand = new scala.util.Random()
    var attempt = list
    do {
      attempt = rand.shuffle(attempt)
    } while (!isSorted(attempt))
    attempt
  }

  def main(args: Array[String]): Unit = {
    println(isSorted(List(1, 2, 3)))
    println(isSorted(List(1, 3, 2)))
    println(isSorted(List(1, 2, 3, 4, 5, 6, 7, 8)))
  }
}

Bu çıktıların "doğru, yanlış, doğru" olduğunu farz ediyorum. Bir süredir koşuyor ...

— Joe K
kaynak

8

Sıralanmış bir tamsayı dizisi, her alt dizinin (dize m'den n'ye kadar olan elemanlar) aynı zamanda bir tamsayı dizisi olma özelliğine sahiptir. Bu açıkça en iyi yöntemin bir RECURSIVE işlevi olduğunu gösterir:

bool isSorted_inner(const std::vector<int> &array, int start, int length){
    if (length == 2){
        if (array[start] < array[start+1]){
            return true;
        }else{
            return false;
        }
    }else{
        return isSorted_inner(array, start, length-1) && isSorted_inner(array, start+1, length-1);
    }
}

bool isSorted(const std::vector<int> &array){
    return isSorted_inner(array, 0, array.size());
}

En hızlı yöntem olmayabilir, ancak bir listenin sipariş edilip edilmediğine dair VERY ACCURATE testi yoktur. Ayrıca, FONKSİYONEL bir paradigma kullandığı için bu kodu okumak ve anlamak inanılmaz derecede kolaydır ve bu nedenle devlet değiştirme ve yinelemeli döngüler korkularından arındırılmıştır.

Umarım bu sizin için faydalı bilgiler olacaktır.

— Allen
kaynak

6

C # - en uzun artan alt

Sıralanmış bir dizi için, en uzun artan alt dizinin uzunluğu, dizinin uzunluğuna eşittir. Algoritmayı buradan kopyaladım , sadece arttırmak yerine azalmayacak şekilde değiştirdim.

static bool isSorted(int[] s)
{
    return s.Length == LongestIncreasingSeq(s);
}

static public int LongestIncreasingSeq(int[] s)
{
    int[] l = new int[s.Length];  // DP table for max length[i]
    int[] p = new int[s.Length];  // DP table for predeccesor[i]
    int max = int.MinValue;

    l[0] = 1;

    for (int i = 0; i < s.Length; i++)
        p[i] = -1;

    for (int i = 1; i < s.Length; i++)
    {
        l[i] = 1;
        for (int j = 0; j < i; j++)
        {
            if (s[j] <= s[i] && l[j] + 1 > l[i])
            {
                l[i] = l[j] + 1;
                p[i] = j;
                if (l[i] > max)
                    max = l[i];
            }
        }
    }
    return max;
}

— fejesjoco
kaynak

6

Stonescript (c) LMSingh - 0 eksi (4102 palindromed).

Aşağıdakiler, yüzlerce yıl önce benim tarafımdan telif hakkı alınmış ve kullanılan bir dil olan Stonescript'te (c) yazılmıştır; NOT: Sanskritçe'nin öncüsüdür.

1. Find a very straight stick in the jungle.  
2. Sum up all the values of the array elements and find that many equal sized stones.  
3. Line up all the values of the array along the side of straight stick from step 1. Each value is to be represented by number of stones for each array element like so...

8 elementli bir dizi örneği. Azalan sırayla sıralanmış :-)

o
oo
oo
oooo
ooooo
ooooo
ooooo
oooooo
ooooooo
oooooooo
========
12345678

- Kod devam etti.

4. E-ball-uate. (In Shakespearean English that means Eye ball it.)  
  4.1 Run your eye from array position 1 top towards array position 8 top.  
  4.2 If it looks sorted, then it is.  
  4.2.1 Start jumping up and down and thumping chest.  
  4.2.2 Go to happy end.  
  4.3 If something isn't quite right, like in case of example below then it isn't.  
  4.3.1 Kick the stones in frustration and anger! Cuz it really is not sorted!  
  4.3.2 Go to sad end.

8 elementli bir dizi örneği. Sıralanmamış :-(

o
oo
oo
oo o
ooooo
ooooo
ooooo
oooooo
ooooooo
oooooooo
========
12345678

- Kod devam etti.

5. Sad end.  
  5.1 Eat an apple.  
  5.2 Fall from grace to next line.  
6. Happy end.

= - = - = - = - = - =
Daha fazla optimizasyonda, adım 4 zımba yaprakları aşağıdaki zımba yaprakları ile değiştirilebilir.
= - = - = - = - = - =

4. Roll a stone from top of position 1 towards top of position 8, pushing the rolling stone towards the top stone for each position while moving to the right.  
  4.1 If rolling stone reaches the position 8 then it's sorted.  
  4.1.1 Start jumping up and down and thumping chest.  
  4.1.2 Go to happy end.  
  4.2 If the rolling stone gets stuck in a trough, then it isn't.  
  4.3.1 Kick the stones in frustration and anger!  
  4.3.2 Go to sad end.

= - = - = - = - = - =
Sizler için tüm kod yarıkları ve güç hata ayıklayıcıları için, 4. adımdaki yukarıdaki ikinci varyasyona kasten bir hata ekledim.

— LMSingh
kaynak

3

4.3.*4.2.*

— Böceği

4

JavaScript

Bu sizi “yaratıcılık” hakkında şok eden şeydi:

Çünkü sıralı bir dizi için
* all the elements on the left side of any element must be smaller 
* all the elements on the right side of any element must be bigger
Bu nedenle, tüm elemanlar için bir ana döngü çalıştırın ve ana biri içerisinde (biri sol taraf, diğeri sağ taraf) olmak üzere iki iç içe döngü çalıştırarak yukarıdaki iki koşulu kontrol edin.

Böylece, açıklanan algoritmanın bir javascript uygulamasını veriyorum:

function checkArraySorted(array) {
  for (a = 0; a < array.length; a++) {
    for (b = 0; b < a; b++) {
       if (array[b] > array[a]) return false;
    }
    for (b = a + 1; b < array.length; b++) {
       if (array[b] < array[a]) return false;
    }
  }
  return true;
}

Test edelim:

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

checkArraySorted([1, 2, 3]);
> true

checkArraySorted([1, 2, 3, 4]);
> true

Mükemmel çalışıyor gibi görünüyor! O(n²)Olması gereken bir algoritma için ideal bir karmaşıklığa sahiptir O(n), ancak bunu yaparak O(n²)daha verimli hale gelir, çünkü bu bir verimlilik ölçüsüdür, bundan O(n²)daha verimlidir O(n).

— Victor Stafusa
kaynak

'Orta' kullanmak istemedim. İlk iç içe döngü 0'dan a'ya, ikincisinin de + 1'den uzun olması gerekiyordu. BTW, 1,2,3 sıralanmalı, değil mi?

— microbian

@microbian Tamam, düzenlendi.

— Victor Stafusa

4

C

Bundan sonra, "sıralanmış", "artan düzende sıralanmış" anlamına gelir.

Bir dizi iff sıralama değil a[i]>a[i+1]

Yani izin verirsek x=a[i]-a[i+1],x dizi sıralanmamıştır IFF pozitif olacaktır.

xOlumlu olup olmadığını test etmek için iki parçaya ayırabiliriz: xolumsuz değil vex sıfır değil

Olup olmadığı için basit bir test xNegatifx*x , eşit olup olmadığını test etmemizdir x*abs(x). xÇünkü bu durum negatifse yanlış olmalıdır (-1)*(-1)==1.

Sıfır testi yapmak için başka bir basit test kullanabiliriz: 0./(float)xSayı Değil iff xsıfırdır.

İşte kodun tamamı: (dizinin 5 elementi olduğunu varsayar)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main() {
    int i, a[5];
    for(i=0;i<5;i++) scanf("%d",&a[i]);
    int sorted=1;
    for(i=0;i<4;i++) {
        int x=a[i]-a[i+1];
        if(x*x==x*abs(x)&&!isnan(0./(float)x)) {
            sorted=0;
            break;
        }
    }
    puts(sorted?"sorted":"not sorted");
    return 0;
}

— ace_HongKongIndependence
kaynak

Aslında, test etmek a[i]-a[i+1] > 0zaten sorunlu. Bütün bu işleri yapmana gerek yok.

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Gereksiz şeyler yapmak, kod trolling'in esas noktasıdır, değil mi? (Sorunlu derken neyi kastediyorsunuz?)

— ace_HongKongIndependence

1

İmzalanan tamsayı taşması UB. Etrafı saran davranışı tanımlasak bile, INT_MAX - INT_MIN yaparsak sonuç negatif bir sayı olacaktır (INT_MAX ile bir [i] ve INT_MIN ile bir [i + 1] ile değiştirin).

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Sadece bir ev ödevi problemi olduğu için, öğretmenin çok fazla aşırı sayı vermediğini varsayalım.

— ace_HongKongIndependence

TAMAM. Sadece troll + kötülük yapmayı tercih ediyorum.

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

Her şey ne kadar emin olmak istediğinizle ilgilidir. Kesinlik verilmediğinden, aşağıdakiler aslında oldukça iyi bir performans göstermektedir. Aşağıdaki kod iyi bir tahminde bulunur, ancak emeğin birkaç kez tekrarlanması gerektiğinden eminseniz. Olmak istiyorsanız gerçekten emin, bir döngü içinde çalıştırmak ve çok defalar bir düzine yapmalıdır. Mükemmel ölçeklenebilirlik!

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static const int size = 100;

int issorted(int *array, int size)
{
    int idx = random() % size;
    return (array[idx] >= array[0]);
}

void check_array(int *array, int size)
{
    if (issorted(array, size)) {
        puts("The array is sorted but I am not 100% sure.");
    } else {
        puts("The array is definitely not sorted in ascending order.");
    }
}

int main(void)
{
    int *array = malloc(sizeof(int) * size);
    int i = 0;

    srand(time(NULL));

    for (i = 0; i < size; i++) {
        array[i] = random();
    }

    check_array(array, size);

    for (i = 0; i < size; i++) {
        array[i] = i + 1;
    }

    check_array(array, size);
    free(array);

    return 0;
}

Bu bir tedavi değil mi?

— n0la
kaynak

4

C

int is_sorted(int *T, int n)
{
return false;
}

Olasılık 1- (1 / n!) Ve karmaşıklık O (1) ile çalışır. Açıkçası çok büyük rastgele diziler için en iyi yöntem.

Karmaşıklık yalnızca O (1) olduğundan, daha iyi bir tahmin için iki kez çalıştırın.

— CPRI
kaynak

3

C

Bu işlev, dizinin sıralanıp sıralanmadığını size söylemekten daha fazlasını yapar. Size doğru yerde kaç tane eleman olduğunu söyler. Her türlü veri için kullanılabilir.

Kodunuzun takip edilmesini kolaylaştırmak için tanımlayıcı değişken adlarını kullanmanın önemine dikkat edin. Öte yandan, i değişkenini, programda başka bir yerde bildirilmesi zorunlu olduğu için ilan etmemize gerek yoktur.

int sortcheck(array_to_be_checked[10])
{
  int number_of_elements_in_right_place=0;

  for (i = 1; i = 10; i++)
    number_of_elements_in_right_place += i == array_to_be_checked[i];

  return number_of_elements_in_right_place;
}

Düzenleme: Bu, daha büyük diziler için daha iyi bir yoldur. Bunun avantajı, bir insanın kontrol edeceği şekle benzer olmasıdır.

int sortcheck(array_to_be_checked[32767])
{
  i=rand(); j=rand();
  while( (array_to_be_checked[i] > array_to_be_checked[j]) = (i > j) ) 
  {
    printf("I think it's sorted");
    i=rand(); j=rand();
  };
  printf("It wasn't sorted");
}

— Seviye Nehri St
kaynak

1

"İ değişkenini, programda başka bir yerde bildirilmesi zorunlu olduğu için bildirmemize gerek yok." gülmeye değdi.

— Jonathan Van Matre

@JonathanVanMatre Teşekkürler ama bu kodda yanlış olan tek şey değil.

— Seviye Nehri St

3

JavaScript + daha fazla istatistik

@Cominterm tarafından önerilen çözümü çok beğendim. Ama zaten sıralanan bir listeyle karşılaştırarak? Bu hile yapmaktır!

Bunun yerine, dizinin otomatik korelasyonunu hesaplarım (dizi ile dizi arasındaki korelasyon bir konum değiştirilir). Sonra, diziyi birçok kez karıştırıyorum ve her seferinde yeni otomatik korelasyon ile orijinal otomatik korelasyonu karşılaştırıyorum. Dizi sıralanırsa, orijinal otomatik korelasyon çoğu zaman en yüksek olur!

http://jsfiddle.net/dB8HB/

Bonus: Eğer p-değeri <0.05 ise, çıktı dizinin sizin için sıralandığını iddia etme görevini otomatik hale getirecektir. Daha ne isteyebilirsin?

Bonus2: Bu uygulama kolaylık sağlamak için JavaScript'in O (n) dizi işlevlerini kullanıyor olsa da, yaklaşım sabit zamanda çalışmak için örneklemeyi kullanabilir!

<form name="out"><textarea name="put" cols="80" rows="3">Press the button</textarea></form> 
<button onclick="startstop();">The button</button>
<script>
var iid=input=0, my=document.forms, isit={'true':0.5,'false':0.5}, ownAutocorr;
function startstop(){
     if(iid){
        clearInterval(iid);
        if(1 - isit.true / (isit.true+isit.false)<0.05){my.out.put.value+="\nYour array is sorted! (p<0.05)";}
        iid=input=0;isit={'true':0.5,'false':0.5}
     }
     else   {
        input=JSON.parse("["+prompt("Comma separated integers")+"]");
        ownAutocorr=pearsonCorrelation(input,cloneShiftArray(input));
        iid=setInterval(trial,50);
    }
}

function trial(){

 var newArr=shuffle(input.slice(0));
 var newAutocorr=pearsonCorrelation(newArr,cloneShiftArray(newArr));
 isit[newAutocorr<ownAutocorr]++;
 my.out.put.value="Your array is sorted with probability " + (isit.true / (isit.true+isit.false)).toFixed(2);
}

function cloneShiftArray(oldArr){
    var newArr=oldArr.slice(0); //clone the array
    var len=oldArr.length;
    //shift the array one
    for(var l=0;l<len-1;l++){
     //performance is important so we'll use bitwise operators
     newArr[l]^=newArr[l+1];
     newArr[l+1]^=newArr[l];
     newArr[l]^=newArr[l+1];
    }
    newArr[l]+=newArr[l-1   ];
    return newArr;
}
function pearsonCorrelation(p1, p2) { //Borrowed from teh interwebs
  var len = p1.length;
  var sum1=sum2=sum1Sq=sum2Sq=pSum = 0;
  for (var l = 0; l < len; l++) sum1 += p1[l];
  for (var l = 0; l < len; l++) sum2 += p2[l];
  for (var l = 0; l < len; l++) sum1Sq += Math.pow(p1[l], 2);
  for (var l = 0; l < len; l++) sum2Sq += Math.pow(p2[l], 2);
  for (var l = 0; l < len; l++) pSum += p1[l] * p2[l];
  var num = pSum - (sum1 * sum2 / len);
  var den = Math.sqrt((sum1Sq - Math.pow(sum1, 2) / len) *
      (sum2Sq - Math.pow(sum2, 2) / len));
  if (den == 0) return 0;
  return num / den;
}
function shuffle(array) {//also borrowed
  var currentIndex = array.length, temporaryValue, randomIndex;
  while (0 !== currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }
  return array;
}
</script>

— Fabio Beltramini
kaynak

3

JavaScript / SVG - sunDialsort

Bu çözüm <, <=,> veya> = karşılaştırıcıları kullanmaz. Bir sıralama işlevi gibi olabildiğince az okumasını sağlamaya çalıştım.

Yöntem

Değerleri bir yay boyunca nokta olarak çizin.
Yükselen bir dizi için her değer çizimin toplam genişliğini genişletir ve başlangıç X'ini düşürmez (istisna: iki özdeş değer).
Genişlik küçülmeyeceğinden a! = Yeterli olacaktır,
X'in artıramayacağı gibi bir == yeterli olacaktır.
İki özdeş değeri belirlemek için, her nokta aslında artan uzunlukta bir çizgidir. Ünite uzunluğunun 1 / değer sayısından az olması.

Trolling

Bu çok kötü kodu okuma yolculuğuna aşağıdaki yüz avuçlarını ekledim.

işlev sunDialsort (bonus hatalı büyük harf) adındaki diziyi sıralamaya gidiyor gibi görünebilir
Tüm değişken isimleri için kullanılan lit-geek referansı
dizideki öğelerin sayısını saymak için regex çekici kullanıldı
uyarı kutusu kullandı
2 ardışık değişkenin aynı olduğu kenar durumu için çözüm, kod miktarını iki katına çıkardı (bir astar bunu ayarlayabilirdi), işlevin amacını karıştırmak için bu kodun çoğunu çok erken koydu.
Min'i bulmak ve max, en uzun sayıyı bulmak ve bir sonraki 10'luk güce kadar inmek, umarım bu, insanları kokudan atar.

xml

<body>
<svg id="dial" height="400" width="400" transform=""></svg>
</body>

fonksiyon

sunDialsort = function (values)
{
    var twas = values.toString();  
    var brillig = twas.match(/,/g).length + 1; //<1>
    //find the sig figs we are working with (longest number)
    var and = [], the = 0;
    for (var jabberwock = 0; jabberwock < twas.length; jabberwock++)
    {
        switch (twas.charAt(jabberwock))
        {
        case ("."):
            break; //dont count
        case (","):
            and.push(the);
            the = 0;
            break;
        default:
            the++;
        }
    }
    and.push(the);
    var slithy = Math.max.apply(Math, and);
    //assume did/toves based on number of characters
    var toves = Math.pow(10, slithy);
    var did = toves * -1;
    console.log(did + "," + toves + "," + brillig);
    //for each number make a horizontal svg line of length (jabberwock*acuuracy)     
    var gyre = 1 / brillig;
    var gimble, wabe, all, mimsy, were, borogoves, mome, raths;
    var outgrabe = true;
    for (jabberwock = 0; jabberwock < brillig; jabberwock++)
    {
        gimble = document.createElementNS('http://www.w3.org/2000/svg', 'path');
        gimble.setAttribute("stroke", "blue"); //green is not a creative colour
        gimble.setAttribute("d", "M0 20 h " + (jabberwock * gyre));
        wabe = (values[jabberwock] - did) / (toves - did);
        mimsy = 90 - (wabe * 180);
        gimble.setAttribute("transform", "rotate(" + mimsy + ")");
        document.getElementById("dial").appendChild(gimble);
        borogoves = document.getElementById("dial").getBBox();
        if (mome)
        {
            raths = (borogoves.width != all && were == borogoves.x);
            console.log("test " + raths);
            all = borogoves.width;
            if (!raths)
            {
                outgrabe = false
            }
        }
        else
        {
            were = borogoves.x;
            all = borogoves.width;
            mome = true;
        }
    }
    return outgrabe
};
alert(sunDialsort([1, 2, 3, 3, 4341, 556]));

Herhangi biri test etmek isterse, burada okunabilir değişken adlarına sahip bir sürüm var. http://jsfiddle.net/outRideACrisis/r8Awy/

— OutRideACrisis
kaynak

3

C

İkili arama yalnızca sıralı dizilerde çalıştığından, bir dizinin sıralanıp sıralanmadığını kontrol etmek için tek yapmamız gereken, dizinin tüm öğeleri için ikili bir aramanın çalıştığını doğrulamaktır. Herhangi bir öğe bulamazsa, dizinin sıralanmadığını biliyoruz.

İletilen komut satırı argümanlarının tümü, baştaki sıfırlar olmadan ondalık tam sayılar olmalıdır.

#include <stdlib.h>
#include <string.h>

int compar(const void *a, const void *b) {
  char *const *sa = a, *const *sb = b;
  int cmp = strlen(*sa) - strlen(*sb);
  if (cmp == 0) cmp = strcmp(*sa, *sb);
  if (cmp == 0) cmp = sa - sb;
  return cmp;
}

int main(int argc, char *argv[]) {
  if (argc-- && argv++) {
    for (int i = 0; i != argc; i++) {
      if (bsearch(argv+i, argv, argc, sizeof *argv, compar) != argv+i) {
        return 1;
      }
    }
  }
  return 0;
}

— HVD
kaynak

3

JavaScript

a = prompt("Please enter the data");
r = prompt("Does your array arouse moral distaste and contempt?");
if ((/yes/i).test(r))
  alert("The array is sordid.");

— Jason C
kaynak

1

{ 69 , 313 , 187 , 31338 )

— Geobits

2

C

Dizinin bir kopyasını alın
kopyayı azalan sıralama
bu dizinin verilen dizinin tersi olup olmadığını kontrol edin

    #include<stdio.h>
    #include<stdlib.h>
    #include <stddef.h>
    #include<string.h>
    int main(){
     int arr[100],i,j,temp;
     int a[] = {1,2,3,4,5,6,7,8,9,10};
     char b[256];

     printf("Loading the program please wait...");
      int s = sizeof(a)/sizeof(a[0]);
     for(i=0; i<999999999; i++);//best way to make the program more realistic
     system("cls");

     for(i=0;i<s; i++ )
     arr[i] = a[i];

     for(i=0;i<s;i++){
          for(j=i;j<s;j++){
               if(arr[i] < arr[j]){
               temp=arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
               }
           }
     } //sorting array in descending order

     int p = 0;
     for(i=0; i<s; i++)
     {
         if (a[s-i-1] != arr[i])
         p++;
     }

     if(p>0)
     printf("No");
     else
     printf("yes");
     getch();


     }

— mhmd
kaynak

2

Mathematica

Bu algoritma çalışıyor gibi görünüyor, fakat biraz yavaş. Sıralamanın daha hızlı yolları olabilir ama ben onları bulamadım.

Listenin rastgele sıralamasını alın ve sıralı olup olmadığını kontrol edin ( OrderedQ ).
Eğer öyleyse, dur. Aksi takdirde, 1. adımı tekrarlayın.

Aşağıdaki kod listeyi 18 saniyeden fazla bir sürede sıraladı.

a = {23, 50, 16, 57, 19, 60, 40, 7, 30, 54};
n = 1;
Timing[While[! OrderedQ[a], a = RandomSample[a]; n++]]
n
a

{18.581763, Null}
8980699
{7, 16, 19, 23, 30, 40, 50, 54, 57, 60}

— DavidC
kaynak

Görev, girişin zaten sıralanıp sıralanmadığını kontrol etmekti .

— Ilmari Karonen

Çözümümün arkasındaki temel fikir budur (yine de, OrderedQsadece eğlenceler için ikinci dereceden bir zaman kullanırım) sonunda "şimdi sıraladığımız bir tane var, başladığımız şey mi?"

— Şubat’ta stand

2

JavaScript

function isSorted(arr) {
    if (arr.length === 1 && typeof arr[0] !== 'number' || arr[0].toString().indexOf('.') !== -1 || arr[0] > (-1 >>> 0) || arr[0] !== arr[0] || arr[0] === Infinity) {
        // Return false in the case of one non-number element.
        // isSorted returns false for arrays containing non-numbers for consistency
        // with PHP, but that doesn’t work for one element, so that’s the purpose
        // of this check.
        return false;
    }

    var obj = {};
    var i;

    for (i = arr.length; i--;)
        obj[arr[i]] = true;

    for (var x in obj)
        if (arr[++i] != x) return false;

    return true;
}

Bu işlev falseyanlış dönebilir , ancak modern tarayıcılarda görünmeyebilir; Bunu kontrol edebilir ve gerekirse daha yavaş geri dönüş sağlayabilirsiniz (soruda açıklandığı gibi):

var isModern = /chrome/i.test(typeof navigator === 'object' && navigator.userAgent);

if (!isModern) {
    isSorted = function() {
        // I develop on good browsers, so the implementation is left as an exercise
        // to the reader if he or she wants to support outdated browsers.
    };
}

Bunun negatif rakamlar üzerinde öngörülemeyen sonuçlar verdiğini söylüyorlar, ancak asıl mesele, işleri tahmin etmekte ne kadar iyi olduğunuzdur.

— Ry-
kaynak

2

Chrome'un insanların böyle şeyleri yapmalarını engellemek için nesne özelliklerini karıştırmasını dilerim…

— Bergi

2

Java (Levenshtein Uzaklığı)

Bu uygulamada orijinal diziyi klonladım ve klonlanan örneği sıralıyorum. Ardından, Levenshtein mesafesi hesaplanır. Sıfırsa, orijinal dizi sıralanır.

Not: getLevenshteinDistance () uygulaması Jakarta Commons Lang'ten alınmıştır ve CharSequence yerine int [] üzerinde çalışmak üzere değiştirilmiştir.

import java.util.Arrays;

public class CheckSorting {

    public boolean isSorted(int[] array) {
        int[] sortedArray = Arrays.copyOf(array, array.length);
        Arrays.sort(sortedArray);

        return CheckSorting.getLevenshteinDistance(array, sortedArray) == 0;
    }

    public static int getLevenshteinDistance(int[] s, int[] t) {
        int n = s.length;
        int m = t.length;

        if (n == 0) {
            return m;
        } else if (m == 0) {
            return n;
        }

        if (n > m) {
            int[] tmp = s;
            s = t;
            t = tmp;
            n = m;
            m = t.length;
        }

        int p[] = new int[n + 1];
        int d[] = new int[n + 1];
        int _d[];

        int i;
        int j;

        int t_j;

        int cost;

        for (i = 0; i <= n; i++) {
            p[i] = i;
        }

        for (j = 1; j <= m; j++) {
            t_j = t[j - 1];
            d[0] = j;

            for (i = 1; i <= n; i++) {
                cost = s[i - 1] == t_j ? 0 : 1;
                d[i] = Math.min(Math.min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost);
            }

            _d = p;
            p = d;
            d = _d;
        }
        return p[n];
    }
}

— user3001267
kaynak

Bir dizinin sıralanıp sıralanmadığını belirlemenin “yaratıcı” yolları

Yakut

JavaScript

Java - Özyinelemeli Alt kümeler

Ne? Elbette o kadar da zor değil ...

Yeterince konuşma, kodunu alalım!

C ++ - kaba kuvvet yöntemi

Bilgi vermek

Doge Ruby

PHP

İstatistiğin gücü

Yakut

Deterministik olmayan çözüm

C #

Scala

C # - en uzun artan alt

JavaScript

C

C

C

JavaScript + daha fazla istatistik

JavaScript / SVG - sunDialsort

Yöntem

Trolling

xml

fonksiyon

C

JavaScript

C

Mathematica

JavaScript

Java (Levenshtein Uzaklığı)