51

Dada uma matriz inteira, escreva um programa que determine se está classificado em ordem crescente.

Lembre-se de que esta é uma pergunta de trollagem de código.

Estou procurando as maneiras mais interessantes que as pessoas criam.

A resposta com a maioria dos votos positivos vence.

Esta pergunta é inspirada em uma solução 'criativa' que um candidato me deu em uma entrevista :)

A solução 'criativa' era mais ou menos assim:

Porque para uma matriz classificada

todos os elementos no lado esquerdo de qualquer elemento devem ser menores

todos os elementos no lado direito de qualquer elemento devem ser maiores

Portanto, execute um loop principal para todos os elementos e verifique as duas condições acima executando dois loops aninhados dentro do principal (um para o lado esquerdo e outro para o lado direito)

Fiquei chocado!!.

popularity-contest code-trolling

— microbiano
fonte

58

Isto não é uma duplicata. Alguns moderadores acham necessário marcar cada pergunta como duplicada para outras sem lê-la. Esta não é uma questão de classificação. Leia-o.

— microbian

3

No final do concurso, também gostaria de conhecer a solução "criativa"! :)

— Vereos

16

Os moderadores do @micro Diamond são eleitos pela comunidade. Você está confundindo moderadores com o sistema de privilégios.

— Maçaneta

3

@microbian Então você contratou esse cara?

— VisioN

3

Se apenas a API StackExchange permitisse acesso de gravação, eu faria a pergunta "Esta matriz está classificada?" e contar upvotes on positivos / respostas negativas ..

— Michael Foukarakis

77

Rubi

Todo mundo sabe: a classificação é muito lenta e leva muitos ciclos (o melhor que você pode fazer é fazer alguma coisa n log(n)). Portanto, é bastante fácil verificar se a matriz está classificada. Tudo o que você precisa fazer é comparar o tempo de execução da classificação da matriz e da matriz classificada.

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
fonte

19

Isso depende do algoritmo de classificação. A classificação de mesclagem ou de heap não mostraria nenhuma diferença, independentemente de a matriz já estar classificada ou não.

— Niklas B.

4

@NiklasB. Ruby usa quicksort . Dito isso, esse método pode ser complicado e fornecer falsos positivos quando a matriz de entrada estiver quase classificada ou, mais provavelmente, falsos negativos quando a matriz for classificada (seria muito improvável treference <= trunpara todos os casos classificados, apenas por outras coisas não determinísticas) . Em teoria, parece que você obteria cerca de 50% de falsos negativos para o caso classificado?

— Jason C

6

Pensamento interessante, mas não determinístico. É tão bom quanto se pode fazer dez flexões e depois mais dez flexões e depois decidir se a primeira matriz foi classificada ou não, porque uma suou mais no segundo conjunto de flexões. Esquecemos que rodamos código em máquinas multitarefas? Também em matrizes muito pequenas, o intervalo de tempo simplesmente não é preciso o suficiente. +1 para uma tentativa selvagem embora!

— LMSingh

11

@NiklasB. O Timsort (uma variante do mergesort) é executado em tempo linear em matrizes classificadas (e também parcialmente classificadas).

— Bakuriu

3

@ JasonC - vale a pena notar que isso torna a implementação acima ainda mais duvidosa: baseia-se não apenas no conhecimento de que o algoritmo de classificação interno do ruby é quicksort (que por si só não é documentado e, portanto, uma coisa duvidosa), mas que a implementação específica é otimizado para o caso de dados já classificados (que quicksort por padrão não é: quicksort é apenas O (n log n) em casos médios ... seu pior desempenho é O (n ^ 2) e em uma implementação ingênua que Na verdade, o pior caso está sendo chamado em dados já classificados).

— 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
fonte

55

-1 JQuery insuficiente.

— Pierre Arlaud 28/02

3

Eu tive uma idéia semelhante que solicitaria a matriz e, em seguida, um por um prompt "é maior que isso?" E se todas são verdadeiras, então a matriz é classificada

— Zach Thacker

41

Java - Subconjuntos recursivos

Bem-vindo ao Stack Overflow! Essa é uma excelente primeira pergunta, já que ela supera alguns codificadores veteranos. Deixe-me fornecer algumas informações básicas antes de distribuir o código:

Determinar a classificação pode ser uma tarefa difícil à primeira vista. Para qualquer conjunto de comprimento n, há n! possíveis formas de encomendá-lo. Estes são chamados permutações . Se sua matriz tiver elementos distintos, apenas uma dessas possibilidades será classificada! Para encontrar o classificado, você deve peneirar todos eles até encontrar o correto (possivelmente apenas), descartando todos os outros.

O que? Certamente, não é que difícil ...

Algoritmos com n! A complexidade leva muito tempo para entradas maiores, mas com um pouco de trabalho, podemos contornar isso e reduzir toda uma ordem de complexidade. Ainda é tempo exponencial, mas é muito melhor que fatorial.

Para fazer isso, precisamos considerar apenas o seguinte fato matemático: Se uma matriz é classificada, todos os seus subconjuntos (relativamente ordenados) também são classificados. Você pode pedir uma prova formal aos especialistas da Matemática , mas é intuitivamente verdade. Por exemplo, para o conjunto 123, os subconjuntos adequados são 1 2 3 12 13 23. Você pode ver que eles estão todos ordenados. Agora, se o original fosse 213, você teria 2 1 3 21 23 13e imediatamente poderá ver que 21está com defeito.

A razão pela qual isso é importante é porque há muito menos que n! subconjuntos. De fato, existem apenas 2 ⁿ -2 subconjuntos que precisamos examinar. Podemos excluir o conjunto que contém toda a matriz de números originais, bem como o conjunto vazio.

Ainda assim, 2 ⁿ -2 pode dar muito trabalho. Como na maioria das coisas que excedem o tempo polinomial, uma abordagem de dividir e conquistar funciona bem aqui. A abordagem mais simples? Recursão !

As etapas básicas são simples. Para cada subconjunto de sua entrada, você gera subconjuntos menores . Então, para cada um deles, você faz a mesma coisa. Quando seus subconjuntos estiverem no tamanho 2, basta verificar qual é o maior. Como você reduz o tamanho dos subconjuntos a cada vez, na verdade ele é mais rápido do que você esperaria.

O fato principal aqui é que você pode sair mais cedo , assim que encontrar um único subconjunto fora de ordem. Você não precisa procurar por todos eles. Se alguém é ruim, todo o grupo é ruim. Essa é uma consideração de velocidade que você não vê em muitas dessas outras respostas.

Chega de conversa, vamos ter o código!

Fiz isso em Java, pois é uma linguagem popular e fácil de ler. A elegância da recursão deve ser aparente:

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

Para o registro, fiquei entediado e o matei depois de esperar 15 minutos por uma matriz classificada de 12 elementos. Ele fará 11 elementos em cerca de 45 segundos. Claro, ele realmente faz sair mais cedo para não-classificadas, de modo que é, hum, bom.

Atualização: em uma nova reinicialização, ele faz 12 elementos em 13 minutos. 13 leva quase 3 horas e 14 é às 20 horas e contando.

— Geobits
fonte

8

+1 é provavelmente o algoritmo menos eficiente que eu já vi. Deve estar em torno de O (n! * 2 ^ (n!)) - Complexidade (provavelmente pior).

— Ral Zarek 28/02

6

Tenho certeza que já vi coisas piores, mas é muito ruim. Tentei, sem entusiasmo, determinar a complexidade, mas desisti e liguei O(big).

— Geobits

11

Fornecer uma solução menos eficiente que a tentativa ingênua do problema do vendedor ambulante é impressionante!

— recursion.ninja #

3

Como a chance de uma matriz de 12 elementos ser classificada é de apenas 1 em 479 milhões, realmente não importa que leve um tempo para ter certeza absoluta de que uma é, com certeza? Você nunca está realmente provável para ver um no mundo real ...

— Jules

2

@ Geobits Sem problemas. Execute o algoritmo de Victor e responda "yes" no primeiro prompt.

— Jason C

29

C ++ - um método de força bruta

Todo mundo sabe que os métodos de força bruta são sempre os mais rápidos.

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

A rotina real é mais longa (vai para std :: npos), mas estou limitado a 30000 caracteres na postagem aqui.

— Mr Lister
fonte

Eu realmente gosto disso.

— Jakob

3

É como a abordagem "use todas as partes do búfalo" nas declarações de casos.

— Jonathan Van Matre

Isso é incrível. Desenrole todos os loops!

— McKay

ótimo pensamento !!!

— precisa saber é o seguinte

26

Informar

Inform é uma linguagem para escrever jogos de ficção interativos para o interpretador clássico Infocom Z-machine. Para evitar spoilers, estou dando os resultados do meu programa primeiro e depois o código fonte.

Edit: Fiz uma pequena revisão para permitir adicionar números à matriz e incluí uma descrição encantadora da sala.

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

E com este código fonte:

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

21

Doge Ruby

Primeiro você deve executar este código de instalação

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

Em seguida, basta armazenar a matriz em uma variável chamada codinge executar:

  very coding

                 many ruby
so algorithm


      wow

E sua resposta será impressa (verdadeira ou falsa).

Adicione também o código doge para obter o desempenho ideal:

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

Esta é a maneira mais fácil.

(a arte ASCII foi gerada por um script que escrevi, derivado dessa imagem .)

— Maçaneta da porta
fonte

7

Você esqueceu "tão algoritmo". Uma amostra real de doge possui 3 sentenças antes de "uau". E sim, eu sou muito divertido em festas.

— Pierre Arlaud 28/02

@ArlaudPierre Heh, ok, corrigido: P

— Maçaneta da porta

11

Então, comente, muito melhoria, muitos úteis. Uau.

— Pierre Arlaud 28/02

Você deveria ter escrito um programa de BF em ascii em forma de doge ... nova idéia de pergunta !!

— TheDoctor

19

PHP

Você adoraria a facilidade e franqueza da solução a seguir. O conceito geral e as funções de ponta usadas nesta obra-prima de codificação o levará imediatamente à lista de elite dos principais desenvolvedores do mundo.

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

— Visão
fonte

+1 Porque você está usando o mesmo conceito da minha resposta para a pergunta de classificação

— Victor Stafusa

4

Isso funcionaria se a sra. Roberts introduzir os valores?

— user80551

3

@ user80551 sim, porque não existe uma tabela chamada estudantes

— catraca aberração

3

@JonathanVanMatre Certamente a segurança é um dos lados mais fortes desse código.

— VisioN

11

Esta é minha nova resposta favorita neste site; mas para marcas extras que eu adoraria ver você usar um PDO para a segurança

— alexandercannon

17

C # - O poder das estatísticas

O que você realmente precisa fazer para resolver isso é reorganizar a questão de uma maneira que torne a solução óbvia. Como essa é basicamente uma pergunta do tipo "verdadeiro-falso", o que você está perguntando é essencialmente "como posso ter 100% de certeza de que a matriz está classificada?" Se uma palavra sair dessa pergunta, é a palavra "certa". Qual é a melhor maneira de medir a certeza? Você entendeu: estatísticas.

Outras respostas aqui apenas verificam se a matriz está classificada em uma direção . Esta solução testa a ordem crescente e decrescente ao mesmo tempo. O truque é escolher uma matriz do mesmo tamanho que você já sabe que é classificada (fácil de criar uma) e descobrir como a ordem de cada matriz se correlaciona com a outra. Calcular o coeficiente de correlação Kendall tau rank é a maneira mais fácil de fazer isso:

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

Resultado:

Unsorted
Sorted
Sorted

Essa função também é muito fácil de estender a funcionalidade, pois seria trivial adicionar funcionalidades como "Principalmente classificada" ou "Mais classificada do que não" ou "Completamente aleatória".

Editar

Quase esqueci de revisar a eficiência do algoritmo. Atualmente é O (7). Há um no nome do método, um em cada uma das palavras-chave "for", um na declaração "double" e dois nos usos da variável "ordenação". Você pode melhorar isso até O (0) (o mais baixo possível) renomeando a função, alterando o dobro para um decimal, desmovendo "ordenação" para "srtdnss" e convertendo os loops for para enquanto loops.

— Comintern
fonte

2

Recalculei meticulosamente a complexidade e determinei que fosse O (8). Você está acenando com a mão, que eu acredito que deveria levar em consideração. Para ter uma complexidade verdadeiramente O (7), considere retornar "ascendente" / "aleatório", em vez de "classificado" / "não classificado".

— Geobits 01/03

@ Geobits - eu olhei novamente, e é claro que você está correto. Eu acho que isso mostra que existe uma complexidade mínima de O (1) ao retornar as strings. Este é um preço pequeno a pagar, porque retornar um booleano é duas vezes pior.

— Comintern

11

+1 para o cálculo de O (). -1 por não calcular também um Spearman rho, porque duas correlações não são melhores que uma? E +1 para estatísticas em C #, o favorito comprovado dos estatísticos.

— Jonathan Van Matre

Por favor, diga-me a O(7)coisa é uma piada

— mbatchkarov

@mbatchkarov - É pouca notação O. :-)

— Comintern

16

Rubi

A estratégia a seguir revelará eventualmente se uma matriz é classificada:

A ser uma matriz (classificada ou não, por exemplo, [1,2,3] ou [1,3,2])
P é uma matriz que contém todas as permutações de A
Se A for classificado, é o máximo ou o mínimo de P (que basicamente são as versões ordenadas de A em Ruby)

Versão online para teste.

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

— David Herrmann
fonte

11

Acho que não entendi a explicação. Se a matriz for, por exemplo, [1, 9, 100], o mínimo é 10019 e o máximo é 91100, mas o número classificado é 19100. Jogando com a versão online, max é [100,9,1] e min é [1.9.100]. Não vejo onde algo está sendo "representado por um número"; parece que as matrizes estão sendo encomendadas lexicograficamente. Suponho que seria o mesmo se todos os números fossem apenas um dígito.

— Joshua Taylor

"... o máximo ou o mínimo ..." adorei.

— microbian

@ JoshuaTaylor: Obrigado pelo aviso! Eu queria explicar isso de uma forma facilmente compreensível - que acabou sendo errado plain;) eu corrigi a minha descrição ...

— David Herrmann

2

@JoshuaTaylor os métodos ruby Matriz # max e #min selecionam o elemento maior e menor em relação aos operadores <e>. Nas matrizes, <e> implementam a classificação lexicográfica. [1,9,100] é o mínimo de todas as permutações ordenadas de 1, 9 e 100 na ordenação lexicográfica.

— Karl Damgaard Asmussen

Isso é quase qualidade de produção.

— primo

12

Solução não-determinística

Esse código provavelmente funciona.

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
fonte

8

Se você definir o número de iterações para -n ^ 2 * ln (1-p), poderá garantir com uma probabilidade de p que todas as combinações sejam verificadas!

— Hannesh 27/02

E que valores de p são válidos para que essa solução seja aceita como "código funcional, mas trolling"? :)

— fejesjoco

2

Em stackoverflow.com/questions/2580933 , a chance de erro de cálculo de uma comparação devido aos raios cósmicos seria de 0,0000018 (1,8e-6) a cada segundo. Portanto, se: 1) você pode descobrir quanto tempo leva uma iteração, 2) Podemos usar a fórmula de @Hannesh para calcular a probabilidade e, em seguida, resolver o sistema de equações para encontrar o número de iterações que tornam sua solução indistinguível de um método isSorted padrão.

— Xantix 03/03

11

Pitão

Se a lista estiver classificada, todo número será menor ou igual ao próximo número. Portanto, remover o número mais à esquerda trará o valor médio, caso contrário, a lista não será classificada. Vamos colocar isso em um loop para verificar cada número

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

is_sorted ([1,2,3]) #True
is_sorted ([3,2,1]) #False
is_sorted ([1,4,3,2,0,3,4,5]) #False

O leitor atento perceberá que não funciona exatamente assim.
is_sorted ([1,4,3,2,0,3,4,11]) #False
is_sorted ([1,4,3,2,0,3,4,12]) #True
is_sorted ([1,2 , 1,2,1,2,1,2,99]) #True

— VBCPP
fonte

9

Bater

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

toque em um arquivo para cada elemento da matriz, no diretório e compare o resultado com a matriz original.

Eu não sou muito bom com bash, eu só queria experimentá-lo :)

— Zach Thacker
fonte

Legal, isso pressupõe que o diretório "./nums" já exista. Talvez um "mkdir -p nums" em algum lugar?

— Camelthemammel

Ah, sim, isso faz sentido: P

— Zach Thacker 28/02

8

C #

As noções de "menor" ou "maior" são muito em 2013 . Programadores reais usam apenas o modulooperador!

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
fonte

E se o mesmo número aparecer duas vezes? Em seguida, liste [i]% list [i + 1] == 0.

— Simon

@Simon Oh ho! Na verdade, acho que dois números idênticos são classificados. Adicionada uma comparação para este caso de borda. Bom achado.

— Pierre-Luc Pineault 27/02

5

Fico feliz em saber que {0, -1, 2} é uma lista classificada.

— Pierre Arlaud 28/02

9

@ArlaudPierre Se você quer ser um verdadeiro programador de 2014, precisa deixar de lado tudo que é negativo. O mundo é positivo, o mundo é absoluto, o mundo é módulo!

— Pierre-Luc Pineault 28/02

11

Como você não gosta da noção de "maior" e "menor", é uma pena que você tenha que incluir esses sinais menores que e maiores que. Você deveria ter usado matrizes em vez de listas.

— Sr. Lister

8

Scala

Verificar se uma matriz é classificada é fácil! Basta verificar se o primeiro elemento é menor que o segundo. Depois, organize o resto e veja se são iguais.

Infelizmente, a classificação é um problema difícil. Não há muitos algoritmos conhecidos ou eficientes para classificar uma matriz; de fato, é um enorme ponto cego no estado atual do conhecimento em ciência da computação. Então, proponho um algoritmo simples: embaralhe a matriz e verifique se está classificada, o que, como já foi dito, é fácil! Continue embaralhando até que esteja classificado.

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

Suponho que essa saída seja "verdadeira, falsa, verdadeira". Já está em funcionamento há algum tempo ...

— Joe K
fonte

8

Uma matriz classificada de números inteiros tem a propriedade de que toda sub-matriz (por exemplo, elementos n a m da matriz) também é uma matriz classificada de números inteiros. Obviamente, isso implica que o melhor método é uma função RECURSIVE:

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

Pode não ser o método mais rápido, mas não deixa de ser um teste MUITO PRECISO se uma lista é ou não solicitada. Também é incrivelmente fácil de ler e entender esse código porque ele usa um paradigma FUNCIONAL e, portanto, está livre dos horrores da mudança de estado e dos loops iterativos.

Espero que seja uma informação útil para você.

— Allen
fonte

6

Subsequência crescente mais longa

Para uma matriz classificada, o comprimento da subsequência crescente mais longa é igual ao comprimento da matriz. Copiei o algoritmo daqui , apenas o modifiquei para não diminuir, em vez de aumentar.

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
fonte

6

Stonescript (c) LMSingh - 0 menos (4102 palíndromo).

A seguir, está escrito no Stonescript (c), um idioma protegido por direitos autorais e usado por mim muitos séculos atrás, ou seja, nos tempos antigos antes dos quadros intermediários. NOTA: É um precursor do sânscrito.

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...

Exemplo de uma matriz com 8 elementos. Ordenado por ordem descendente :-)

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

- Código continuou.

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.

Exemplo de uma matriz com 8 elementos. Não classificado :-(

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

- Código continuou.

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

= - = - = - = - = - =
Em otimizações adicionais, as folhas perfuradas da etapa 4 podem ser substituídas pelas folhas perfuradas a seguir.
= - = - = - = - = - =

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.

= - = - = - = - = - =
Para todos os detetives de código e depuradores de energia por aí, intencionalmente adicionei um bug na segunda variação acima da etapa 4. Você consegue encontrá-lo?

— LMSingh
fonte

3

Eu encontrei o bug - tudo 4.3.*deve ser4.2.*

— Timtech

4

Javascript

Foi isso que o deixou chocado com a "criatividade":

Porque para uma matriz classificada
* 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
Portanto, execute um loop principal para todos os elementos e verifique as duas condições acima executando dois loops aninhados dentro do principal (um para o lado esquerdo e outro para o lado direito)

Então, eu dou uma implementação em javascript do algoritmo descrito:

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

Vamos testá-lo:

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

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

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

Parece funcionar perfeitamente! Tem uma complexidade de O(n²), ideal para um algoritmo que deveria ser O(n), mas, ao fazê- O(n²)lo, torna-se mais eficiente, já que essa é uma medida de eficiência, e O(n²)é mais eficiente que O(n).

— Victor Stafusa
fonte

Eu não quis usar um 'meio'. O primeiro loop aninhado era de 0 a a, e o segundo era de a + 1 no comprimento. Aliás, 1,2,3 deve ser resolvido, não é?

— microbian

@microbian Ok, editado.

— Victor Stafusa 27/02

4

C

A seguir, "classificado" significa "classificado em ordem crescente".

Uma matriz não é classificada se a[i]>a[i+1]

Portanto, se deixarmos x=a[i]-a[i+1], xserá positivo se a matriz não for classificada.

Para testar se xé positivo, podemos dividi-lo em duas partes: xnão é negativo e xnão é zero

Um teste simples para se xé negativo é que testamos se x*xé igual a x*abs(x). Esta condição deve ser falsa se xfor negativa, desde (-1)*(-1)==1.

Para testar o zero, podemos usar outro teste simples: 0./(float)xNão é um número, se xfor zero.

Então, aqui está o código inteiro: (assume que a matriz possui 5 elementos)

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

Na verdade, testar a[i]-a[i+1] > 0já é problemático. Não precisa fazer todos esses tipos de animais.

— ǹ̷̰ĥ̷̳h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 28/02

Fazer coisas desnecessárias é o ponto principal de trollagem de código, não é? (E o que você quer dizer com problemático?) #

— Ace_HongKongIndependence

11

O excesso de número inteiro assinado é UB. Mesmo se definirmos o comportamento de contorno, se fizermos INT_MAX - INT_MIN, o resultado será um número negativo (substitua um [i] por INT_MAX e um [i + 1] por INT_MIN).

— ǹ̷̰ĥ̷̳h̷͉̃a̷̭̿h̸̡̅ẗ̵̷̨̰́̀ĥ̷̷̳̰̀ĥ̷̳

Como é apenas um problema de lição de casa, vamos supor que o professor não dê tantos números extremos.

— ace_HongKongIndependence

ESTÁ BEM. Só que eu prefiro trollar + ser mau.

— N

4

É tudo sobre o quão certo você deseja ser. Como nenhuma certeza foi dada, o que se segue é realmente um bom desempenho. O código abaixo fornece um bom palpite, mas se você tiver certeza de que deve repetir a função algumas vezes. Se você deseja ser realmente certeza, você deve executá-lo em um loop e fazê-lo de uma dúzia de vezes. Escalabilidade perfeita!

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

Isso não é um prazer?

— n0la
fonte

4

C

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

Trabalha com probabilidade 1- (1 / n!) E complexidade O (1). Obviamente, o melhor método para matrizes aleatórias muito grandes.

Como a complexidade é apenas O (1), para uma melhor estimativa, execute duas vezes.

— cpri
fonte

3

C

Esta função faz mais do que apenas informar se a matriz está classificada. Ele informa quantos elementos estão no lugar certo. Pode ser usado para qualquer tipo de dados.

Observe a importância do uso de nomes de variáveis descritivos para facilitar o seu código. Por outro lado, não precisamos declarar a variável i, pois ela deve ser declarada em outro lugar do programa.

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

Edit: Esta é uma maneira melhor para matrizes maiores. A vantagem disso é que é semelhante à maneira como um humano verificaria.

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

— Level River St
fonte

11

"Não precisamos declarar a variável i, pois ela deve ser declarada em outro lugar do programa." valia a pena rir.

— Jonathan Van Matre

@ JonathanVanMatre Obrigado, mas não é de forma alguma a única coisa errada com este código.

— Level River St

3

JavaScript + mais estatísticas

Gostei muito da solução sugerida pela @Cominterm. Mas comparando com uma lista já classificada? Isso é batota!

Em vez disso, calculo a autocorrelação da matriz (a correlação entre a matriz e a matriz à esquerda mudou de posição). Em seguida, embaralho a matriz várias vezes e cada vez que comparo sua nova autocorrelação à autocorrelação original. Se a matriz fosse classificada, a autocorrelação original seria a mais alta na maioria das vezes!

http://jsfiddle.net/dB8HB/

Bônus: se o seu valor p for <0,05, a saída automatizará a tarefa de reivindicar que a matriz está classificada para você. O que mais você poderia pedir?

Bônus2: Embora essa implementação use as funções de matriz O (n) do JavaScript por conveniência, a abordagem pode usar amostragem para executar em tempo constante!

<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
fonte

3

JavaScript / SVG - sunDialsort

Esta solução não usa os comparadores <, <=,> ou> =. Eu tentei fazê-lo ler o menos possível como uma função de classificação.

Método

Plote os valores como pontos ao longo de um arco.
Para uma matriz ascendente, cada valor aumentará a largura total do desenho e não diminuirá o X inicial (exceção: dois valores idênticos).
Como a largura não pode encolher, a! = Será suficiente,
Como X não pode aumentar, um == será suficiente.
para fixar dois valores idênticos, cada ponto é na verdade uma linha, de comprimento crescente. Onde o comprimento da unidade é menor que 1 / número de valores.

Trollando

Adicionei as seguintes palmas das mãos ao longo da jornada de leitura desse código muito ruim.

A função pode parecer que vai classificar a matriz, denominada sunDialsort (capitalização incorreta de bônus)
referência lit-geek usada para todos os nomes de variáveis
usou o martelo regex para contar o número de elementos na matriz
usou uma caixa de alerta
a solução para o caso de borda em que duas variáveis consecutivas são a mesma coisa que duplicou a quantidade de código (um liner poderia ter classificado), coloque muito desse código cedo para confundir o objetivo da função.
em vez de encontrar o mínimo e o máximo, encontre o número mais longo e arredonde para a próxima potência de dez, espero que isso afaste as pessoas.

xml

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

função

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

Se alguém quiser testar, há uma versão aqui com nomes de variáveis legíveis. http://jsfiddle.net/outRideACrisis/r8Awy/

— OutRideACrisis
fonte

3

C

Como uma pesquisa binária funciona apenas em matrizes classificadas, para verificar se uma matriz é classificada, tudo o que precisamos fazer é verificar se uma pesquisa binária funciona para todos os elementos da matriz. Se ele não encontrar nenhum elemento, sabemos que o array não está classificado.

Os argumentos da linha de comando transmitidos devem ser números inteiros decimais sem zeros à esquerda.

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

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
fonte

11

{ 69 , 313 , 187 , 31338 }

— Geobits 5/14

2

C

Faça uma cópia da matriz
classifique a cópia em ordem decrescente
verifique se esta matriz é o inverso da matriz fornecida

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

2

Mathematica

Esse algoritmo parece funcionar, mas é um pouco lento. Pode haver maneiras mais rápidas de classificar, mas eu não as encontrei.

Faça uma ordem aleatória da lista e verifique se está em ordem (com OrderedQ).
Se for, pare. Caso contrário, repita a etapa 1.

O código a seguir classificou a lista em pouco mais de 18 segundos.

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, Nulo}
8980699
{7, 16, 19, 23, 30, 40, 50, 54, 57, 60}

— DavidC
fonte

A tarefa era verificar se a entrada já está classificada.

— Ilmari Karonen

Essa é a idéia essencial por trás da minha solução (porém, uso um período quadrático OrderedQapenas para brincadeiras) com a verificação adicional no final "agora que temos uma ordenada, foi com isso que começamos?"

— Boothby

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

Esta função pode retornar falseincorretamente, mas não nos navegadores modernos; você pode verificar isso e fornecer um fallback mais lento (conforme descrito na pergunta), se necessário:

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

Eles dizem que isso gera resultados imprevisíveis em números negativos, mas o que realmente depende é o quão bom você é em prever as coisas.

— Ry-
fonte

2

Desejo Chrome iria embaralhar as propriedades do objeto para impedir as pessoas de fazer coisas como esta ...

— Bergi

2

Java (distância de Levenshtein)

Nesta implementação, clono a matriz original e classifico a instância clonada. Então, a distância de Levenshtein é calculada. Se for zero, a matriz original foi classificada.

Nota: A implementação getLevenshteinDistance () é obtida do Jakarta Commons Lang e modificada para trabalhar em int [] em vez de CharSequence.

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
fonte

Maneiras "criativas" para determinar se uma matriz é classificada

Rubi

Javascript

Java - Subconjuntos recursivos

O que? Certamente, não é que difícil ...

Chega de conversa, vamos ter o código!

C ++ - um método de força bruta

Informar

Doge Ruby

PHP

C # - O poder das estatísticas

Rubi

Solução não-determinística

C #

Scala

Subsequência crescente mais longa

Javascript

C

C

C

JavaScript + mais estatísticas

JavaScript / SVG - sunDialsort

Método

Trollando

xml

função

C

Javascript

C

Mathematica

Javascript

Java (distância de Levenshtein)