ユーザーがdoubleの配列を入力し、プログラムがソートされた配列を出力するプログラムが必要です


280

注:この質問は、最初にここに投稿してから厳しく編集されました。ルールはここに移動されました。回答を投稿する前に読んで、この目的を理解してください。これは、カテゴリで作成された最初の質問でした。

Stack Overflowの怠zyなユーザーが次の質問をすると想像してください。

ユーザーがdoubleの配列を入力し、プログラムがソートされた配列を出力するプログラムが必要です。コードを教えていただけますか?

このユーザーをトロールするコードをどのように作成できますか?経験の浅いプログラマには便利に見えるが、実際にはまったく役に立たないコードを作成します。

勝者が最も投票された回答です。ただし、回答が何らかの理由で適格でない場合を除きます(適格要件については、タグwikiの説明を確認してください)。以前に最も投票数が多かった回答が受理された後、今後、投票数で打たれた場合、新しい最良の回答が受理され、以前の回答は受理されません。同点の場合は、同点の勝者の中から勝者を自由に選択するか、もう少し待ちます。

コードのない回答は対象外です。彼らは面白くて賛成票をもらうかもしれませんが、受け入れられません。

ルールはタグの説明にあります。

注:これは質問です。質問や回答を真剣に受け取らないでください。詳細はこちら



6
@bluesm自分の学習時間を「無駄にする」のではなく、誰かに問題を解決するように依頼することを既に決めている場合、自分で学習できる場所へのリンクを投稿しても何の役にも立ちません。
IQAndreas

3
うわー、この質問は24時間以内に100の賛成票と10,000のビューを獲得しようとしています!
ジョーZ.

18
私の良さ、ビクター、あなたのアバウトボックスはとても悲しい...私たちは皆、私たちの浮き沈みがありますが、あなたは人を打ち負かすべきではありません。あなたは今、どこでもコードゴルファーのヒーローです!
SimonT

4
スリープソートに基づいたソリューションをまだ誰も提供していないことに驚いた
フランクファーマー

回答:


178

ここのコミュニティは、宿題を手伝おうとしないことがあります。だからあなたは非常に多くの冗談の答えを得ています。しかし、私は助けたいです。「C」での完全なソリューションを次に示します(JavaまたはRubyを使用して「スクリプト」ではなく「プログラミング」を学習したいと考えているため)。私が最初に学んだときに知っていたと思う多くのヒントを含めました

#include <stdio.h>

//Always use meaningful names for types
typedef unsigned char boolean;
#define True 't'
#define FALSE (!True)

//this is a really neat trick for swapping values efficiently
void swap(long* a,long *b) { *a=*a^*b;*b=*b^*a;*a=*a^*b; }

//Here's a readability improvement
#define until(condition) while(!(condition))

int main(int n, char*args[]){
  double *d;
  int i;
  char input[5];  //should be long enough for most doubles.
  boolean sorted = FALSE;

  //In C, you need to specify the array size beforehand, so ask
  printf("Please enter the length of the array\n");
  gets(input);
  //scan the input string and convert to a value
  sscanf(input,"%s",&input[0]);
  n=(long)atol(input);

  //allocate space, make sure you get the order of arguments right.
  d = calloc(sizeof(double),n); 

  //Get and sort the array
  until (sorted) {

     for (i=0;i<n;i++) {
        //It's important to always ask nicely
        printf("Please enter the %d%s array item\n",i,i==1?"st":"th");
        scanf("%lf",d+i);
     }
     //do a compare and exchange sort:
     sorted = !sorted;  //not sorted
     //check all the items
     printf("%d %d\n",i,n);
     for (i=1;i<n;i++) {
        //compare
        if (d[i]<d[i-1]) {
          //exchange 
          swap(d+i,d+i-1);
          sorted = FALSE;
        }
     }
     //show results
     printf("The array is%ssorted\n",sorted?" ":" not "); }
  //use the --> "downto operator" for counting downto 0. 
  for (;n-->0;) printf("%lf\n",*d++);
  }

32
ほとんどすべてのアドバイスは間違っており、入力済みのリストを入力するまで入力リストを要求し続けるだけです。
AShelly

47
+ 1、1st, 2th, 3th, 4th...downto演算子-非常に高度なCプログラミング手法。
カヤ

5
を使用する必要がありますsscanf(input, "%5s", &input[0])。そうしないと、入力の解析中にオーバーランバグが発生する可能性があります。またchar input[sizeof(int)+1]、64ビットシステムとの下位互換性のために、入力を宣言する必要があります。
SH1

12
i==1?"st":"th"ハハハ...
ガイSirton

15
Javaにはガベージコレクションがあります。したがって、Javaは「スクリプト」用であり、実際のプログラミングではありません。これが基本的なCS101です。(だからトロルは言う。)
AShelly

181

これはjavaにあります。MySQLデータベースを作成し、そこに番号を挿入し、ORDER BY句で選択を行い、MySQLによって指定された番号を出力するため、完全に不正行為であり、受け入れられず、修正できません。実際、ソートを行っているのはプログラムではなく、MySQLです。

package sorter;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;

public class SortingAlgorithm {

    private static final String CREATE_DB = "CREATE DATABASE sorting";
    private static final String DROP_DB = "DROP DATABASE sorting";
    private static final String CREATE_TABLE = "CREATE TABLE sorting.sorting ( num double not null )";

    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        List<Double> doubles = new ArrayList<>(50);
        String typed;
        do {
            typed = JOptionPane.showInputDialog(null, "Type a double:");
            if (typed != null) doubles.add(Double.parseDouble(typed));
        } while (typed != null);

        List<Double> sorted = new ArrayList<>(50);

        try (Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306", "root", "root")) {
            try (PreparedStatement ps = con.prepareStatement(CREATE_DB)) {
                ps.executeUpdate();
            }
            try (PreparedStatement ps = con.prepareStatement(CREATE_TABLE)) {
                ps.executeUpdate();
            }

            for (Double d : doubles) {
                try (PreparedStatement ps = con.prepareStatement("INSERT INTO sorting.sorting (num) VALUES (" + d + ")")) {
                    ps.executeUpdate();
                }
            }

            try (
                    PreparedStatement ps = con.prepareStatement("SELECT * FROM sorting.sorting ORDER BY num");
                    ResultSet rs = ps.executeQuery())
            {
                while (rs.next()) {
                    sorted.add(rs.getDouble("num"));
                }
            }
            try (PreparedStatement ps = con.prepareStatement(DROP_DB)) {
                ps.executeUpdate();
            }
        }

        JOptionPane.showMessageDialog(null, "The array sorted is: " + sorted);
    }
}

103
実際、多くのJavaコーダーが仕様に対する解決策の許容可能な一致と見なすものにとっては、実際には少し近すぎます!!
レブム博士13

10
また、非常に多数のオブジェクトをソートする必要がある場合も考慮してください。データベース内でそれらを「プログラム外」でソートすることは、実行可能なソリューションです。
ヴィクトルサイフェルト

40
ここでは抽象化が十分ではありません。少なくとも10のインターフェイス、20の実装、列挙、単体テスト、カバレッジテスト、Maven、統合テスト、モックが必要です...
Naftuli Kay

6
@NaftuliTzviKay MySQLSortEnterpriseEditionを作成して、アイデアを実装する必要があります。ビクターはここからコードをGPLライセンスすることに同意しますか?
ジョーZ.

14
@JoeZ。はい、私の答えはライセンスモデルに関するコメントが不足しているため、プログラムの開始時にユーザーにEULAを承認させる必要があります。しかし、私はそれを遅延OPに提供しているので、待望のプレミアムMySQLSortEnterpriseEdidtionを作成するのに役立つなど、非営利的な使用には無料です。
ビクターStafusa

142

C#-オーバーキルのようなキルはありません

まずは、GiMmEtHaCoDeZ様、タスクを分割してみましょう。

  1. 数字を読む
  2. それらを並べ替える
  3. ソートされた数値を出力します。

「分割統治」はソフトウェアの問題を扱う際に非常に重要な戦略であるため、一度に1つずつ取り組むことができます。

1.読書

ソフトウェアのもう1つの重要な問題は汎用性です。ユーザーが数値を入力する方法が指定されていないため、コンソール、ファイル、Webサービスなどで発生する可能性があります。現時点では考えられない方法もあります。そのため、当社のソリューションがさまざまなタイプの入力に対応できることが重要です。それを達成する最も簡単な方法は、重要な部分をインターフェースに抽出することです。

public interface IDoubleArrayReader
{
  IEnumerable<double> GetDoubles();

  DoubleArrayReaderType Type {get;}
}

ここDoubleArrayReaderTypeで、列挙は

public enum DoubleArrayReaderType
{
  Console,
  File,
  Database,
  Internet,
  Cloud,
  MockService
}

ソフトウェアをゼロからテスト可能にすることも重要です。そのため、インターフェイスの実装は

public class MockServiceDoubleArrayReader : IDoubleArrayReader
{
    IEnumerable<double> IDoubleArrayReader.GetDoubles()
    {
      Random r = new Random();  
      for(int i =0; i<=10; i++)
      {
        yield return r.NextDouble();
      }
    }

    DoubleArrayReaderType IDoubleArrayReader.Type 
    {
      get
      {
        return DoubleArrayReaderType.MockService;
      }
    }
}

次に、論理的な質問は、適切なIDoubleArrayReaderコードをロードする方法を知ることです。単純なファクトリを使用する限り、それは簡単です。

public static class DoubleArrayInputOutputFactory
{
  private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;

  static DoubleArrayInputOutputFactory()
  {
      readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayReader)
          {
            readers.Add((instance as IDoubleArrayReader).Type, 
                        (instance as IDoubleArrayReader));
          }
        }
        catch
        {
          continue;
        }
      }
  }

  public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
  {
    return readers[type];
  }
}

リフレクションを使用してすべてのアクティブなリーダーをロードするため、将来の拡張機能は自動的に使用可能になることに注意してください。

IDoubleArrayReader reader = DoubleArrayInputOutputFactory
                           .CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
var doubles = reader.GetDoubles();

2.処理(ソート)

次に、処理する必要があります。つまり、取得した数字を並べ替えます。ステップは互いに完全に独立しているため、ソートサブシステムにとっては、数値がどのように入力されたかは関係ありません。さらに、並べ替え動作も変更される可能性があります。たとえば、より効率的な並べ替えアルゴリズムを適切に入力する必要がある場合があります。したがって、当然、要求された処理動作をインターフェースで抽出します。

public interface IDoubleArrayProcessor
{
  IEnumerable<double> ProcessDoubles(IEnumerable<double> input);

  DoubleArrayProcessorType Type {get;}
}

public enum DoubleArrayProcessorType
{
  Sorter,
  Doubler,
  Tripler,
  Quadrupler,
  Squarer
}

そして、ソート動作はインターフェースを実装するだけです:

public class SorterDoubleArrayProcessor : IDoubleArrayProcessor
{
    IEnumerable<double> IDoubleArrayProcessor.ProcessDoubles(IEnumerable<double> input)
    {
      var output = input.ToArray();
      Array.Sort(output);
      return output;
    }

    DoubleArrayProcessorType IDoubleArrayProcessor.Type 
    {
      get
      {
        return DoubleArrayProcessorType.Sorter;
      }
    }
}

もちろん、処理インスタンスをロードおよび管理するファクトリーが必要になります。

public static class DoubleArrayProcessorFactory
{
  private static Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor> processors;

  static DoubleArrayProcessorFactory()
  {
      processors = new Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayProcessor)
          {
            processors.Add((instance as IDoubleArrayProcessor).Type, (instance as IDoubleArrayProcessor));
          }
        }
        catch
        {
          continue;
        }
      }
  }

  public static IDoubleArrayProcessor CreateDoubleArrayProcessor(DoubleArrayProcessorType type)
  {
    return processors[type];
  }

}

3.出力を書く

これは入力を反映するプロセスであるため、ここで言うことはあまりありません。実際、次のように、読み取りファクトリと書き込みファクトリを単一のDoubleArrayInputOutputFactoryに結合できます。

public interface IDoubleArrayWriter
{
  void WriteDoublesArray(IEnumerable<double> doubles);

  DoubleArrayWriterType Type {get;}
}

public enum DoubleArrayWriterType
{
  Console,
  File,
  Internet,
  Cloud,
  MockService,
  Database
}

public class ConsoleDoubleArrayWriter : IDoubleArrayWriter
{
    void IDoubleArrayWriter.WriteDoublesArray(IEnumerable<double> doubles)
    {
      foreach(double @double in doubles)
      {
        Console.WriteLine(@double);
      }
    }

    DoubleArrayWriterType IDoubleArrayWriter.Type 
    {
      get
      {
        return DoubleArrayWriterType.Console;
      }
    }
}


public static class DoubleArrayInputOutputFactory
{
  private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;
  private static Dictionary<DoubleArrayWriterType, IDoubleArrayWriter> writers;

  static DoubleArrayInputOutputFactory()
  {
      readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
      writers = new Dictionary<DoubleArrayWriterType, IDoubleArrayWriter>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayReader)
          {
            readers.Add((instance as IDoubleArrayReader).Type, (instance as IDoubleArrayReader));
          }
        }
        catch
        {
          continue;
        }
      }

      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayWriter)
          {
            writers.Add((instance as IDoubleArrayWriter).Type, (instance as IDoubleArrayWriter));
          }
        }
        catch
        {
          continue;
        }
      }

  }

  public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
  {
    return readers[type];
  }

  public static IDoubleArrayWriter CreateDoubleArrayWriter(DoubleArrayWriterType type)
  {
    return writers[type];
  }

}

すべてを一緒に入れて

最後に、メインプログラムは、既に構築したこの素晴らしい機能をすべて使用するため、コードは次のようになります。

var doubles = reader.GetDoubles();
doubles = processor.ProcessDoubles(doubles);
writer.WriteDoublesArray(doubles);

どこ、例えば我々が定義することができreaderwriterかつprocessor使用して

IDoubleArrayReader reader = DoubleArrayInputOutputFactory.CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
IDoubleArrayProcessor processor = DoubleArrayProcessorFactory.CreateDoubleArrayProcessor(DoubleArrayProcessorType.Sorter);
IDoubleArrayWriter writer = DoubleArrayInputOutputFactory.CreateDoubleArrayWriter(DoubleArrayWriterType.Console);

49
笑、ListSortのEnterprise Edition©:-P 1
ドアノブ

14
クレイジーなオーバーコーディングの場合は+1。私はそれらを個別に+1できるようにあなたが3つ以上の「モジュール」の答えにあなたの答えを破る示唆
greggo

15
そして、上部の桜は、それが実際にライブラリのソートを使っているということです:)これは、仕様に完全だし、完全に役に立たない
SWeko

9
それは...美しかった...
アンドリュー

7
これは簡単な例であるため、DIを使用するとOPが混乱するだけです。
SWeko

132

さらに文字通りの解釈:

echo " aaehrrty"

つまり、「配列」がソートされます。


5
これを投稿するためにここに来ました。
Quuxplusone

5
ファイルとして保存sort.shし、として呼び出すsh sort.sh "an array of doubles"
Kyssタオ

「ユーザーがdoubleの配列を入力する」を見逃したと思います。
ダケリング14年

1
@Dukelingそれが、Kyss Taoのコメントのポイントです。"an array of doubles"コマンドライン引数としてスクリプトに渡すことができます。
AJMansfield 14年

108

Perl

CodeGolf.SEで行ったすべての作業のうち、これにはおそらく少なくとも数時間かかりました。

$_[0]=eval<>;
for(0..$#{$_[0]}**2){
 @_[$#_+1]=[\(@{$_[$#_]}),$#{$_[$#_]}+1];
 for(1..$#{$_[$#_]}-$#_){
  if(eval('${'x$#_.'@{$_[$#_]}[$_-1]'.'}'x$#_)>eval('${'x$#_.'@{$_[$#_]}[$_]'.'}'x$#_)){
   ${$_[$#_]}[$#{$_[$#_]}]=$_;
  }
 }
 (${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]-1],${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]])=(${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]],${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]-1]);
}
for(0..~~@{$_[0]}){
 $\.=eval('${'x$#_.'${$_[$#_]}[$_-1]'.'}'x$#_).','
}
$\=~s/,*$//;$\=~s/^,*//;$\="[$\]";
print;

入力は形式で[2,4,5,7,7,3]、出力は形式[2,3,4,5,7,7]です。

今説明する時間がありません...後で戻ってください。

とにかく、Perlには匿名配列と呼ばれるものがあります。配列ですが、名前はありません。ただし、わかっているのは、それを指す参照(メモリの場所)です。角括弧で囲まれた一連の数字は、匿名配列を作成し、それへの参照を返します。

この答えは、一連の匿名配列から構築され、その参照はに格納され@_ます。入力は匿名配列に変換されます。次に、他の匿名配列を作成します。各配列の要素は、前の配列の要素への参照です。配列内の要素を並べ替える代わりに、その配列内の要素へのポインタを並べ替えます。また、ソート操作の各ステップ(およびそれ以上)に新しい配列を作成します。


3
悪の!悪の!悪の!
DGM

56
他のPerlスクリプトと同じくらい解読可能です:)
Corey Goldberg

6
@swelljoe実際に$_は、その時点では空の文字列です。目的の出力をに保存しました$\ 。これは出力レコードの区切りです。
PhiNotPi

4
@アンディシンプル。「どのように機能しますか?」
ジョンドボラック

1
そして、すべてのユーザーが作成した変数はすべてthinkableの規則に従ってかわいい名前持っている
ハーゲン・フォン・Eitzenを

80

Python

入力配列から並べ替えられていないすべての要素を削除することにより、ユーザーに並べ替えられた配列を提供します。

import sys

sorted = []
for number in map(float, sys.stdin.read().split()):
    if not sorted or number >= sorted[-1]:
         sorted.append(number)
print sorted 

アルゴリズムは、リストをソートせずに各要素を追加するだけでリストを調べます。したがって、出力はソートされたリストであり、元のリストのすべての要素を含むリストではありません。opがリストがソートされた順序であるかどうかだけをチェックする場合、出力に値が欠落していることに気付かないことがあります。


1
あなた自身を投稿する前に他の回答をご覧ください。言語の名前を追加する必要があります。この質問に答えるには、OPをトロールするために何をしているかを簡単に説明する必要もあります。
ワシ

5
へへ、これは実際に私を大声で笑わせた。とにかく、少し良い説明が役立つことに同意します。
oconnor0

2
sys.stdin.read()タイプミスへの二重呼び出しか、実際のトローリング回答の一部ですか?確かにそれは入力として配列を与えるためにOPを挫折し、結果を待ち続けます...
Bakuriu

うわー、それは大丈夫です。
Sylverdrag

13
O(n)ソートアルゴリズム。いいね
ejrb 14年

65

バッシュ、54文字

CやPythonなどの低速で非効率的な言語を使用した多くの回答...すべてのスクリプト言語の母であるBashでソリューションを提供することで、少しスピードを上げましょう。

私はあなたが何を考えているのか知っています-Bashは浮動小数点演算さえも処理できません。さて、見よ、強力なSleepSortアルゴリズムの私の実装:

#!/bin/bash

for i in $@; do echo -n $(sleep $i)$i' '& done
echo "Leveraging the power of your $(grep -c ^processor /proc/cpuinfo) cores to \
sort optimally by spawning $(jobs -l | wc -l) concurrent sorting threads..."
wait
echo -e "\nThe array sorted."

プログラムには、コマンドライン引数として入力が提供されます。サンプル実行:

> ./sleepsort.sh 7 1 4 3 2.752 6.9 0.01 0.02
Leveraging the power of your 4 cores to optimally by spawning 8 concurrent sorting threads...
0.01 0.02 1 2.752 3 4 6.9 7
The array sorted.

これには、ここで説明するすべての動作アルゴリズムの中でおそらく最も短いという利点もあります。そうです-bashの強力な1行。bashビルトインのみを使用し、外部バイナリを呼び出しません(つまり、純粋にオプションの詳細出力をカウントしない場合)。bogosortsとは異なり、その実行時間は決定的です。

ヒント:効果的な最適化は、ソートする前に入力値を係数で除算することです。実装は読者に任されています。

編集:

きれいに印刷されていない54文字のゴルフバージョンの短縮:

#!/bin/sh
for i in $@;do echo $(sleep $i)$i&done;wait

11
トローリング1:アルゴリズムは機能しますが、明らかに非常に遅い可能性があります-番号を出力する前にその数秒間スリープし、番号ごとにスレッドを生成します(したがって、順番どおりです)。トローリング2:さらに、コードの大部分は、生成されるスレッドの数に関する素晴らしいコメントの作成に費やされ、余分な冗長出力のためにシステムのCPU情報を不必要かつ無償で読み取り、解析します。トローリング3:最後に「並べ替えられた配列」を出力しますが、これは完了したようです。トローリング4:ユーザーはctrl-cを押して「ソート」をキャンセルできません。
暴動

4
5.の使用により、GNU / Linuxでのみ機能します/proc/cpuinfo
kps11346

5
ちなみに非常に創造的なソリューション:)
ドミトリー

8
これは素晴らしいです。それがどれほど素晴らしいかさえ表現できません。私はそれを積極的に使用することを検討しています。理由はありません。

4
私は実際にどこかに本番環境で使用されているこのバリアントを本当に持っています。それは私の言い訳ですので、しかし、そのような状況では、プロセスの実行時間は、重要である...
暴動

64

JavaScriptには組み込みsort()関数があり、次のように使用できます。

var numbers = [6, 2.7, 8];
numbers.sort();
// => [2.7, 6, 8]

...ああ、完全に言及するのを忘れてしまった、それは辞書順、すなわちにソート10 < 9して9 < -100。おそらくそれはあなたがとにかく期待するものです。


8
それは組み込み関数だからです。
ウェインワーナー

62

(jPL)jQueryプログラミング言語

そのためにはjQueryを使用する必要あります。この問題の簡単な解決策は次のとおりです。

function jSort() {
    var a = 0.0; // position 1
    var b = 0.0; // position 2
    var c = 0.0; // position 3

    var arr = [];
    var nArr = [];

    // don't forget to validate our array!
    if (window.prompt("You must only type double values. Type 1 if you accept the terms.") != 1) {
        alert("You can't do that.");
        return;
    }

    for (var i = 0; i < 3; i++) {
        if (i == 0) {
            var a = window.prompt("Type a double value");
            arr.push(a);
        }
        if (i == 1) {
            var b = window.prompt("Type a double value");
            arr.push(b);
        }
        if (i == 2) {
            var c = window.prompt("Type a double value");
            arr.push(c);
        }
    }

    // Now the tricky part
    var b1 = false;
    var b2 = false;
    var b3 = false;
    for (var i = 0 ; i < 3; i++) {
        // check if the variable value is the same value of the same variable which now is inside the array
        if (i == 0) {
            if (a == arr[i]) {
                b1 = true;
            }
        }

        if (i == 1) {
            if (b == arr[i]) {
                b2 = true;
            }
        }

        if (i == 2) {
            if (c == arr[i]) {
                b3 = true;
            }
        }
    }

    if (b1 == true && b2 == true && b3 == true) {
        if (arr[0] > arr[1]) {
            if (arr[0] > arr[2]) {
                nArr.push(arr[0]);
            } else {
                nArr.push(arr[2]);
            }
        }

        if (arr[1] > arr[0]) {
            if (arr[1] > arr[2]) {
                nArr.push(arr[1]);
            }
            else {
                nArr.push(arr[2]);
            }
        }

        if (arr[2] > arr[0]) {
            if (arr[2] > arr[1]) {
                nArr.push(arr[2]);
            } else {
                nArr.push(arr[1]);
            }
        }

        console.log(arr.sort(function (a, b) { return a - b }));
        alert(arr.sort(function (a, b) { return a - b }));
    }
}

jSort();


55
私はこれがjQueryを実際に使用しない方法が特に好きです。
KRyan

8
-1配列の命名に、ハンガリー語表記、特にを使用して意味されるjQueryオブジェクト$、を使用する配列、aおよびwindow.promptasの結果を含める必要がありますp
カンタス94

2
「トリッキーな部分」はエレガントです。OP、いつかその種のコード構造を持つように努めてください。
クリスバーカー

2
F'n doble「検証」LOOOOOOOOOOOOL omg omg day made!少ないキャップに編集
HC_

54

C

このソリューションは、Cが提供する簡潔さとOSレベルのアクセスを、GNU / Linuxの強力で再利用可能なソフトウェアコンポーネントと組み合わせます。

#include <stdlib.h>

main(int argc, char **argv)
{
    system("echo Enter numbers one per line, ending with ctrl-D; sort -g");
}

4
または「スクリプト」:#!/usr/bin/sort
メカニカルカタツムリ14年

54

ルビー

print "Input an array of doubles: "
gets
puts "the array sorted."

かなり自明です。

または、入力が実際に「doubleの配列」であることを要求します。

print "Input an array of doubles: "
g = gets until /an array of doubles\n/
puts "the array sorted."

gets.chomp余分な悪のために使用していません。また、末尾まで後に正規表現を使用します。これは、OPをさらに混乱させることができるとは知りませんでした(Jan Dvorakに感謝します)!


4
アイデアを拡張して、ユーザーが文字列を入力するまで繰り返し入力を求めますan array of doubles
Wrzlprmft

@Wrz OK、完了:-)
ドアノブ

2
貧弱なOPは改行を削除する方法を理解する必要があるため、これは非常に優れています(なぜならのgets代わりにを使用するためですgets.chomp)。
wchargin

@WCharginうん、私は最初のリビジョンでそれを持っていました(リビジョン履歴を参照)が、それをさらに邪悪なものにするために削除しました>:D これを編集します:-)
ドアノブ

1
+1ここでアカウントを作成しました。これはまさに私が答える方法です!大好きです!
DGM

44

Python3.3

確かに、stdinのリストリテラルとして指定された配列をソートできる最も単純な Pythonプログラムは次のとおりです。

collections = __import__(dir(object.__subclasses__()[7])[1][4:-3] + chr(116))

URL = ('https://www.google.com/search?client=ubuntu&channel=fs&q=dante+alighieri'
      '%27s+divina+commedia&ie=utf-8&oe=utf-8#channel=fs&q=__++divina+commedia+'
      'dante+alighieri+inferno+__').translate(
          dict.fromkeys(map(ord, '+-.:,;bcdefghjklopqrstuvwxyz/&=#?%')))[30:]
SECRET_KEY = URL[2:10][::-1][3:-1]
DATA = '{}{}{}'.format(URL[:2], SECRET_KEY[:2] + SECRET_KEY[:-3:-1], URL[-2:])



if getattr(DATA, dir(list)[7])(__name__):
    pieces = 'literally - evil'.split(' - ')
    r = getattr(collections, 
                '_'.join([pieces[0][:-2],
                          pieces[1].translate({ord('j')-1: 'a'})])
                )((getattr(globals()['__{}__'.format('buildings'.translate(
                        {100:'t', 103:None}))], 'in' r"put"))
                  ())
    tuple((lambda lst:
           (yield from map(list,
                           map(lambda k: (yield from k), 
                               ((lambda i: (yield from map(lambda t:
                                             (lst.append(lst[i]) or
                                              lst.__setitem__(i, lst[t]) or
                                              lst.__setitem__(t, lst.pop())),
                                              (j for j in range(i)
                                                if (lambda: lst[i] < lst[j])())
                                              ))
                                )(è) for è in range(
                                                getattr(lst,
                                                        dir(lst)[19])()))))
          )
        )(r))
    print(r)

残念ながら、yield from式を使用するため、python3.3 +でのみ機能します。コードは非常に自明である必要があるため、教授に引き渡す際に問題が発生することはありません。


トローリングは、OPが意図したとおりのことを行う完全に機能するソリューションを提供することですが、その方法は次のとおりです。

  • 理解できない(初心者)
  • 教師に対処することは不可能です:
    • OPはそれを理解できません
    • たとえ先生がそれを理解するために解読する時間がなかったとしても
  • プログラミングが彼にとって難しいと思うかもしれない素朴な初心者にとっては怖い

要約すると、この回答は、特定の観点からの完全に有効な回答で要求をあざける学生のフラストレーションを大幅に増加させます。


(上記のコードを理解するのが難しいと思われる場合は読んでいない)

実装されているソートアルゴリズムが実際には

バブルソート!... OPでさえ理解できる方法で確実に実装できます。それ自体はあいまいなアルゴリズムではなく、OPが完全に理解することができる何かの優れたコード難読化です。


3
これにはもっと説明が必要だと思います。あなたは今インフェルノに何をしていますか?
KRyan

1
うわー、Pythonで非ASCII変数名を実行できますか?知りませんでした
kratenko

1
@kratenko python3 +から。python2では、インタープリターはASCIIをエンコードとして想定しているため、エラーが発生します。python3では、インタープリターはエンコードとしてUTF-8を想定し、識別子のUnicodeプロパティによって「文字」であるすべての文字を受け入れます。
バクリウ

3
@KRyan:彼は明らかに、Hellが人々を9つのサークルに入れるために使用するソート方法を採用しています。
ジョーZ.

10
なんてこった…+1
ショーンオールレッド

41

C-遅い、使いにくい、受け入れられないコーディングスタイル

ソートアルゴリズム自体はスローソートとして知られており、約n ^(log n / 2)のベストケースの複雑さ(複雑さ)を持っています。このアルゴリズムは、Andrei BroderとJorge Stolfiの素晴らしい論文「Pessimal Algorithms and Simplexity Analysis」で公開されています。

void sort(double* arr, int n, int i, int j)
{
        if(i < j) {
                int m = (i+j)/2;
                sort(arr, n, i  , m);
                sort(arr, n, m+1, n);
                if(arr[m] > arr[j]) {
                        double t = arr[j];
                        arr[j] = arr[m];
                        arr[m] = t;
                }
                sort(arr, n, i, j-1);
        }
}

ただし、ソート自体は役に立たないため、ユーザーがソートしたいデータを入力する方法が必要です。doubleの解析は苦痛なので、バイトごとに入力しないでください。

const unsigned MAX_ELEMS = 100;
int main()
{
        int i=0, j=0, len;
        char a[MAX_ELEMS*8];
        double* arr = (double*) a;
        short isNull=1;

        while(1) {
                a[i++] = getchar();
                if(i%8 == 0) {
                        if(isNull)
                                break;
                        isNull = 1;
                }
                else if(a[i-1] != 0)
                        isNull = 0;
        }

        len=i/8 - 1;

        sort(arr, len-1, 0, len-1);

        for(i = 0; i < len; i++)
        {
                printf("%f ", arr[i]);
        }
}

動作することを証明するには:

 $ gcc -g trollsort.c -o trollsort
trollsort.c: In function ‘main’:
trollsort.c:43:3: warning: incompatible implicit declaration of built-in function ‘printf’
 $ echo -en "\0\0\0\0\0\xe4\x94\x40\0\0\0\0\0\0\xf0\x3f\0\0\0\0\0\0\x45\x40\0\0\0\0\0\0\0\0" | ./trollsort
1.000000 42.000000 1337.000000

最終的には次のとおりです。

  • 私が知っている最も遅い決定論的なソートアルゴリズム
  • リストの長さに関するハードコードされた無制限の制限
  • 絶対に恐ろしい入力で、出力を同様にすることもできますが、この方が面白いと思います。
    • 考慮してください:あなたのマシンがプログラムを使用するエンディアンであることを知る必要があります。
    • また、0を入力することはできません(-0でも構いません)
  • ポインターの算術演算と、ポインターはどちらの方法でもキャストされるため、型にはほとんど関係ありません

これには、7バイトを超えるすべての入力に対する未定義の動作があります。受け入れられる答えではありません。
マイケルスペンサー

1
「Pessimal Algorithms」ペーパーが大好きです。ありがとう。
ライアン

「私が知っている最も遅い確定的ソートアルゴリズム」– おそらく最も遅い確定的ソートアルゴリズム。それがAFAIRの論文の要点です。
コンラッドルドルフ

@MichaelSpencer手の込んだケア?入力サイズが24バイトの例を挙げましたが、出力は期待どおりのものです(ここでは冗談が抜けていると思います)。
塩奈

2
@Sashoがbogo-sortの場合、ベストケース実行時間は\ Omega(n)(n-1回の比較、0回の操作)です。それははるかに速い、別名です。\ Omega(n ^(log n / 2))よりも悪い。
塩奈

39

ルビー、邪悪なボゴソート!(ボーナス:ユーザー入力によるbogosort)

print "Input array of doubles, separated by commas: "
arr = gets.split(",")
arr.shuffle! until arr.each_cons(2).all? {|x| x[0] < x[1]}
puts arr * ","

「悪」のねじれ:

  • もちろん、本当に本当に本当に本当に本当に本当に本当に本当にゆっくりと走ります
  • 文字列比較を使用するため、10は2未満です。2 .map &:to_f行目に追加することで簡単に修正できますが、OPは
  • 使用しchompていないため、最後の番号には最後に神秘的な改行があります
  • 使用しstripていないため、カンマの周りにスペースを入れて入力すると、数字の周りに不思議な空白があります(例:のスペース1.5, 2

または、ユーザー入力によるボゴソートはどうですか?!>:D

print "Input array of doubles, separated by commas: "
arr = gets.split(",")
arr.shuffle! until arr.each_cons(2).all? {|x|
    print "Is #{x[0]} less than #{x[1]}? (y/n) "
    gets =~ /y/
}
puts arr * ","

なぜbogobogosortではないのですか?(!趣のあるO(N *(N)^ n)の時間で実行)
wchargin

@Wchargin私はそれを検討するかもしれません:-)あなたは私の最近の編集に興味があるかもしれません!(申し訳ありませんが、低速であるために、私はコンピュータ:-Pにアクセスすることはできませんので、今の自分の携帯電話上で実際よ)
ドアノブ

37

COBOL

承知しました!「猿でもできる!」

入力をソートする簡単なCOBOLプログラムを次に示します。コメントを読んで、それがいかに簡単で拡張可能であるかを正確に確認してください。これの真の利点は、試行された真のメカニズムであり、Javaなどの比較的テストされていない新しい言語や、WebベースまたはMicrosoftのものに依存しないことです。それは本当に効果的にコンパイルされ、このような手順はFortune500で最も成功している金融会社や他の業界リーダーによって使用されています。このコードは多くの専門家によってレビューされており、ソートの優れたメカニズムとして認識されています。

000100 IDENTIFICATION DIVISION.
000200* Cobol sort. Consistent with COBOL 390
000300* does not use sections; does not use go to
000400* uses sort procedures
000500* does a sort with some minimal input validation
000600* since everything is done in an orderly way,
000700* you can easily add code of your own to this program
000800 PROGRAM-ID. 'SORTEX1'.
000900 ENVIRONMENT DIVISION.
001000 CONFIGURATION SECTION.
001100 INPUT-OUTPUT SECTION.
001200 FILE-CONTROL.
001300*    INPUT FILE UNSORTED
001400     SELECT UNSORTED-FILE ASSIGN UNSORTED.
001500*    The work file for the sort utility
001600*    you need the select and an sd but do not need jcl for it
001700     SELECT SORT-WORK      ASSIGN      SORTWORK.
001800*    output file normally a disk/tape file
001900*    for this program, send it to the printer
002000     SELECT SORTED-FILE ASSIGN SORTED.
002100*
002200 DATA DIVISION.
002300 FILE SECTION.
002400*
002500 FD  UNSORTED-FILE
002600     RECORDING MODE IS F
002900     RECORD CONTAINS  80 CHARACTERS.
003000
003100 01  UNSORTED-RECORD.
003200     05  WS-UR-ACCT-NO        PIC X(5).
003300     05  FILLER               PIC X(5).
003400     05  WS-UR-AMOUNT         PIC 9(5).
003500     05  WS-UR-CUST-NAME      PIC X(10).
003600     05  FILLER               PIC X(5).
003700     05  WS-UR-TRANS-CODE     PIC X(1).
003800     05  FILLER               PIC X(49).
003900
004000  SD  SORT-WORK
004400      RECORD CONTAINS  80 CHARACTERS.
004500*
004600 01  SORT-WORK-RECORD.
004700*    You need a definition and picture for
004800*    the field that is sorted on (sort key)
004900     05  SW-ACCT-NO    PIC X(05).
005000*    YOU NEED A FILLER TO COMPLETE THE DEFINITION
005100     05  FILLER        PIC X(75).
005200*
005300 FD  SORTED-FILE
005400     RECORDING MODE IS F
005700     RECORD CONTAINS  80 CHARACTERS.
005800*
005900 01  SORTED-RECORD.
006000     05  WS-SR-ACCT-NO        PIC X(05).
006100     05  FILLER               PIC X(05).
006200     05  WS-SR-AMOUNT         PIC 9(05).
006300     05  WS-SR-CUST-NAME      PIC X(10).
006400     05  FILLER               PIC X(55).
006500
006600 WORKING-STORAGE SECTION.
006700 01  SWITCHES.
006800     05  UNSORTED-FILE-AT-END      PIC X   VALUE 'N'.
006900     05  SORT-WORK-AT-END          PIC X   VALUE 'N'.
007000     05  valid-sw                  PIC X   VALUE 'N'.
007100
007200 01  COUNTERS.
007300      05 RELEASED-COUNTER PIC S9(7)
007400                PACKED-DECIMAL VALUE +0.
007500      05 REJECT-COUNTER   PIC S9(7)
007600                PACKED-DECIMAL VALUE +0.
007700
007800 PROCEDURE DIVISION.
007900     PERFORM INITIALIZATION
008000*    Compare this logic to that of the simple program
008100*    notice how the sort verb replaces the
008200*    perform main until end of file etc
008300     SORT SORT-work ASCENDING KEY SW-ACCT-NO
008400         INPUT PROCEDURE SORT-INPUT
008500         OUTPUT PROCEDURE SORT-OUTPUT
008600     PERFORM      TERMINATION
008700     GOBACK.
008800
008900 INITIALIZATION.
009000*    Do what you normally do in initialization
009100*    open the regular input file (not the sort work file)
009200*    and other files needed
009300*    (you could open them in the sort input procedure, too)
009400     OPEN INPUT UNSORTED-FILE
009500          output SORTED-FILE
009600*    READ THE FIRST RECORD ON THE REGULAR INPUT FILE
009700     PERFORM READ-IT.
009800*    Whatever else you do in initialization
009900*    headers, initialize counters, etc
010000
010100 TERMINATION.
010200*    Do what you normally do in termination
010300*    print out total lines
010400*    close the files you opened
010500*    display totals
010600     CLOSE UNSORTED-FILE
010700           SORTED-FILE.
010800
010900 READ-IT.
011000     READ UNSORTED-FILE
011100     AT END MOVE 'Y' TO UNSORTED-FILE-AT-END
011200     END-READ.
011300
011400 SORT-INPUT.
011500*    This is the 'sort input procedure'
011600*    when control passes thru the last statement in it
011700*    the input phase of the sort is finished
011800*    and actual sorting takes place
011900     PERFORM SORT-INPUT-PROCESS-ALL
012000        UNTIL UNSORTED-FILE-AT-END = 'Y'.
012100
012200  SORT-INPUT-PROCESS-ALL.
012300*  This is the point when you have each unsorted input record
012400*  in your hands
012500*  many programs do some validation or selection here
012600*  to determine which records are actually given to the sort util
012700*  we will do some simple validation here
012800     MOVE 'Y' TO VALID-SW
012900     PERFORM SORT-INPUT-VALIDATE
013000     IF VALID-SW = 'Y'
013100     THEN
013200**       Give the unsorted input record to the sort utility
013300         RELEASE SORT-work-RECord FROM unsorted-RECORD
013400         ADD 1 TO RELEASED-COUNTER
013500     ELSE
013600**       Here, you have decided not to give the unsorted input
013700**       record to the sort utility
013800         ADD 1 TO REJECT-COUNTER
013900     END-IF
014000     PERFORM READ-IT.
014100
014200 SORT-INPUT-VALIDATE.
014300*    Check the regular input record for validity.
014400*    if it is not suitable for sorting, set the valid sw
014500*    other validation criteria would apply for other files
014600     IF WS-UR-ACCT-NO IS equal to spaces
014700        THEN MOVE 'N' TO VALID-SW
014800     END-IF.
014900
015000 SORT-OUTPUT.
015100*    This is the 'sort output procedure'
015200*    when control passes thru the last statement in it
015300*    the output phase of the sort is finished
015400*    you have seen (returned) the last sorted record
015500*    and the sort utility is finished
015600     PERFORM RETURN-IT
015700     PERFORM SORT-OUTPUT-PROCESS-ALL
015800         UNTIL SORT-WORK-AT-END = 'Y'.
015900
016000 RETURN-IT.
016100*    Gets each sorted record from the sort utility
016200*    return is logically like a read
016300      RETURN SORT-work
016400         AT END MOVE 'Y' TO SORT-work-AT-END
016500      END-RETURN.
016600
016700 SORT-OUTPUT-PROCESS-ALL.
016800      PERFORM SORT-OUTPUT-PROCESSING
016900      PERFORM RETURN-IT.
017100 SORT-OUTPUT-PROCESSING.
017200* Here you do the things you do in a
017300* regular program's main processing routine
017400* add totals, compute things
017500* write detail records, print lines, etc
017600* you could put control break check here
017700* this program just and writes the record out to "sorted file"
017900     MOVE SORT-WORK-RECORD TO SORTED-RECORD
018100     WRITE SORTED-RECORD.

6
この質問への回答には、COBOLのみを使用します。+1
syb0rg

5
ああ、パンチカードの新鮮な香り
Sklivvz

3
@EbenezerSklivvze-笑 私はかつてアセンブリー大学の教授が昔ながらのパンチカードについてクラスに話していたときにブックマークとして使用していたパンチカードを取り出しました。彼は十分に床を張っていました(1994年のことです:)。...私の同世代の多くは、これまで全体のデッキを見て考えてはいけない
DVK

30

OPはそれらをソートする方法を言ったことはありません...またはダブルスの彼の定義は何ですか。データ型を想定しますdoubleが、重複として解釈します。ここでJavaScriptを使用します。

var arr = [4, 6, 7, 4, 5, 9, 11, 7],
    flag = 1,
    result = [];

while( arr.length ) {
  for( var i = 0, index = 0; i < arr.length; ++i ) {
    if( arr[i] * flag < arr[index] * flag ) {
      console.log(arr[i], arr[index]);
      index = i;
    }
  }
  arr.splice(index, 1);
  flag = -flag;
}

結果:交互の順序 [4, 11, 4, 9, 5, 7, 6, 7]


4
「データ型をダブルと仮定しますが、重複として解釈します」。本当に天才だけがそのように考えるでしょう。ただ素晴らしい!
フェリペミオッソ

@FelipeMiosso ...私はあなただけの皮肉しているかどうかわからないんだけど、正直に言うと
Kiruse

1
ハハ...私は皮肉でした。本当にそう思う人がいることは知っています。とにかく...あなたの答えは壮大でした!たくさん笑った。
フェリペミオッソ

@FelipeMiosso喜んで笑ってくれました。;)
Kiruse

console.logすべて!
エミールヴィクストローム

28

PHP

エラー処理を備えた完全な実装を次に示します。それはどんなものにとっても最速ですarray of doubles

<?php
  function arraySorter($arr) {
      foreach ($arr as $el) {
          if ($el != 'double') {
              throw new Exception('Unexpected Error: Invalid array!');
          }
      }
      return $arr;
  }

  $arrayOfDoubles = Array('double', 'double', 'double', 'double', 'double');
  var_dump(arraySorter($arrayOfDoubles));
?>

25
do
{
}
while(next_permutation(begin(ar), end(ar)));

C ++の次の順列は、配列が並べ替えられている場合はtrueを返し、それ以外の場合(並べ替えられた後)はfalseを返します。したがって、配列を並べ替えてから、上記のようにdo-whileで使用することになっています(したがって、並べ替えられた配列に完全な円を作成します)。


+1 next_permutation答えに使用することを考えましたが、これは私が考えていたよりもずっときれいです。
jliv902

25

[正確な指示による解決]

関連する標準、マイクロプロセッサシステムのバイナリ浮動小数点演算の IEC 60559:1989 仕様をお読みください 。こちらで購入できます§5.10totalOrder述部の詳細の脚注では、次のことに注意してください。

totalOrderは、フォーマット内のすべてのエンコーディングに完全な順序付けを強制しません。特に、一方または両方のエンコーディングが非標準である場合のように、同じ浮動小数点表現の異なるエンコーディングを区別しません。

したがって、doubleをソートするコードを記述することは不可能であることがわかります。これはトリックの質問です。ハ、ハ、とても賢い!教授にコースをとても楽しんでいると伝えてください。

[編集:何が私を必要としないではない問題は全順序を要求していることを前提とします]


3
しかし、問題はダブルをソートすることでした。値が(合計)順序である必要はありません。たとえば、配列を正と負の2つの数値にソートできます。あなたは質問に二度とwereかれました。
塩奈

23

邪悪なJavaScript:

OP、すべてをお伝えしたくはありませんので、ご自身でユーザーから入力を得る方法を考えさせていただきます(ヒント:use prompt)。

それができたら、配列を渡してソートできる関数を次に示します。配列、配列の最小値、および増分を指定するだけです。

var sortDoubles = function (unsortedArray, minimumVal, increment) {
    var sortedArray = [];

    while (unsortedArray.length != sortedArray.length) {
        var index = unsortedArray.indexOf(minimumVal);
        if (index != -1) {
            sortedArray.push(unsortedArray[index]);
        }

        minimumVal += increment;
    }

    return sortedArray;
};

以下に、ユーザー入力の例[1.5、-3.5、12、10、-19.5]で実際に動作するフィドルを示します。


注:パフォーマンスが悪く、複雑で、当面の問題に対して拡張できないことは別として、OPが浮動小数点演算について知らない場合、これは特にイライラします。たとえば、ユーザー入力が[8.1, 5, -.8, 2.3, 5.6, 17.9]で、OPが単純な値(minimumVal=-.8およびincrement=.1)を選択した場合、プログラムは永久に実行されます。関連するノートでは、私は現在、このまさに問題のために機能していない2つのブラウザタブの誇りに思っている所有者です:)

注II:上記のコードを書いても嫌だと感じました。

注III: MWAハハハハ!


良いアイデア。あなたはまだプログラミングの初心者だったとき、あなたはクールだったに違いありません。
ピエールアラード14年

22

Javaで私が気に入っている実際の答えは次のとおりです。

printlnの前にLineを追加すると、配列がソートされます

Arrays.sort( array );

説明はありませんが、OPを混乱させますが、動作し、経験豊富なプログラマーから賛成を得ます。


別の同様の答え

Arrays.sort()を見てください

あいまいな正解を与えながら、OPに自分の研究を行うよう間接的に指示する。さらなる研究がなければ、OPは依然として混乱しています。また、リンクが古いドキュメントを指していることも気に入っています。


10
これは有用であり、したがって、下票に値する。
エモリー

11
ほとんどのStackOverflowの留守番の私のスタイルを説明し、「彼に漠然とした正解与えながら間接的に自分の研究を行うためにOPを伝える」:/
コーリー・ゴールドバーグ

7
「Arrays.sort()を見てください」...「プログラムでそれを使用する方法の例を入手できますか?」...素晴らしい。
SimonT

5
特に、私たちの謙虚なOPはおそらくクラスのためにソートを自分で書く必要があるため、Array.sort()は彼にとってまったく役に立たないので、+ 1。
ケビン

2
Ctrl + F->「プログラムでの使用例はありますか?」= 3結果。
Qix

21

JAVAのソーティング問題のための遺伝的アルゴリズム/モンテカルロ法

ソートの問題は長い間コンピューティングサイエンスで知られており、多くの優れたソリューションが見つかりました。近年、バイオコンピューティングに大きな進歩があり、生物学が問題をどのように解決するかを見ることは、難しい問題を解決するのに非常に役立つことが示されています。このソートアルゴリズムは、これらのアイデアを最大限に活用して、ソートの問題を解決するために使用します。アイデアはとてもシンプルです。順序付けられていない配列から始め、これがどのようにソートされているかを調べます。それに「ソート」のスコアを与えてから、ランダムなコンポーネントで配列を並べ替えます-両親のことをすべて知っていても子供がどのように見えるかが明確ではない生物学のように!これは遺伝的アルゴリズムの部分です。つまり、その配列の子孫を作成します。次に、子孫が親よりも適切にソートされているかどうかを確認します(別名生存者)。この場合、次の順列を構築するための開始点としてこの新しい配列を使用して、配列が完全にソートされるまで続きます。このアプローチの素晴らしい点は、配列が既に最初から少しソートされている場合、時間がかかることです!

package testing;

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;

import org.joda.time.DateTime;
import org.joda.time.Interval;


public class MonteCarloSort {
    private static final Random RANDOM  = new Random();


    public static void main(String[] args) {


        List doubleList = new java.awt.List();

        //  prompt the user to enter numbers
        System.out.print("Enter a number or hit return to start sorting them!");


        //  open up standard input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String input = null;

        //  read the numbers from the command-line; need to use try/catch !!!
        do{

            try {
                input = br.readLine();
            } catch (IOException ioe) {
                System.out.println("IO error trying to read a number!");
                System.exit(1);
            }


                try {
                    double d = Double.parseDouble(input);
                    doubleList.add(input);
                } catch (NumberFormatException e) {
                    if (!input.equals("")) System.out.println("Only numbers are allowed.");
                }

        } while (!input.equals(""));



        printCurrentListAndStuff(doubleList);

        while (isAscSorted(doubleList) < doubleList.getItemCount()){
            List newlist = createPermutation(doubleList);

            //genetic algorithm approach!
            if (isAscSorted(doubleList) <= isAscSorted(newlist)){
                //the new list is better, so we use it as starting point for the next iteration!
                doubleList = newlist;
                printCurrentListAndStuff(doubleList);

            }

        }

        System.out.println("done!");
    }

    private static void printCurrentListAndStuff(List doubleList){
        System.out.print("array sortedness is now " + isAscSorted(doubleList) + "(max = "+doubleList.getItemCount()+"): ");
        printList(doubleList);
        System.out.print("\n"); 
    }

    private static void printList(List doubleList){
        for (int i = 0; i < doubleList.getItemCount(); i++){
            String doubleVal = doubleList.getItem(i);
            System.out.print((i>0?", ":"") +doubleVal);
        }   
    }

    private static List createPermutation(List doubleList){
        int sortedness = isAscSorted(doubleList);
        if (sortedness == doubleList.getItemCount()) return doubleList;

        //we take the first non fitting item and exchange it by random
        int swapWith = RANDOM.nextInt(doubleList.getItemCount());

        //it makes no sense to swap with itself, so we exclude this
        while (swapWith == sortedness){
            swapWith = RANDOM.nextInt(doubleList.getItemCount());
        }

        List newList = new List();
        for (int i = 0; i < doubleList.getItemCount(); i++){
            if ( i == sortedness){
                newList.add(doubleList.getItem(swapWith));  
            }
            else if ( i == swapWith){
                newList.add(doubleList.getItem(sortedness));    
            }
            else{
                newList.add(doubleList.getItem(i));
            }

        }
        return newList;

    }

    /**
     * A clever method to get the "degree of sortedness" form a given array. the
     * bigger the number the more sorted it is. The given list is fully sorted if
     * the return value is the length of the list!
     * 
     * @param doubleList
     * @return a number
     */
    private static int isAscSorted(List doubleList){
        double current = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < doubleList.getItemCount(); i++){
            String doubleVal = doubleList.getItem(i);
            if (Double.parseDouble(doubleVal) >= current){
                current = Double.parseDouble(doubleVal);
            }
            else{
                return i;
            }
        }
        return doubleList.getItemCount();
    }

}

エクストラ

  • java.awt.Listの誤用
  • 一貫性のない、悪い変数の命名
  • バイオコンピューティングについての完全にでたらめな何とか
  • 説明における独創的で一貫性のない言語
  • モンテカルロは、単純な決定論的問題にとって明らかに間違ったツールです
  • 不要な輸入
  • おそらくより多くのグッズ...

このGAまたはモンテカルロをトロールの別のレベルと呼んでいますか?これはランダム化された山登りアルゴリズムだと思います。
塩奈

このプログラムを流行語の名前に関連付けることは意図的でしたが、「ランダム化された山登りアルゴリズム」のことも聞いたことはありません...そして広義では、GAとモンテカルロは明らかに間違っているほど遠くないと思います...
luksch

19

Python

a = map(float, raw_input().split())
print sorted(a, key=lambda x: int(x * 10**3) % 10 + int(x * 10**5) % 10)

3 番目と5 番目の小数点以下の合計で配列(リスト)をソートします。


5
残念ながら、これはすべてを削除してからlambda x:に置き換えることで簡単に修正されxます。それでも、初心者のコーダーはそれを決して知ることはないので、称賛に値します!
ジョーZ.

18

C ++

これは機能します...最終的に。

これが私のソートアルゴリズムです。

template <typename Iterator>
void sort (Iterator first, Iterator last)
{
    while (std::is_sorted (first, last) == false) {
        std::shuffle (first, last, std::random_device()) ;
    }
}

完全なプログラムは次のとおりです。

#include <algorithm>
#include <iostream>
#include <random>
#include <string>
#include <sstream>
#include <vector>

namespace professional 
{
    template <typename Iterator>
    void sort (Iterator first, Iterator last) ;

} // end of namespace professional

std::vector <double> get_doubles () ;

int main (void)
{
    std::vector <double> vecVals = get_doubles () ;
    professional::sort (std::begin (vecVals), std::end (vecVals)) ;

    for (const double d : vecVals) {
        std::cout << d << " " ;
    }

    std::cout << std::endl ;

    return 0 ;
}

template <typename Iterator>
void professional::sort (Iterator first, Iterator last)
{
    while (std::is_sorted (first, last) == false) {
        std::shuffle (first, last, std::random_device()) ;
    }
}

std::vector <double> get_doubles ()
{
    std::cout << "Please enter some space delimited doubles." << std::endl ;

    std::vector <double> vecVals ;

    std::string strLine ;
    std::getline (std::cin, strLine) ;

    std::stringstream ss (strLine) ;

    while (1) {
        double d = 0 ;
        ss >> d ;

        if (ss.bad () == false && ss.fail () == false) {
            vecVals.push_back (d) ;
        }

        else {
            break ;
        }
    }

    return vecVals ;
}

6
あなたの「アルゴリズム」には涙が出ました。
ネイト

ああ、これはアルゴリズムではありません。終了を許可されていないためです>:D
jmacedo

@joxnas、実際には非決定的でランダムなデバイスが利用できないシステムでは、ランダマイザーは実際には周期的かもしれません。次に、ランダマイザーによって許可された可能な順列のセットが、すべての可能な入力配列の長さ$ n $に対して可能な順列のセット$ S_n $を包含するかどうかに依存します。
バグ

ああ、LaTeXはTeX.SEとMath.SEでのみサポートされていたのを忘れていました。スヌーティーイタリックのシンボルを想像してください。
バグ

18

ここで、目を楽しませてください。

<?php
if (isset($_POST["doubleArray"]) === true) {
    $doubleValues = explode(":", $_POST["doubleArray"]);
    if (is_numeric($_POST["smallestDouble"]))
    {
        $sorted = $_POST["sorted"] . ":" . $doubleValues[$_POST["smallestDouble"]];
        unset($doubleValues[$_POST["smallestDouble"]]);
        $doubleValues = array_values($doubleValues);        
    }

    if (count($doubleValues) > 0) {
        $i = 0;
        foreach ($doubleValues as $value) {
            echo $i . " : " . $value . "<br />";
            $i++;
        }
        echo "Type the index of the smallest double value in the list: ";
    } else {
        echo "Sorted values" . $sorted;
    }
}else {
       echo "Enter double values separated by a colon (:)";

}
?>

<form name="form1" method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>" >
<?php
if (!isset($doubleValues)) {
    echo '<input type="text" name="doubleArray" /><br>';
} else {
    echo '<input type="hidden" name="doubleArray" value="' .
    implode(":", $doubleValues) .
    '" ><input type="text" name="smallestDouble" /><br>'.
    '<input type="hidden" name="sorted" value="' . $sorted . '" >';
}
?>
    <input type="submit" value="Submit">
</form>

このコードは配列を表示し、ユーザーに配列の最小の倍を入力するように要求します。次に、ソートされた番号のリストに番号を追加し、配列からdoubleを削除して、残りの配列番号を表示します。

*誤解:弱点ですが、OPはプログラムがユーザーにソートの支援を求めることを正確に期待していません。

*不正行為:ユーザーは実際の並べ替えを行うユーザーです。

*パフォーマンス:アレイのすべての数にはサーバーの往復が必要であり、ユーザーは最小数を手動で見つける必要があります。パフォーマンスはそれほど悪くなりません。

*容認できない:私はそれをカバーしたと思う。そして、それを再利用して幸運を祈ります。最悪の場合、ユーザーはコードの90%を取り除き、繰り返しループして最小値を見つけ、そのたびにそれらを削除することができます。これにより、効率の最も低いソートアルゴリズムの1つが得られます。

*創造的で悪:あなたは私に言う。


2
あなたは「あなたの目ごちそう」をしてくれPHPウーを与えると言う
Aidiakapi

3
「悪」は要件の一部でしたね。
Sylverdrag

17

Javascriptインテリジェントデザインソート

function sort(array){
    console.log("Someone more intelligent than you has already sorted this optimally. Your puny brain cannot comprehend it");
    return array;//I do believe that this is the fastest sorting algorithm there is!
}

6
クレジットが期限のあるクレジット:dangermouse.net/esoteric/intelligentdesignsort.html
wchargin

1
プログラミングコンテストでインテリジェントデザインを打ち負かす理由を理解していないのですか?
khebbie

12
@khebbieどうして?
コンラッドルドルフ

問題は、ユーザーが数字を入力するユーザーである場合、ユーザーは自分よりもインテリジェントになるということです。;)
d -_- b 14年

16

Python –必須 #1

このコードは、数字のプレフィックスツリーを作成し、再帰的に繰り返し処理することで、数値の昇順ではなく辞書編集順にダブルを並べ替えます。

class trie_node:
    def __init__(self):    
        self.chn = {}
        self.instances = 0
        for char in "0123456789.-+e":
            self.chn[char] = None
    def insert_number(self, number):
        if(number == ""):
            self.instances += 1
        else:
            self.chn[number[0]] = trie_node()
            self.chn[number[0]].insert_number(number[1:])

def get_sorted_array(node, number):
    array_to_return = [number] * node.instances
    for char in "0123456789.-+e":
        if node.chn[char] != None:
            array_to_return += get_sorted_array(node.chn[char], number + char)
    return array_to_return

def pcg_sort(arr):
    root = trie_node()

    for element in arr:
        root.insert_number(str(element))

    sarr = get_sorted_array(root, "")
    fsarr = []
    for element in sarr:
        fsarr.append(float(element))

    return fsarr

input_array = []

while True:
    number = raw_input("Enter a double (/ to end): ")
    if(number == "/"):
        print pcg_sort(input_array)
        break
    else:
        try:
            number = float(number)
            input_array.append(number)
        except ValueError:
            pass

それはn log n時間内に機能し、実際にはソートされたリストを保持する賢い方法ですが、残念ながらOPにとっては完全に間違ったことをします。


4
また、すべての数値が小数点の前に同じ桁数を持っている場合、それは実際に正しく動作するため、OPは入力の、言う、2, 1, 3, 8, 5
ジョーZ.

14

doubleの配列をソートします。Javaの場合:

public String sort(double[] input){
String s = "";
for(Double d:input){
    s+=Long.toBinaryString(Double.doubleToRawLongBits(d));
}
char[] chars=s.toCharArray();
Arrays.sort(chars);
s="";
for(char c:chars){
    s+=c;
}
return s;}

例えば:

[0.0, 1.5, 123]

の未ソートのバイナリ表現から

011111111111000000000000000000000000000000000000000000000000000100000001011110110000000000000000000000000000000000000000000000

エレガントに並べ替えられた

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111


11

ユーザーがdoubleの配列を入力し、プログラムがソートされた配列を出力するプログラムが必要です。コードを教えていただけますか?

@kealistごとに編集してください。コメントを付けて、分割がもっともらしいように見えるようにする方が良いと思います。でREBOLの ...

doubled-list: load ask "Input list of doubles: "

;-- The list is of doubles, so we have to undouble them before sorting
;-- Use MAP-EACH to create a new list with each element divided by two
undoubled-list: map-each num doubled-list [num / 2] 

;-- Note: We could also have sorted before we undoubled the numbers
print sort undoubled-list

彼らは実際にダブルが何であるかを知らないという考えを演じ、ダブルのリストは2を掛けた数の束であると信じるかもしれません。


6
入力が既に2倍になっているので、それらを半分にする必要があるかもしれません!
キーラリスト

@kealist私は考えましたが、これは「倍増」が起こっているという考えに基づいています。[2 * num]を持っていると少し良くなると思います。
レブム博士13

10

質問を故意に誤解しています:

再帰的アプローチの使用:

def recsort(array):
    "Recursive sort"
    if array:
        for j, i in enumerate(array):
            for l1 in recsort(array[:j]):
                for l2 in recsort(array[j+1:]):
                    yield i + l1 + l2
                    yield i + l2 + l1
    else:
        yield ''

for p in recsort(raw_input("Array:")):
    print p

ソートされた配列は、配列内のあらゆるタイプのデータ、あらゆる種類のソート順、入力のあらゆる種類のセパレーターについても、ある時点で出力されることが保証されているため、このアプローチは非常に柔軟です。主な欠点は、大きな配列では少し遅いことですが、マルチスレッドで簡単に解決できます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.