You will receive as input a list that contains integers and strings. Your task is to move all of the strings to the end of the list and all of the integers to the beginning of the list.
This is code-golf so the answer with the least number of bytes wins.
lambda l:l.sort(key=dir)
Sorts in place, modifying the input list. It so happens that the dir of a number is smaller than that of a string because the __abs__ method that numbers have comes alphabetically first.
>> dir(1)
['__abs__', '__add__', '__and__', ...]
>> dir('a')
['__add__', '__class__', '__contains__', ...]
The only built-in to use as a key that would be shorter than dir is id, but it seems to puts strings before numbers, and I don't know if its behavior is consistent.
sorted
Python 2 allows comparing different types, and conveniently numbers come before strings.
05AB1E does this exactly as specified.
{
Or, verify all test cases (so far)
Even if the answer is a one-byte answer, I still feel like typing the explanation.
Implicit input as a list
{ Sort the list (numbers go before the strings)
a=>a.sort((a,b)=>!b.big-!a.big)
The deprecated but still widely supported method .big() is defined for Strings and undefined for Numbers. Hence the sorting criterion !b.big-!a.big which is either \$-1\$, \$0\$ or \$1\$.
L.sort(key=lambda x:str(type(x)))
And in fact this is how I'd write it in live code too, probably...
L.sort(key=lambda x:str(type(x)))?
\$\endgroup\$
Feb 15, 2020 at 14:28
L->{L.sort((i,j)->i==i.toString()?1:-1);}
-2 bytes thanks to @Neil.
Input as a List of Objects, with String and Integer items.
Explanation:
L->{ // Method with Object-List parameter and no return-type
L.sort( // Sort the List by:
(i,j)-> // For every pair of items `i,j`:
i==i.toString()? // If `i` is a String (by checking whether `i` and the builtin
// String-conversion of `i` reference the same instance):
1 // Put it after item `j`
: // Else:
-1);} // Put it before item `j`
i==i.toString()?1:-1 saves 2 bytes. (Obviously, this can only ever be true for String objects, and it's also fortunately trivially true for all String objects.)
\$\endgroup\$
s==s.trim() to check whether a String didn't contained any trailing and/or leading white-spaces.)
\$\endgroup\$
Feb 18, 2020 at 20:56
-1 thanks to Jo King.
*.sort(*~~Str)
This is an anonymous WhateverCode function nested within another. I didn't know I could do that.
lambda x:[*filter(lambda _:type(_)==int,x)]+[*filter(lambda _:type(_)==str,x)]
Your task is to move all strings..., there is no output or function needed, and from what I see for example from the 05AB1E's answer, isn't sort($t,2); enough?
\$\endgroup\$
p=egrep\ ^-?[0-9]+$
tee a|$p
$p -v<a
A value is considered to be an integer if: (1) the first character is either a digit or a minus sign; (2) any other characters are all digits; and (3) at least one digit is present. Any value that is not an integer is considered to be a string.
function(L)sort(unlist(L))
Straightforward: unlist then sort the list L. Works because digits sort before alphabetic letters, be them upper or lower case.
f(a,l,p,c)struct{int*s,i;}*a,*p;{for(c=l,p=a;c--;p++)p->s?:printf("%d ",p->i);for(;l--;a++)a->s&&printf("%s ",a->s);}
C does not have lists of combined strings and integers so instead I use an array of structures; if the string is NULL (which a real string never will be), then print the integer instead. Of course, go over the list an print the integers first, then the strings.
Stable sort.
Decimals will be placed in the integer section
DECLARE @ table(a varchar(99))
INSERT @ values('1'),('a'),('abc'),('1'),('d'),('84753')
SELECT*FROM @ ORDER BY-isnumeric(a)
o$dir(N)
I don't know what it is about python eval that makes me feel like I'm bending the rules, but I like it :)
O$^m`^(-?[0-9]+$)?.*$
$1
Try it online! Explanation:
m`^(-?[0-9]+$)?.*$
Match each line, capturing it if it's an integer.
O$
$1
Sort the matches by the captured integer, as a string. This sorts non-integers to the beginning as nothing was captured which results in the empty string in the substitution.
^
Reverse the list after sorting.
Ｆ²ΦＥθ⭆¹κ⁼ι⁼κ§θλ
Try it online! Link is to verbose version of code. Explanation:
Ｆ²
Make two passes over the input items.
Ｅθ⭆¹κ
Stringify all the input items...
Φ...⁼ι⁼κ§θλ
... and filter on those elements that are not or are unchanged under stringification respectively.
@ECHO OFF
Setlocal EnableDelayedExpansion
Set /P S=Str:
FOR %%B IN (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) DO (
IF "!L!"=="" (Set L=!S:%%B= !) Else (Set L=!L:%%B= !)
)
FOR %%C IN (0,1,2,3,4,5,6,7,8,9) DO (
IF "!R!"=="" (Set R=!S:%%C= !) Else (Set R=!R:%%C= !)
)
Set S=%L: =%%R: =%
ECHO(%S%
pause
Expects and returns a List<Any>. The order of ints and strings in the returned list should be stable.
{it.partition{it is Int}.let{(a,b)->a+b}}
^'#s
See the README to see how to run this
^'#s # Expects the list as input
^' # Sort the input using the following function as a key:
#s # Is string?
[ [ real? 0 1 ? ] sort-with ]
Is it a real number? Then sort it as though it were 0. Otherwise, sort it as though it were 1.
Golfed version. Attempt This Online!
_.sortWith{case(i:String,j:Any)=>2<1;case(i:Any,j:String)=>2>1;case _=>2>1}
Ungolfed version. Attempt This Online!
object Main {
trait N {
def c(L: List[Any]): List[Any]
}
val n: N = (L: List[Any]) => {
L.sortWith {
case (i: String, j: Any) => false
case (i: Any, j: String) => true
case _ => true
}
}
def main(args: Array[String]): Unit = {
test(1, 4, "2", "c", 6)
test("a", 1, "b", 2, "c", 3, "1", "2", "3")
}
def test(a: Any*): Unit = {
var list = a.toList
prettyPrint(list)
print(": ")
list = n.c(list)
prettyPrint(list)
println()
}
def prettyPrint(list: List[Any]): Unit = {
print("[")
for (i <- list.indices) {
val o = list(i)
o match {
case s: String => print("\"" + s + "\"")
case _ => print(o)
}
if (i < list.size - 1) print(",")
}
print("]")
}
}
