text:
Find the needle in the haystack
Given a rectangular haystack of size at least 2x2 composed of all the same printable ASCII characters, output the location (counting from the top-left) of the needle which is a different character.
For example, if the following haystack is input:
#####
###N#
#####
#####

The output should be 3,1 when zero-indexed (what I'll be using in this challenge) or 4,2 when one-indexed.
The haystack can be composed of any printable ASCII character:
^^^
^^^
^N^
^^^
^^^
^^^

output: 1,2
and the needle will be any other printable ASCII character:
jjjjjj
j@jjjj
jjjjjj

output 1,1
It's also possible to have a needle in the corner:
Z8
88

output 0,0
88
8Z

output 1,1
or to have the needle at the edge:
>>>>>>>>>>
>>>>>>>>>:
>>>>>>>>>>

output 9,1
Rules and Clarifications

Input and output can be given by any convenient method. This means you can take input as a list of list of characters, as a single string, etc.
You can print the result to STDOUT or return it as a function result. Please state in your submission what order the output is in (i.e., horizontal then vertical, as used in the challenge, or vice versa).
Either a full program or a function are acceptable.
You do not get to pick which characters to use. That's the challenge.
The haystack is guaranteed to be at least 2x2 in size, so it's unambiguous which is the needle and which is the hay.
There is only ever one needle in the input, and it's only ever one character in size.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Suggested test case: 88\n8Z (with any two characters of course).

Can we take input as a multi-dimensional array? i.e. [
['#','#','#','#','#'],
['#','#','#','N','#'],
['#','#','#','#','#'],
['#','#','#','#','#'] ];

@gwaugh Like a list of list of characters? Yes, that's fine (and explicitly called out as OK).

Can we take input as a pair of a string without newlines and the width (or height) of the haystack? i.e. ("########N###########", 5)

@someone Yes, though it doesn't have a real quorum, I feel that should be allowed.

On the topic that @someone asked, can we take input as pair of string w/o NL and width as function params?

@gwaugh Yes, that's fine.

@AdmBorkBork would a numpy array of int32 be fine as input? (note that numpy does have char arrays as well)

@ASCII-only If int32 is the only way to take input, that would be OK, but given that char arrays are possible, I'm going to rule that numpy must use char arrays.

What about ##\n@@ i.e. same amount of both characters

@FireCubez There's only one needle. I can make that explicitly clear, if you think it's necessary?

i.e. input is guaranteed to only have one needle? I think you should clear that up, since I got confused at first.

@FireCubez Added. Thanks!

"The haystack is guaranteed to be at least 2x2 in size" – does this mean it's guaranteed to be at least 2 wide and 2 high, or that it's guaranteed to be at last 4 characters in area?

@Deadcode I think also 3x1 or 1x3 may be correct. It could be enough to have one needle different from the rest from my point of view.

@Deadcode Guaranteed at least 2 wide and 2 high. While AZTECCO is correct that 1x3 or 3x1 is enough to distinguish the needle and hay, such a situation will never happen.

R, 49 47 44 bytes
function(m,`?`=which)m==names(?table(m)<2)?T

Try it online!
Takes input as a matrix, returns 1-indexed coordinates

That which assignment is disgracefully smooth.

I was so excited to try this challenge in R, then I saw this and decided to cry in awe instead

Perl 6, 41 38 37 bytes
3 bytes saved thanks to @nwellnhof.
1 byte saved thanks to Jo King.
{map {[+] ^∞Z*!<<.&[Z~~]},$_,.&[Z]}

Try it online!
Explanation
It takes the input as a list of lists of characters and returns list of length 2 containing zero-based X and Y coordinates of the needle.
It works by applying the block {[+] ^∞ Z* !<<.&[Z~~]} on the input and on its transpose. .&[Z~~] goes through all columns of the argument and returns True if all the elements are the same, False otherwise. We then negate all the values (so we have a list with one bool per column, where the bool answers the question "Is the needle in that column?"), multiply them element-wise with a sequence 0,1,2,... (True = 1 and False = 0) and sum the list, so the result of the whole block is the 0-based number of the column where the needle was found.
Nwellnhof's better approach, Perl 6, 34 bytes
{map *.first(:k,*.Set>1),.&[Z],$_}

Try it online!
Explanation
Generally the same approach, just more effective. It still uses a block on the array and its transpose, but now the block converts all rows intoSets and checks for the number of elements. The first function then gives index (due to the :k) of the first row that contained more than 1 element. Because of that, the order of $_ and .&[Z] needed to be swapped.

Nice approach! 34 bytes with first(:k), Set and .&[Z].

@nwellnhof, very well done. You basically found what I wanted to find but failed to do that :—). (Also I had no idea that you could write .&[Z].)

In general, .&[op] doesn't seem to be equivalent to [op] $_ but it works with Z for some reason.

Python 2, 57 bytes
lambda m:[map(len,map(set,a)).index(2)for a in zip(*m),m]

Try it online!

A port of this to Python 3 can be 62 bytes:
lambda m:[[len(set(v))for v in a].index(2)for a in(zip(*m),m)]

The list comprehension, [len(set(v))for v in a], is shorter than the double map by two bytes now as it would need to be cast to a list like list(map(len,map(set,a)))
Try it online!

Brachylog, 20 bytes
c≡ᵍ∋Ȯ&;I∋₎;J∋₎gȮ∧I;J

Try it online!
Outputs [I,J], where I is the row index and J the column index, both 0-indexed.
Stupidely long, but getting indexes in Brachylog is usually very verbose.
Explanation
c                       Concatenate the Input into a single string
 ≡ᵍ                     Group identical characters together
   ∋Ȯ                   Ȯ is a list of One element, which is the needle character
     &;I∋₎              Take the Ith row of the Input
          ;J∋₎          Take the Jth character of the Ith row
              gȮ        That character, when wrapped in a list, is Ȯ
                ∧I;J    The output is the list [I,J]

PHP, 99 85 bytes
Using string without newlines and the width (or height) ('########N###########', 5) as input.

-5 bytes by removing chr() call, props to @Titus
-9 bytes by taking input as two function args, also props to @Titus

function($a,$l){return[($p=strpos($a,array_flip(count_chars($a,1))[1]))%$l,$p/$l|0];}

Try it online!
Ungolfed:
function need_hay( $a, $l ) {

    // identify the "needle" by counting the chars and
    // looking for the char with exactly 1 occurrence
    // note: this is 1 byte shorter than using array_search()
    $n = array_flip( count_chars( $a, 1 ) )[1];

    // find the location in the input string
    $p = strpos( $a, $n );

    // row is location divided by row length, rounded down
    $r = floor( $p / $l );

    // column is remainder of location divided by row length
    $c = $p % $l;

    return array( $c, $r );

}

Output:
#####
###N#
#####
#####
[3,1]

^^^
^^^
^N^
^^^
^^^
^^^
[1,2]

jjjjjj
j@jjjj
jjjjjj
[1,1]

no need for chr: If the second parameter for strpos is an integer, it will be interpreted as an ASCII code. -> -5 bytes. 2) Two function parameters $s,$w can save another 9 bytes.

@Titus, removing the chr() that's brilliant. Thx!  The func params did occur to me too, I just didn't want to run afowl of input req's. I'll clarify w/OP.

05AB1E, 9 6 bytes
Saved 3 bytes switching input format.
Input is taken as a string and a row-length.
Output is a zero-based list of the form [y, x]
D.mks‰

Try it online!
or as a Test Suite
Explanation
D           # duplicate the input string
 .m         # get the least frequent character
   k        # get its index in the string
    s       # swap the row length to the top of the stack
     ‰      # divmod the index of the least frequent char with the row length

Dang, you beat me to it. Was working on an answer. Had just finished a 13-byter. But yours is way better, so +1 instead. :) Completely forgot about .m..

@KevinCruijssen: Yeah. I don't think I've ever used  .m before, but I was reasonably sure I'd seen it at some point :)

Python 3 + NumPy, 75 66 bytes
-9 bytes thanks to @ASCII-only
lambda x:where(x.view('i')-median(x.view('i')))
from numpy import*

Try it online!
This assumes that the input is a NumPy array. The output is zero-indexed, and first vertical, then horizontal.
It converts the input from char to int then calculates the median of the array, which will be the haystack character. We subtract that from the array, which makes the needle the only non-zero element. Finally, return the index of that element with numpy.where().

Since you know the input will be ASCII (i.e. fits in a byte) why not use uint8 for one byte less?

Language has to be "Python 3 + numpy" here since numpy isn't included with the normal Python distribution

@Draconis that was actually my plan, but that introduced zeros between the correct uint8 ASCII-codes. I assume this is because Python3 uses Unicode as standard input format for strings.

also it would be nice if you linked "numpy" to numpy's website

74

Also, might want to ask OP if it's ok to take input already converted to uint32

69

66

Wow nice @ASCII-only. I included this in my answer, please let me know if this is ok with you or if you'd prefer to create a separate answer.

It's fine, after all it's not only based off your solution, but also I don't normally use numpy anyway. Plus, it's kinda unavoidable that a solution might be very similar anyway given that all solutions are public and this is a relatively easy challenge

JavaScript (ES6), 55 bytes
Takes input as \$(s)(w)\$, where \$s\$ is a string and \$w\$ is the width of the matrix. Returns \$[x,y]\$.
s=>w=>[(i=s.indexOf(/(.)\1+(.)/.exec(s+s)[2]))%w,i/w|0]

Try it online!

JavaScript (ES6),  65  64 bytes
Saved 1 byte thanks to @Neil
Takes input as a matrix of characters. Returns \$[x,y]\$.
m=>m.some((r,y)=>r.some((c,x)=>!m[p=[x,y],~y&1].includes(c)))&&p

Try it online!
How?
We look for the first character \$c\$ located at \$(x,y)\$ which does not appear anywhere in another row \$r[Y]\$. We can perform this test on any row, as long as \$Y\ne y\$. Because the input matrix is guaranteed to be at least \$2\times 2\$, we can simply use \$Y=0\$ if \$y\$ is odd or \$Y=1\$ if \$y\$ is even.

~y&1 saves a byte over y&1^1.

Java 8, 132 111 bytes
m->{int c=m[0][0],i=0,j;for(c=m[1][0]!=c?m[1][1]:c;;i++)for(j=m[i].length;j-->0;)if(m[i][j]!=c)return i+","+j;}

-8 bytes (and -13 more implicitly) thanks to @dana.
Input as character-matrix.
Try it online.
Explanation:
m->{                    // Method with char-matrix parameter and String return-type
  int c=m[0][0],        //  Character to check, starting at the one at position 0,0
      i=0,j;            //  Index integers
  for(c=m[1][0]!=c?     //  If the second character does not equal the first:
         m[1][1]        //   Use the character at position 1,1 instead
        :c;             //  Else: keep the character the same
      ;i++)             //  Loop `i` from 0 indefinitely upwards:
    for(j=m[i].length;j-->0;)
                        //   Inner loop `j` in the range (amount_of_columns, 0]:
      if(m[i][j]!=c)    //    If the `i,j`'th character doesn't equal our character to check:
        return i+","+j;}//     Return `i,j` as result

124 - the final return statement should never get hit. There might be a better way to keep the outer loop going?

@dana Thanks! As for: "There might be a better way to keep the outer loop going?", there certainly is; just removing it so it becomes an infinite loop. And then the return""; is unreachable and can be removed as well. :D So -21 bytes thanks to you.

Interesting... I had tried removing the outer loop condition and was getting an unreachable code error. Didn't know that removing the final return was the fix.

What exactly does the --> operator do in the inner loop? I was trying to find the java docs for that syntax but couldnt find anything

@KBusc It's two operators: i-- and >. :) See this SO answer for more info. So the i > 0 is executed first, checking if i is larger than 0. And then i is decreased by 1 with i--, before it enters the body of the loop.

Huh, neat, I dindt know you could do that. Thanks!

Jelly, 5 bytes
Outputs [height, width] (1-indexed).
ŒĠLÐṂ

Try it online!
ŒĠLÐṂ – Monadic link / Full program. Takes a list of strings M as input.
ŒĠ    – Group the multidimensional indices by their values (treating M as a matrix).
  LÐṂ – And retrieve the shortest group of indices (those of the unique character).

Jelly, 5 bytes
ŒĠḊÐḟ

Try it online!

Jelly, 4 bytes
Maybe this could've just been a comment for Mr. Xcoder it is pretty similar...
ŒĠEƇ

A monadic link accepting the matrix of characters which yields a list of one item, the  1-indexed (row, column) co-ordinate from top-left.
(...As a full program given an argument formatted such that parsing results in a list of lists of characters -- that is a list of strings in Python format -- the single coordinate is printed.)
Try it online!
How?
ŒĠEƇ - Link: matrix, M
ŒĠ   - multi-dimensional indices grouped by Value
     -  ...due to the 2*2 minimum size and one needle this will be a list of two lists one
     -     of which will have length one (the needle coordinates as a pair) and the other
     -     containing all other coordinates as pairs
   Ƈ - filter keeping those for which this is truthy:
  E  -   all equal?
     -   ... 1 for the list of length 1, 0 for the list of at least 3 non-equal coordinates

Well... this seems borderline, since the EƇ is clever.

Wolfram Language 37 58 bytes
My earlier entry did not correctly handle the case where the "odd character out" was at the upper left corner of the matrix.  This does.
#~Position~Keys[TakeSmallest[Counts@Flatten@#,1]][[1]]&

Counts@Flatten@# lists how many of each character are in the array, #.
TakeSmallest[...,1] returns the least frequent count, in the form of an association rule such as <| "Z"->1|>
Keys...[[1]] returns the "key" to the only item in the association, that of the least used character. ("Z" in the present case)
#~Position~... returns then position of the key in the original matrix, #.

MATL, 12 8 bytes
tX:XM-&f

Try it online!
Using the mode function as the majority-detector. Returns 1-based indices.
 t           % duplicate the input
  X:         % turn the copy into a linear array
    XM       % find the arithmetic mode of that (the 'haystack' character)
      -      % Subtract that from the original input
       &f    % find the position of the non-zero value in that result

-4 characters thanks to @LuisMendo

@LuisMendo Thanks. I don't think I knew about the 2 output version of find, even in MATLAB. (Hi, btw!)

Perl 5 -p00, 52 45 bytes
/^(.)(\1*
)*(\1*)|^/;$_=$&=~y/
//.$".length$3

45 bytes
52 bytes
How

-p00 : like -n but also print, paragraph mode
/^(.)(\1*
)*(\1*)|^/ : matches either

from start $1: first character, $2: repetition (not used), $3: characters before the "needle" in the line, $& whole match
or null string (position 0) no capture.

$_= : to assign the default input/argument variable
so $&=~y/
// the number of newlines of $&
.$". : concatenate with $" (space character by default) and concatenate
length$3 : the length of $3

R 42 bytes
function(m)which(ave(m,m,FUN=length)==1,T)

Try it online!
Input: a haystack matrix m
Output: (row,col) vector - index starting at 1

Nice job, and welcome to PPCG! I believe this is 42 bytes, since the f= can be omitted from the byte count, but not the function(m)=.

@BLT I wasn't sure about that but thanks for the heads up :)

Python 2, 53 47 bytes
lambda s,w:divmod(s.find(min(s,key=s.count)),w)

Try it online!
Call as f("########N###########", 5) (allowed in a comment). Outputs (y, x).
Erik saved 6 bytes, suggesting rearranging the output + using divmod. Thanks!

You can reorder the output, so you can use the divmod builtin.

C# (Visual C# Interactive Compiler), 109 108 107 bytes
First() => Last() for -1 byte
currying for -1 byte thanks to Embodiment of Ignorance
a=>w=>{var d=a.Where(b=>b!=a[0]).Select(b=>a.IndexOf(b));return d.Count()>1?(0,0):(d.Last()%w,d.Last()/w);}

Try it online!

J, 22 bytes
$#:(i.~.{~1 i.~#/.~)@,

Try it online!
NB. returns answer in (row, column) format.

PowerShell, 107 98 82 77 bytes
$l=@{}
$args|%{if($_-10){$l.$_+=$x++,+$y}else{$x=0;++$y}}
$l|% v*|? c*t -eq 2

Try it online!
Takes a splatted string with LFs. Returns zero-indexed location x,y. Unrolled:
$locations=@{}                      # make a hashtable. key=char, value=location array
$args|%{
    if($_-10){                      # if current char is not LF
        $locations.$_+=$x++,+$y     # add $x,$y to hashtable value and move $x to next pos
    }else{
        $x=0;++$y                   # move $x,$y to next line
    }
}
$locations|% Values|? Count -eq 2   # find and output location array with 2 elements (x,y)

Scala, 98 bytes
Golfed version. Try it online!
def f(m:Seq[String])=m.transpose.map(_.toSet.size).indexOf(2)::m.map(_.toSet.size).indexOf(2)::Nil

Ungolfed version. Try it online!
object Main {
  def main(args: Array[String]): Unit = {
    val tests = Seq(
      """#####
        |###N#
        |#####
        |#####""".stripMargin,
      """^^^
        |^^^
        |^N^
        |^^^
        |^^^
        |^^^""".stripMargin,
      """jjjjjj
        |j@jjjj
        |jjjjjj""".stripMargin,
      """Z8
        |88""".stripMargin,
      """88
        |8Z""".stripMargin
    )

    val f: Seq[String] => Seq[Int] = m => m.transpose.map(_.toSet.size).indexOf(2) :: m.map(_.toSet.size).indexOf(2) :: Nil

    tests.foreach { test =>
      val v = test.split("\n")
      v.foreach(println)
      println("   -> " + f(v) + "\n")
    }
  }
}

Julia, 78 bytes
s->(n=argmin(x->count(x,'
's),s);q=split(s);~=findlast;b=~(n.∈q);(n~q[b],b))

Attempt This Online!
This function takes input as a single string, which probably isn't the most efficient approach. The output is 1-indexed.
-19 bytes thanks to MarcMush: add a newline to the haystack to guarantee that the needle is always the least frequent character, even in a 2x2 haystack.
Interestingly, concatenating a character literal with a string variable doesn't require an operator in Julia. Apparently, it's parsed just like numeric literal coefficients with variables. This saves a byte here, which is the best thing to come out of Julia's choice of concatenation operator.

Julia, 78 bytes: s->(n=argmin(x->count(x,' 's),s);q=split(s);~=findlast;b=~(n.∈q);(n~q[b],b))

Lua, 103 91 bytes
s,l=...s:gsub('.',load'c=...b=b or not s:find(c..c,1,1)and s:find(c,1,1)')print(b%l-1,b//l)

Try it online!
Ungolfed version:
s,l=...                                           --Take in haystack and line width as args
s:gsub('.',function (d)                           --For each character in s
    b=b or not s:find(c..c,1,1)and s:find(c,1,1)  --If there is only one instance of c, store location
end)
print(b%l-1,b//l)                                 --Print results

Stax, 15 bytes
this can probably be golfed down a bit as there's a lot of register shenanigans i'm not a huge fan of. takes an array of a single string with a width
Ç║æ░·╝;J╕╤¢ⁿÿì<

Try it online! (With test cases)
This is Packed Stax, which unpacks to the following:
Stax, 17 bytes
Nc|!IYxhX%yx/2l|u

Run and debug it
N                 # get the string
 c|!              # get the rarest element
    I             # get the first index in the string of this
     Y            # store that in register Y
      xh          # get the width
        X         # and store this value in register x
         %        # modulo with what was stored in register Y
          yx      # register y and register x from above
            /     # divide them
             2l   # create an array of the top two elements on the stack
               |u # and put it in a format which can be printed

Java 8, 104 Bytes
(x,w)->{int i=0,p=x.length;for(;i<p;i++)if(x[i]!=x[(i+1)%p]&&x[i]!=x[(i+2)%p])break;return i/w+","+i%w;}

Input is array of char, and integer indicating row width.
Output is zero-based, vertical then horizontal (i.e., row number then column number)
Explanation:
(x,w)->{
    int i=0, p=x.length;
    for (;i<p;i++)          //iterate through characters in x
      if (x[i]!=x[(i+1)%p] && x[i]!=x[(i+2)%p])    //compare x[i] with the two subsequent characters in array, wrapping around if necessary
        break;
    return i/w+","+i%w;}  //return row number then column number, zero-based

Python 3, 93 bytes
def f(s):x=s.find("\n")+1;return[(i%x,i//x)for i,c in enumerate(s)if s.count(c)<2and" "<c][0]

Try it online!
Input is taken as a multiline string. Output is 0-indexed

Octave, 40 bytes
@(x){[r,c]=find(x-mode(+x(:))) [c,r]}{2}

Port of @sundar's MATL answer. Output is a two-element vector with 1-based column and row indices.
Try it online!

Retina 0.8.2, 41 bytes
s`(?=(.)+\1)(.*?¶)*(.*)(?!\1|¶).+
$.3,$#2

Try it online! 0-indexed. Explanation:
s`

Allow . to match newlines. This costs 3 bytes (3rd byte is the ? before the ¶) but saves 6 bytes.
(?=(.)+\1)

Look ahead for two identical characters. \1 then becomes the hay.
(.*?¶)*

Count the number of newlines before the needle.
(.*)

Capture the hay to the left of the needle.
(?!\1|¶)

Ensure that the needle isn't hay or a newline.
.+

Match the rest of the hay so that the result replaces it.
$.3,$#2

Output the width of the left hay and the number of newlines.

C# (Visual C# Interactive Compiler), 82 bytes
x=>w=>{int y=x.IndexOf(x.GroupBy(c=>c).Last(g=>g.Count()<2).Key);return(y%w,y/w);}

Thanks to dana for shaving off 6 bytes!
Try it online!
Old solution, 106 bytes
n=>m=>{var z=n.Distinct();int d=n.IndexOf(n.Count(c=>c==z.First())>1?z.Last():z.First());return(d%m,d/m);}

Both take input as a string and an integer specifying the amount of columns.
Try it online!

@dana never knew that Enumerable.Last() accepted a delegate, thanks

C (clang), 74 bytes
h(char*s,z,x){for(s+=z--;*s==*--s|*s==s[-1];)z--;printf("%d,%d",z%x,z/x);}

Try it online!
DEGOLF
int h(char*s,int z,int x){// z = string size, x = row size

 for(s+=z--;
 // move pointer just over the end of the string
 // and move z counter to the end of string

*s-*--s?   ==>  *s==*--s|  @ceilingcat suggestion
 // if the previous element is different we will check if the next element is also different
 // if not the result is 1 and the iteration continue
 // in the first iteration it will be different because the pointer is just  over the end

 *s-s[-1]? ==> changed to *s==s[-1]   @ceilingcat suggestion
 // the second check returns 0 if the char changed again so it was the needle
 // if not it's because in the first iteration the first check finded a difference just because the pointer was just over the end

 /*0:1*/   :1;)z--;

 printf("%d,%d",z%x,z/x);
}

Python 3, 93 89 85  58 bytes
Complete rewrite taking input as concatenated string, width:
lambda g,w:divmod(g.index({g.count(c):c for c in g}[1]),w)

Try it online!

Original answer:

def k(g):t=''.join(g);return divmod(t.index({t.count(c):c for c in t}[1]),len(g[0]))

EDIT: Saved 4 bytes by swapping linebreak/indent for semicolons. Saved another 4 bytes by using divmod(thanks @JonathanFrech).
Try it online!
I know this could be a lot shorter, but I just wanted to try an approach around this dict comprehension.

Using divmod would save five bytes.

APL (Dyalog Unicode), 9 bytesSBCS
Anonymous tacit prefix function. In a sense, this is actually a kind of poly-glot, as it takes as argument either a character matrix or a list of strings, with the code meaning something else in each case. Always returns [row,column] in which ever index origin is currently active. (APL lets you choose.)
⍸↑=∊~∘∊∩/

Try it online!
If the argument is a matrix, the function works like this:
 ∩/ intersection reduction of each row. Since there will be at least one all-hay row, this gives us at least one hay character. And since every row has at least one hay character, the intersection will always empty out the row that has the needle character.
 ∊ ϵnlist (flatten) this, giving us one or more hay characters
 ∘ then…
 ~ remove all such characters from…
 ∊ the ϵnlisted (flattened) argument, leaving just the needle
 ↑= Boolean matrix indicating where the matrix equals the needle
 ⍸ the indices where true
If the argument is a list of strings, the function works like this:
 ∩/ intersection reduction of the strings. Since only one string will have a needle, and all strings have hay, this will give us one or more hay characters without the needle character.
 ∊ ϵnlist (flatten) this, giving us the one or more hay characters
 ∘ then…
 ~ remove all such characters from…
 ∊ the ϵnlisted (flattened) argument, leaving just the needle
 ↑= Boolean matrix indicating where the matrix constructed by merging the strings equals the needle
 ⍸ the indices where true

Ruby, 43 bytes
Takes the haystack as a single line and its width as arguments. Returns the 0-based row, then column as an array.
->s,w{(/[^#{s[/(.)(?=\1)/]}]/=~s).divmod w}

Attempt This Online!

Arturo, 49 bytes
$[s w]->/%index s first select tally s[k v][1=v]w

Try it
Takes input as a single line and a width. Returns a 0-indexed [row col] pair.

Vyxal, 5 bytes
ƒ⊍hÞḟ

Try it Online!
Takes a list of lines. Outputs 0-indexed [row, column]. Vyncode does nothing here apparently, it decided.
Explained
ƒ⊍hÞḟ
ƒ⊍    # reduce by set xor
  h   # get the first of that
   Þḟ # find it's multidimensional index

C (gcc), 81 bytes
Takes input as three pointers: one to the array, and two to the dimensions. Returns by modifying the dimensions to be the coordinates of the needle.
i;f(char*a,int*w,int*h){for(i=0;*a==a[i];i++);i=i-1?i:*a==a[2];*h=i/ *w,*w=i%*w;}

Try it online!
Degolf
i;f(char*a,int*w,int*h)
{
  for(i=0;*a==a[i];i++); // Count the number of elements equal to
                         // the one at (0,0)
  i=i-1?i:*a==a[2];  // Special case i==1, because it is
          // ambiguous whether the needle is at 0 or 1 there.
  *h=i/ *w,*w=i%*w; // Modify pointers to indicate coordinates.
  // the space between i/ and *w is required, as /* starts a comment
}

Suggest i=*a;i=strspn(a,&i) instead of for(i=0;*a==a[i];i++)

Python 2, 63 bytes
lambda s,w:divmod(s.find({s.count(c):c for c in s}[1]),w)[::-1]

Try it online!
Expects a string with no newlines and the width of the haystack as arguments.
Explanation:
                         # get a dictionary of (number of occurrences : character)
                         {s.count(c):c for c in s}
                         # only one character will have one occurrence, so get that character
                         .........................[1]
                  # get the 0-indexed index of the needle character
                  s.find(............................)
           # flat_index / width will give us how many rows "down" the needle is (the y-value)
           # the remainder will give us how many columns "over" the needle is (the x-value)
           # so take the divmod and reverse the returned values to get (x,y)
           divmod(....................................,w)[::-1]
# anonymous function, takes haystack string with no newlines and haystack width
lambda s,w:

C# .NET, 133 112 111 bytes
m=>{var c=m[0][0];c=m[1][0]!=c?m[1][1]:c;for(int i=0,j;;i++)for(j=m[i].Count;j-->0;)if(m[i][j]!=c)return(i,j);}

-1 byte thanks to @EmbodimentOfIgnorance.
Port of my Java answer, but with a List<List<char>> input and int-tuple output, instead of char[][] input and string output.
Try it online.

Can't you save two bytes by turning you char[][] into a List<List<char>>? Since List<T>.Count is shorter than Array.Length

@EmbodimentofIgnorance Thanks! :)

MATLAB, 68 22 bytes
[r,c]=find(v~=v(1));if size(r,1)>1 disp([1,1]);else disp([r,c]);end;
If I could exclude any one case, such as [1,1] in this solution, I could have saved several bytes.
Updated solution:
@(v)find(v-mode(v(:)))

Thanks to @sundar for helping me with the special case problem and saving 42 bytes! Also, thanks to @Luis_Mendo for the suggestions and saving me another 2 bytes!

I think you can get rid of the check for [1,1] case by using mode(v(:)) instead of v(1).

You need to wrap your code so that it is a full program or a function; you cannot assume that the input is in a variable v. Also, you can probably replace ~= by -, and remove the final ;

MATL, 11 bytes
tX:YmyYk-&f

Output is row, then column; 1-based.
Try it online!
Explanation
t    % Implicit input. Duplicate
X:   % Linearize into a column
Ym   % Compute mean (characters are converted to ASCII codes)
y    % Duplicate from below: pushes input again
Yk   % Closest value: gives the input value that is closest to the mean
-    % Subtract, element-wise. Gives non-zero for the value farthest from the mean
&f   % Two-output find: gives row and column indices of nonzeros. Implicit display

Pyth, 15 14 12 bytes
.Dxz-zh.-z{z

Takes input as the length of the row and the input without lines and outputs as [row, column].
Try it here
Explanation
.Dxz-zh.-z{z
       .-z{z    Subtract one of each character from the input.
      h         Take the first.
    -z          Remove all instances from the input.
  xz            Find the remaining character in the input.
.D          Q   Take the result divmod the (implicit) length of the row.

Old approach
mxJmt{kdeSJ.TB

Try it here
Explanation
mxJmt{kdeSJ.TB
           .TBQ   Take the (implicit) input and its transpose...
m      d          ... and for each...
   mt{k           ... deduplicate each row...
 xJ     eSJ       ... and find the index of the largest.

Charcoal, 40 bytes
≔§⎇⌕θ§θ¹ηθ⁰ζＳθＷ⁼№θζＬθ«⊞υωＳθ»Ｉ⌕Ｅθ⁼ιζ⁰,ＩＬυ

Try it online! Link is to verbose version of code. I must be doing something wrong because this is almost as long as the Retina answer. Explanation:
≔§⎇⌕θ§θ¹ηθ⁰ζ

Check whether the second character in the first string is also the first character, and take the first character of the first string if so otherwise the first character of the second string if not. This is then the hay.
ＳθＷ⁼№θζＬθ«⊞υωＳθ»

Keep reading strings until a string whose hay is less than its length is found.
Ｉ⌕Ｅθ⁼ιζ⁰,ＩＬυ

Output the position of the mismatching element and then the number of strings previously read.

Röda, 81 bytes
f a{i=indexOf;l=i("
",a)+1;chars a|sort|count|[[_2,_1]]|min|i _[1],a|[_%l,_1//l]}

Try it online!
Takes input as a string containing newline-terminated lines. Returns a stream containing 0-indexed horizontal and vertical indexes.

Perl 5 -n0, 77 bytes
$t=(@b=sort/./g)[0]eq$b[1]?pop@b:$b[0];++$y&/\Q$t/g&&say"$y,",pos for /.+$/mg

Try it online!
Output is row,column starting from the top left, 1-indexed

Haskell, 64 bytes
f s=[(r,c)|c<-[0..],r<-[0..length s-1],any(notElem$s!!r!!c)s]!!0

Try it online! f takes a list of lines and returns zero-indexed (row,column).
Works by iterating through the columns and rows and looking for a character which does not appear on all rows.

APL+WIN, 39 bytes
Index origin =1.
Prompts for character matrix as a string input followed by row width.
Outputs row by column index position.
(,(⍳i÷n)∘.,⍳n←⎕)[((1=+/m∘.≡m)/⍳i←⍴m←⎕)]

Try it online! Courtesy of Dyalog Classic
Explanation:
⍳i←⍴m←⎕ Prompt for string and create a vector of indices from 1 to length string.

(1=+/m∘.≡m) Boolean vector identifying position of unique character in string.

(...)/⍳i Use Boolean to select index position of unique character.

,⍳n←⎕ Prompt for row width of character matrix and create a vector of indices.

,(⍳i÷n)∘., Create a nested vector of row by column indices of character matrix.

(...)[...] Select row by column index position of unique character.

Kotlin, 142 bytes
The result is zero based [vertical,horizontal].
{d:List<String>->val h=if(d[0][0]!=d[0][1])d[1][0]
else d[0][0]
var a=""
for(r in d.indices)for(c in d[r].indices)if(h!=d[r][c])a="[$r,$c]"
a}

Try it online!

Python3
Well I've never tried to do code golf before and I really can't compete with some of
these really good solutions, so I've prepared a long-form answer just to demonstrate
how I would solve this problem. This function takes a 2-D list of characters of any
size as its input.
(edited to shorten the function up as much as I could)
def f(i):
    a = None
    b = 0
    c = None
    d = 0
    h = len(i)
    for y in range(h):
        for x in range(len(i[y])):
            if a == None:
                a = i[y][x]
            elif a != None:
                if i[y][x] != a:
                    c = i[y][x]
            if i[y][x] == a:
                b += 1
            elif i[y][x] == c:
                d += 1
    if b == 1:
        n = a
    elif d == 1:
        n = c
    for y in range(h):
        for x in range(len(i[y])):
            if i[y][x] == n:
                return (x, y)

Here is a longer version that demonstrates the example input. If you run this script
it will show you the 2-D array and the needle (randomly generated every time) as
well as solve it with the find_needle() function.
# Code golf! Needle in a haystack challenge
# sgibber2018 (my email handle)
"""
Notes: I can't really compete with what's already been done but I'm doing
       it just to do it.
"""

import random

input_height = 10
input_width = 10
example_input = [["#" for x in range(input_width)] \
    for y in range(input_height)]
needle_spot_y = random.randrange(input_height)
needle_spot_x = random.randrange(input_width)
example_input[needle_spot_y][needle_spot_x] = "!"

for y in range(input_height):
    print(example_input[y])

# and now for the algorithm itself:
def find_needle(example_input):
    # declare two variables to count different char types
    c1 = None
    c1_count = 0
    c2 = None
    c2_count = 0
    # iterate through the whole list
    height = len(example_input)
    for y in range(height):
        for x in range(len(example_input[y])):
            # assign c1 or c2 accordingly
            if c1 == None:
                c1 = example_input[y][x]
            elif c1 != None:
                if example_input[y][x] != c1:
                    c2 = example_input[y][x]
            # count the symbols based on whether or not they match
            if example_input[y][x] == c1:
                c1_count += 1
            elif example_input[y][x] == c2:
                c2_count += 1
    # Find the value with just one increment
    if c1_count == 1:
        needle = c1
    elif c2_count == 1:
        needle = c2
    # go back through the list and find the needle and get it's pos
    for y in range(height):
        for x in range(len(example_input[y])):
            if example_input[y][x] == needle:
                return (x, y)

print(find_needle(example_input))

The function find_needle() takes a 2-D list and returns the coordinates of the
character that only has one count. I could probably shorten this up a little but I
don't think I can compete with the existing Python3 answer which is mighty impressive.
How do you calculate the size of your answers?

Done! I'm wary of violating Python's whitespace rules too much but I shortened all the variables. Thanks for the heads up. How do I calculate the bytes?

You can use a number of tools.  Here is an environment you can use that counts bytes, if you hit the link button at the top it will even generate an form filled answer for you.  Also some tips:  most operators =, == etc. don't require space on each side of them, so you can remove that easily, If you want to reply to a user in comments you can use @  other wise they are unlikely to see it.  Anyway, hope you have fun here!

I'd also suggest looking at the Tips for golfing in Python page for some general shortcuts you can take

Welcome to PPCG! I recommend going through the tips as per Jo King's suggestion. RE: "I'm wary of violating Python's whitespace rules" - for code-golf you need to violate whatever saves bytes and still works; however for this challenge we can make do with no newlines at all - the only white-space abuse of the port of my Python 2 answer to Python 3 (at 62 bytes) is to miss the space between ) and for [twice] and between in and ( - and, in fact, no "Python rules" are broken only "style guidelines" (although I don't actually see this one in PEP-8).

The current code (using tabs or single spaces in place of four spaces) is 387 bytes. Removing trivial white-space is 347 bytes.

Employing a bunch of golfing techniques and the fact that we do not need both counts (we are guaranteed a single needle and >=3 others) we can get this method to 158 bytes.

Wow good tips thanks. I'll employ them on the next one!

C# (.NET Core), 135 111 bytes
S=>{for(int x=0,y;;x++)try{for(y=0;;y++)if(S[x][y]!=(S[0][0]==S[0][1]?S[0][0]:S[1][0]))return y+","+x;}catch{}}

Try it online! (111 bytes)
Try it online! (135 bytes)
New one:
for (int x = 0, y; ; x++)
    try
    {
        for (y = 0; ; y++)
            if (S[x][y] != (S[0][0] == S[0][1] ? S[0][0] : S[1][0]))
                return y + "," + x;
    }
    catch { }

Previous one:
int i = 0, y;
var r = "";
for (; i < S.Length; i++)
    for (y = 0; y < S[i].Length; y++)
        r = S[i][y] != (S[0][0] == S[0][1] ? S[0][0] : S[1][0]) ? i + "," + y : r;
return r;

C (VC++) Visual Studio 2017, 538bytes
well there can be a couple of Bytes be stripped of if the haystack and needle string is Input via command line Parameters but i can not get it to work proberly then so the haystack and needle string is hard coded in the source (ugly….. ) takes 50bytes
Maybe anyone wants to improve on that
anyway the  Code i came up with is
#include"stdafx.h"
#define r v[1][i]
#define i(x,y) if(x==y)
void main(){const char*v[]={"haystack.exe","#####\n##+##\0" };int i=0,z=0,s=0,c=r,f=c,a=-1,h=0;do{c=r;i(c,f)a++;i(a,1)h=c;if(h&&c!=h&&c!=10)break;i(c,10){z++;s=0;}}while(s++,i++,c);printf("%d,%d",s-1,z);}

the ungolfed variant is
#include "stdafx.h"

int main(/*int argc, const char * argv[]*/)
{
    const char * argv[] = {"haystack.exe","#####\n##+##\0" };
    int i = 0,row = 0, col = 0;
    char character = argv[1][i];
    char firstChar = character;
    int howMany = -1;
    char hay = '\0';
    do
    {
        char character = argv[1][i];
        if (character == firstChar)
        {
            howMany++;
        }
        if (howMany ==1)
        {
            hay = character;
        }
        if ((hay != '\0') && (character != hay)&&(character!='\n'))
        {
            break;
        }
        if (character == '\n')
        {
            row++;
            col = 0;
        }
        col++;
        i++;
    } while (character != '\0');
    printf("%d,%d", col-1, row);
    while (1);
    return 0;
}

i dont expect this to be explained

Welcome to PPCG! I'm not familiar enough with C++ to assist, but I know there's a tips page you can check out.

Befunge-98 (PyFunge), 62 bytes
~:04p~-k#v>~:a-!2j6$_04g-!..@
-#v_$$1+0>  >~:a
.;>04g-#;_1+^@.

Try it online!
Output is: column row


text:
Plight of the Concorde
Background
The traveling salesman problem (TSP) asks for the shortest circuit that visits a given collection of cities.  For the purposes of this question, the cities will be points in the plane and the distances between them will be the usual Euclidean distances (rounded to the nearest integer).  The circuit must be "round-trip", meaning it must return to the starting city.
The Concorde TSP solver can solve instances of the Euclidean traveling salesman problem, exactly and much faster than one would expect.  For example, Concorde was able to solve an 85,900-point instance exactly, parts of which look like this:
However, some TSP instances take too long, even for Concorde.  For example, no one has been able to solve this 100,000-point instance based on the Mona Lisa.  (There is a $1,000 prize offered if you can solve it!)
Concorde is available for download as source code or an executable.  By default, it uses the built-in linear program (LP) solver QSopt, but it can also use better LP solvers like CPLEX.
The challenge
What is the smallest TSP instance you can generate that takes Concorde more than five minutes to solve?
You can write a program to output the instance, or use any other method you would like.
Scoring
The fewer points in the instance the better.  Ties will be broken by the file size of the instance (see below).
Standardization
Different computers run faster or slower, so we will use the NEOS Server for Concorde as the standard of measurement for runtime.  You can submit a list of points in the following simple 2-d coordinate form:
#cities
x_0 y_0
x_1 y_1
.
.
.
x_n-1 y_n-1

The settings that should be used on NEOS are "Concorde data(xy-list file, L2 norm)", "Algorithm: Concorde(QSopt)", and "Random seed: fixed".
Baseline
The 1,889-point instance rl1889.tsp from TSPLIB takes "Total Running Time: 871.18 (seconds)", which is more than five minutes.  It looks like this:

Relevant SE post on Generating hard Concode cases.

88 Cities, 341 seconds runtime on NEOS
In a recent paper we constructed a family of hard to solve euclidean TSP instances. You can download the instances from this family as well as code for generating them here:
http://www.or.uni-bonn.de/%7Ehougardy/HardTSPInstances.html
The 88 city instance from this family takes Concorde on the NEOS server more than 5 minutes. The 178-city instance from this family takes already more than a day to solve.

This is amazing!!

Very nice paper! Amazing outcome. You totally deserve the win on this!

77 cities, 7.24 minutes (434.4 seconds) average run time on NEOS
I’m a little late to the party, but I’d like to contribute a 77-node instance, weruSnowflake77.
I created this instance while trying to understand which local and global characteristics impose an upward pressure on the amount of time concorde takes to match its best lower bound with the length of its shortest found tour.
To construct this instance, I began with a base graph (13 x 13 square), and then systematically introduced new points or translated old points, retaining the adjustments that appeared to make concorde go deeper into its branches on average before cutting.
The technique is similar to the way a genetic algorithm mutates existing tours and retains shorter tours for the next generation of mutations, except the graph itself is being mutated and the harder-to-solve graphs are retained. It's also similar to the way we mutate graphs using relaxations to help construct good lower bounds, except I'm going the opposite way, mutating an existing graph to construct a graph with hard to find lower bounds.
In the process I’ve found a few smaller graphs that take concorde minutes to solve, but this is the first small graph I’ve found that takes concorde a minimum of 5 minutes.
With 10 trial runs on NEOS using the fixed seed and QSopt, the average runtime was 7.24 minutes (434.531 seconds). The minimum runtime was 5.6 minutes (336.64 seconds). The maximum runtime was 8.6 minutes (515.80 seconds). No trials were discarded. Full benchmark table below:
Benchmark results over 10 runs:
----------------------------------
| Run | Job ID# | Total running  |
|     |         | time (seconds) |
|-----|---------|----------------|
| 1   | 7739963 | 513.44         |
| 2   | 7740009 | 336.64         |
| 3   | 7740023 | 514.25         |
| 4   | 7740029 | 447.97         |
| 5   | 7740038 | 357.10         |
| 6   | 7740072 | 447.47         |
| 7   | 7740073 | 336.19         |
| 8   | 7740075 | 515.80         |
| 9   | 7740088 | 361.26         |
| 10  | 7740091 | 515.19         |
----------------------------------

weruSnowflake77 (x-y list, L2 norm):
77
-700 -700
700 -700
200 0
0 200
-200 0
0 -200
0 0
-600 600
-500 600
-400 600
-300 600
-200 600
-100 600
0 600
100 600
200 600
300 600
400 600
500 600
600 600
-600 -600
-500 -600
-400 -600
-300 -600
-200 -600
-100 -600
0 -600
100 -600
200 -600
300 -600
400 -600
500 -600
600 -600
600 -500
600 -400
600 -300
600 -200
600 -100
600 0
600 100
600 200
600 300
600 400
600 500
-600 -500
-600 -400
-600 -300
-600 -200
-600 -100
-600 0
-600 100
-600 200
-600 300
-600 400
-600 500
-500 -500
-400 -400
-300 -300
-200 -200
-100 -100
100 100
200 200
300 300
400 400
500 500
100 -100
200 -200
300 -300
400 -400
500 -500
-100 100
-200 200
-300 300
-400 400
-500 500
700 700
-700 700

Repository

Github URL: https://github.com/LDubya/weruSnowflake77

Problem set files from repo:

weruSnowflake77.txt (x-y list file, L2 norm)
weruSnowflake77.tsp (TSPLIB format, EUC_2D)

Cool!  Here's a picture of your instance if you want to edit it into your post:  https://i.stack.imgur.com/DnJ7T.png

@A.Rex thanks! Yep that's one of the optimum routes. It should (hypothetically) have lots of different routes of the same optimal length. Is there a good way for us to quantify how many different optimal routes an instance can have? If Concorde does branch and cut, I bet it could remember all the branches that are the same length...

Python 3, 911 cities, 1418 seconds of run time on NEOS
The following Python 3.x script generates the coordinates of 911 cities. It took NEOS 1418 seconds to calculate the shortest path of 47739.
Here is A picture of thee shortest path (thanks to A. Rex):

The code/algorithm is based on the Feigenbaum bifurcation, which I used to generate a series of values, which I used as a basis for generating the coordinates of the cities. I experimented with the parameters until I found a number of cities under 1000 that took NEOS a surprising amount of time (well above the required 5 minutes).
x = 0.579
coords = []
for _ in range(1301):
    if int(3001*x) not in coords:
        coords.append(int(3001*x))
    x = 3.8*x*(1-x)
coords = list(zip(coords, coords[::-1]))
print(len(coords))
for coord in coords:
    print(f"{coord[0]} {coord[1]}")

PS: I have a script running in search for a lower number of cities that also take >5 minutes on NEOS. I'll post them in this answer if I find any.
PS: Damn! Running this script with l parameter 1811 instead of 1301 results in 1156 cities with a running time on NEOS of just over 4 hours, which is a lot more than other cases with similar parameters...

Here's a picture of your 911-city tour if you want to edit it into your post: https://i.imgur.com/G1ZPX0k.png

@A.Rex thanks. Added it.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Quine outputs itself in binary
Your task, if you wish to accept it, is to write a program that outputs its own source code in the binary UTF-8 representation.
Rules

The source must be at least 1 byte long.
Your program must not take input (or have an unused, empty input).
The output may be in any convient format.
Optional trailing newline is allowed.
Notice that one byte is 8 bits, and the length of the binary UTF-8 representation is necessarily a multiple of 8.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.
Standard loopholes are forbidden.

Example
Let's say your source code is Aä$$€h, its corresponding UTF-8 binary representation is 010000011100001110100100001001000010010011100010100000101010110001101000.
If I run Aä$$€h the output must be 010000011100001110100100001001000010010011100010100000101010110001101000.
A      --> 01000001
ä      --> 1100001110100100
$      --> 00100100
$      --> 00100100
€      --> 111000101000001010101100
h      --> 01101000
Aä$$€h --> 010000011100001110100100001001000010010011100010100000101010110001101000

String to binary UTF-8 converters

Try it online!
utf8-convert

By "binary", do you mean a string representation of the binary values, i.e. a string consisting of only 1's and 0's?

@mdahmoune Now that's already much better. The question remains how to represent something as UTF-8. Notice that Unicode representation is mainly based on the looks of a character (only occasionally on semantic meaning). What if no assigned Unicode glyph looks like a character in the source code? Unicode also has many look-alikes (homoglyphs). How does one decide which one to use? E.g. Dyalog APL has an AND function which may be encoded as 01011110 or 0010011100100010 in UTF-8 (they look pretty alike: ^ vs ∧)

Better example: 01111100 and 0010001100100010 encode | and ∣.

@Adám I think it would be fair to output any binary sequence that corresponds to a symbol that will compile/run in a certain implementation of a language.

How about machine code? (Commodore C64 takes 28 bytes assuming the machine code itself is the "source")

Does it have to be a program, not a function that takes a pointer to an output buffer?  Like @MartinRosenau, I'm wondering about machine code.  If a whole program is required, I think we could probably still follow the usual code-golf rules of only counting the actual executable bytes as "the source", not any executable file metadata.  (i.e. the contents of a .text section for an x86-64 Linux executable that base2-dumps itself to stdout, perhaps using RIP-relative addressing got get its own code bytes. Or not, because if we have to be an executable, we can be position-dependent and shorter.)

Does the "binary" dump of UTF-8 have to be in any particular character set or encoding?  Can we choose to dump it in a format that packs 8 binary bits per octet (i.e. actual binary UTF-8, a serialization format for Unicode codepoints)?  Or do you require a text representation of base 2 digits, using the ASCII subset of UTF-8?  Or any choice of pre-existing encoding used for text, like EBCDIC or UTF-16?  Basically it annoys me when people use "binary" to mean a serialization format with 1 bit per character, similar to hex. UTF-8 itself is a binary format composed of 0s and 1s.

@PeterCordes If you can dump it in a format that packs 8 binary bits per octet then any standard quine would count as a binary quine.

@immibis: that's exactly my point.  In computing, the word "binary" is not sufficient to describe what this question is trying to ask for.  It's fairly clear from context what's intended, but I think I could rules-lawyer my way into a standard quine in a UTF-8 source (i.e. not x86 machine code, because that's not always valid UTF-8) with phrases like "the binary UTF-8 representation", because UTF-8 is a binary format for serializing Unicode codepoints.

Oh, that's probably what @MartinRosenau was getting at.  What about languages that aren't textual in the first place, like machine code?  Many instruction sequences don't form valid UTF-8 sequences, where the upper bits signal how many later bytes are part of the same character.  Can we just have a function base-2 dump itself in ASCII/UTF-8?

V, 28 (or 16?) Latin 1 bytes (35 UTF-8 bytes)
ñéÑ~"qpx!!xxd -b
ÎdW54|D
Íßó

Try it online!
Hexdump (in Latin 1):
00000000: f1e9 d17e 2271 7078 2121 7878 6420 2d62  ...~"qpx!!xxd -b
00000010: 0ace 6457 3534 7c44 0acd dff3            ..dW54|D....

Output (binary representation of the same code in UTF-8, not Latin 1):
110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

Explanation:
ñéÑ~"qpx            " Standard quine. Anything after this doesn't affect the
                    " program's 'quine-ness' unless it modifies text in the buffer
        !!xxd -b    " Run xxd in binary mode on the text
Î                   " On every line...
 dW                 "   delete a WORD
   54|              "   Go to the 54'th character on this line
      D             "   And delete everything after the cursor
Í                   " Remove on every line...
  ó                 "   Any whitespace
 ß                  "   Including newlines

Or...
V, 16 bytes
ñéÑ~"qpx!!xxd -b

Try it online!
Output:
00000000: 11000011 10110001 11000011 10101001 11000011 10010001  ......
00000006: 01111110 00100010 01110001 01110000 01111000 00100001  ~"qpx!
0000000c: 00100001 01111000 01111000 01100100 00100000 00101101  !xxd -
00000012: 01100010 00001010                                      b.

OP said:

The output may be in any convenient format.

This outputs in a much more convenient format for V :P (but I'm not sure if that's stretching the rules)

CJam, 20 bytes
{s"_~"+{i2b8Te[}%}_~

Try it online!
Surprised to see CJam winning! we'll see how long that lasts...

05AB1E, 105 bytes
0"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J

05AB1E has no UTF-8 conversion builtins, so I have to do everything manually..
Try it online or verify that it's a quine.
Explanation:
quine-part:
The shortest quine for 05AB1E is this one: 0"D34çý"D34çý (14 bytes) provided by @OliverNi. My answer uses a modified version of that quine by adding at the ... here: 0"D34çý..."D34çý.... A short explanation of this quine:
0               # Push a 0 to the stack (can be any digit)
 "D34çý"        # Push the string "D34çý" to the stack
        D       # Duplicate this string
         34ç    # Push 34 converted to an ASCII character to the stack: '"'
            ý   # Join everything on the stack (the 0 and both strings) by '"'
                # (output the result implicitly)

Challenge part:
Now for the challenge part of the code. As I mentioned at the top, 05AB1E has no UTF-8 conversion builtins, so I have to do these things manually. I've used this source as reference on how to do that: Manually converting unicode codepoints into UTF-8 and UTF-16. Here a short summary of that regarding the conversion of Unicode characters to Unicode†:

Convert the unicode characters to their unicode values (i.e. "dЖ丽" becomes [100,1046,20029])
Convert these unicode values to binary (i.e. [100,1046,20029] becomes ["1100100","10000010110","100111000111101"])
Check in which of the following ranges the characters are:

0x00000000 - 0x0000007F (0-127): 0xxxxxxx
0x00000080 - 0x000007FF (128-2047): 110xxxxx 10xxxxxx
0x00000800 - 0x0000FFFF (2048-65535): 1110xxxx 10xxxxxx 10xxxxxx
† 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

†: Unicode is capped at 21 bits, but UTF-8 is capped at 17 bits. So the range of 4 above would instead be:
0x00010000 - 0x0010FFFF (65536-1114111): 10000xxx 10xxxxxx 10xxxxxx 10xxxxxx
The character d will be in the first range, so 1 byte in UTF-8; character Ж is in the second range, so 2 bytes in UTF-8; and character 丽 is in the third range, so 3 bytes in UTF-8.
The x in the pattern behind it are filled with the binary of these characters, from right to left. So the d (1100100) with pattern 0xxxxxxx becomes 01100100; the Ж (10000010110) with pattern 110xxxxx 10xxxxxx becomes 11010000 10010110; and the 丽 (100111000111101) with pattern 1110xxxx 10xxxxxx 10xxxxxx becomes 1110x100 10111000 10111101, after which the remaining x are replaced with 0: 11100100 10111000 10111101.
So, that approach I also used in my code. Instead of checking the actual ranges, I just look at the length of the binary and compare it to the amount of x in the patterns however, since that saves a few bytes.
Ç               # Convert each character in the string to its unicode value
 b              # Convert each value to binary
  ε             # Map over these binary strings:
   Dg           #  Duplicate the string, and get its length
     •Xó•       #  Push compressed integer 8657
         18в    #  Converted to Base-18 as list: [1,8,12,17]
            @   #  Check for each if the length is >= to this value
                #  (1 if truthy; 0 if falsey)
   ƶ            #  Multiply each by their 1-based index
    à           #  Pop and get its maximum
     ©          #  Store it in the register (without popping)
   i            #  If it is exactly 1 (first range):
    7j          #   Add leading spaces to the binary to make it of length 7
      0ì        #   And prepend a "0"
   ë            #  Else (any of the other ranges):
    R           #   Reverse the binary
     6ô         #   Split it into parts of size 6
       Rí       #   Reverse it (and each individual part) back
    ć           #   Pop, and push the remainder and the head separated to the stack
     7®-        #   Calculate 7 minus the value from the register
        j       #   Add leading spaces to the head binary to make it of that length
         š      #   Add it at the start of the remainder-list again
    Tì          #   Prepend "10" before each part
      J         #   Join the list together
    1®<×        #   Repeat "1" the value from the register - 1 amount of times
        ì       #   Prepend that at the front
  ]             # Close both the if-else statement and map
   ð0:          # Replace all spaces with "0"
      J         # And join all modified binary strings together
                # (which is output implicitly - with trailing newline)

See this 05AB1E answer of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •Xó•18в is [1,8,12,17].

?:: 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx this range is incorrect :  UTF-8 codepoints that map to 4 bytes only go up to 4^8 + 4^10 - 1

@RAREKpopManifesto It doesn't change my program, but you're indeed right. I've fixed the explanation. You may want to leave the same comment on the stackoverflow answer I copied it from. :)

JavaScript (Node.js), 60 bytes
-15 bytes from @Neil and @Shaggy
f=_=>[...Buffer(`f=`+f)].map(x=>x.toString(2).padStart(8,0))

Try it online!

padStart(8,0) saves 2 bytes.

The spec allows for output to be in any convenient format so you could keep the map and ditch the join to output an array of bits

60 bytes with output as an array of bytes.

Thanks @Neil and @Shaggy!!

Perl 5, 42 bytes
$_=q(say unpack'B*',"\$_=q($_);eval");eval

TIO

Java 10, 339 308 265 227 225 186 184 bytes
v->{var s="v->{var s=%c%s%1$c;return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}";return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}

-8 bytes thanks to @NahuelFouilleul removing the unnecessary &255 (and an additional -35 for bringing to my attention that the full program specs of the challenge had been revoked and a function is allowed now as well..)
-41 bytes thanks to @OlivierGrégoire.
Try it online.
Explanation:
quine-part:

var s contains the unformatted source code String
%s is used to put this String into itself with s.format(...)
%c, %1$c and 34 are used to format the double-quotes (")
s.format(s,34,s) puts it all together

Challenge part:
v->{                         //  Method with empty unused parameter and String return-type
  var s="...";               //   Unformatted source code String
  return 0+                  //   Return, with a leading "0":
   new java.math.BigInteger( //    A BigInteger of:
     s.format(s,34,s)        //     The actual source code String
      .getBytes())           //     Converted to a list of bytes (UTF-8 by default)
   .toString(2);}            //    And convert this BigInteger to a binary-String

265 bytes using lambda, also because all source is ascii seems unsigned int c&255 is not needed

@NahuelFouilleul The original question stated "You must build a full program." and "Your output has to be printed to STDOUT.", hence the verbose border-plate code I have instead of a lambda function returning a String. Good point about not needing &255 however since we don't use any non-ASCII characters, thanks!

ok i'm not yet very familar with the usages, but other languages like javascript give a lambda returning a string, also i don't understand why in java we don't count the type and the final semicolon when using lambda where could i find rules?

@OlivierGrégoire error: incompatible types: byte cannot be converted to Long

@NahuelFouilleul Relevant meta posts: Untyped functions in static languages; Unnamed functions in code golf; What are our rules about additional code accompanying function submissions?; Are we allowed to use empty input we won't use when no input is asked?; Byte count for named, recursive lambda expression in C#.

s.format(s,34,s).chars().forEach(c->System.out.printf("%08d",new Long(Long.toString(c,2)))); is one byte shorter than for(int c:s.format(s,34,s).getBytes())System.out.printf("%08d",new Long(Long.toString(c,2)));, so I guess the quine should be shorter as well, but I can't get how to make it work (hence the previous failure as well).

@OlivierGrégoire Thanks! And what was the part that you couldn't work out? Personally I remove the content of the String when making changes. Then ctrl+A and paste it in. Then change the inner var s="" to var s=%c%s%1$c, and every other " to %1$c and % to %%.

Well, that's where I'm lost. However I tried and here's a new candidate for 184 bytes. Tell me if I'm wrong somewhere ;)

@OlivierGrégoire Ah, nice approach! Completely forgot about BigInteger being pretty short for converting to binary-Strings. And 2 more bytes by changing the return'0'+ to return 0+. Hmm, why is that leading 0 necessary btw? It confuses me that all inner binary-Strings have this leading 0, but the very first one not when using BigInteger.toString(2)..

You're fast! The '0' stayed for only 20 seconds before being changed to <space>0 in my comment! :-)

The leading 0 is there because it's required: "Notice that one byte is 8 bits, and the length of the binary UTF-8 representation is necessarily a multiple of 8."

@OlivierGrégoire I know it's required for the challenge. :) I meant that I don't understand why all the other binary substrings are 8 bits with leading 0s, but the first one is not. Although I guess BigInteger.toString(2) convert its bytes to binary-Strings of size 8, joins them all together, and convert it back to a BigInteger (implicitly removing the leading 0), before converting to a String?

Oh, that? It's because BigInteger takes all the bytes as one mega number where bits happen to be spread over several bytes. Only the first zero(es) are not significant: the other ones are significant, so they are shown. It's not as if BigInteger considered each byte to be a number by itself.

Rust, 187 bytes
fn f(o:u8){for c in b"go!g)n;t9(zgns!b!ho!c#%#/huds)(zhg!b_n <27zqshou )#z;19c|#-b_n(:|dmrdzg)1(:|||go!l`ho)(zg)0(:|".iter(){if c^o!=36{print!("{:08b}",c^o);}else{f(0);}}}fn main(){f(1);}

Try it online!

Perl 6, 46 bytes
<say "<$_>~~.EVAL".ords.fmt("%08b",'')>~~.EVAL

Try it online!
The standard quine with .fmt("%08b",'') formats the list of ordinal values into length 8 binary and joins with an empty string.

Python 2, 68 67 bytes
_="print''.join(bin(256|ord(i))[3:]for i in'_=%r;exec _'%_)";exec _

Try it online!
A modification of this answer
-1 bytes by removing the space after 'in' (thanks @mdahmoune)

-1 byte: u can drop the space after in

you haven't updated your TIO link. also, I tried to do '%08b'%ord(i) instead of bin(256|ord(i))[3:], but it didn't work for some reason

R, 138 114 bytes
x=function(){rev(rawToBits(rev(charToRaw(sprintf("x=%s;x()",gsub("\\s","",paste(deparse(x),collapse="")))))))};x()

Try it online!
Uses R’s ability to deparse functions to their character representation. The revs are needed because rawToBits puts the least significant bit first. as.integer is needed because otherwise the bits are displayed with a leading zero.
Edited once I realised that any convenient output was allowed. Also was out by one on original byte count.

Python 3.8 (pre-release), 62 bytes
exec(a:="print(''.join(f'{i:08b}'for i in b'exec(a:=%r)'%a))")

Try it online!
How it work :

exec(a:="print('exec(a:=%r)'%a)") is a quine
f'{i:08b}' converts i into its 8-digits binary representation
b'example_string' is a binary sting. When we iterate over it, it convert the characters by their unicode value
''.join( ... for i in ...) iterate over a string an concatenate the char after the transformation

C# (Visual C# Interactive Compiler), 221 bytes
var s="var s={0}{1}{0};Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!
C# (Visual C# Interactive Compiler) with flag /u:System.String, 193 bytes
var s="var s={0}{1}{0};Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!

Bash + GNU tools, 48 bytes
trap -- 'trap|xxd -b|cut -b9-64|tr -dc 01' EXIT

TIO

thanks, updated indeed it's the shortest variation otherwise should be removed from trap output

Ruby, 45 bytes
eval$b=%q[puts "eval$b=%q[#$b]".unpack("B*")]

Try it online!

Burlesque, 33 bytes
#Q/v(#Q)+]up~-' ;;\[{**b28'0lp}m[

Try it online!
#Q       # Push remaining stack to stack (Quine)
/v       # Drop input (empty string/whatever)
(#Q)+]up # #Q does not add itself. Complete quine, convert to string
~-       # Remove extraneous brackets
' ;;\[   # Remove extraneous spaces
{
 **      # get codepoint
 b2      # Convert to binary
 8'0lp   # Pad to 8 with 0s
}m[      # Apply to each char of quine

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Borderless table
In this challenge you are going to place letters from the alphabet in a Cartesian plane and output the result as a text.
Your input will consist in a list of list with 3 parameters:

X coordinate
Y coordinate
String

How?
We know that a Cartesian plane contain 2 axes \$(X, Y)\$ and 4 quadrants where the signs of the \$(X,Y)\$ coordinates are \$(+,+)\$, \$(−,+)\$, \$(−,−)\$, and \$(+,−)\$. For example
Consider the following 3 by 3 matrix as a Cartesian plane
\begin{matrix} (-1,1) & (0,1) & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}
If we are given in the input something like [[-1,1,L],[0,1,F]] our matrix will look something similar to
\begin{matrix} L & F & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}
And the final output LF
In addition to that there are some points we need to follow in order to get the correct output:

When a X,Y coord is repeated, you will need to concatenate the strings. Example: assume in (-1,1) the string F is placed and you need to place the string a in the same point. You concatenate both strings resulting in Fa and that is the value that will go in (-1,1).
Your output need to be consistent to the matrix. Example imagine this as your final result:

\begin{matrix} Ma & r & ie \\ i & s & (1,0) \\ cute & (0,-1) & (1,-1) \end{matrix}
You must output
Ma  rie
i   s
cute

Why?
You can view this as a table where the columns are the values of the x-axis and the rows the y-axis.
        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma"     |      "r"      |     "ie"
Row 2   |  "i"      |      "s"      |
Row 3   |  "cute"   |               |

All columns values must have the same length
        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma  "   |      "r"      |     "ie"
Row 2   |  "i   "   |      "s"      |
Row 3   |  "cute"   |               |

Finnaly we output the result
Ma  rie
i   s
cute

Test Cases
Input
------------
[[3, 3, "c"]
[4, 1, "un"]
[5, 3, "e"]
[4, 3, "od"]
[4, 2, "lf"]
[1, 2, "go"]
[2, 1, "i"]
[2, 1, "s f"]]

Output
--------------
      code
go     lf
  is f un

Input
--------------
[[0, 0, 's'],
[-1,1, 'M'],
[0, 1, 'r'],
[-1,1, 'a'],
[1, 1, 'i'],
[-1, 0, 'i'],
[1, 1, 'e'],
[-1,- 1, 'c'],
[-1,- 1, 'u'],
[-1, -1, 'te']]

Output.
----------------
Ma  rie
i   s
cute

Notes

This is supposed to be code-golf
You can wrap the coordinates in a single list e.g [[3, 3], "c"]
You can take the input in any reasonable format
You can assume there wont be any number or empty spaces only in the input. e.g. There can be something like a a but never 1 or " " or 1a or 1 1

sandbox

May we take two inputs; a list of coordinates and a list of values? (This would also help for languages that don't allow mixed types.)

Should  [[2,0,"a"],[-2,0,"b"],[0,8,"HI"],[0,-1,"c"]] display "HI" as having 7 empty rows between itself and origin?  If so, can we add it as a test?

Can strings consist of only spaces and/or only digits? My answer need some serious reworking if the answer is yes due to implicit conversion between strings and integers.. (And if the answer is yes, could you add some test cases for this, especially where the number in the string is smaller/larger than the smallest/largest coordinate.)

@KevinCruijssen You can assume there wont be any number or empty spaces only in the input. There can be something like a a but never 1 or   or 1a or 1 1

Can output be an array of lines?

@Shaggy No. output the result as a text. Hope it is not a problem :c

@LuisfelipeDejesusMunoz Thanks. Oh, and one more question I'm sure more people here would want to know: who is Marie? ;p

@KevinCruijssen My crush 5 years ago :c

Can we take input as a list of named tuples? Something like this: (int a,int b,string c)?

JavaScript (ES8),  186 180  179 bytes
Saved 1 byte thanks to @Shaggy
a=>(g=d=>a.some(([x,y,s])=>(w[x+=d]>(l=((r=o[y=d-y]=o[y]||[])[x]=[r[x]]+s).length)||(w[x]=l),x|y)<0,w=[o=[]])?g(-~d):o.map(r=>w.map((w,x)=>(r[x]||'').padEnd(w)).join``).join`
`)``

Try it online!
Negative indices in JS (or the lack of them)
Given an array A[], it's perfectly legal in JS to do something like A[-1] = 5. However, this will not save the value in the array itself. Instead, it will implicitly coerce this negative index to a string ("-1") and set the corresponding property in the surrounding object of the array.
The bad news is that properties are not iterable with methods such as map():
a = [];
a[1] = 3;
a[-1] = 5;
a.map((v, i) => console.log(v + ' is stored at index ' + i))

Try it online!
The above code will only display 3 is stored at index 1.
A possible workaround would be:
a = [];
a[1] = 3;
a[-1] = 5;
Object.keys(a).map(k => console.log(a[k] + ' is stored with key ' + k))

Try it online!
But:

This is not very golf-friendly.
The keys are not sorted in numerical order.

What we do here
We definitely want to work with positive values of both \$x\$ and \$y\$ in order to avoid the problems described above.
We could do a first pass on the data, looking for the minimum value of \$x\$ and the minimum value of \$y\$. But that would be quite lengthy.
Here's what we do instead:

we start with \$d=0\$
we process an iteration where \$x\$ is replaced with \$x+d\$ and \$y\$ is replaced with \$d-y\$
if we have either \$x<0\$ or \$y<0\$ for any entry, we abort and recursively start another attempt with \$d+1\$

I think you can save a byte by declaring o within w: w=[o=[]].

@Shaggy I think that's safe indeed. Thanks. :)

APL (Dyalog Unicode), 39 bytesSBCS
Anonymous infix lambda taking* lists of coordinates and strings as left and right arguments.
{⊃,/↑¨↓⌽m⊣m[c],←⍵⊣m←(⊃⌈/c←1+⍺-⌊/⍺)⍴⊂''}

Try it online!
{…} "dfn"; left (coordinates) and right (strings) arguments are ⍺ and ⍵:
 ⊂'' enclosed empty string, so use as fill for an array
 (…)⍴ cyclically reshape into an array of the following dimensions:
  ⌊/⍺ the lowest value along each axis of the coordinates
  ⍺- subtract that from all the coordinates
  1+ add that to one (since we want the inclusive range)
  c← store in c (for coordinates)
  ⌈/ the highest value along each axis of those
  ⊃ unpack to use as dimensions
 m← store in m (for matrix)
 ⍵⊣ discard that in favour of the strings
 m[c],← append those to m at the coordinates c
 m⊣ discard those in favour of the amended m
 ⌽ mirror
 ↓ split into list of lists of strings
 ↑¨ mix each list of strings into a character matrix, padding with spaces
 ,/ reduce by horizontal concatenation
 ⊃ unpack (since reduction reduces rank from 1 to 0)

* If taking a single argument of interwoven coordinates and strings is required, it will be 5 bytes longer.

Python 2, 188 185 181 bytes
s=sorted;d={};k={}
for x,y,c in input():d[x]=d.get(x,{});k[~y]=d[x][y]=d[x].get(y,'')+c
for y in s(k):print''.join('%*s'%(-max(map(len,d[x].values())),d[x].get(~y,''))for x in s(d))

Try it online!

05AB1E, 45 44 bytes
WsàŸãεUõIvyнXQiyθ«]IZsß->ôεíDéθgjí}øRJʒðKĀ}»

Takes the input-coordinates as an inner list.
Try it online or verify all test cases.
Explanation:
Wsà           # Get the minimum and maximum of the (implicit) input-list
   Ÿ          # Create a list in the range [min, max]
    ã         # Create each possible pair by taking the cartesian product with itself
ε             # Map each coordinate to:
 U            #  Pop and store the coordinate in variable `X`
 õ            #  Push an empty string ""
  Iv          #  Loop `y` over the input-items:
    yн        #   Get the coordinates of item `y`
      XQi     #   If it's equal to variable `X`:
         yθ   #    Get the string of item `y`
           «  #    Concat it to the (non-)empty string
]             # Close the if-statement, loop, and map
 IZsß         # Get the maximum and minimum of the input-list
     -        # Subtract them from each other
      >       # And increase it by 1
       ô      # Split the list into parts of this size
ε             # Map each part to:
 í            #  Reverse each inner string
  Déθg        #  Get the length of the longest inner string
      j       #  Prepend spaces to each item up to that length
       í      #  And reverse every item back again
              #  (so the spaces are trailing instead of leading)
}ø            # After the map: zip/transpose; swapping rows/columns
  R           # Reverse the entire list
   J          # Join each inner list together to a single string
ʒðKĀ}         # Remove all strings consisting only of spaces
     »        # Join the strings by newlines (and output implicitly)

Perl 5 -p00 -MList::Util=max, 148 bytes
s/(\S+) (\S+) (.*)
/$a{$1}=max$a{$1},length($h{$2}{$1}.=$3);''/ge;for$y(sort{$b-$a}keys%h){map{printf"%-$a{$_}s",$h{$y}{$_}}sort{$a-$b}keys%a;say""}

TIO
How

s/(\S+) (\S+) (.*)
/ ... ;''/ge;, substitution flags /g loop /e eval, replacement evaluates to empty clearing line input/default variable
$a{$1}=max$a{$1},length($h{$2}{$1}.=$3), autovivifies a map %h of map whose first level keys y second level x and concatenate string $3 to the value, get the length and autovivifies a second map %a whose keys x and value the max of length over the column (x)
for$y(sort{$b-$a}keys%h){ ... ;say""}, for row indices $y in keys of %h sorted numerically reverse, say"" at the end to print a newline
map{ ... }sort{$a-$b}keys%a, for column index $_ in keys %a sorted numerically
printf"%-$a{$_}s",$h{$y}{$_}, print string aligned to the left with column width

Charcoal, 60 bytes
≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζＦ…·⌊ζ⌈ζ«≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε⮌εＭ⌈ＥεＬκ±Ｌε

Try it online! Link is to verbose version of code. Explanation:
≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζ

Extract the coordinates from the input.
Ｆ…·⌊ζ⌈ζ«

Loop over the x-coordinates.
≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε

Loop over the y-coordinates, extracting and concatenating all of the strings at the given coordinates.
⮌ε

Print the strings in reverse order as the y-coordinates are reversed compared to Charcoal's coordinate system.
Ｍ⌈ＥεＬκ±Ｌε

Move to the start of the next column.

Clean, 212 206 bytes
import StdEnv,StdLib
? =minList
m=maxList
c=flatten
$a#(x,y,z)=unzip3 a
=flatlines(map c(transpose[[ljustify(m(map length l))k\\l<-[reverse[c[s\\(u,v,s)<-a|u==i&&v==j]\\j<-[?y..m y]]],k<-l]\\i<-[?x..m x]]))

Try it online!


text:
School moving out (Day 1)
Challenge Taken with permission from my University Code Challenge Contest

For some years now, the number of students in my school has been growing steadily. First the number of students was increased by classroom, but then it was necessary to convert some spaces for some groups to give classes there, such as the gym stands or, this last course, up to the broom room.
Last year the academic authorities got the budget to build a new building and started the works. At last they have finished and the new building can be used already, so we can move (the old building will be rehabilitated and will be used for another function), but it has caught us halfway through the course. The director wants to know if the move will be possible without splitting or joining groups, or that some students have to change groups.
Challenge
Given the amount of students of the current groups and the new classrooms (capacity), output a truthy value if it is possible to assign a different classroom, with sufficient capacity, to each of the current groups, or a falsey value otherwise.
Test Cases
Input: groups of students => [10, 20, 30], classrooms capacity => [31, 12, 20]
Output: True

Input: groups of students => [10, 20, 30], classrooms capacity => [100, 200]
Output: False

Input: groups of students => [20, 10, 30], classrooms capacity => [20, 20, 50, 40]
Output: True

Input: groups => [30, 10, 30, 5, 100, 99], classrooms => [40, 20, 50, 40, 99, 99]
Output: False

Input: groups => [], classrooms => [10, 10, 10]
Output: True

Input: groups => [10, 10, 10], classrooms => []
Output: False

Input: groups => [], classrooms => []
Output: True

Input: groups => [10, 1], classrooms => [100]
Output: False

Input: groups => [10], classrooms => [100, 100]
Output: True

Input: groups => [1,2,3], classrooms => [1,1,2,3]
Output: True

Notes

You can take the input in any reasonable format
You can output any Truthy/Falsey value (1/0, True/False, etc...)
code-golf

Suggested testcase: g=[1,2,3], c=[1,1,2,3]

Do you have permission to post it here?

@Adám Yes. I asked my teacher (who is the one in charge of the contest) and he said there is no problem. The only thing is that it is one challenge each day

Is 0 a valid value for groups or classrooms?

@nimi You can assume there wont be any group or classroom with 0 (I dont think it is possible to have a group of student of 0 students)

Must the 2 outputs be consistent?

@Shaggy Any falsey/truthy value

Brachylog, 4 bytes
It's always nice to see a challenge and know brachylog is gonna beat everyone.
Takes current classes as input and new classrooms as output; It will output true if it finds a way to fit the students, false otherwise
p≤ᵐ⊆

Explanation
The code has 3 parts of which the order actually doesn't matter
≤ᵐ --> projects each value to a value bigger/equal then input
⊆  --> input is a ordered subsequence of output
p  --> permutes the list so it becomes a unordered subsequence

Try it online!

Pyth, 11 bytes
.AgM.t_DMQ0

Takes input as a list of lists, classroom sizes first, group sizes second. Try it online here, or verify all the test cases at once here.
.AgM.t_DMQ0   Implicit: Q=eval(input())
      _DMQ    Sort each element of Q in reverse
    .t    0   Transpose, padding the shorter with zeroes
  gM          Element wise test if first number >= second number
.A            Are all elements truthy? Implicit print

Jelly, 9 bytes
Takes the classrooms as first argument and the groups as second argument.
Œ!~+Ṡ‘ḌẠ¬

Try it online!
Commented
NB: This Ṡ‘ḌẠ¬ is far too long. But I suspect that this is not the right approach anyway.
Œ!~+Ṡ‘ḌẠ¬  - main link taking the classrooms and the groups e.g. [1,1,2,3], [1,2,3]
Œ!         - computes all permutations of the classrooms    -->  [..., [1,2,3,1], ...]
  ~        - bitwise NOT                                    -->  [..., [-2,-3,-4,-2], ...]
   +       - add the groups to each list; the groups fits   -->  [..., [-1,-1,-1,-2], ...]
             in a given permutation if all resulting values
             are negative
    Ṡ      - take the signs                                 -->  [..., [-1,-1,-1,-1], ...]
     ‘     - increment                                      -->  [..., [0,0,0,0], ...]
      Ḍ    - convert from decimal to integer                -->  [..., 0, ...]
       Ạ   - all truthy?                                    -->  0
        ¬  - logical NOT                                    -->  1

Japt, 9 bytes
ñÍí§Vñn)e

Try it or run all test cases on TIO
ñÍí§Vñn)e     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  í           :Interleave with
    Vñn       :  V sorted by negating each integer
   §          :  Reduce each pair by checking if the first is <= the second
       )      :End interleaving
        e     :All true?

ñÍeÈ§Vn o

Try it or run all test cases on TIO
ñÍeÈ§Vn o     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  e           :Does every element return true
   È          :When passed through the following function
    §         :  Less than or equal to
     Vn       :  Sort V
        o     :  Pop the last element

Out of curiosity, why is there a single-byte builtin for 2 - n In Japt? What kind of use-cases does it have to justify it being a 1-byte builtin?

Good question, @KevinCruijssen. Í is a shortcut for n2<space> and was created for use with strings, converting them from base-2 to base-10 numbers (a fairly common need). However, the n method, when applied to a number, subtracts that number from the method's argument (default=0). So here, although subtracting from 0 would suffice for sorting the array in reverse order, using the shortcut saves me a byte over ñn<space>. I could have also used it when sorting V but it wouldn't have saved any bytes as I'd still need a space, instead of the ), to close the í method.

05AB1E, 14 12 8 bytes
€{í0ζÆdP

Port of @Sok's Pyth answer, so make sure to upvote him as well!
Takes the input as a list of lists, with the classroom-list as first item and group-list as second item.
Try it online or verify all test cases.
Explanation:
€{         # Sort each inner list
  í        # Reverse each inner list
   0ζ      # Zip/transpose; swapping rows/columns, with 0 as filler
     Æ     # For each pair: subtract the group from the classroom
      d    # Check if its non-negative (1 if truthy; 0 if falsey)
       P   # Check if all are truthy by taking the product
           # (and output implicitly)

Old 12-byte answer:
æε{I{0ζÆdP}à

Takes the classroom-list first, and then the group-list.
Try it online or verify all test cases.
Explanation:
æ             # Take the powerset of the (implicit) classroom-list,
              # resulting in a list of all possible sublists of the classrooms
 ε            # Map each classroom sublist to:
  {           #  Sort the sublist
   I{         #  Take the group-list input, and sort it as well
     0ζ       #  Transpose/zip; swapping rows/columns, with 0 as filler
       Æ      #  For each pair: subtract the group from the classroom
        d     #  Check for everything if it's non-negative (1 if truthy; 0 if falsey)
         P    #  Check if all are truthy by taking the product
          }à  # After the map: check if any are truthy by getting the maximum
              # (and output the result implicitly)

Hehe I was pleasantly surprised that Pyth had beaten 05AB1E for a change, but turns out it was the algorithm after all :oP

@Sok Sorry to disappoint you. ;p But thanks for the -4 bytes. :D

Python 2, 49 bytes
Outputs by exit code, fails for falsy input.
g,r=map(sorted,input())
while g:g.pop()>r.pop()>y

Try it online!

MATL, 10 bytes
yn&Y@>~!Aa

Try it online! Or verify all test cases.
Explanation
Consider inputs [20, 10, 30], [20, 20, 50, 40] as an example. Stack is shown bottom to top.
y     % Implicit inputs. Duplicate from below
      % STACK: [20 10 30]
               [20 20 50 40]
               [20 10 30]
n     % Number of elements
      % STACK: [20 10 30]
               [20 20 50 40]
               3
&Y@   % Variations. Gives a matrix, each row is a variation
      % STACK: [20 10 30]
               [20 10 30
                20 20 40
                20 20 40
                ···
                50 40 20]
>~    % Less than? Element-wise with broadcast
      % STACK: [1 1 1
                1 1 1
                1 1 1
                ···
                1 1 0]
!     % Transpose
      % STACK: [1 1 1 ··· 0
                1 1 1 ··· 1
                1 1 1 ··· 1]
A     % All. True for columns that only contain nonzeros
      % STACK: [1 1 1 ··· 0]
a     % Any. True if the row vector contains at least a nonzero. Implicit display
      % STACK: 1

Haskell, 40 bytes
c%l=[1|x<-l,x>=c]
s#g=and[c%s<=c%g|c<-s]

Try it online!

C# (Visual C# Interactive Compiler), 77 74 bytes
a=>b=>a.Count==a.OrderBy(x=>-x).Zip(b.OrderBy(x=>-x),(x,y)=>x>y?0:1).Sum()

Try it online!
Commented code:
// a: student group counts
// b: classroom capacities
a=>b=>
  // compare the number of student
  // groups to...
  a.Count==
  // sort student groups descending
  a.OrderBy(x=>-x)
     // combine with classroom
     // capacities sorted descending
     .Zip(
        b.OrderBy(x=>-x),
        // the result selector 1 when
        // the classroom has enough
        // capacity, 0 when it doesn't
        (x,y)=>x<y?0:1
     )
     // add up the 1's to get the number
     // of student groups who can fit
     // in a classroom
     .Sum()

I wasn't able to find a reasonable one-liner for it. Nice job!

Haskell, 66 bytes
import Data.List
q=sortOn(0-)
x#y=and$zipWith(<=)(q x)$q y++(0<$x)

Try it online!

Perl 5 -pal, 67 62 bytes
@NahuelFouilleul saved 5 bytes with a rearrangement and a grep
$_=!grep$_>0,map$_-(sort{$b-$a}@F)[$x++],sort{$b-$a}<>=~/\d+/g

Try it online!
67 bytes version
Takes the space separated list of class sizes on the first line and the space separated list of room sizes on the next.

-5 bytes

Bash + GNU tools, 68 bytes
(sort -nr<<<$2|paste -d- - <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

69 bytes
(paste -d- <(sort -nr<<<$2) <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

TIO
takes student rooms as first and second argument as string numbers delimited by newline
returns exit status 1 for true or 0 for false

Common Lisp, 74 bytes
(defun c(s r)(or(not(sort s'>))(and(sort r'>)(<=(pop s)(pop r))(c s r))))
Non-minified
(defun can-students-relocate (students rooms)
  (or (not (sort students #'>))
      (and (sort rooms #'>)
           (<= (pop students)
               (pop rooms))
           (can-students-relocate students rooms))))

Test it
Note that sort permanently mutates the list, and pop rebinds the variable to the next element.
In effect this just recursively checks that the largest student group can fit in the largest room.  There are 3 base-cases:

No students - return T
Students, but no rooms - return NIL
Students and rooms, but largest student group larger than largest room - return NIL

Python 2, 71 67 64 bytes
lambda g,c:s(g)==s(map(min,zip(s(g)[::-1],s(c)[::-1])))
s=sorted

Try it online!

In Python 3, you can remove the zip(...) to save 5 bytes.

JavaScript, 56 bytes
s=>c=>s.sort(g=(x,y)=>y-x).every((x,y)=>c.sort(g)[y]>=x)

Try it

Fails for groups of 7 and 9 in classes of 8 and 10.

Thanks for pointing that out, @Neil. I wondered if the naked sort wouldn't come back to bite me in the ass! I'll have to roll back to my original solution until I can find time to try again.

C# (Visual C# Interactive Compiler), 105 93 91 82 81 79 77 76 74 bytes
Now matches dana's score!
n=>m=>{n.Sort();m.Sort();int i=m.Count-n.Count;i/=n.Any(b=>m[i++]<b)?0:1;}

Throws an error if false, nothing if true.
-12 bytes thanks to @Destrogio!
Try it online!
Explanation
//Function taking in a list, and returning another function
//that takes in a list and doesn't return
n=>m=>{
  //Sort the student groups from smallest to largest
  n.Sort();
  //Sort the classrooms fom smallest capacity to largest
  m.Sort();
  //Initialize a variable that will function as a sort of index
  int i=m.Count-n.Count;
  //And divide that by...
  i/=
    //0 if any of the student groups...
    n.Any(b=>
      //Don't fit into the corresponding classroom and incrementing i in the process
      /*(In the case that a the amount of classrooms are less than the amount of
      student groups, an IndexOutOfRangeException is thrown)*/
      m[i++]<b)?0
    //Else divide by 1
    :1;
}

93 bytes - Try it online!

@Destrogio Thanks!

Retina 0.8.2, 50 bytes
\d+
$*
%O^`1+
%`$
,
^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

Try it online! Link includes test suite. Takes two lists of groups and rooms (test suite uses ; as list separator). Explanation:
\d+
$*

Convert to unary.
%O^`1+

Reverse sort each list separately.
%`$
,

Append a comma to each list.
^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

Check that each of the numbers in the first list can be matched to the appropriate number in the second list. Each time \3 contains the previously matched rooms and the next group \2 therefore needs to be able to fit into the next room. The (?>\3?) handles the case of the first room when there are no previous rooms yet.

Charcoal, 28 bytes
Ｗ∧⌊θ¬›⌈§θ¹⌈§θ⁰ＵＭθΦκ⁻ν⌕κ⌈κ¬⊟θ

Try it online! Link is to verbose version of code. Takes a list of lists of rooms and groups and outputs - if the rooms can accommodate the groups. Explanation:
Ｗ∧⌊θ¬›⌈§θ¹⌈§θ⁰

Repeat while a group can be assigned to a room.
ＵＭθΦκ⁻ν⌕κ⌈κ

Remove the largest room and group from their lists.
¬⊟θ

Check that there are no unallocated groups remaining.

Perl 6, 34 bytes
{none [Z>] $_>>.sort(-*)>>[^.[0]]}

Try it online!
Takes input as a list of two lists, the groups and the classrooms, and returns a None Junction that can be boolified to true/false.
Explanation:
{                                }   # Anonymous code block
           $_>>.sort(-*)             # Sort both lists from largest to smallest
                        >>[^.[0]]    # Pad both lists to the length of the first list
 none                                # Are none of
      [Z>]                           # The groups larger than the assigned classroom

Ruby, 57 bytes
->c,r{r.permutation.any?{|p|c.zip(p).all?{|a,b|b&&a<=b}}}

Try it online!
Takes c for classes, r for rooms. Checks all permutations of rooms instead of using sort, because reverse sorting costs too many bytes. Still looks rather long though...

Java (OpenJDK 8), 183 bytes
a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return false;}for(int i=0;i<b;i++){if(a[0][i]>a[1][i]){return false;}}return true;}

Try it online!
With a little helpful advice from Kevin Cruijssen and simply another glance over my code myself, I can decrease my score by a whole 9% just by replacing three English words!
Java (OpenJDK 8), 166 bytes
a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return 0;}for(int i=0;i<b;){if(a[0][i]>a[1][i++]){return 0;}}return 1;}

Try it online!

You'll have to include the import java.util.*; in your byte-count. You can however golf it to 144 bytes in Java 8, or 140 in Java 10 by replacing the boolean with var.

PS: If you do need true/false in your code, 1>0/0>1 are shorter alternatives. :)

actually, i did remember to include the extra 24 bytes into my count! (i believe it was you informed that me of that rule months ago XD), but thank you for the tip! ill give it a shot!

This fails the last test case.

About your 166-byte version: although the question state you can return 1/0 and I guess it's fine in this case, please note that in Java unlike Python, JavaScript, C, etc. 1/0 are usually not considered as valid truthy/falsey outputs. And in my first comment I mentioned a 144-bytes version. :) Although, it's now also invalid because it doesn't work for the last test case, as mentioned by @Shaggy.

PowerShell, 80 bytes
param($s,$c)!($s|sort -d|?{$_-gt($r=$c|?{$_-notin$o}|sort|select -l 1);$o+=,$r})

Try it online!
Less golfed test script:
$f = {

param($students,$classrooms)
$x=$students|sort -Descending|where{
    $freeRoomWithMaxCapacity = $classrooms|where{$_ -notin $occupied}|sort|select -Last 1
    $occupied += ,$freeRoomWithMaxCapacity    # append to the array
    $_ -gt $freeRoomWithMaxCapacity           # -gt means 'greater than'. It's a predicate for the 'where'
}                                             # $x contains student groups not assigned to a relevant classroom
!$x                                           # this function returns a true if $x is empty

}

@(
    ,(@(10, 20, 30), @(31, 12, 20), $true)
    ,(@(10, 20, 30), @(100, 200), $False)
    ,(@(20, 10, 30), @(20, 20, 50, 40), $True)
    ,(@(30, 10, 30, 5, 100, 99), @(40, 20, 50, 40, 99, 99), $False)
    ,(@(), @(10, 10, 10), $True)
    ,(@(10, 10, 10), @(), $False)
    ,(@(), @(), $True)
    ,(@(10, 1), @(100), $False)
    ,(@(10), @(100, 100), $True)
    ,(@(1,2,3), @(1,1,2,3), $True)
) | % {
    $students, $classrooms, $expected = $_
    $result = &$f $students $classrooms
    "$($result-eq$expected): $result"
}

R, 65 bytes
function(g,r)isTRUE(all(Map(`-`,sort(-g),sort(-r)[seq(a=g)])>=0))

Try it online!