Reliably Broken Sort

Question

Given a list of positive integers that contains at least 3 distinct entries, output a permutation of that list that isn't sorted in ascending or descending order.

Examples

1,2,3 -> 2,1,3 or 3,1,2 or 1,3,2 or 2,3,1
1,2,3,3 -> 2,1,3,3 or 3,1,2,3 or 1,3,2,3 etc..

Thanks @Arnauld and @NoOneIsHere for the title!

Answer 1

JavaScript (ES6), 39 34 bytes

a=>[a.sort((x,y)=>x-y).pop(),...a]

Sort the array in ascending order, pop the last element and use it as the first element of a new array. Then destructure the remaining elements of the original array into the new array (In JS, both sort and pop modify the original array).

---

Test it

o.innerText=(f=

a=>[a.sort((x,y)=>x-y).pop(),...a]

)(i.value=[1,2,3]);oninput=_=>o.innerText=f(i.value.split`,`)

<input id=i><pre id=o>

Answer 2

Brachylog, 2 bytes

o↻

Try it online!

or

o↺

Try it online!

Sorts then rotates the list

Answer 3

Jelly, 3 bytes

Ṣṙ1

Try it online!

Answer 4

Ohm, 2 bytes

S╙

Try it online!

Sort and rotate to the right.

Answer 5

Japt, 3 bytes

n é

Test it

Sorts (n) the array and rotates it (é) one element to the right.

Answer 6

APL, 9 bytes

{1⌽⍵[⍋⍵]}

Try it online!

How?

⍵[⍋⍵] - sort the list

1⌽ - rotate by 1

Answer 7

Python 3, 31 bytes

lambda a:sorted(a)[1:]+[min(a)]

Try it online!

-1 byte thanks to xnor

Answer 8

Pyth, 7 5 4 bytes

.P1S

Try it online!

-1 byte thanks to FryAmTheEggman

Answer 9

TI-Basic (TI-84 Plus CE), 31 bytes

Prompt A
SortA(LA
max(LA→B
dim(LA)-1→dim(LA
augment({B},LA

Prompts for input in the format {1,2,3,4}.

TI-Basic is a tokenized language, all tokens used here are one-byte.

Explanation:

Prompt A         # 3 bytes, store user input in LA
SortA(LA         # 4 bytes, sort LA ascending
max(LA→B         # 6 bytes, save the last value in the sorted list to B
dim(LA)-1→dim(LA # 11 bytes, remove the last value from LA
augment({B},LA   # 7 bytes, prepend B to LA and implicitly print the result

Answer 10

05AB1E, 2 bytes

{Á

Try it online!

Answer 11

05AB1E, 2 bytes

{À

Try it online!

Answer 12

Retina, 21 bytes

O#`
s`(.*)¶(.*)
$2¶$1

Try it online! Sort and rotate as per usual. At least there's no unary conversion this time.

Answer 13

Java 8, 68 37 bytes

l->{l.sort(null);l.add(l.remove(0));}

-31 bytes thanks to @Nevay (forgot Java 8 had a List#sort(Comparator) method..)

Modifies the input-ArrayList, instead of returning a new one.

Explanation:

Try it here.

l->{                   // Method with ArrayList parameter and no return-type
  l.sort(null);        //  Sort the input-list (no need for a Comparator, thus null)
  l.add(l.remove(0));  //  Remove the first element, and add it last
}                      // End of method

Answer 14

Haskell, 36 37 bytes

import Data.List
f(a:b)=b++[a];f.sort

Use view patterns to match on the head of a sorted version of the input list, then append the first item of the list to the tail of the remaining list.

View patterns aren't worth it. Sort the list, take the head off, append it to the end. In this case, it turns out that the naive solution typed out compactly is the best.

Answer 15

Perl 6,  43  19 bytes

{first {![<=]($_)&&![>=] $_},.permutations}

Try it

*.sort[1..*,0].flat

Try it

Note that [1..*,0] would result in ((2,3),1), so .flat is there to turn it into (2,3,1)

Answer 16

Mathematica, 18 bytes

RotateLeft@Sort@#&

Try it online!

Answer 17

Ly, 7 bytes

&nasprl

Try it online!

Ugh, ruining the sort is so expensive!

Explanation:

&nasprl

&n      # take input as a list of numbers
  a     # sort
   sp   # save top of stack and pop
     r  # reverse stack
      l # load saved item

Answer 18

R, 33 32 29 bytes

Takes input from stdin. Sorts the list and then moves the first element to the end, ensuring that it is no longer sorted. Saved three bytes due to Giuseppe.

c(sort(x<-scan())[-1],min(x))

Another implementation, same byte count:

c((x<-sort(scan()))[-1],x[1])

Answer 19

Proton, 19 bytes

a=>sorted(a)[1to,0]

Try it online!

-2 bytes indirectly thanks to xnor

Not yet working on TIO; waiting for a pull.

Answer 20

Ohm, 2 bytes

S╜

Try it online!

I think this is dissimilar enough from totallyhuman's post to post a new answer; I hope you don't mind :P EDIT: DAMMIT YOU NINJA'D ME

Answer 21

Python, 31 bytes

def f(a):a[1:]=a[a.sort():0:-1]

Yet another Python solution.

Sadly, this one has the same length to HyperNeutrino's answer.

Answer 22

C# (Mono), 76 67 bytes

using System.Linq;a=>a.OrderBy(n=>n).Skip(1).Concat(new[]{a.Min()})

Saved 9 bytes thanks to @Patrick Stephansen.

Try it online!

Answer 23

PHP, 44 bytes

requires PHP 5.4 or later for short array syntax.

sort($a=&$argv);print_r([array_pop($a)]+$a);

sort arguments, replace 0-th argument with removed last argument, print.
Run with -nr or try it online.

---

The 0-th argument is the script file name, "-" if you call PHP with -r. "-" is compared to the other arguments as a string, and since ord("-")==45, it is smaller than any number. The numbers themselves, although strings, are compared as numbers: "12" > "2".

php -nr '<code>' 3 4 2 5 1 and sort($a=&$argv) lead to $a=["-","1","2","3","4","5"] →
[array_pop($a)]+$a is [0=>"5"]+[0=>"-",1=>"1",2=>"2",3=>"3",4=>"4"],
which results in [0=>"5",1=>"1",2=>"2",3=>"3",4=>"4"].

Answer 24

Pyth, 5 bytes

.>SQ1

Explanation

SQ - sort input list

.>SQ1 - rotate input list cyclicaly by 1

Answer 25

Retina, 10 bytes

O#`
O^#-2`

Try it online!

O#`     Sort the list
O^#-2`  Reverse sort the list other than the last element

This leaves the list with the 2nd highest element first and the highest element last which is never correctly sorted

Answer 26

Gaia, 3 bytes

ȯ1«

Try it online!

Same as other answers: sort ȯ and rotate left once 1«.

Answer 27

Ruby, 18 bytes

Submitted on mobile. Please don't kill me for problems.

->a{a.sort.rotate}

Answer 28

Python 3, 28 bytes

lambda a:a[1:a.sort()]+a[:1]

Try it online!

a.sort() sorts a in place and returns None. None can be used as a slicing index and is the same as omitting that index.

Answer 29

Python 3, 31 bytes

lambda a:a.sort()or[a.pop(),*a]

Try it online! or Verify all test cases.

Inspired by Shaggy's JS answer.

Answer 30

RProgN 2, 2 bytes

§›

Try it online!

Answer 31

Julia, 23 bytes

f(x)=sort(x)[[2:end;1]]

Slightly shorter than, but equivalent to f(x)=circshift(sort(x),1). I wish I could makeamethod based on select that was more, compact but I can not

Answer 32

Common Lisp, 52 bytes

(let((x(sort(read)'<)))(rotatef(nth 0 x)(nth 1 x))x)

Try it online!

Answer 33

Clojure, 36 bytes

#(let[s %](cons(last s)(butlast s)))

Stole the solution to sort it and push the last element to the start of the list.

Answer 34

TeX - 207 183 bytes

\def\a#1 #2 #3 #4 {\ifnum#2#1#3\def\e{#3 #4 #2 }\else\def\e{#2 #4 #3 }\fi\e}\def\b#1 #2 #3 {\a< #1 #2 \a> #3 {} }\def\c#1 #2 {\ifnum#1=#2\let\b\f\def\d#1 {#1 \c}\else\let\d\b\fi\d#1 #2 }\def\f#1 #2 {#2 #1 }

This is the best I can do with a language that doesn't really have data structures, or many builtins.

The approach is to take the first three numbers we find, and do a broken sort as follows: Sort the first two by greater, and then take the second two by lesser. This should always result in our list being unsorted. It's convenient to ignore anything but the first 3 unique inputs.

We also have a check for two of the same number in a row. In that case, we scan ahead until we find a different number, and then switch the two, ensuring that our list is out of order.

I'm gonna work on golfing this down, but it's the best approach I can think of.

EDIT: Considerable work has been put in to this, to make it more golfy and also actually work. So here it is:

\let~\def~\a#1 #2 {\if^#2~\e{\box9 #1 }\else\ifnum#1\h#2~\e{\hbox{#1 }\a#2 }\else~\e{\hbox{#2 }\a#1 }\ifnum#1=#2~\h{=}\setbox9=\lastbox\fi\fi\fi~\g{>}\e}~\g{<}~\h{\g}\everypar{\a}\x^

I changed the the method from inserting things into the input to one where we recurse, replaced \expandafter with \everypar, and added that when it finds an equal number, it grabs the last number typeset and saves it until the second to last slot, ensuring that 1 2 2 (the case that secretly broke the previous answer) will be incorrectly sorted as 2 1 2.

This is just a function, to properly use it you need to: have input stored on the variable \x (or you could type in a list of numbers, with a ^ as a delimeter).

If you'd really like to try this, then do this

\read1to\x    

before the lines of this function.

Answer 35

Ruby, 20 bytes

->(x){x.sort.rotate}

I can't figure out how to use lambdas on TIO, but I'll add a link when I do

Answer 36

SmileBASIC, 33 bytes

DEF B A
SORT A
PUSH A,SHIFT(A)END

Modifies the array in place. This uses the simple sort+rotate algorithm, though there may be a shorter solution involving RINGCOPY or something (the problem being that COPY and RINGCOPY don't work well when copying between overlapping parts of the same array)