Bei einem rechteckigen Heuhaufen mit einer Größe von mindestens 2x2, der aus denselben druckbaren ASCII-Zeichen besteht, geben Sie die Position (von links oben gezählt) der Nadel aus, die ein anderes Zeichen ist.

Wenn zum Beispiel der folgende Heuhaufen eingegeben wird:

#####
###N#
#####
#####

Die Ausgabe sollte 3,1bei Nullindexierung (was ich in dieser Herausforderung verwenden werde) oder 4,2bei Einindexierung erfolgen.

Der Heuhaufen kann aus einem beliebigen druckbaren ASCII-Zeichen bestehen:

^^^
^^^
^N^
^^^
^^^
^^^

Ausgabe: 1,2

und die Nadel wird jedes andere druckbare ASCII-Zeichen sein:

jjjjjj
j@jjjj
jjjjjj

Ausgabe 1,1

Es ist auch möglich, eine Nadel in der Ecke zu haben:

Z8
88

Ausgabe 0,0

88
8Z

Ausgabe 1,1

oder um die Nadel am Rand zu haben:

>>>>>>>>>>
>>>>>>>>>:
>>>>>>>>>>

Ausgabe 9,1

Regeln und Erläuterungen

• Die Ein- und Ausgabe kann auf jede bequeme Weise erfolgen . Dies bedeutet, dass Sie Eingaben als Liste von Zeichen, als einzelne Zeichenfolge usw. vornehmen können.
• Sie können das Ergebnis an STDOUT drucken oder als Funktionsergebnis zurückgeben. Bitte geben Sie in Ihrer Einreichung an, in welcher Reihenfolge die Ausgabe erfolgt (dh horizontal und vertikal, wie in der Challenge verwendet, oder umgekehrt).
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Sie müssen nicht auswählen, welche Zeichen verwendet werden sollen. Das ist die Herausforderung.
• Der Heuhaufen hat garantiert eine Größe von mindestens 2x2, so dass eindeutig ist, welche Nadel und welche das Heu ist.
• Es gibt immer nur eine Nadel in der Eingabe und es ist immer nur ein Zeichen groß.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

R , 49 47 44 Bytes

function(m,`?`=which)m==names(?table(m)<2)?T

Probieren Sie es online!

Nimmt die Eingabe als Matrix und gibt 1-indizierte Koordinaten zurück

Perl 6 ,41 38 37 Bytes

3 Bytes gespart dank @nwellnhof.

1 Byte gespart dank Jo King.

{map {[+] ^∞Z*!<<.&[Z~~]},$_,.&[Z]}

Probieren Sie es online!

Erläuterung

Es nimmt die Eingabe als Liste von Zeichenlisten und gibt eine Liste der Länge 2 zurück, die nullbasierte X- und Y-Koordinaten der Nadel enthält.

Es funktioniert, indem der Block {[+] ^∞ Z* !<<.&[Z~~]}auf den Eingang und auf seine Transponierung angewendet wird. .&[Z~~]Durchläuft alle Spalten des Arguments und gibt ansonsten zurück, Trueob alle Elemente gleich sind False. Wir negieren dann alle Werte (also haben wir eine Liste mit einem Bool pro Spalte, in der der Bool die Frage "Befindet sich die Nadel in dieser Spalte?" Beantwortet) und multiplizieren sie elementweise mit einer Folge von 0,1,2. .. ( True = 1und False = 0) und summieren die Liste, sodass das Ergebnis des gesamten Blocks die 0-basierte Nummer der Spalte ist, in der die Nadel gefunden wurde.

Nwellnhofs besserer Ansatz, Perl 6 , 34 Bytes

{map *.first(:k,*.Set>1),.&[Z],$_}

Probieren Sie es online!

Erläuterung

Im Allgemeinen der gleiche Ansatz, nur effektiver. Es verwendet immer noch einen Block im Array und dessen Transponierung, aber jetzt konvertiert der Block alle Zeilen in Setsund überprüft die Anzahl der Elemente. Die firstFunktion gibt dann den Index (aufgrund der :k) der ersten Zeile an, die mehr als 1 Element enthielt. Aus diesem Grund musste die Reihenfolge von $_und .&[Z]ausgetauscht werden.

Python 2 , 57 Bytes

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

Probieren Sie es online!

Ein Port von diesem zu Python 3 kann 62 Bytes umfassen :

lambda m:[[len(set(v))for v in a].index(2)for a in(zip(*m),m)]

Das Listenverständnis [len(set(v))for v in a]ist nun um zwei Bytes kürzer als die Doppelkarte, da es in eine Liste wie die umgewandelt werden müsstelist(map(len,map(set,a)))

Probieren Sie es online!

Brachylog , 20 Bytes

c≡ᵍ∋Ȯ&;I∋₎;J∋₎gȮ∧I;J

Probieren Sie es online!

Ausgaben [I,J], wobei sowohl Ider Zeilenindex als auch Jder Spaltenindex 0-indiziert sind.

Dummerweise lang, aber das Abrufen von Indizes in Brachylog ist normalerweise sehr ausführlich.

Erläuterung

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

Verwenden von Zeichenfolgen ohne Zeilenumbrüche und der Breite (oder Höhe ('########N###########', 5) als Eingabe.

• -5 Bytes durch Entfernen des chr () -Aufrufs, Requisiten an @Titus
• -9 Bytes durch Eingabe als zwei Funktionsargumente. Stellt auch @Titus zur Verfügung

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

Probieren Sie es 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 );

}

Ausgabe:

#####
###N#
#####
#####
[3,1]

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

jjjjjj
j@jjjj
jjjjjj
[1,1]

05AB1E , 9 6 Bytes

3 Bytes beim Umschalten des Eingabeformats gespeichert.

Die Eingabe wird als Zeichenfolge und Zeilenlänge verwendet.
Die Ausgabe ist eine nullbasierte Liste des Formulars[y, x]

D.mks‰

Probieren Sie es online! oder als Test Suite

Erläuterung

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

Python 3 + NumPy , 75 66 Bytes

-9 Bytes dank nur @ ASCII

lambda x:where(x.view('i')-median(x.view('i')))
from numpy import*

Probieren Sie es online!

Dies setzt voraus, dass die Eingabe ein NumPy-Array ist. Die Ausgabe ist nullindexiert und zuerst vertikal, dann horizontal.

Es konvertiert die Eingabe von, charum intdann den Median des Arrays zu berechnen, bei dem es sich um das Heuhaufenzeichen handelt. Wir subtrahieren das vom Array, was die Nadel zum einzigen Nicht-Null-Element macht. Abschließend geben Sie den Index dieses Elements mit zurück numpy.where().

Gelee , 5 Bytes

Ausgaben [Höhe, Breite] (1-indiziert).

ŒĠLÐṂ

Probieren Sie es 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).

Gelee , 5 Bytes

ŒĠḊÐḟ

Probieren Sie es online!

Gelee , 4 Bytes

_{Vielleicht hätte das nur ein Kommentar für Mr. Xcoder sein können, es ist ziemlich ähnlich ...}

ŒĠEƇ

Ein monadischer Link, der die Zeichenmatrix akzeptiert und eine Liste mit einem Element ergibt, wobei die 1-indizierte (Zeile, Spalte) Koordinate von oben links ist.
(... Als vollständiges Programm mit einem Argument, das so formatiert ist, dass das Parsen zu einer Liste von Zeichenlisten führt - das ist eine Liste von Zeichenfolgen im Python-Format -, wird die einzelne Koordinate gedruckt.)

Probieren Sie es online!

Wie?

ŒĠ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

JavaScript (ES6), 55 Byte

$(s)(w)$$s$$w$$[x,y]$

s=>w=>[(i=s.indexOf(/(.)\1+(.)/.exec(s+s)[2]))%w,i/w|0]

Probieren Sie es online!

JavaScript (ES6),  65  64 Byte

1 Byte dank @Neil gespeichert

$[x,y]$

m=>m.some((r,y)=>r.some((c,x)=>!m[p=[x,y],~y&1].includes(c)))&&p

Probieren Sie es online!

Wie?

$c$$(x,y)$$r[Y]$$Y\ne y$$2\times 2$$Y=0$$y$$Y=1$$y$

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 (und -13 impliziter) dank @dana .

Eingabe als Zeichenmatrix.

Probieren Sie es online aus.

Erläuterung:

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

MATL , 12 8 Bytes

tX:XM-&f

Probieren Sie es online!

Verwendung der modeFunktion als Majoritätsdetektor. Gibt 1-basierte Indizes zurück.

 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 Zeichen dank @LuisMendo

Wolfram Language 37 58 Bytes

Mein früherer Eintrag behandelte den Fall, in dem sich das "ungerade Zeichen heraus" in der oberen linken Ecke der Matrix befand, nicht richtig. Das macht.

#~Position~Keys[TakeSmallest[Counts@Flatten@#,1]][[1]]&

Counts@Flatten@#Listen , wie viele der einzelnen Zeichen sind in dem Array #.

TakeSmallest[...,1] gibt die am wenigsten häufige Anzahl in Form einer Assoziationsregel zurück, wie z <| "Z"->1|>

Keys...[[1]]Gibt den "Schlüssel" für das einzige Element in der Zuordnung zurück, das des am wenigsten verwendeten Zeichens. ("Z" im vorliegenden Fall)

#~Position~...Gibt die Position des Schlüssels in der ursprünglichen Matrix zurück #.

Perl 5 -p00, 52 45 Bytes

/^(.)(\1*
)*(\1*)|^/;$_=$&=~y/
//.$".length$3

45 Bytes

52 Bytes

Wie

• -p00: wie -naber auch drucken, Absatzmodus
• /^(.)(\1* )*(\1*)|^/ : passt entweder
  • von Anfang an $1: erstes Zeichen $2,: Wiederholung (nicht verwendet) $3,: Zeichen vor der "Nadel" in der Zeile, $&ganze Übereinstimmung
  • oder null string (position 0) keine erfassung.
• $_= : um die Standardeingabe- / Argumentvariable zuzuweisen
• also $&=~y/ //die Anzahl der Zeilenumbrüche von$&
• .$".: verketten mit $"(Leerzeichen standardmäßig) und verketten
• length$3 : die Länge von $3

R 42 Bytes

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

Probieren Sie es online!

Eingabe: eine Heuhaufenmatrixm

Ausgabe: (row,col) Vektor - Index ab1

C # (Visual C # Interactive Compiler) , 109 108 107 Byte

^{First () => Last () für -1 Byte}

^{Currying für -1 Byte dank Verkörperung der Ignoranz}

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);}

Probieren Sie es online!

J , 22 Bytes

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

Probieren Sie es online!

NB. Gibt die Antwort im (Zeilen-, Spalten-) Format zurück.

Python 2 , 53 47 Bytes

lambda s,w:divmod(s.find(min(s,key=s.count)),w)

Probieren Sie es online!

Aufruf als f("########N###########", 5)(in einem Kommentar erlaubt ). Ausgänge (y, x).

Erik sparte 6 Bytes und schlug vor, die Ausgabe mit neu zu ordnen divmod. Vielen Dank!

PowerShell , 107 98 82 77 Byte

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

Probieren Sie es online!

Nimmt einen splatted String mit LFs. Gibt die mit Nullen indizierte Position x, y zurück. Abgerollt:

$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)

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]

Probieren Sie es online!

Die Eingabe erfolgt als mehrzeilige Zeichenfolge. Der Ausgang ist 0-indiziert

Oktave , 40 Bytes

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

Port von @ Sundars MATL-Antwort . Die Ausgabe ist ein Vektor mit zwei Elementen mit 1-basierten Spalten- und Zeilenindizes.

Probieren Sie es online!

Retina 0.8.2 , 41 Bytes

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

Probieren Sie es online! 0-indiziert. Erläuterung:

s`

Lassen Sie .Zeilenumbrüche übereinstimmen. Dies kostet 3 Bytes (das dritte Byte ist das ?vor dem ¶), spart aber 6 Bytes.

(?=(.)+\1)

Suchen Sie nach zwei identischen Zeichen. \1dann wird das Heu.

(.*?¶)*

Zählen Sie die Anzahl der Zeilenumbrüche vor der Nadel.

(.*)

Nehmen Sie das Heu links von der Nadel auf.

(?!\1|¶)

Stellen Sie sicher, dass die Nadel kein Heu oder eine neue Linie ist.

.+

Passen Sie den Rest des Heus so an, dass das Ergebnis ihn ersetzt.

$.3,$#2

Geben Sie die Breite des linken Heus und die Anzahl der Zeilenumbrüche aus.

C # (Visual C # Interactive Compiler) , 82 Byte

x=>w=>{int y=x.IndexOf(x.GroupBy(c=>c).Last(g=>g.Count()<2).Key);return(y%w,y/w);}

Danke an dana für die 6 Bytes!

Probieren Sie es online!

Alte Lösung, 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);}

Beide akzeptieren die Eingabe als Zeichenfolge und als Ganzzahl, die die Anzahl der Spalten angibt.

Probieren Sie es online!

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;}

Die Eingabe besteht aus einem Array von Zeichen und einer Ganzzahl, die die Zeilenbreite angibt.

Die Ausgabe ist nullbasiert, vertikal und dann horizontal (dh Zeilennummer und dann Spaltennummer).

Erläuterung:

(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 89 85 58 Bytes

Vollständiges Umschreiben unter Verwendung von Eingaben als concatenated string, width:

lambda g,w:divmod(g.index({g.count(c):c for c in g}[1]),w)

Probieren Sie es online!

Ursprüngliche Antwort:

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

BEARBEITEN: 4 Bytes durch Austauschen von Zeilenumbruch / Einzug gegen Semikolon gespeichert. Sparte weitere 4 Bytes mit divmod(danke @JonathanFrech).

Probieren Sie es online!

Ich weiß, dass dies viel kürzer sein könnte, aber ich wollte nur versuchen, dieses dictVerständnis zu umgehen.

MATL , 11 Bytes

tX:YmyYk-&f

Ausgabe ist Zeile, dann Spalte; 1-basiert.

Probieren Sie es online!

Erläuterung

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

Nimmt die Eingabe als Zeilenlänge und die Eingabe ohne Zeilen und Ausgaben als [Zeile, Spalte].
Probieren Sie es hier aus

Erläuterung

.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.

Alter Ansatz

mxJmt{kdeSJ.TB

Probieren Sie es hier aus

Erläuterung

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.     

Kohle , 40 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich muss etwas falsch machen, denn das ist fast so lange, wie die Retina antwortet. Erläuterung:

≔§⎇⌕θ§θ¹ηθ⁰ζ

Überprüfen Sie, ob das zweite Zeichen in der ersten Zeichenfolge auch das erste Zeichen ist, und nehmen Sie gegebenenfalls das erste Zeichen der ersten Zeichenfolge, andernfalls das erste Zeichen der zweiten Zeichenfolge. Das ist dann das Heu.

ＳθＷ⁼№θζＬθ«⊞υωＳθ»

Lesen Sie die Zeichenfolgen weiter, bis eine Zeichenfolge gefunden wird, deren Heu kürzer als ihre Länge ist.

Ｉ⌕Ｅθ⁼ιζ⁰,ＩＬυ

Geben Sie die Position des nicht übereinstimmenden Elements und dann die Anzahl der zuvor gelesenen Zeichenfolgen aus.

MATLAB, 68 22 Bytes

[r,c]=find(v~=v(1));if size(r,1)>1 disp([1,1]);else disp([r,c]);end;

Wenn ich einen Fall wie [1,1]in dieser Lösung ausschließen könnte, hätte ich mehrere Bytes sparen können.

Aktualisierte Lösung :

@(v)find(v-mode(v(:)))

Vielen Dank an @sundar, der mir bei dem speziellen Fallproblem geholfen und 42 Bytes gespart hat! Danke auch an @Luis_Mendo für die Vorschläge und spart mir noch 2 Bytes!

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]}

Probieren Sie es online!

Übernimmt die Eingabe als Zeichenfolge mit Zeilen mit Zeilenumbruch. Gibt einen Stream mit 0-indizierten horizontalen und vertikalen Indizes zurück.