整数リストを並べ替える


22

チャレンジ

本当に簡単です。数字のリストを並べ替えます。

詳細

組み込みのソート関数/ライブラリ/など(list.sort()Pythonなど)を使用せずに、数値のリストを昇順でソートする必要があります。

入出力は、人間が判読できる限り、選択した任意の方法で実行できます。

標準の抜け穴はいつものように禁止されています。

バイト単位の最短コードが優先されます。

使用したソート方法(バブル、挿入、選択など)を説明/リストする必要があります

入力には重複は含まれません。

サンプル入出力

入力: 99,-2,53,4,67,55,23,43,88,-22,36,45

出力: -22,-2,4,23,36,43,45,53,55,67,88,99

注:数字のリストの並べ替えのほぼ正反対


8
これが重複していない場合は非常に驚いていますが、確認する時間がありません。とにかく、「組み込みソート関数」をより適切に定義する必要があります。すべての値にインデックスを付ける関数を使用できますか?[7 2 4 1] -> [4 2 3 1]。また、CSVリストを括弧内に含めることはできますか?また、特定の入力形式は一部の言語に非常に適しており、他の言語には不適切です。これにより、入力の解析は一部のサブミッションでは大きな部分を占め、他のサブミッションでは不要になります。
スチューイーグリフィン

1
@StewieGriffin私は多くのソートの課題を見てきましたが、基本的な整数リストだけをソートすることはありません。一部の言語では簡単で、他の言語でははるかに困難な多くの課題があります。
ミシェルフランシスブスティロス

これ非常に似ていますが、O(Nlog(N))制限があります。
ネイサンメリル

2
この質問に非常に密接に関連していますが、ここでのいくつかの答え(たとえば、デニスの範囲フィルタリング)は入力を整数にする必要があるため、私はだましとして閉じることに投票しません。
ピーターテイラー

関連:youtube.com/user/AlgoRythmics/videos —ハンガリーの踊りを通してアルゴリズムの並べ替えを教えるYoutubeチャンネル!
sergiol

回答:


23

05AB1E、2バイト

コード:

ϧ

Jelly answerと同じアルゴリズム。入力のすべての順列を計算し、最小の順列をポップアウトします。

オンラインでお試しください!


より効率的な方法は次のとおりです。

E[ß,Ž

選択ソートを実行します。CP-1252エンコードを使用します。

オンラインでお試しください!


6
私は誰が2以上になっ表示されていないとして、一時的にこれを受け入れる
Michelfrancis Bustillos

6
@MichelfrancisBustillosも、もしそうなら、それはビルトインでしょう?
破壊可能なレモン

ちょっと前に05AB1E / Baseを見て、それからこれを見ました。一致?
facepalm42

17

ゼリー、3バイト

Œ!Ṃ

これにより、入力リストのすべての順列が生成され、次に辞書的に最小の順列が選択されます。とても効率的です。

独立して同じアイデアを持っていた@Adnanの功績。

オンラインでお試しください!


ゼリー、4バイト

ṂrṀf

これにより、リストの最小値から最大値までの範囲が構築され、元のリストに存在しない範囲要素が破棄されます。これは技術的にはバケットのソートであり、非常に小さなバケットがあります。この特定のバリアントの名前は知りません。

オンラインでお試しください!

使い方

ṂrṀf  Main link. Argument: A (list/comma-separated string)

Ṃ     Compute the minimum of A.
  Ṁ   Compute the maximum of A.
 r    Yield the inclusive range from the minimum to the maximum.
   f  Filter the range by presence in A.

O(非常に)。多くのソートを使用します。
mbomb007

22
O.非常に使用します。多くの並べ替え。驚いた!(ごめん、何?)
デニス

私はアルゴリズムの複雑さに長けていません、これはO(n!)でしょうか?
FlipTack

2
@FlipTackどちらも私ではありません。nがあるので、おそらく少し高いです長さnの配列。
デニス

1
最小の辞書を選択するのは、n!のそれぞれなのでO(n * n!)です。配列は順番に比較する必要があり、辞書比較はO(n)です。世代は(N * N!)Oで行うことができ、効率的に行う場合だけでなくので、私はアルゴリズムがある賭けと同じようにだけはO(n * n個!)も実装されている場合
PunPun1000

12

Python、46 45バイト

lambda l:[l.pop(l.index(min(l)))for _ in 1*l]

単純な選択ソート。


4
l[:]可能性1*l
feersum

9

Brachylog12 7バイト

p.'(s>)

これは順列ソートを使用しますが、これは明らかにひどいですが、ちょっとPythよりも短いです!

説明

p.       Unifies the output with a permutation of the input
  '(  )  True if what's inside the parentheses cannot be proven, else backtrack and
         try with another permutation of the input.
    s    Take an ordered subset from the output
     >   True if the first element is bigger than the second (hence not sorted)
         We don't need to check that the subset is 2 elements long because > will be false
         for inputs that are not 2 elements long anyway

9

Haskell、38バイト

h%t|(a,b)<-span(<h)t=a++h:b
foldr(%)[]

バイナリ機能%新しい要素の挿入hソートされたリストにt分割することによりt、プレフィックスへaの要素<hと接尾辞bの要素の>h中に、そしてスティックhそれらの間。

次に、操作foldr(%)[]は、入力リストから要素を繰り返し挿入することにより、空からソート済みリストを作成します。

これは、直接再帰実装よりも1バイト短い

f(h:t)|(a,b)<-span(<h)$f t=a++h:b
f x=x

41バイトの別の戦略:

f[]=[]
f l|x<-minimum l=x:f(filter(/=x)l)

したがって、これはen.wikipedia.org/wiki/Insertion_sortであり%内部ループを挿入foldrし、外部ループとして適用します。
ピーターコーデス

8

JavaScript(ES6)、51バイト

a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0)

各ループは、これまでに発見されていない最小の番号を見つけます。


これを呼び出すと、[1,2,3,4,5,4,3,2,1]プロデュース[1, 2, 3, 4, 5, Infinity, Infinity, Infinity, Infinity]
ベンジャミングリュンバウム

@BenjaminGruenbaum "入力には重複が含まれません。"
ニール

私は別のアプローチとまったく同じ:バイト持つ
バリント

実際には、1バイト少ない
バリント


8

Python 2、34バイト

def f(s):m=min(s);print m;f(s-{m})

入力をセットとして受け取り、要素を昇順で出力し、エラーで終了します。

クリーンターミネーションは41バイトで実行できます。

def f(s):
 if s:m=min(s);print m;f(s-{m})

または

l=input()
while l:m=min(l);print m;l-={m}

入力は、39バイトのリスト、またはPython 3.5では38バイトのリストとして取得できます。

def f(l):m=min(l);print m;f(set(l)-{m})
def f(l):m=min(l);print(m);f({*l}-{m})

これはen.wikipedia.org/wiki/Selection_sortでm=min(s)/ s - (m)を内側のループとして使用して、ソートされていない要素からminを検索して削除し、外側として再帰を使用します。
ピーターコーデス

8

Haskell、42 41 38バイト

f u=filter(`elem`u)[(minBound::Int)..]

すべての整数(私のマシンでは64ビットに署名)をループし、にある整数を保持しuます。もちろん、妥当な時間内に終了しません。

以前のバージョンはループしまし[minimum u..maximum u]たが、同じ最悪の実行時間を持っています。

編集:@xnorはバイトを保存しました。ありがとう!


filter1つ短いです:f u=filter(`elem`u)[minimum u..maximum u]
xnor

なんとブルートフォース![minimum u..]型の理由で機能しませんか?
-xnor

@xnor:そう思う。を呼び出すとf [1,3,0]、要素はデフォルトIntegerでバインドされていないタイプになりますので、..終わりはありません。のように呼び出す必要がある場合f ([1, 3, 0]::[Int])は、タイプアノテーションをバイトカウントに含める必要があります。
-nimi

複数回出現する要素をどのように検出しますか?
feersum

1
@feersum:ありませんが、課題には「入力に重複は含まれません」とあります。
nimi

8

Oracle SQL 11.2、205バイト

WITH s AS(SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p||','||e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1);         

ゴルフをしていない

WITH 
s AS  -- Split the string using ',' as separator
(     -- ||'' cast the xml type to varchar
  SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))
),  
v(p,f) AS  -- Recursive view : p = sorted string, f last number added
(
  SELECT e,e FROM s -- use each number as seed
  UNION ALL         -- only add a number if it is > the last added
  SELECT p||','||e,e FROM v,s WHERE e+0>f  -- +0 is needed to compare int and not strings
)  
-- The valid string has the same length as the input
SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1)          

並べ替え方法については、ORDER BYわからないので、忘れてしまったことを確認しました。


私はSQLをほとんど知らないが、あなたのコメントから、あなたは残りのソートされていない要素から最小または最大を選択し、ソートされたリストの最後にそれを追加していると思う。これにより、これはen.wikipedia.org/wiki/Selection_sortになります。
ピーターコーデス

8

x86-16マシンコード(BubbleSort int8_t)、20 19バイト

x86-64 / 32マシンコード(JumpDownSort)21 19バイト

変更ログ:

  • lodsb/ pedegの@ ped7gに感謝しcmp [si],al、それを私が見ていたポインターのインクリメント/リセットと組み合わせます。必要なしal/ahため、より大きな整数にほぼ同じコードを使用できます。

  • 新しい(ただし関連する)アルゴリズム、多くの実装の変更:Bubbly SelectionSortは、バイトまたはdwordの小さなx86-64実装を許可します。x86-16の損益分岐点(バイトまたはワード)。また、BubbleSortが持っているsize = 1のバグを回避します。下記参照。

  • 新しい最小値を見つけるたびに、スワップを使用したBubbly Selection Sortが既知のアルゴリズムであるJumpDown Sortであることがわかりました。「バブルソート:考古学的アルゴリズム分析」で説明されています(つまり、バブルソートは吸ったにもかかわらず、どのように普及したのか)。


8ビットの符号付き整数をインプレースでソートします。(符号なしだけ変更、同じコードの大きさjgejae)。重複は問題ではありません。16ビットの8回転(メモリ宛先を使用)を使用してスワップします。

バブルソートはパフォーマンスを低下させるさせますが、マシンコードに実装する最小の1つであることを読みました。これは、隣接する要素を交換するための特別なトリックがある場合に特に当てはまるようです。これはほとんど唯一の利点ですが、(実際の組み込みシステムでは)非常に短いリストに使用するのに十分な場合もあります。

スワップなしの早期終了を省略しました。ウィキペディアの「最適化された」BubbleSortループを使用して、最後のn − 1により、n番目の時間を、その外側のループカウンタは、上部内側のループのためにバインドされています。

NASMリスト(nasm -l /dev/stdout)、またはプレーンソース

 2 address  16-bit       bubblesort16_v2:
 3          machine      ;; inputs: pointer in ds:si,  size in in cx
 4          code         ;; requires: DF=0  (cld)
 5          bytes        ;; clobbers: al, cx=0
 6                       
 7 00000000 49               dec     cx          ; cx = max valid index.  (Inner loop stops 1 before cx, because it loads i and i+1).
 8                       .outer:                 ; do{
 9 00000001 51               push    cx          ;   cx = inner loop counter = i=max_unsorted_idx
10                       .inner:                 ;   do{
11 00000002 AC               lodsb               ;     al = *p++
12 00000003 3804             cmp     [si],al     ;     compare with *p (new one)
13 00000005 7D04             jge     .noswap
14 00000007 C144FF08         rol     word [si-1], 8    ; swap
15                       .noswap:
16 0000000B E2F5             loop    .inner      ;   } while(i < size);
17 0000000D 59               pop     cx          ;  cx = outer loop counter
18 0000000E 29CE             sub     si,cx       ;  reset pointer to start of array
19 00000010 E2EF             loop    .outer      ; } while(--size);
20 00000012 C3               ret

22 00000013  size = 0x13 = 19 bytes.

cx内側のループの周りのプッシュ/ポップは、それが実行されることを意味しますcx = outer_cxで0までします。

rol r/m16, imm88086命令ではなく、後で追加された(186または286)が、これは8086コードではなく、16ビットx86であることに注意してください 。SSE4.1の場合phminposuwが役立つは、それを使用します。

この32ビットバージョン(8ビット整数で動作しますが、32ビットポインター/カウンターを使用)は20バイトです(オペランドサイズのプレフィックスは rol word [esi-1], 8

バグ:size = 1はsize = 65536として扱われます。これは、cx = 0で外側のdo / whileに入ることを妨げるものがないためです。(通常jcxzはそのために使用します。)しかし、幸いなことに、19バイトのJumpDown Sortは19バイトであり、その問題はありません。


オリジナルのx86-16 20バイトバージョン(Ped7gのアイデアなし)。スペースを節約するために省略されています。説明付きの編集履歴を参照してください。


性能

部分的に重複するストア/リロード(メモリ宛先ローテーションで)により、最新のx86 CPU(ストア内のAtomを除く)でストア転送が停止します。高い値が上向きにバブリングしている場合、この余分なレイテンシは、ループで伝達される依存関係チェーンの一部です。ストア/リロードはそもそも吸い込みますが(Haswellでの5サイクルのストア転送レイテンシーなど)、転送ストールは13サイクル以上になります。順不同の実行では、これを隠すのが困難になります。

関連項目:Stack Overflow:同様の実装で、スワップが不要なアーリーアウトのこのバージョンの文字列ソートするためのバブルソート。スワップにxchg al, ah/ mov [si], axを使用します。これは1バイト長く、一部のCPUで部分レジスタストールを引き起こします。(ただし、値を再度ロードする必要があるmemory-dst rotateよりも優れている場合があります)。私のコメントにはいくつかの提案があります...


x86-64 / x86-32ジャンプダウンソート、19バイト(int32_tをソート)

x86-64 System V呼び出し規約を使用してCから呼び出し可能
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (戻り値= max(array []))。

これはhttps://en.wikipedia.org/wiki/Selection_sortですが、min要素の位置を覚える代わりに、現在の候補を配列に入れ換えます。min(unsorted_region)を見つけたら、通常の選択ソートのように、ソートされた領域の最後に格納します。これにより、ソートされた領域が1つ増えます。(コードでrsiは、ソートされた領域の末尾の1つを指します。lodsdそれを進めmov [rsi-4], eax、最小値を格納します。)

ジャンプソートという名前は、バブルソート:考古学的アルゴリズム分析で使用されます。私のソートは本当にジャンプアップソートだと思います。なぜなら、高い要素は上にジャンプし、最後ではなく下をソートしたままになるからです。

この交換設計により、配列の未ソート部分がほとんど逆ソートの順序になり、後に多くのスワップが発生します。(大きな候補から始めて、下位の候補を見続けるため、スワップを続けます。)要素を他の方向に動かしても、「バブル」と呼んでいます。要素を移動する方法も、後方挿入ソートのようなものです。それを実際に見るには、GDBを使用display (int[12])bufし、内部loop命令にブレークポイントを設定して、c(続行)。Returnキーを押して繰り返します。(「display」コマンドは、ブレークポイントにヒットするたびにGDBに配列全体の状態を出力させます)。

xchgmemには暗黙のlock接頭辞があり、これにより余分な時間がかかります。おそらく、効率的なロード/ストアスワップよりも1桁遅くなります。xchg m,rSkylakeの23cスループットごとに1つですが、効率的なswap(reg、mem)のtmp regでload / store / movはクロックごとに1つの要素をシフトできます。loop命令が高速で、内部ループをそれほどボトルネックにしないAMD CPUの比率はより悪いかもしれませんが、スワップが一般的であるため(そしてソートされていない領域が小さくなるにつれてより一般的になるため、ブランチミスは依然として大きなボトルネックになります) )。

 2 Address               ;; hybrib Bubble Selection sort
 3        machine         bubblyselectionsort_int32:   ;; working, 19 bytes.  Same size for int32 or int8
 4        code               ;; input: pointer in rsi, count in rcx
 5        bytes              ;; returns: eax = max
 6                       
 7                           ;dec  ecx           ; we avoid this by doing edi=esi *before* lodsb, so we do redundant compares
 8                                               ; This lets us (re)enter the inner loop even for 1 element remaining.
 9                       .outer:
10                           ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx])
11 00000000 56               push   rsi
12 00000001 5F               pop    rdi
13                           ;mov    edi, esi     ; rdi = min-search pointer
14 00000002 AD               lodsd
16 00000003 51               push   rcx          ; rcx = inner counter
17                       .inner:                   ; do {
18                           ; rdi points at next element to check
19                           ; eax = candidate min
20 00000004 AF               scasd                 ; cmp eax, [rdi++]
21 00000005 7E03             jle  .notmin
22 00000007 8747FC           xchg   [rdi-4], eax   ; exchange with new min.
23                         .notmin:
24 0000000A E2F8             loop  .inner          ; } while(--inner);
26                           ; swap min-position with sorted position
27                           ; eax = min.  If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere
28 0000000C 8946FC           mov    [rsi-4], eax
29 0000000F 59               pop   rcx           ; rcx = outer loop counter = unsorted elements left
30 00000010 E2EE             loop  .outer        ; } while(--unsorted);
32 00000012 C3               ret

34 00000013 13           .size: db $ - bubblyselectionsort_int32
           0x13 = 19 bytes long

以下のための同じコードサイズint8_t:使用lodsb/ scasbAL、および変更[rsi/rdi-4]-1。同じマシンコードは、8/32ビット要素に対して32ビットモードで機能します。8/16ビット要素の16ビットモードは、オフセットを変更して再構築する必要があります(16ビットアドレッシングモードは異なるエンコードを使用します)。しかし、まだ19バイトです。

先に進むdec ecx前に読み込んだ要素と比較することで、初期を回避します。外側のループの最後の繰り返しで、最後の要素をロードし、それがそれ自体よりも小さいかどうかを確認してから実行されます。これにより、BubbleSortが失敗する(size = 65536として扱う)size = 1で動作することができます。

this callerを使用してこのバージョンを(GDBで)テストしました: オンラインで試してみてください!。これをTIOで実行できますが、もちろんデバッガーや印刷はできません。それでも、それ_startを呼び出すものはexit-status = maximum element = 99で終了するため、動作することがわかります。


内部ループのループ状態を改善する余地があるかもしれませんが、多くのバイトを使用しているようです。プッシュ/ポップcxloopて両方に使用できますか?インデックスをゼロまでカウントダウンするために、配列の後ろから前に逆方向にループするかもしれませんか?(bxソートされた部分がループの終わりにあるため、増分します)。
ピーターコーデス

1
19Bになりましたが、多くの変更を加えて、regも入力します(いくつかの変更はおそらく必要ないかもしれませんが、いじくり回していたので、以前の実験からそのまま残っていました)...答えとして、pastebinで確認できます:pastebin.com/0VMzdUjj
Ped7g

@ Ped7g:いいね!私sub si, cxはインデックスの代わりにポインタを使用して外側のループの一部と考えていましたが、lodsb/ については考えていませんでしたcmp [si], allodsw/ dec si、またはlodsb/ xchg al,ahを設定することを検討していましたcmp ah,al
Peter Cordes

@ Ped7g:お使いのバージョンではが必要ですcld。または、呼び出し規約の一部にすることができます。AFAIKは、DFクリアされたことは16ビット呼び出し規約の標準的な部分ではなく、32/64のみです。それとも、ブートローダーでそれを想定できないというだけですか?しかし、カスタムレジスタ呼び出し規約では、これは関数と同じくらいコードフラグメントなので、DF = 0を必要としないのは確かです。(必要に応じてES = DSを使用するので、それがより便利な場合ではscasbなく、代わりに使用できlodsbます。)
Peter Cordes

1
@ Ped7g:16ビットの規則についてはわかりませんが、DFがクリアされたと常に想定できるとは限らないということしか知りません。しかし、それは主にブートローダーのコンテキストにあると思います。私は実際のDOSで書いたものを実行したことがありません。私はAtari Mega 4 STe(68000/68020)、次にLinux(Pentium MMX)を使用していたので、SOの質問で喉がぶつかるまで16ビットx86を完全に避けることができました。
ピーターコーデス

6

C、72バイト

i,j;a(int*l,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];}

バブルソート。最初の引数は配列へのポインターであり、2番目の引数は配列の長さです。gccで動作します。


これには、読みやすいように、未ゴルフバージョンが本当に必要です。三項演算子が開始/終了する場所を追跡するのは本当に難しいです。
ピーターコーデス

5

MATL11 10バイト

Y@t!d0>AY)

入力のすべての順列の非常に非効率的な検査。

オンラインでお試しください!

説明

        % Implicitly grab input array
Y@      % Compute all permutations (each permutation as a row)
t       % Duplicate this matrix
!d      % Transpose and take the differences between the values
0>A     % Find the rows where all differences are > 0
Y)      % Return only the row where this is true
        % Implicitly display the result

5

ルビー、40バイト

選択ソート。無名関数; 引数としてリストを取ります。

->a{r=[];r<<a.delete(a.min)while[]!=a;r}

4

Python、120バイト

def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a]

これはおそらく最短の答えではありませんが、このアルゴリズムはここに属していると感じています。整数のリストを使用して呼び出すと、ソートされた方法で標準出力に出力されます。私はあまりにも大きな数でそれを試していないだろう。


素敵な最初の投稿!そして素敵なユーザー名。:P
Rɪᴋᴇʀ

4

MIPS、68バイト

少し前に、単純な最適化されていないバブルソートの実装を書きました。バイト数はで始まり、loopで終わりli $v0, 10ます。リストアドレスとリストの長さが既にメモリ内にあると仮定しています。

 Address    Code        Basic                     Source

0x00400000  0x3c011001  lui $1,4097           5    main:   la      $s0, list       # List address
0x00400004  0x34300000  ori $16,$1,0               
0x00400008  0x2411000a  addiu $17,$0,10       6            li      $s1, 10         # List length
0x0040000c  0x24080000  addiu $8,$0,0         8    loop:   li      $t0, 0          # swapped
0x00400010  0x24090001  addiu $9,$0,1         9            li      $t1, 1          # for loop "i"
0x00400014  0x1131000b  beq $9,$17,11         11   for:    beq     $t1, $s1, fend  # break if i==length
0x00400018  0x00095080  sll $10,$9,2          13           sll     $t2, $t1, 2     # Temp index, multiply by 4
0x0040001c  0x01505020  add $10,$10,$16       14           add     $t2, $t2, $s0   # Combined address
0x00400020  0x8d4b0000  lw $11,0($10)         15           lw      $t3, 0($t2)     # list[i]
0x00400024  0x8d4cfffc  lw $12,-4($10)        16           lw      $t4, -4($t2)    # list[i-1]
0x00400028  0x21290001  addi $9,$9,1          18           addi    $t1, $t1, 1     # i++
0x0040002c  0x016c082a  slt $1,$11,$12        20           ble     $t4, $t3, for   # if list[i-1] > list[i]
0x00400030  0x1020fff8  beq $1,$0,-8               
0x00400034  0xad4bfffc  sw $11,-4($10)        21           sw      $t3, -4($t2)    # swap and store
0x00400038  0xad4c0000  sw $12,0($10)         22           sw      $t4, 0($t2)     
0x0040003c  0x24080001  addiu $8,$0,1         23           li      $t0, 1          # swapped=true
0x00400040  0x08100005  j 0x00400014          24           j       for
0x00400044  0x20010001  addi $1,$0,1          26   fend:   subi    $s1, $s1, 1     # length--
0x00400048  0x02218822  sub $17,$17,$1             
0x0040004c  0x1500ffef  bne $8,$0,-17         27           bnez    $t0, loop       # Repeat if swapped==true
0x00400050  0x2402000a  addiu $2,$0,10        29           li      $v0, 10        
0x00400054  0x0000000c  syscall               30           syscall

今、私はx86で水から吹き飛ばされるのを待ちます...


1
swapped=trueアーリーアウトチェックを省略して、アレイサイズに基づいてカウントダウンすることができます。8ビット整数をソートする20バイトのx86-16バージョンをご覧ください。ある時点で32ビット整数をソートする通常の32ビットまたは64ビットのx86バージョンを作成することもできますが、16ビットモードの8ビット整数はx86のスイートスポットのようなものです。
ピーターコーデス

4

Awk、66バイト

{b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i}

awkの配列は辞書のようなもので、C配列のようなものではありません。インデックスは不連続にすることができ、必要に応じて成長します(作成されます)。そこで、a各行をキーとして、入力用の配列を作成します。そして、最小値と最大値を保存します。次に、minからmaxにループし、に存在するすべてのキーを出力しaます。bの繰り返し使用を避けるためです$0


4

Python 3、91 62 47バイト

def f(z):
 while z:m=min(z);z.remove(m);yield m

ゴルフの手助けをしてくれたwnnmawSeeqに感謝します。

引数zはリストでなければなりません。これは、選択ソートの変形です。

Pythonがどのように実装されているのかわからないので、どのようにminスタックするのbuilt-in sorting functionsかわかりませんmin。うまくいけば、この解決策はまだ大丈夫です。コメントやPPCGチャットでのゴルフの提案は大歓迎です。


使用しているソートのタイプを必ず明記してください。
ミシェルフランシスブスティロス

@MichelfrancisBustillos私はこれがどんなアルゴリズムであるかを正直に忘れました。選択ソートかもしれませんか?
Sherlock9

1
好奇心から、リストを直接取得しないのはなぜですか?質問は、オープンな入力フォーマットを許可しています
-wnnmaw

1
@wnnmawそれをやった、私はそれを書きましたが、それを投稿するのを忘れました。リマインダーをありがとう:D
Sherlock9

うーん、多分def f(z):\nwhile z:m=min(z);z.remove(m);yield m
-seequ

4

MATL、11バイト

`t4#X<2#)tn

オンラインでお試しください!

これは、次の手順(On 2))でソートします。

  1. 配列の最小値を取得します。
  2. その値を配列から削除し、後で表示するために保存します。
  3. 空になるまで、残りの配列に同じ手順を適用します。
  4. 取得した順にすべての番号を表示します。

MATLはスタックベースです。残りの値を持つ配列は、スタックの最上部に保持されます。削除された値は順番に以下になります。プログラムの最後に、これらすべての値が表示されます。上部の配列も表示されますが、空なので表示されません。

`        % Do...while loop
  t      %   Duplicate. Implicitly take input in the first iteration
  4#X<   %   Compute index of mininum of the array
  2#)    %   Push the minimum, and then the array with remaining entries
  tn     %   Duplicate and push number of elements, to be used as loop condition
         % Implicitly end do...while loop
         % Implicitly display stack contents

3

Pyth- 15 13 11 10バイト

@ジャクベのおかげで2バイト節約できました。

ボゴソート。

f!s>VTtT.p

こちらからオンラインでお試しください

h重複がないことが保証されているので、必要ありません。


@ジャクベバカだと思う
マルティセン

@Sueverで答えたように、OPごとに重複がないことが保証されています。
マルティセン

ごめんなさい!その点を見逃した。
-Suever

3

真剣に、6バイト

,;l@╨m

オンラインでお試しください!

これは、他の多くの回答と同じことを行います。すべての順列を生成し、最小値を選択します。以下のソリューションで作業しているときにこれが機能することを忘れていました。

説明:

,;l@╨m
,;l@    push len(input), input
    ╨m  minimum permutation

真剣に、25バイト(非競合)

シャッフルコマンドのバグで修正したばかりでなければ、これは競争力のあるものになります。

,1WX╚;;pX@dXZ`i@-0<`MπYWX

オンラインでお試しください! これにより、これまでで最高のソートアルゴリズムであるBogosortが実装されます。

説明:

,1WX╚;;pX@dXZ`i@-0<`MπYWX
,                          get input
 1W                    WX  do-while:
   X                         discard
    ╚                        shuffle
     ;;                      dupe twice
       pX@dX                 remove first element of first dupe and last element of second dupe
            Z                zip
             `i@-0<`MπY      test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0)

3

MATL、17 16バイト

@LuisMendoのおかげで1バイトを節約してnull配列を作成

vTbtX<-QI$(f8M+q

バケットの並べ替え。2 31 -1 より大きい範囲で試さないでください。

オンラインでお試しください!

説明

v                  % push an empty array
 T                 % push 1
  b                % bubble the input array up to the top of the stack
   t               % duplicate it
    X<             % find the minimum
      -            % subtract min from input array
       Q           % and increment to adjust for 1-based indexing
        I$(        % resulting array used as indices of empty array 
                   % (the [] way up at the top) that are assigned 1 (from T)
           f       % find the nonzero indices
            8M     % magically retrieve the 4th previous function input :/
                     (aka, the min input array value)
              +    % add it to the indices
               q   % and decrement

TIL:

  • You can initialize an empty array in MATL using [] and grow it, just like in MATLAB
  • How to use ( for assignment indexing
  • How to use the M automatic clipboard

New day, new TIL:

  • vertcat magically creates an empty array when there's nothing on the stack to concatenate

Add to your TIL: an initial [] can be replaced by v. This is because the default number of inputs of v is the number of elements in the stack
Luis Mendo

@LuisMendo Sooo... if there is one array on the stack... ? Investigating.
beaker

Then it does nothing. Think of it as vertcat(STACK{:})
Luis Mendo


3

R, 68 Bytes

Takes input i and outputs o which is the sorted list.

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
o

Explanation:

o<-i                      # Defines output as o
 for(j in 1:length(i)){   # Initializes loop for length of input
  x<-(i-min(i))==0        # Generates logical vector by finding the value 0 
                          # of input less the minimum of input. 
   o[j]<-i[x]             # Puts the smallest value at position j
    i<-i[!x]              # Removes the smallest value from input
      }                   # Ends loop
       o                  # Returns sorted list

Avoiding the permutations means it can sort large lists relatively quickly. The "trick" is that subtracting the smallest value from the input leaves a single 0 that determine both the smallest value and the position of the smallest value.


3

Java 8, 112 92 bytes

Here is another selection sort. The input is a List t of integers and the sorted output is printed to standard out.

t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));}

Update

  • -20 [16-08-21] Used a lambda

Hi Nonlinear, and welcome to PPCG!
isaacg

Welcome to Programming Puzzles & Code Golf! It appears your code assumes a variable t to exist, which makes it a snippet; we require submissions to be full programs or functions which utilize our default I/O formats. We also require imports to factor into the byte count. Let me know if you have any questions!
Alex A.

Thanks for the resources! I modified my answer to be a function and to include the import.
NonlinearFruit

2

Retina, 95

Modified bubble sort. I suspect there are much better ways to do this, even without the retina sort builtin.

-\d+
$*n
\d+
$*11
+`(1+) (n+)
$2 $1
+`\b(n+) (\1n+)|(1+)(1+) \3\b
$2$3 $1$3$4
1(1*)
$.1
n+
-$.&
  • Stage 1 - convert -ve integers to unary with n as the digit; drop the - signs.
  • Stage 2 - convert +ve and zero integers to unary with 1 as the digit; add 1 to each one, so that zero is represented by 1.
  • Stage 3 - Move all -ves to the front.
  • Stage 4 - Sort: move all -ves with the largest magnitude (i.e. smallest numerical) ahead of higher -ves. Move smaller +ves ahead of larger +ves.
  • Stage 5 - Remove 1 from, and convert +ve unaries back to decimal.
  • Stage 6 - convert -ve unaries back to decimal, including sign.

Try it online.



@LeakyNun That doesn't sort the last element in the list.
mbomb007

@mbomb007 right, never mind.
Leaky Nun

2

Ruby, 22 bytes

A quick permutation sort. Runs in O(n!) space and time.

->a{a.permutation.min}

2

Clojure, 73 35 bytes

Bogosort :)

#(if(apply < %)%(recur(shuffle %)))

Earlier version:

#(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%)

Reduces to a sorted list r by splitting it into "smaller than i" and "larger than i" parts. I guess this is the insertion sort.


Nice! I did not know you could recur on an anonymous function. Also didn't know about shuffle.
Matias Bjarland

2

Ruby, 26 24 bytes

Selection sort, similar to Value Ink's answer, but using a different approach for greater golfiness.

According to the specification: "Input/output can be done in any method you choose, as long as it is human readable". I think this fits the description, output is an array of arrays with a single element.

->l{l.map{l-l-=[l.min]}}

example:

->l{l.map{l-l-=[l.min]}}[[2,4,3,1]]
=> [[1], [2], [3], [4]]

2

Java 7, 106 104 bytes

void a(int[]a){for(int b=a.length-1,d=0,c=0,e;d<b*b;c=++d%b)if(a[c]>a[c+1]){e=a[c];a[c++]=a[c];a[c]=e;}}

Here's a good ole bubble sort. The function parameter is modified in place so I don't have to return anything. Still trying to squeeze some bytes out of this so I can beat the java lambda that someone posted.

-1 byte thanks to Geobits for pointing out that normal swapping beats xor'ing
-1 byte thanks to Leaky Nun for pointing out that I can move all the int declarations into the for-loop

Try it online!


2

Ruby, 22 bytes

->a{[*a.min..a.max]&a}

Builds an array out of the range between the minimum and maximum elements of the input array. Returns the intersection between the two arrays.


I guess that's a kind of en.wikipedia.org/wiki/Counting_sort.
Peter Cordes

@PeterCordes That was kinda the point
dkudriavtsev

The question asks you to describe what kind of sort it is, so I thought it was useful to link to the well-known algorithm as well as just describing what it actually does.
Peter Cordes

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