The Task

The task is very simple. Given an array containing only integers and strings, output the largest number and the smallest number.

Test Cases

Input: [1, 2, 3, 4, 5, 6, 7, 8]
Output: 1, 8

Input: [5, 4, 2, 9, 1, 10, 5]
Output: 1, 10

Input: [7, 8, 10, "Hello", 5, 5]
Output: 5, 10

Numbers in strings are not considered integers:

Input: [1, 2, 3, 4, "5"]
Output: 1, 4

If there is only one integer, it is both the largest and smallest integer:

Input: [1]
Output: 1, 1

Input: ["1", "2", "3", "4", 5]
Output: 5, 5


  • You can assume that an array will always contains at least one integer.
  • All integers are positive (greater than 0)
  • The order of the output doesn't matter.
  • This is , so the submission with the least amount of bytes wins!
  • Strings can contain all printable ASCII characters (32 - 126) and are non-empty.
  • \$\begingroup\$ How are strings that contain quote marks represented in the input? \$\endgroup\$ – feersum Feb 5 '16 at 11:23
  • \$\begingroup\$ @feersum Wouldn't that depend on your language? \$\endgroup\$ – Martin Ender Feb 5 '16 at 11:25
  • \$\begingroup\$ @feersum With escape characters probably, but if the language doesn't handle that, that's okay. \$\endgroup\$ – Adnan Feb 5 '16 at 11:25
  • \$\begingroup\$ @MartinBüttner If input is taken from stdin, it should not depend on what language is used. \$\endgroup\$ – feersum Feb 5 '16 at 13:31
  • 3
    \$\begingroup\$ @feersum That's new to me. Even from STDIN [1, 2, 3] 1 2 3 and {1; 2; 3} are all valid input formats, so I don't see why it should be any different for string literals received from STDIN. \$\endgroup\$ – Martin Ender Feb 5 '16 at 13:33

34 Answers 34


Seriously, 9 6 bytes


Try It Online

How it works

,                              Read list input
 ì                             Remove everything but numbers from it
  ;                            Make a copy
   m                           Extract its min value
    @M                         Extract the other one's max value
                               Implicit output (max then min)
  • \$\begingroup\$ Ah, yes, I was looking for such a command. But the docs are not easy to search. \$\endgroup\$ – quintopia Feb 6 '16 at 5:03
  • \$\begingroup\$ I agree. The docs are my next big goal. \$\endgroup\$ – Mego Feb 6 '16 at 6:32

JavaScript (ES6), 54 56

Edit 2 bytes saved thx @Neil

Note: x===+x is true if and only if x is a number

  • 3
    \$\begingroup\$ Why the outer ()s? \$\endgroup\$ – Neil Feb 5 '16 at 12:41
  • \$\begingroup\$ @Neil what outer ()? Why on earth should I have outer ()s? \$\endgroup\$ – edc65 Feb 5 '16 at 14:27
  • \$\begingroup\$ This returns a function, you still need to call it. (or just remove a=>) \$\endgroup\$ – Michael Theriot Feb 5 '16 at 16:18
  • 2
    \$\begingroup\$ Yes it's an anonymous function. It's quite a common way to post an answer in JavaScript @MichaelTheriot \$\endgroup\$ – edc65 Feb 5 '16 at 16:29
  • \$\begingroup\$ @MichaelTheriot By default, we allow submissions to be standalone functions rather than always requiring full programs. \$\endgroup\$ – Alex A. Feb 5 '16 at 18:39

Pyth, 14 11 10 bytes


Try it online. Test suite.


  • Q: evaluated input
  • #: filter that on:
    • I: the value being the same after:
      • ^…1 raising it to power 1
  • S: sort that
  • _B: create array [previous, reversed(previous)]
  • hM: take first item of each item of that

The hardest part is to golf the removal of strings, which currently takes 4 bytes. The current approach works due to ^<str>1 taking the first Cartesian power of the sequence (basically, the list of the string's characters), but ^<int>1 is just the identity function.

  • \$\begingroup\$ Hrm, you could also use *#_1Q to remove the strings, which would be shorter if a variable was initialized to negative one... \$\endgroup\$ – FryAmTheEggman Feb 5 '16 at 14:07

Python 2, 42 bytes

In Python 2, integers are always less than strings during comparisons, so a simple min(s) will find the smallest integer. When finding the maximum though, we must filter out strings first. The anonymous function accepts a sequence and returns a tuple with the minimum and maximum.

lambda s:(min(s),max(x for x in s if''>x))


[1,'77', 6, '', 4] -> (1, 6)
  • 3
    \$\begingroup\$ You need a lambda a: stuck before that. \$\endgroup\$ – Doorknob Feb 5 '16 at 12:29
  • \$\begingroup\$ if x>0 or if''>x save one byte. \$\endgroup\$ – grc Feb 5 '16 at 12:39
  • \$\begingroup\$ @Doorknob, now lambda as suggested. \$\endgroup\$ – Logic Knight Feb 5 '16 at 14:00
  • 1
    \$\begingroup\$ @Dennis, I did not know this. I have edited the solution to make clear the comparison only works in Python 2. \$\endgroup\$ – Logic Knight Feb 5 '16 at 23:17
  • 1
    \$\begingroup\$ Building up: lambda s:(min(s),-min(-1*_ for _ in s)) (39 bytes) \$\endgroup\$ – Fran Borcic Feb 8 '16 at 9:10

Jelly, 8 bytes


Try it online!


In a perfect world, it would suffice to intersect the list with a flattened version of itself. Strings are simply lists of characters in Jelly, so while the original list would contain integers and strings, the flattened version would contain integers and characters, leaving only the integers in the intersection.

In the real world, both the parsers of both input and string literals yield characters instead of strings of length 1. The only way to pass a singleton string to a function would be to encode it "manually" as, e.g., [”a], which is a character wrapped in an array.

This would save a byte, for a total of 7 bytes (Try it online!).


Since that's probably not acceptable, we also need a way to differentiate characters from integers.

Jelly's bitwise atoms desperately try to convert their arguments to integers. They start by vectorizing until they encounter types of depth 0 (numbers or characters), then attempt to convert them to integers. For a character that represents an integer, this will be successful. For others, a dyadic, bitwise atom will simply give up and return 0.

For example, bitwise ORing the list [1, "2", "34", "-5", "a", "bc"] with itself will yield

[1, 2, [3, 4], [0, 5], 0, [0, 0]]

By intersecting the result with the original list, we get rid of the arrays and the integers that weren't present in the original list.

How it works

|f¹Ṣ0,1ị  Main link. Input: A (list)

|         Bitwise OR the list A with itself.
 f¹       Filter the result by presence in A.
   Ṣ      Sort the resulting list of integers.
    0,1ị  Retrieve the elements at those indexes.
          Indices are 1-based and modular in Jelly, so 0 is the last (maximum),
          and 1 is the first (minimum).

Mathematica, 20 bytes


Test cases

(* {1,4} *)
  • 1
    \$\begingroup\$ Why is there the * there? It seems like you can get to 19 just by cutting it. \$\endgroup\$ – A Simmons Feb 5 '16 at 12:07
  • 1
    \$\begingroup\$ @ASimmons It is necessary. MinMax@Select[#>0&] is not a valid pure function. \$\endgroup\$ – njpipeorgan Feb 5 '16 at 12:10
  • 1
    \$\begingroup\$ @ASimmons @* is function composition, whereas @ is function application. \$\endgroup\$ – Martin Ender Feb 5 '16 at 12:11
  • 1
    \$\begingroup\$ MinMax@Select[# > 0 &][{1, 2, 3, 4, "Hello", 5}] yields a correct response \$\endgroup\$ – A Simmons Feb 5 '16 at 12:13
  • 1
    \$\begingroup\$ @ASimmons Try assign MinMax@Select[# > 0 &] to a symbol, or just evaluate it. \$\endgroup\$ – njpipeorgan Feb 5 '16 at 12:16

Ruby, 57 36 29 bytes

Newbie here, so I don't know if there is any standard or universally accepted place/way to calculate bytes used, any help would be very appreciated!

Edited as per manatwork & Doorknob's comment!



2.3.0 :076 > f=->n{[(n.map(&:to_i) & n).min, (n.map(&:to_i) & n).max]}
 => #<Proc:0x007ff7650ee868@(irb):76 (lambda)>
2.3.0 :077 > f[[7, 8, 10, "Hello", 5, 5]]
 => [5, 10]
  • 1
    \$\begingroup\$ 36 characters: ->n{[(x=n.map(&:to_i)&n).min,x.max]} \$\endgroup\$ – manatwork Feb 5 '16 at 11:44
  • 2
    \$\begingroup\$ 29 bytes, using minmax: ->a{(a.map(&:to_i)&a).minmax} \$\endgroup\$ – Doorknob Feb 5 '16 at 12:03

CJam, 15 13 bytes


An unnamed block (function) which expects the input array on the stack and leaves the output array in its place.

Run all test cases.


_     e# Duplicate.
:z    e# Map over list: a) take abs() of integer elements (a no-op) or b) wrap strings
      e# in an array.
&     e# Set intersection: only the integers will appear in both arrays.
$     e# Sort.
2*    e# Repeat array twice (to make the code work with single-integer input).
_,    e# Duplicate, get length N.
(%    e# Decrement, get every (N-1)th element, i.e. the first and the last.
  • \$\begingroup\$ I sugeested e) and e( to aditsu. He hasn't accepted that \$\endgroup\$ – username.ak Feb 5 '16 at 21:15
  • \$\begingroup\$ @username.ak I don't think those are really useful. Adding a two-char operator that only saves a single byte over the current solution isn't something aditsu is likely to implement, and I also think there must be more useful features to use those for. \$\endgroup\$ – Martin Ender Feb 5 '16 at 21:27
  • \$\begingroup\$ it will save 3 bytes: q~_e(ae)a+ \$\endgroup\$ – username.ak Feb 6 '16 at 10:50
  • \$\begingroup\$ @username.ak Well that's assuming that e( and e) would ignore strings or something, which seems inconsistent. And if it did involve comparison with strings it would probably fail the same way that $ and e> can't compare integers with strings. \$\endgroup\$ – Martin Ender Feb 6 '16 at 11:04

Haskell, 41 39 bytes

f x=[minimum,maximum]<*>[[i|Left i<-x]]

In Haskell all elements of a list have to be of the same type, so I cannot mix Integer and String. However, there's the Either type for combining two types into a single one. The input list is therefore of type Either Integer String1. f filters the Integers, removes the Either wrapper, puts the list as the single element in a new list (e.g. [[1,2,3]]), so that <*> can apply the functions given in the first argument to it.

Usage example: f [Left 1, Left 3, Right "Hello", Left 2] -> [1,3].

Edit: @xnor brought <*> into play and saved 2 bytes. Thanks!

1 actually it's fully polymorphic in the second type as the String property is never used.

  • \$\begingroup\$ Nice idea with the pattern match. You can save two chars with a reversed map: f x=[minimum,maximum]<*>[[i|Left i<-x]] \$\endgroup\$ – xnor Feb 7 '16 at 9:23
  • \$\begingroup\$ @xnor: very nice. Thanks a lot! \$\endgroup\$ – nimi Feb 7 '16 at 10:01

jq, 21 characters


Sample run:

bash-4.3$ bin/jq '[.[]|numbers]|min,max' <<< '[7, 8, 10, "Hello", 5, 5]'

On-line test:


Mathematica, 28 bytes

  • \$\begingroup\$ I still don't understand your obsession with Nothing... It doesn't mean anything special... Also, for 23 bytes: MinMax@*Select[NumberQ] \$\endgroup\$ – LegionMammal978 Feb 5 '16 at 11:48
  • \$\begingroup\$ @LegionMammal978 Make use of "all integers are positive"! See my answer. \$\endgroup\$ – njpipeorgan Feb 5 '16 at 11:56
  • 1
    \$\begingroup\$ Nice solutions guys, I should have thought of doing it that way! @LegionMammal978, Nothing does have a special meaning. Since Mathematica 10.2, it gets automatically removed from Lists. \$\endgroup\$ – A Simmons Feb 5 '16 at 12:05
  • \$\begingroup\$ @LegionMammal978 Nothing is a documented function in the latest versions. \$\endgroup\$ – Mr.Wizard Feb 8 '16 at 3:00

PHP, 50 48 bytes

<?=min($a=array_filter($a,is_int)).', '.max($a);
  • 1
    \$\begingroup\$ Beat me by 2 minutes :). \$\endgroup\$ – TMH Feb 5 '16 at 12:03
  • 2
    \$\begingroup\$ It's generally forbidden to suppose that the input is already in a variable. By the way, you can save two bytes by removing the ' around is_int. \$\endgroup\$ – Blackhole Feb 5 '16 at 16:23
  • \$\begingroup\$ @Blackhole Thanks. Didn't realise. I've utilised your quote removal :) \$\endgroup\$ – PaulSkinner Feb 5 '16 at 16:45

Retina, 71

Thanks (as always) to @MartinBüttner for the golfing help.

Not competitive golf-wise, but its interesting to implement integer bubble sorting in Retina.

Assumes all strings in the input are " double-quoted and don't contain any escaped double quotes \".


$&$*a $&$*a
+`\b(a+) +\1(a+)\b
$1$2 $1
 +[a ]+ +


Input is newline-separated.

Try it online.

  • \$\begingroup\$ I think you can use <space>.*<space> in the second to last stage because of greed. \$\endgroup\$ – FryAmTheEggman Feb 12 '16 at 18:18

Mathematica, 14



tests = {
   {1, 2, 3, 4, 5, 6, 7, 8},
   {5, 4, 2, 9, 1, 10, 5},
   {7, 8, 10, "Hello", 5, 5},
   {1, 2, 3, 4, "5"},
   {"1", "2", "3", "4", 5}

# & @@@ MinMax@# & /@ tests
{{1, 8}, {1, 10}, {5, 10}, {1, 4}, {1, 1}, {5, 5}}


When MinMax gets non-numeric input it reduces the problem as far as it can, then leaves terms wrapped in Min and Max:

MinMax @ {7, 8, 10, "Hello", 5, 5}
{Min[5, "Hello"], Max[10, "Hello"]}

Due to the automatic ordering that takes place strings follow integers.

Apply at levelspec {1}, shorthand @@@, is then used to pull the first argument of non-atomic elements. Note that 5 is untouched here:

foo @@@ {5, Max[10, "Hello"]}
{5, foo[10, "Hello"]}

Oracle SQL 11.2, 189 bytes



        SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i 
        FROM   DUAL 
WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

The sub-query parse the array and split it to populate a view with one element per row. Then the non numeric elements are filtered out.

I wish I could have found a way to do it with LEAST and GREATEST, but no luck with how to handle the array as a parameter.

  • \$\begingroup\$ You're leaving the [] in the array so you're not selecting the max or min if they're the first or last elements of the array. You also don't need your WHERE clause, you're already selecting aggregates so you don't need to filter. Search for numeric characters in your regexes and push the number conversion down to the sub-query (very little danger of pushed predicates) and it becomes 126 bytes: select min(i),max(i)from(select to_number(regexp_substr(&1,'\d+',1,level))i from dual connect by level<=regexp_count(&1,'\d')) \$\endgroup\$ – Ben Feb 7 '16 at 18:57
  • \$\begingroup\$ There's no need for a + in the second regex here as it doesn't matter if you generate a few extra rows (saves a byte). It's also worth noting though that if you have a string made up solely of numbers you won't ignore it here; that needs overloaded functions in the same package, so is not at all pretty. \$\endgroup\$ – Ben Feb 7 '16 at 19:00

vimscript, 25 bytes

sort n

Yep, that's right, vimscript.

Expects input in the form


And outputs in the form



g/"/d    delete all lines that contain quotes
sort n   sort numerically
t.       duplicate the first line
t.       duplicate it again
2,$-1d   delete from line 2 to line (END-1)

The first line needs to be duplicated twice to handle the edge case of an input of a single number. This is because the last command will complain if there are only two lines when it is reached, since it ends up being 2,1d which is a backwards range.


Perl 44 39 + 3 = 41 bytes


Requires -pa flags:

$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 5 4'
1 5
$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 4 "5"'
1 4

Thanks to @manatwork for shaving off a few bytes

  • \$\begingroup\$ Which Perl version? For your second example I get different result: pastebin.com/judJys5g \$\endgroup\$ – manatwork Feb 5 '16 at 12:33
  • \$\begingroup\$ @manatwork You are correct, Figure I cannot remove sort{$a-$b}grep... \$\endgroup\$ – andlrc Feb 5 '16 at 12:36
  • \$\begingroup\$ The requirement doesn't state that the output has to be formatted exactly as in the examples and in this task clearly not the formatting is the point. So many of us just used what is handier in our language of choice. In Perl I would do it like this: $_="@a[0,-1]". \$\endgroup\$ – manatwork Feb 5 '16 at 13:22
  • \$\begingroup\$ One character shorter filtering: grep!/"/. \$\endgroup\$ – manatwork Feb 5 '16 at 13:27
  • \$\begingroup\$ It says the array will be numbers and strings. All the examples in the question are with double-quoted strings, but I don't see anything saying they can't be single-quoted. I think !/\D/ is necessary instead of !/"/, for one more byte. \$\endgroup\$ – msh210 Feb 7 '16 at 3:45

Julia, 35 bytes


This is a lambda function that accepts an array and returns a tuple of integers. To call it, assign it to a variable.

Julia has a built-in function extrema for getting the minimum and maximum elements of an array as a tuple. However, since the array can also have strings in it, we first have to filter those out. We can do that by testing whether each element is an integer using isa.


Japt, 23 bytes

[V=Uf_bZÃn@X-Y})g Vw g]

Test it online!

How it works

[V=Uf_  bZÃ n@  X-Y})g Vw g]
[V=UfZ{ZbZ} nXY{X-Y})g Vw g]

UfZ{ZbZ}   // Filter out the items Z in U where Z.b(Z) is falsy.
           // For numbers, this the original number, which is always non-0 (non-falsy).
           // For strings, this returns Z.indexOf(Z), which is always 0 (falsy).
nXY{X-Y}   // Sort by subtraction. Small items move to the front, large to the back.
V=         // Set variable V to the resulting array.
)g Vw g    // Take the first item in V, and the first in V.reverse().
[       ]  // Wrap them in an array so both are sent to output.

Bash, 40 31 30 bytes

sort -n|sed /\"/d|sed '1p;$p;d'

Requires a line separated list:

$ echo $'5\n4\n2\n9\n1\n"10"\n5' | sort -n|sed /\"/d|sed '1p;$p;d'

Thanks to @manatwork to shave off a few bytes

  • \$\begingroup\$ sed '1p;$p;d' saves a byte. \$\endgroup\$ – Dennis Feb 7 '16 at 3:58

PowerShell, 53 36 bytes


Saved 17 bytes thanks to @goric

OOOF ... PowerShell usually plays pretty fast and loose with casting, which is normally a good thing for golfing, but hurts it here.

Takes our input $args[0] and pipes it into a Where-Object statement (the ?) that will only select integers and passes them along the pipeline, discarding anything else. Since dynamic re-casting happens on-the-fly in the background for you (e.g., 1+"5" returning 6 is perfectly valid PowerShell), we need to use the -is operator in order to differentiate between the data types.

From there, we pipe that collection into Sort-Object, which will sort the integers from smallest to largest. The outer () is necessary so we can reference the first and last elements with [0,-1] (i.e., the smallest and the largest), but note we also need the outer @ to force casting the output of sort as an array if there's only one object (as the result of the ?, or only one object was input).

  • 1
    \$\begingroup\$ Take a look at the -is type operator here. I think you could replace .GetType().Name-eq"Int32" with -is[int] to save 17 bytes \$\endgroup\$ – goric Feb 8 '16 at 20:53
  • \$\begingroup\$ @goric Super awesome! Thanks for the massive golf! \$\endgroup\$ – AdmBorkBork Feb 8 '16 at 21:37

MATL, 23 bytes


Try it online!

"       % implicitly input cell array. For loop that iterates on each cell
  @     %   push each cell
  Y:    %   cell's contents (either a number or a string)
  tX%   %   duplicate and push class. This will produce 'char'  or 'double'
  1)    %   get first letter: either 'c' or 'd'
  2\    %   is its ASCII code odd?
  ?     %   if so...
    x   %     delete (it's a string)
  ]     %   end if
  N$h   %   concatenate all stack into an array. This array will contain up to
        %   three numbers: minimum up to now, maximum up to now, new value (if any)
  tX<   %   duplicate. Push minimum
  wX>   %   swap. Push maximum.
        % implicitly end for
        % implicitly display stack contents
  • \$\begingroup\$ Oh, my bad :p. Nice answer though :) \$\endgroup\$ – Adnan Feb 5 '16 at 12:36
  • \$\begingroup\$ @Adnan Thanks! A little too long :-) \$\endgroup\$ – Luis Mendo Feb 5 '16 at 12:36

JavaScript (ES5), 105 bytes

function a(b){m=Math;b=b.filter(function(c){return c===+c});alert(m.min.apply(m,b)+','+m.max.apply(m,b))}

Usage: a([1,2,3,'4'])

Just trying :)


function a(b){
    return c===+c
  alert(m.min.apply(m,b) + ',' + m.max.apply(m,b))

Pyth, 11 bytes



   f    Q   - filter([V for T in >], Q)
    !>Tk    - not(T>"")
  S         - sorted(^)
hJ       eJ - print first and last element

Try it here!


Perl 6, 25 bytes

The obvious answer would be this WhateverCode lambda


If it has to be a full program

put get.words».&val.grep(Int).minmax.bounds

The input to this full program is a space separated list of values


# give it a lexical name
my &code = *.grep(Int).minmax.bounds;

say code [1, 2, 3, 4, 5, 6, 7, 8];  # (1 8)
say code [5, 4, 2, 9, 1, 10, 5];    # (1 10)
say code [7, 8, 10, "Hello", 5, 5]; # (5 10)
say code [1, 2, 3, 4, "5"];         # (1 4)
say code [1];                       # (1 1)
say code ["1", "2", "3", "4", 5];   # (5 5)

say code []; # (Inf -Inf)

𝔼𝕊𝕄𝕚𝕟, 16 chars / 20 bytes


Try it here (Firefox only).

Not bad, not bad...


This outputs an array containing both the maximum and minimum. (ï⇔⒡≔=+$⸩, basically filters out all strings in the input, МƲ gets the maximum in the input, and МƵ gets the minimum.

Just a note: this is the first challenge where I get to use , which basically turns ï⇔ into ï=ï.


Python 3, 56 bytes

lambda x:[m(t for t in x if str(t)!=t)for m in(min,max)]

Try it online on Ideone.


APL (Dyalog), 13 bytes


Try it online!

 enlist (flatten – this makes all the strings into characters in the big list)

⎕AV~⍨ remove all characters in the Atomic Vector (the character set – leaves numbers)

() apply the following tacit function:

⌊/ the minimum across

, appended to

⌈/ the maximus across


Java (OpenJDK 8), 124 bytes

a->{int s[]={0,0},t;for(Object i:a)try{t=(int)i;s[0]=s[0]<1|t<s[0]?t:s[0];s[1]=s[1]<t?t:s[1];}catch(Exception e){}return s;}

Try it online!

Java 8 lambda function, takes array as input and gives out array {min, max}. Non competing, because the input has to be an integer array.

Fixed and -1 byte thanks to Kevin Cruijssen

  • \$\begingroup\$ You could make this competing by taking a list of Objects and checking if an item is an integer or String. \$\endgroup\$ – Kevin Cruijssen May 7 '18 at 14:19
  • \$\begingroup\$ @KevinCruijssen done, thanks \$\endgroup\$ – HyperNeutrino May 8 '18 at 12:00
  • \$\begingroup\$ <i now gives an error without integer-cast. Also, your initial code (and this one as well) doesn't work for min, since it will always output 0 for min. Here is a possible fix. EDIT: Try-catch seems to be 1 byte shorter than the if(i instanceof Integer). \$\endgroup\$ – Kevin Cruijssen May 8 '18 at 12:11
  • \$\begingroup\$ @KevinCruijssen oh didn't notice that, thanks! \$\endgroup\$ – HyperNeutrino May 9 '18 at 12:09

Jolf, 20 bytes

I can probably golf this... I need to implement type-checking shorter solutions.

γ fxd='nF~tH0ͺZkγZKγ
 _fx                 filter the input
    d='nF~tH0        checking for number type
γ                    call that "γ"
             ͺ       pair
              ZkγZKγ  the min and max of the array

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.