51

정수 배열이 주어지면 오름차순으로 정렬되는지 결정하는 프로그램을 작성하십시오.

이것은 코드 트롤링 질문이라는 것을 기억하십시오.

사람들이 생각해내는 가장 흥미로운 방법을 찾고 있습니다.

대부분의 공감대가있는 답이 이깁니다.

이 질문은 응시자가 인터뷰에서 나에게 준 '크리에이티브'솔루션에서 영감을 얻은 것입니다. :)

'크리에이티브'솔루션은 다음과 같습니다.

정렬 된 배열 때문에

요소의 왼쪽에있는 모든 요소는 더 작아야합니다

요소의 오른쪽에있는 모든 요소는 더 커야합니다

따라서 모든 요소에 대해 메인 루프를 실행하고 메인 루프 안에 두 개의 중첩 루프를 실행하여 위의 두 가지 조건을 확인하십시오 (하나는 왼쪽, 하나는 오른쪽)

나는 충격 받았다!!.

popularity-contest code-trolling

— 마이크로 비안
소스

58

중복되지 않습니다. 일부 중재자는 모든 질문을 읽지 않고 다른 질문에 중복 표시해야한다고 생각합니다. 이것은 전혀 정렬 질문이 아닙니다. 읽어.

— microbian

3

대회가 끝나면 "창의적인"솔루션도 알고 싶습니다! :)

— Vereos

16

@micro Diamond 중재자는 커뮤니티에서 선출됩니다. 권한 시스템과 중재자를 혼동하고 있습니다.

— Doorknob

3

@microbian 그래서 그 사람을 고용 했습니까?

— VisioN

3

StackExchange API 만 쓰기 액세스를 허용 한 경우 "이 배열이 정렬 되었습니까?"라는 질문을합니다. 긍정적 / 부정적인 답변을 upvotes 계산 ..

— 마이클 Foukarakis에게

77

루비

모두가 알고 있습니다 : 정렬이 매우 느리고 많은 사이클이 필요합니다 (가장 좋은 것은로 무언가 n log(n)). 따라서 배열이 정렬되어 있는지 확인하는 것은 매우 쉽습니다. 배열을 정렬하고 정렬 된 배열을 정렬하는 런타임을 비교하기 만하면됩니다.

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

— 하워드
소스

19

이것은 정렬 알고리즘에 따라 다릅니다. 병합 정렬 또는 힙 정렬은 배열이 이미 정렬되어 있는지 여부에 관계없이 전혀 차이가 표시되지 않습니다.

— Niklas B.

4

@NiklasB. 루비는 quicksort를 사용합니다 . 즉,이 방법은 입력 배열이 거의 정렬 될 때 까다로워지고 오 탐지를 유발할 수 있거나 배열 이 정렬 될 때 가음 성일 가능성이 높습니다 ( treference <= trun비결정론 적 인 다른 것들 때문에 모든 정렬 된 경우에는 매우 드 very니다 ) . 이론적으로는 정렬 된 경우에 약 50 %의 거짓 부정을 얻는 것처럼 보입니까?

— Jason C

6

재미있는 생각이지만 결정적이지는 않습니다. 10 번의 푸시 업과 10 번의 추가 푸시 업을 수행 한 다음 첫 번째 어레이가 두 번째 푸시 업 세트에서 더 많이 땀을 흘 렸기 때문에 첫 번째 어레이가 정렬되었는지 여부를 결정합니다. 멀티 태스킹 머신에서 코드를 실행하는 것을 잊었습니까? 또한 매우 작은 배열에서는 시간 조각이 충분히 정확하지 않습니다. 그래도 야생의 시도 +1!

— LMSingh

1

@NiklasB. Timsort (Mergesort의 변형)는 정렬 된 (및 부분적으로 정렬 된) 배열에서 선형 시간으로 실행됩니다.

— Bakuriu

3

@JasonC-이것이 위의 구현을 더욱 모호하게 만든다는 점에 주목할 가치가 있습니다. 루비의 내부 정렬 알고리즘이 퀵 정렬 (자체적으로 문서화되지 않았으므로 의존해야 할 모호한 것)에 대한 지식뿐만 아니라 특정 구현에 의존합니다. 이미 정렬 된 데이터의 경우에 최적화되어 있습니다 (기본적으로 빠른 정렬은 아닙니다 : quicksort는 평균 경우 O (n log n)입니다 ... 최악의 성능은 O (n ^ 2)이며 순진한 구현에서는 최악의 경우는 이미 분류 된 데이터에서 실제로 호출됩니다).

— Jules

52

자바 스크립트

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

— 빅터 스타 푸사
소스

55

-1 JQuery가 충분하지 않습니다.

— Pierre Arlaud

3

나는 배열을 요구할 비슷한 아이디어를 가지고 있었고, 하나 하나의 프롬프트 "이것이 이것보다 큰가?" 그리고 모두 사실이라면 배열이 정렬됩니다

— Zach Thacker

41

Java-재귀 서브 세트

스택 오버플로에 오신 것을 환영합니다! 이것은 심지어 베테랑 코더조차도 뛰어 넘기 때문에 훌륭한 첫 번째 질문입니다. 코드를 전달하기 전에 약간의 배경 정보를 제공하겠습니다.

정렬 성을 결정하는 것은 언뜻보기에 어려운 작업이 될 수 있습니다. 길이 n의 모든 세트에는 n이 있습니다! 가능한 주문 방법. 이를 순열 이라고 합니다. 배열에 고유 한 요소가있는 경우 이러한 가능성 중 하나만 정렬됩니다! 정렬 된 것을 찾으려면 올바른 것을 찾을 때까지 다른 것을 버려야합니다.

뭐? 확실히 그렇게 어렵지 않습니다 ...

N과의 알고리즘! 더 큰 입력에는 복잡성이 오래 걸리지 만 약간의 작업으로 해결할 수 있으며 전체 복잡성을 줄일 수 있습니다. 여전히 지수 시간이지만 계승보다 훨씬 낫 습니다.

이를 위해서는 다음과 같은 수학적 사실 만 고려하면됩니다. 배열을 정렬하면 (상대적으로 정렬 된) 하위 집합 도 모두 정렬됩니다. 공식 전문가에게 수학 전문가에게 공식적인 증거를 요청할 수는 있지만 직관적입니다. 예를 들어 set 123의 경우 적절한 하위 집합은 1 2 3 12 13 23입니다. 당신은 그들이 모두 주문한 것을 볼 수 있습니다. 이제 원본이 213이면을 보았을 것입니다. 2 1 3 21 23 13그러면 21순서가 잘못 되었음을 알 수 있습니다 .

이것이 중요한 이유는 n보다 훨씬 적기 때문입니다! 서브 세트. 실제로, 우리가 볼 필요 가있는 2 ⁿ -2 서브 세트 만이 있습니다. 빈 세트뿐만 아니라 원래 숫자의 전체 배열을 포함하는 세트를 제외 할 수 있습니다.

여전히 2 ⁿ -2는 많은 작업이 될 수 있습니다. 다항식 시간을 초과하는 대부분의 항목과 마찬가지로 분할 및 정복 방식이 여기에서 잘 작동합니다. 가장 간단한 방법? 재귀 !

기본 단계는 간단합니다. 입력의 모든 하위 집합에 대해 더 작은 하위 집합 을 생성 합니다. 그런 다음 각각에 대해 동일한 작업을 수행합니다. 하위 집합의 크기가 2가되면 어느 것이 더 큰지 확인하면됩니다. 매번 서브 세트의 크기를 줄이므로 실제로 예상보다 빠릅니다.

여기서 중요한 사실은 단일 하위 집합이 고장난 즉시 조기 에 종료 할 수 있다는 것입니다 . 당신은하지 않습니다 이 그들 모두를 검색 할 수 있습니다. 하나가 나쁘면 전체 그룹이 나빠집니다. 이것은 다른 많은 답변에서 볼 수없는 속도 고려 사항입니다.

충분한 이야기, 코드를 보자!

나는 대중적인 언어이기 때문에 읽기 쉬운 Java 로 이것을했습니다. 재귀의 우아함이 분명해야합니다.

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

기록을 위해, 나는 정렬 된 12 요소 배열을 15 분 기다린 후 지루해졌습니다. 약 45 초 안에 11 개의 요소를 수행합니다. 물론, 정말 하지 않은 분류에 대한 이전 종료를, 그래서 좋은, 음,입니다.

업데이트 : 새로 다시 부팅하면 13 분 안에 12 개의 요소가 수행됩니다. 13은 거의 3 시간이 걸리고 14는 20 시간이며 계산합니다.

— 지오 비트
소스

8

+1 이것은 아마도 내가 본 것 중 가장 효율적인 알고리즘 일 것입니다. 약 O (n! * 2 ^ (n!))-복잡성이어야합니다 (아마도 더 나쁩니다).

— Ral Zarek

6

나는 더 본 적이 확신하지만 입니다 아주 나쁜. 나는 진지하게 복잡성을 결정하려고 노력했지만 포기하고 그것을 불렀습니다 O(big).

— Geobits

1

여행사 직원 문제의 순진한 시도보다 덜 효율적인 솔루션을 제공하는 것은 인상적입니다!

— recursion.ninja

3

12 요소 배열이 정렬 될 확률은 479 백만 명 중 1 명이므로 실제로 확실하다는 데 시간이 걸리지 않습니다. 당신은 실제로 현실 세계에서 하나를 볼 가능성이 거의 없습니다.

— Jules

2

@Geobits 문제 없습니다. Victor의 알고리즘을 실행 하고 첫 번째 프롬프트에서 "yes"로 응답 하십시오 .

— Jason C

29

C ++-무차별 대입 방법

모든 사람들은 무차별 대입 방법이 항상 가장 빠르다는 것을 알고 있습니다.

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

실제 루틴은 더 길지만 (std :: npos로 이동) 여기에 게시 할 때 30000 자로 제한됩니다.

— 미스터 리스터
소스

나는 정말로 이것을 좋아한다.

— Jakob

3

이것은 사례 진술에 대한 "버팔로의 모든 부분을 사용하는"접근과 같습니다.

— Jonathan Van Matre

대단해. 모든 루프를 푸십시오!

— McKay

좋은 생각 !!!

— bikram990

26

알려

Inform은 클래식 Infocom Z- 머신 통역사를위한 대화 형 소설 게임을 작성하기위한 언어입니다. 스포일러를 피하기 위해 먼저 프로그램 결과를 제공 한 다음 소스 코드를 제공합니다.

편집 : 배열에 숫자를 추가 할 수 있도록 작은 개정을했으며 매력적인 방 설명이 포함되었습니다.

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

그리고 소스 코드와 함께 :

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

— 조나단 반 마테
소스

21

총독 루비

먼저이 설정 코드를 실행해야합니다

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

그런 다음 배열을 변수에 저장하고 다음을 coding실행하십시오.

  very coding

                 many ruby
so algorithm


      wow

그리고 귀하의 답변이 인쇄됩니다 (true 또는 false).

최적의 성능을 위해 doge 코드도 추가하십시오.

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

이것이 가장 쉬운 방법입니다.

(ASCII 아트는 이 이미지 에서 파생 된 필자가 작성한 스크립트에 의해 생성되었습니다 .)

— 손잡이
소스

7

"그래서 알고리즘"을 잊어 버렸습니다. 실제 총독 샘플은 "wow"앞에 3 개의 문장이 있습니다. 그리고 그렇습니다, 나는 파티에서 매우 재미있다.

— Pierre Arlaud

@ArlaudPierre Heh, 좋아, 고정 : P

— Doorknob

11

의견, 매우 개선, 많은 유용한. 와.

— Pierre Arlaud

당신은 doge 모양의 ascii로 새로운 BF 프로그램을 작성해야합니다 ... 새로운 질문 아이디어 !!

— TheDoctor

19

PHP

다음 솔루션의 용이성과 직설 성을 좋아합니다. 이 코딩의 걸작에 사용 된 전반적인 개념과 최첨단 기능은 즉시 세계 최고의 개발자의 엘리트 목록을 제공합니다.

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

— 전망
소스

+1 당신은 정렬 질문에 대한 나의 대답

— Victor Stafusa

4

Roberts 여사 가 값을 입력 하면 이것이 효과 가 있습니까?

— user80551

3

@ user80551 yes 학생이라는 테이블이 없기 때문에

— ratchet freak

3

@JonathanVanMatre 확실히 보안은이 코드의 가장 강력한 측면 중 하나입니다.

— VisioN

1

이것은이 웹 사이트에서 제가 가장 좋아하는 답변입니다. 하지만 별도의 표시를 위해 나는 당신이 보안을 위해 PDO를 사용보고 싶어요

— alexandercannon

17

C #-통계의 힘

이 문제를 해결하기 위해 실제로해야하는 것은 솔루션을 분명하게 만드는 방식으로 질문의 틀을 다시 잡는 것입니다. 이것은 기본적으로 "true-false"유형의 질문이므로 "배열이 정렬되었는지 100 % 확신 할 수있는 방법"은 무엇입니까? 그 질문에서 한 단어가 나오면 "확실하다"라는 단어입니다. 확실성을 측정하는 가장 좋은 방법은 무엇입니까? 당신은 그것을 얻었다 : 통계.

다른 답변은 배열이 한 방향으로 정렬되어 있는지 확인합니다 . 이 솔루션은 오름차순과 내림차순을 동시에 테스트합니다. 요령은 이미 알고있는 것과 동일한 크기의 배열을 가져 와서 쉽게 만들 수 있고 각 배열의 순서가 다른 배열과 얼마나 관련이 있는지 알아내는 것입니다. Kendall tau 순위 상관 계수를 계산하는 것이 가장 쉬운 방법입니다.

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

산출:

Unsorted
Sorted
Sorted

이 기능은 "가장 많이 정렬 됨"또는 "보다 정렬되지 않은 것보다"또는 "완전히 임의의 것"과 같은 기능을 추가하는 것이 쉽기 때문에 기능을 확장하기가 매우 쉽습니다.

편집하다

알고리즘의 효율성을 극복하는 것은 거의 잊었습니다. 이것은 현재 O (7)입니다. 메소드 이름에는 하나, "for"키워드에는 하나, "double"선언에는 하나, 변수 "sortedness"는 두 개가 있습니다. 함수의 이름을 바꾸고, 소수를 10 진수로 변경하고, "분류"를 "srtdnss"로 해제하고, for 루프를 while 루프.

— 코민테른
소스

2

나는 복잡성을 복잡하게 재 계산하고 그것을 O (8)로 결정했다. 실제로 고려해야 할 결과물을 손으로 옮깁니다. 실제로 O (7) 복잡성을 갖기 위해 "정렬"/ "정렬되지 않은"대신 "오름차순"/ "어쩌면 위험"을 반환하는 것을 고려할 수 있습니다.

— Geobits

@ Geobits-나는 그것을 다시 보았고 물론 당신은 맞습니다. 문자열을 반환 할 때 O (1)의 최소 복잡성이 있음을 보여줍니다. 부울을 반환하는 것이 두 배 나쁘기 때문에 이것은 지불해야 할 작은 가격입니다.

— Comintern

1

O () 계산의 경우 +1 Spearman rho를 계산하지 않은 경우 -1입니다. 두 개의 상관 관계가 하나보다 낫지 않기 때문입니까? 통계가 가장 선호하는 C #의 통계는 +1입니다.

— Jonathan Van Matre

그게 O(7)농담이라고 말해줘

— mbatchkarov

@mbatchkarov-작은 O 표기법입니다. :-)

— Comintern

16

루비

다음 전략은 결국 배열이 정렬되어 있는지를 나타냅니다.

A 배열 (예 : [1,2,3] 또는 [1,3,2])
P 는 A의 모든 순열을 보유하는 배열입니다 .
경우 A는 정렬, 그것은 최대 또는 최소 중 하나입니다 P는 (기본적으로의 정렬 된 버전있는 루비를)

테스트를위한 온라인 버전 .

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

— 데이비드 허먼
소스

1

설명을 이해하지 못하는 것 같습니다. 배열이 예를 들어 [1, 9, 100]이면 최소값은 10019이고 최대 값은 91100이지만 정렬 된 숫자는 19100입니다. 온라인 버전으로 재생하면 최대 값은 [100,9,1]이고 최소값입니다. [1,9,100]입니다. "숫자로 표현 된"것이 어디에 있는지 알 수 없습니다. 배열이 사전 식으로 정렬되는 것처럼 보입니다. 모든 숫자가 한 자리이면 동일하다고 생각합니다.

— Joshua Taylor

"... 최대 값이든 최소값이든 ..."이 마음에 들었습니다.

— microbian

@JoshuaTaylor : 고마워요! 내 설명을 ... 수정) 명백히 잘못 었죠 - 나는 쉽게 이해할 수있는 방법으로 그것을 설명하기 위해 원

— 데이비드 헤르만

2

@JoshuaTaylor 루비 메소드 Array # max 및 #min은 <및> 연산자와 관련하여 가장 크고 가장 작은 요소를 선택합니다. 배열에서 <및>는 사전 식 정렬을 구현합니다. [1,9,100]은 사전 식 순서에서 1, 9 및 100의 모든 정렬 된 순열의 최소값입니다.

— Karl Damgaard Asmussen

거의 생산 품질입니다.

— primo

12

비 결정적 솔루션

이 코드는 아마 작동합니다.

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
}

— 페예 쇼코
소스

8

반복 횟수를 -n ^ 2 * ln (1-p)로 설정하면 p의 확률로 모든 조합을 확인할 수 있습니다!

— Hannesh

그리고이 솔루션이 "작업 코드이지만 트롤링"으로 받아 들여지기 위해 유효한 p 값은 무엇입니까? :)

— fejesjoco

2

에서 stackoverflow.com/questions/2580933 인해 우주 광선에 비교 계산 착오의 가능성이 0.0000018 (1.8E-6) 초마다 것입니다. 따라서 1) 반복에 걸리는 시간을 알아낼 수 있습니다 .2) @Hannesh의 공식을 사용하여 확률을 계산 한 다음 방정식 시스템을 풀고 솔루션을 구분할 수없는 반복 횟수를 찾을 수 있습니다. 표준 isSorted 방법.

— Xantix

11

파이썬

목록이 정렬되면 모든 숫자가 다음 숫자보다 작거나 같습니다. 따라서 가장 왼쪽의 숫자를 제거하면 평균값이 올라가고 그렇지 않으면 목록이 정렬되지 않습니다. 각 번호를 확인하기 위해 이것을 루프에 넣을 것입니다

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

관찰 독자는 정확히 그렇게 작동하지 않는다는 것을 알게 될 것입니다.
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]) # 참

— VBCPP
소스

9

세게 때리다

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

배열의 각 요소에 대한 파일, 디렉토리를 터치하고 ls 결과를 원래 배열과 비교하십시오.

나는 bash에별로 좋지 않다. 나는 그냥 시도해보고 싶었다. :)

— 잭 테커
소스

좋은 점은 "./nums"디렉토리가 이미 존재한다고 가정합니다. "mkdir -p nums"어딘가에?

— camelthemammel

아, 맞아 : P

— Zach Thacker

8

씨#

"더 작은"또는 "더 큰"의 개념은 너무나 2013 년 입니다. 실제 프로그래머는 modulo운영자 만 사용합니다 !

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

— 피에르 루 피노
소스

같은 숫자가 두 번 나타나면 어떻게합니까? 그런 다음 list [i] % list [i + 1] == 0입니다.

— Simon

@ 시몬 오호! 실제로 두 개의 동일한 숫자가 정렬되어 있다고 생각합니다. 이 엣지 케이스에 대한 비교를 추가했습니다. 좋은 발견.

— Pierre-Luc Pineault 2019

5

{0, -1, 2}가 정렬 된 목록이라는 것을 알게되어 기쁩니다.

— Pierre Arlaud

9

@ArlaudPierre 2014 년 진정한 프로그래머가 되려면 부정적인 모든 것을 제쳐 놓아야합니다. 세상은 긍정적이고 세상은 절대적이며 세상은 모듈로입니다!

— Pierre-Luc Pineault

1

"더 큰"과 "작은"이라는 개념이 마음에 들지 않기 때문에보다 작거나 큰 표시를 포함해야한다는 것은 부끄러운 일입니다. 리스트가 아닌 배열을 사용해야합니다.

— Mr Lister

8

스칼라

배열이 정렬되어 있는지 확인하는 것은 쉽습니다! 첫 번째 요소가 두 번째 요소보다 작은 지 확인하십시오. 그런 다음 나머지를 정렬하고 동일한 지 확인하십시오.

불행히도 정렬은 어려운 문제입니다. 배열을 정렬하기위한 잘 알려져 있거나 효율적인 알고리즘은 많지 않습니다. 사실 그것은 컴퓨터 과학 지식의 현재 상태에서 커다란 사각 지대입니다. 그래서 간단한 알고리즘을 제안합니다. 배열을 섞은 다음 배열이 정렬되어 있는지 확인하십시오. 이미 언급했듯이 쉽습니다. 정렬 될 때까지 계속 섞으십시오.

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

나는 이것이 "true, false, true"를 출력한다고 가정한다. 한동안 실행되고 있습니다 ...

— 조 케이
소스

8

정렬 된 정수 배열에는 모든 하위 배열 (예 : 배열의 요소 n-m)도 정렬 된 정수 배열이라는 속성이 있습니다. 이것은 가장 좋은 방법이 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());
}

가장 빠른 방법은 아니지만 목록의 주문 여부에 대한 매우 정확한 테스트입니다. 이 코드는 FUNCTIONAL 패러다임을 사용하기 때문에이 코드를 읽고 이해하기가 매우 쉬우므로 상태 변경 및 반복 루프에 대한 공포가 없습니다.

이것이 유용한 정보가되기를 바랍니다.

— 앨런
소스

6

C #-가장 긴 서브 시퀀스 증가

정렬 된 배열의 경우 가장 긴 부분 시퀀스의 길이는 배열의 길이와 같습니다. 여기서 알고리즘을 복사했지만 증가하는 대신 감소하지 않도록 수정했습니다.

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

— 페예 쇼코
소스

6

Stonescript (c) LMSingh-0 빼기 (4102 palindromed).

다음은 몇 세기 전에 저에게 저작권이 있고 사용 된 언어 인 Stonescript (c)로 작성되었습니다. 즉, 미들 프레임 이전의 오래된 시대입니다. 참고 : Sanskrit의 선구자입니다.

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 개인 배열의 예 내림차순으로 정렬 :-)

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

-코드는 계속되었습니다.

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 개인 배열의 예 분류되지 않음 :-(

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

-코드는 계속되었습니다.

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

=-=-=-=-=-=
추가 최적화에서 4 단계 펀치 리프를 다음 펀치 리프로 교체 할 수 있습니다.
=-=-=-=-=-=

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.

=-=-=-=-=-=
모든 코드 sleuth 및 파워 디버거를 위해 위의 4 단계의 두 번째 변형에서 의도적으로 버그를 추가했습니다. 찾을 수 있습니까?

— LMSingh
소스

3

나는 버그를 발견했다 – 모든 4.3.*것4.2.*

— Timtech

4

자바 스크립트

이것이 "창의성"에 대해 충격을 준 것입니다.

정렬 된 배열 때문에
* 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
따라서 모든 요소에 대해 메인 루프를 실행하고 메인 루프 안에 두 개의 중첩 루프를 실행하여 위의 두 가지 조건을 확인하십시오 (하나는 왼쪽, 하나는 오른쪽)

따라서 설명 된 알고리즘의 자바 스크립트 구현을 제공합니다.

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

그것을 테스트 할 수 있습니다 :

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

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

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

완벽하게 작동하는 것 같습니다! 그것의 복잡성을 가지고 O(n²)있어야하는 알고리즘에 대한 이상적인, O(n)있지만 수행하여 O(n²)이 효율의 측정은 매우 이래로,보다 효율적인하게 O(n²)보다 효율적이다 O(n).

— 빅터 스타 푸사
소스

나는 '중간'을 사용하는 것을 의미하지 않았습니다. 첫 번째 중첩 루프는 0에서 a까지 였고 두 번째는 a + 1에서 길이까지였습니다. BTW, 1,2,3을 정렬해야합니까?

— microbian

@microbian 좋아요, 편집했습니다.

— Victor Stafusa

4

씨

이하, "정렬"은 "오름차순으로 정렬"을 의미한다.

배열은 iff로 정렬되지 않습니다 a[i]>a[i+1]

우리가 허락한다면 그래서 x=a[i]-a[i+1], x배열이 정렬되지 않습니다 IFF에 긍정적 인 것입니다.

x양수인지 테스트하기 위해 두 부분으로 나눌 수 있습니다. x음수 x가 아니고 0이 아닙니다.

x음수 인지 여부에 대한 간단한 테스트 x*x는와 같은지 여부를 테스트하는 것 입니다 x*abs(x). x음수 인 경우이 조건은 false 여야합니다 (-1)*(-1)==1.

0을 테스트하기 위해 다른 간단한 테스트를 사용할 수 있습니다. 0./(float)xis Not a Number iff x는 0입니다.

전체 코드는 다음과 같습니다 (배열에 5 개의 요소가 있다고 가정)

#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_ 홍콩 독립
소스

실제로 테스트 a[i]-a[i+1] > 0는 이미 문제가 있습니다. 모든 종류의 일을 할 필요는 없습니다.

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

불필요한 것들을하는 것이 코드 트롤링의 요점입니다. 그렇지 않습니까? (그리고 당신은 문제가 무엇을 의미합니까?)

— ace_HongKongIndependence

1

부호있는 정수 오버 플로우는 UB입니다. 랩 어라운드 동작을 정의하더라도 INT_MAX-INT_MIN을 수행하면 결과는 음수가됩니다 (a [i]를 INT_MAX로 바꾸고 a [i + 1]을 INT_MIN으로 바꿉니다).

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

숙제 문제 일 뿐이므로 교사가 극한의 숫자를 많이주지 않는다고 가정 해 봅시다.

— ace_HongKongIndependence

승인. 트롤 + 악을 선호합니다.

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

4

그것은 당신이 얼마나 확신하고 있는지에 관한 것입니다. 확실성이 주어지지 않았으므로 다음과 같은 성능이 실제로 현명합니다. 아래 코드는 좋은 추측이지만, 확실하다면이 기능을 몇 번 반복해야합니다. 당신이되고 싶다면 정말 있는지, 당신은 루프를 실행하고 그것을 시간의 다스를해야한다. 완벽한 확장 성!

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

이것은 대접이 아닌가?

— n0la
소스

4

씨

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

확률 1- (1 / n!) 및 복잡도 O (1)에서 작동합니다. 매우 큰 임의의 배열에 가장 적합한 방법입니다.

복잡도는 O (1)이므로 더 나은 추정을 위해서는 두 번 실행하십시오.

— cpri
소스

3

씨

이 함수는 배열이 정렬되었는지 여부를 알려주는 것 이상을 수행합니다. 올바른 위치에 몇 개의 요소가 있는지 알려줍니다. 모든 유형의 데이터에 사용할 수 있습니다.

코드를 쉽게 따르기 위해 설명 변수 이름을 사용하는 것이 중요합니다. 반면에 변수 i는 프로그램의 다른 곳에서 선언되도록 바인딩되어 있으므로 변수를 선언 할 필요가 없습니다.

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

편집 : 이것은 더 큰 배열에 더 좋은 방법입니다. 이것의 장점은 인간이 확인하는 방식과 유사하다는 것입니다.

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

— 레벨 리버 스트리트
소스

1

"변수 i는 프로그램의 다른 곳에서 선언되어야하기 때문에 변수를 선언 할 필요가 없습니다." 웃음의 가치가 있었다.

— Jonathan Van Matre

@JonathanVanMatre 고마워하지만 결코이 코드에 유일한 잘못은 아닙니다.

— Level River St

3

자바 스크립트 및 기타 통계

@Cominterm이 제안한 솔루션을 많이 좋아했습니다. 그러나 이미 정렬 된 목록과 비교합니까? 부정 행위입니다!

대신 배열의 자기 상관을 계산합니다 (배열과 배열 간의 상관 관계가 왼쪽으로 한 위치 이동했습니다). 그런 다음 배열을 여러 번 섞어서 매번 새로운 자기 상관을 원래 자기 상관과 비교합니다. 배열이 정렬 된 경우 원래 자기 상관이 가장 많이 발생합니다!

http://jsfiddle.net/dB8HB/

보너스 : p- 값 <0.05 인 경우 출력은 배열이 사용자를 위해 정렬되었다고 주장하는 작업을 자동화합니다. 무엇을 더 요청할 수 있습니까?

Bonus2 :이 구현에서는 편의상 JavaScript의 O (n) 배열 함수를 사용하지만이 방법은 샘플링을 사용하여 일정한 시간에 실행할 수 있습니다!

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

— 파비오 벨트 라 미니
소스

3

자바 스크립트 / SVG-sunDialsort

이 솔루션은 <, <=,> 또는> = 비교기를 사용하지 않습니다. 가능한 한 정렬 함수처럼 읽지 않으려 고했습니다.

방법

호를 따라 값을 점으로 플로팅합니다.
오름차순 배열의 경우 각 값은 도면의 전체 너비를 넓히고 시작 X를 줄이지 않습니다 (예외 : 두 개의 동일한 값).
너비가 줄어들 수 없으므로! =로 충분합니다.
X는 ==를 증가시킬 수 없으므로 충분합니다.
두 개의 동일한 값을 고정시키기 위해 각 점은 실제로 길이가 증가하는 선입니다. 단위 길이가 1 / 값 수보다 작은 경우.

조업

이 나쁜 코드를 읽는 여정에 다음과 같은 페이스 팜을 추가했습니다.

함수는 배열을 정렬하는 것처럼 보일 수 있습니다.
모든 변수 이름에 lit-geek 참조 사용
정규식 망치를 사용하여 배열의 요소 수를 계산했습니다.
경고 상자를 사용함
두 개의 연속 변수가 동일한 두 배의 변수가 동일한 코드의 양을 두 배로 늘린 경우 (한 라이너는 정렬 할 수 있음)이 코드의 많은 부분을 초기에 두어 함수의 목적을 혼란스럽게합니다.
최소값과 최대 값을 찾는 대신 가장 긴 숫자를 찾아서 다음 10의 거듭 제곱으로 올림하는 대신 사람들이 향기를 맡을 수 있기를 바랍니다.

xml

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

기능

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

누군가 테스트하고 싶다면 읽을 수있는 변수 이름이있는 버전이 있습니다. http://jsfiddle.net/outRideACrisis/r8Awy/

— 아웃 라이드
소스

3

씨

이진 검색은 정렬 된 배열에서만 작동하므로 배열이 정렬되어 있는지 확인하려면 배열의 모든 요소에 대해 이진 검색이 작동하는지 확인하면됩니다. 요소를 찾지 못하면 배열이 정렬되지 않은 것입니다.

전달 된 명령 행 인수는 모두 앞에 0이없는 10 진 정수 여야합니다.

#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
소스

3

자바 스크립트

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

— 제이슨 C
소스

1

{ 69 , 313 , 187 , 31338 }

— Geobits

2

씨

배열의 사본을 만듭니다
사본을 내림차순으로 정렬
이 배열이 주어진 배열의 반대인지 확인하십시오

    #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
소스

2

매스 매 티카

이 알고리즘은 작동하는 것 같지만 약간 느립니다. 정렬하는 더 빠른 방법이있을 수 있지만 찾지 못했습니다.

목록을 무작위로 순서대로 나열하고 순서가 ( OrderedQ) 인지 확인하십시오 .
그렇다면 중지하십시오. 그렇지 않으면 1 단계를 반복하십시오.

다음 코드는 목록을 18 초 이상 정렬했습니다.

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
소스

작업은 입력이 이미 정렬 되어 있는지 확인하는 것이 었습니다 .

— Ilmari Karonen

이것은 OrderedQ마지막에 추가 검사와 함께 내 솔루션의 근본적인 아이디어입니다 (물론 재미를 위해 2 차 시간을 사용하지만 ). 이제 우리는 정렬 된 것을 얻었습니다.

— boothby

2

자바 스크립트

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

이 기능은 false최신 브라우저에서는 잘못 반환 될 수 있습니다 . 이를 확인하고 필요한 경우 질문에 설명 된대로 더 느린 폴백을 제공 할 수 있습니다.

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

그들은 이것이 음수에 대해 예측할 수없는 결과를 제공한다고 말하지만, 실제로 모든 것은 당신이 물건을 예측하는 데 얼마나 좋은지입니다.

— Ry-
소스

2

사람들이 이와 같은 작업을 수행하지 못하도록 Chrome에서 객체 속성을

— 섞으면 좋겠습니다

2

자바 (레 븐슈 테인 거리)

이 구현에서는 원래 배열을 복제하고 복제 된 인스턴스를 정렬합니다. 그런 다음 레 벤슈 테인 거리가 계산됩니다. 0이면 원래 배열이 정렬 된 것입니다.

참고 : getLevenshteinDistance () 구현은 Jakarta Commons Lang에서 가져와 CharSequence 대신 int []에서 작동하도록 수정되었습니다.

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

— 사용자 3001267
소스

배열이 정렬되어 있는지 확인하는 "크리에이티브"방법

루비

자바 스크립트

Java-재귀 서브 세트

뭐? 확실히 그렇게 어렵지 않습니다 ...

충분한 이야기, 코드를 보자!

C ++-무차별 대입 방법

알려

총독 루비

PHP

C #-통계의 힘

루비

비 결정적 솔루션

씨#

스칼라

C #-가장 긴 서브 시퀀스 증가

자바 스크립트

씨

씨

씨

자바 스크립트 및 기타 통계

자바 스크립트 / SVG-sunDialsort

방법

조업

xml

기능

씨

자바 스크립트

씨

매스 매 티카

자바 스크립트

자바 (레 븐슈 테인 거리)