Avec une botte de foin rectangulaire d'au moins 2x2 composée de tous les mêmes caractères ASCII imprimables, génère l'emplacement (en partant du coin supérieur gauche) de l'aiguille, qui est un caractère différent.

Par exemple, si la pile de foin suivante est entrée:

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

La sortie devrait être 3,1à l'index zéro (ce que je vais utiliser dans ce défi) ou 4,2à un index.

La botte de foin peut être composée de n'importe quel caractère ASCII imprimable:

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

sortie: 1,2

et l'aiguille sera tout autre caractère ASCII imprimable:

jjjjjj
j@jjjj
jjjjjj

sortie 1,1

Il est également possible d'avoir une aiguille dans le coin:

Z8
88

sortie 0,0

88
8Z

sortie 1,1

ou d'avoir l'aiguille au bord:

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

sortie 9,1

Règles et clarifications

• L'entrée et la sortie peuvent être données par n'importe quelle méthode commode . Cela signifie que vous pouvez utiliser les entrées sous forme de liste de caractères, de chaîne unique, etc.
• Vous pouvez imprimer le résultat dans STDOUT ou le renvoyer en tant que résultat de fonction. Veuillez indiquer dans votre soumission l'ordre dans lequel se trouve la sortie (c'est-à-dire horizontale puis verticale, telle qu'utilisée dans le défi ou vice versa).
• Un programme complet ou une fonction sont acceptables.
• Vous ne pouvez pas choisir les personnages à utiliser. C'est le défi.
• La botte de foin a une taille minimum de 2x2, il est donc clair que l’aiguille et le foin.
• Il n’ya jamais qu’une aiguille dans l’entrée et sa taille n’est jamais plus grande.
• Les échappatoires standard sont interdites.
• Il s’agit du code-golf, donc toutes les règles de golf habituelles s’appliquent et le code le plus court (en octets) gagne.

R , 49 47 44 octets

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

Essayez-le en ligne!

Prend les entrées sous forme de matrice, retourne les coordonnées indexées 1

Perl 6 ,41 38 37 octets

3 octets sauvés grâce à @nwellnhof.

1 octet sauvé grâce à Jo King.

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

Essayez-le en ligne!

Explication

Il prend l'entrée comme une liste de listes de caractères et renvoie la liste de longueur 2 contenant les coordonnées X et Y de l'aiguille basées sur zéro.

Cela fonctionne en appliquant le bloc {[+] ^∞ Z* !<<.&[Z~~]}sur l'entrée et sur sa transposition. .&[Z~~]parcourt toutes les colonnes de l'argument et retourne Truesi tous les éléments sont identiques, Falsesinon. Nous nions ensuite toutes les valeurs (nous avons donc une liste avec un booléen par colonne, où le booléen répond à la question "L'aiguille est-elle dans cette colonne?"), Multipliez-les élément par séquence avec une séquence 0,1,2 ,. .. ( True = 1et False = 0) et additionner la liste, le résultat du bloc entier est donc le nombre de 0 de la colonne où l'aiguille a été trouvée.

Meilleure approche de Nwellnhof, Perl 6 , 34 octets

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

Essayez-le en ligne!

Explication

Généralement la même approche, juste plus efficace. Il utilise toujours un bloc sur le tableau et sa transposition, mais maintenant, le bloc convertit toutes les lignes en Setset vérifie le nombre d'éléments. La firstfonction donne ensuite l'index (en raison de :k) de la première ligne contenant plus d'un élément. A cause de cela, l'ordre $_et .&[Z]doit être échangé.

Python 2 , 57 octets

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

Essayez-le en ligne!

Un port de celui-ci sur Python 3 peut contenir 62 octets :

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

La compréhension de la liste,, [len(set(v))for v in a]est plus courte que la double carte de deux octets maintenant, car elle devrait être convertie en liste commelist(map(len,map(set,a)))

Essayez-le en ligne!

Brachylog , 20 octets

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

Essayez-le en ligne!

Sorties [I,J], où Isont l'index de ligne et Jl'index de colonne, tous deux indexés par 0.

Extrêmement long, mais obtenir des index dans Brachylog est généralement très prolixe.

Explication

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 octets

Utilisation de chaîne sans nouvelles lignes et la largeur (ou hauteur) ('########N###########', 5) en entrée.

• -5 octets en supprimant l'appel chr (), les accessoires à @Titus
• -9 octets en prenant l'entrée comme deux arguments de fonction, ainsi que les accessoires de @Titus

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

Essayez-le en ligne!

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

}

Sortie:

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

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

jjjjjj
j@jjjj
jjjjjj
[1,1]

05AB1E , 9 à 6 octets

Sauvegardé 3 octets de commutation de format d'entrée.

L'entrée est considérée comme une chaîne et une longueur de ligne.
La sortie est une liste de formulaire de base zéro[y, x]

D.mks‰

Essayez-le en ligne! ou en tant que suite de tests

Explication

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 octets

-9 octets grâce à @ ASCII uniquement

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

Essayez-le en ligne!

Cela suppose que l'entrée est un tableau NumPy. La sortie est indexée à zéro, d'abord verticale, puis horizontale.

Il convertit l'entrée de charen, intpuis calcule la médiane du tableau, qui sera le caractère de la botte de foin. Nous soustrayons cela du tableau, ce qui fait de l’aiguille le seul élément non nul. Finalement, retournez l'index de cet élément avec numpy.where().

Gelée , 5 octets

Sorties [hauteur, largeur] (indexé 1).

ŒĠLÐṂ

Essayez-le en ligne!

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

Gelée , 5 octets

ŒĠḊÐḟ

Essayez-le en ligne!

Gelée , 4 octets

_{Peut-être que cela aurait pu être un commentaire pour M. Xcoder, c'est assez similaire ...}

ŒĠEƇ

Un lien monadique acceptant la matrice de caractères qui produit une liste d'un élément, la coordonnée 1-indexée (ligne, colonne) en haut à gauche.
(... En tant que programme complet, avec un argument formaté de telle sorte que l'analyse donne une liste de listes de caractères - c'est-à-dire une liste de chaînes au format Python - la coordonnée unique est imprimée.)

Essayez-le en ligne!

Comment?

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

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

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

Essayez-le en ligne!

JavaScript (ES6),  65  64 octets

Enregistré 1 octet grâce à @Neil

$[x,y]$

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

Essayez-le en ligne!

Comment?

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

Java 8, 132 111 octets

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 octets (et -13 plus implicitement) grâce à @dana .

Entrée en tant que matrice de caractères.

Essayez-le en ligne.

Explication:

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 octets

tX:XM-&f

Essayez-le en ligne!

Utiliser la modefonction comme détecteur de majorité. Renvoie les index basés sur 1.

 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 caractères grâce à @LuisMendo

Wolfram Language 37 58 octets

Mon entrée précédente ne traitait pas correctement le cas où le "caractère impair" était dans le coin supérieur gauche de la matrice. Cela fait.

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

Counts@Flatten@#combien de listes de chaque personnage sont dans le tableau, #.

TakeSmallest[...,1] renvoie le nombre le moins fréquent, sous la forme d'une règle d'association telle que <| "Z"->1|>

Keys...[[1]]renvoie la "clé" sur le seul élément de l'association, celui du personnage le moins utilisé. ("Z" en l'espèce)

#~Position~...Renvoie la position puis de la clé dans la matrice d' origine, #.

Perl 5 -p00, 52 45 octets

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

45 octets

52 octets

Comment

• -p00: comme -nmais aussi imprimer, mode paragraphe
• /^(.)(\1* )*(\1*)|^/ : correspond soit
  • à partir du début $1: premier caractère $2,: répétition (non utilisé) $3,: caractères avant l'aiguille dans la ligne, $&correspondance complète
  • ou chaîne nulle (position 0) pas de capture.
• $_= : pour assigner la variable d'entrée / argument par défaut
• donc $&=~y/ //le nombre de nouvelles lignes de$&
• .$".: concaténer avec $"(espace par défaut) et concaténer
• length$3 : la longueur de $3

R 42 octets

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

Essayez-le en ligne!

Entrée: une matrice de botte de foinm

Sortie: (row,col) vecteur - index à partir de1

C # (compilateur interactif Visual C #) , 109 108 107 octets

^{First () => Last () pour -1 octet}

^{currying pour -1 octet grâce à Incarnation 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);}

Essayez-le en ligne!

J , 22 octets

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

Essayez-le en ligne!

NB renvoie la réponse au format (rangée, colonne).

Python 2 , 53 47 octets

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

Essayez-le en ligne!

Appeler en tant que f("########N###########", 5)(autorisé dans un commentaire ). Sorties (y, x).

Erik a sauvegardé 6 octets, suggérant de réorganiser la sortie + using divmod. Merci!

PowerShell , 107 98 82 77 octets

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

Essayez-le en ligne!

Prend une chaîne éclaboussée avec LF. Renvoie l'emplacement indexé zéro x, y. Déroulé:

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

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]

Essayez-le en ligne!

L'entrée est considérée comme une chaîne multiligne. La sortie est indexée sur 0

Octave , 40 octets

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

Réponse MATL du port de @ sundar . La sortie est un vecteur à deux éléments avec des index de colonne et de ligne basés sur 1.

Essayez-le en ligne!

Retina 0.8.2 , 41 octets

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

Essayez-le en ligne! 0 indexé. Explication:

s`

Permet de .faire correspondre les nouvelles lignes. Cela coûte 3 octets (le 3ème octet est le ?précédent ¶) mais enregistre 6 octets.

(?=(.)+\1)

Recherchez deux personnages identiques. \1devient alors le foin.

(.*?¶)*

Comptez le nombre de nouvelles lignes avant l'aiguille.

(.*)

Capturez le foin à gauche de l'aiguille.

(?!\1|¶)

Assurez-vous que l'aiguille n'est pas du foin ou une nouvelle ligne.

.+

Faites correspondre le reste du foin afin que le résultat le remplace.

$.3,$#2

Affiche la largeur du foin gauche et le nombre de nouvelles lignes.

C # (compilateur interactif Visual C #) , 82 octets

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

Merci à Dana d'avoir réduit de 6 octets!

Essayez-le en ligne!

Ancienne solution, 106 octets

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

Les deux prennent une entrée sous forme de chaîne et un entier spécifiant le nombre de colonnes.

Essayez-le en ligne!

Java 8, 104 octets

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

L'entrée est un tableau de caractères et un entier indiquant la largeur de la ligne.

La sortie est basée sur zéro, verticale puis horizontale (c'est-à-dire numéro de ligne puis numéro de colonne)

Explication:

(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 octets

Réécriture complète en prenant les entrées comme concatenated string, width:

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

Essayez-le en ligne!

Réponse originale:

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

EDIT: sauvegardé 4 octets en échangeant des sauts de ligne / retrait pour des points-virgules. Sauvegardé 4 autres octets en utilisant divmod(merci @JonathanFrech).

Essayez-le en ligne!

Je sais que cela pourrait être beaucoup plus court, mais je voulais juste essayer une approche autour de cette dictcompréhension.

MATL , 11 octets

tX:YmyYk-&f

La sortie est rangée, puis colonne; Basé sur 1.

Essayez-le en ligne!

Explication

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 octets

.Dxz-zh.-z{z

Prend l'entrée en tant que longueur de la ligne et l'entrée sans lignes et les sorties en tant que [rangée, colonne].
Essayez-le ici

Explication

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

Ancienne approche

mxJmt{kdeSJ.TB

Essayez-le ici

Explication

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.     

Charbon de bois , 40 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Je dois faire quelque chose de mal parce que c'est presque aussi long que la réponse de la rétine. Explication:

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

Vérifiez si le deuxième caractère de la première chaîne est également le premier caractère et prenez le premier caractère de la première chaîne si tel est le cas, le premier caractère de la deuxième chaîne sinon. C'est alors le foin.

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

Continuez à lire les chaînes jusqu'à ce qu'une chaîne dont le foin soit inférieur à sa longueur soit trouvée.

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

Affiche la position de l'élément incompatible, puis le nombre de chaînes lues précédemment.

MATLAB, 68 22 octets

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

Si je pouvais exclure un cas, comme [1,1]dans cette solution, j'aurais pu économiser plusieurs octets.

Solution mise à jour :

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

Merci à @sundar de m'avoir aidé avec le problème de cas particulier et d'économiser 42 octets! Merci également à @Luis_Mendo pour les suggestions et m'avoir sauvé 2 octets de plus!

Röda , 81 octets

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

Essayez-le en ligne!

Prend l'entrée en tant que chaîne contenant des lignes terminées par une nouvelle ligne. Renvoie un flux contenant des index horizontaux et verticaux indexés sur 0.