Où est le 0xBEEF?

92

Ce défi a été inspiré par la publicité de cette Wendy's de 1984.

Où est le boeuf?

Illustration de TS Rogers

Votre tâche consiste à trouver un 0xBEEF hexadécimal sur un bun binaire.

Le «boeuf» se compose du modèle suivant:

1 0 1 1  (0xB)
1 1 1 0  (0xE)
1 1 1 0  (0xE)
1 1 1 1  (0xF)

Et le «chignon» consiste en une matrice binaire 12x12, telle que:

1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1

Contribution

Votre programme ou fonction prendra la matrice binaire en entrée. Le format de la matrice est très flexible, mais il doit être clairement décrit dans votre réponse.

Par exemple:

  • une seule chaîne binaire, avec ou sans séparateurs entre les lignes:

    "111001111110 110100100000..."

    ou:

    "111001111110110100100000..."

  • un tableau de chaînes binaires:

    ["111001111110", "110100100000", ...]

  • un tableau de nombres (chaque nombre décrivant une ligne une fois reconvertie en binaire et complétée à gauche avec des zéros):

    [3710, 3360, ...]

Sortie

Les coordonnées (X, Y)du "boeuf", (0, 0)étant le coin supérieur gauche du chignon.

Sinon, vous pouvez utiliser des coordonnées basées sur 1 (mais pas une combinaison des deux formats, comme 0 pour X et 1 pour Y).

Pour l'exemple ci-dessus, la réponse attendue est (3, 4)(basée sur 0) ou (4, 5)(basée sur 1):

   00 01 02 03 04 05 06 07 08 09 10 11 
00  1  1  1  0  0  1  1  1  1  1  1  0
01  1  1  0  1  0  0  1  0  0  0  0  0
02  0  1  0  0  0  1  1  1  1  1  0  1
03  1  0  0  1  0  0  1  0  0  1  0  0
04  1  0  0 [1  0  1  1] 0  0  1  1  1
05  1  1  1 [1  1  1  0] 0  0  0  1  0
06  1  1  0 [1  1  1  0] 0  0  0  0  1
07  1  0  0 [1  1  1  1] 0  0  0  0  1
08  1  0  0  1  1  1  0  1  1  1  1  1
09  1  1  1  1  1  0  0  1  1  1  1  1
10  1  0  0  0  0  1  0  1  0  1  1  1
11  1  1  0  0  1  1  0  0  0  0  1  1

Encore une fois, tout format raisonnable fonctionnerait aussi longtemps que cela est spécifié dans votre réponse. Veuillez également indiquer si vous utilisez des coordonnées basées sur 0 ou sur 1.

Règles

  • Vous pouvez supposer en toute sécurité qu'il y a toujours exactement un "boeuf" sur le pain. Votre code n'est pas requis pour prendre en charge les cas comportant plus d'un boeuf ou aucun boeuf.
  • Le motif bœuf apparaîtra toujours comme décrit. Il ne sera jamais tourné ou reflété de quelque manière que ce soit.
  • C'est du code-golf, donc la réponse la plus courte en octets est gagnante. Les échappatoires standard sont interdites.

Cas de test

Dans les cas de test suivants, chaque ligne de la matrice est exprimée sous forme de représentation décimale.

Input : [ 3710, 3360, 1149, 2340, 2407, 4034, 3521, 2529, 2527, 3999, 2135, 3267 ]
Output: [ 3, 4 ]

Input : [ 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 ]
Output: [ 3, 7 ]

Input : [ 2796, 206, 148, 763, 429, 1274, 2170, 2495, 42, 1646, 363, 1145 ]
Output: [ 6, 4 ]

Input : [ 3486, 3502, 1882, 1886, 2003, 1442, 2383, 2808, 1416, 1923, 2613, 519 ]
Output: [ 1, 1 ]

Input : [ 3661, 2382, 2208, 1583, 1865, 3969, 2864, 3074, 475, 2382, 1838, 127 ]
Output: [ 8, 8 ]

Input : [ 361, 1275, 3304, 2878, 3733, 3833, 3971, 3405, 2886, 448, 3101, 22 ]
Output: [ 0, 3 ]

Input : [ 3674, 2852, 1571, 3582, 1402, 3331, 1741, 2678, 2076, 2685, 734, 261 ]
Output: [ 7, 7 ]
Arnauld
la source
L'utilisation d'indices basés sur 1 est-elle autorisée (en haut à gauche (1,1))?
Poignée de porte
@Doorknob Oui, s'il s'agit du même format pour X et Y (la question est mise à jour en conséquence).
Arnauld
35
Points bonus si nous indiquons également si 0xBEEF est 0xDEAD? : P
TuxCrafting
10
Ce défi est vraiment aléatoire et un peu idiot. Mais c’est encore un très beau défi. +1
DJMcMayhem
Puis-je sortir y, x(c.-à-d. Ordre inverse)?
Luis Mendo

Réponses:

30

Jelly , 20 17 16 octets

ṡ€4ḄZw€“¿ÇÇБĖUṀ

L'entrée est sous la forme d'une matrice booléenne, la sortie est la paire d'index de base 1 (Y, X) .

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça fonctionne

ṡ€4ḄZw€“¿ÇÇБĖUṀ  Main link. Argument: M (2D array of Booleans)

ṡ€4               Split each row into 9 chunks of length 4.
   Ḅ              Convert these chunks from base 2 to integer.
    Z             Zip/transpose. This places the columns of generated integers
                  into the rows of the matrix to comb through them.
       “¿ÇÇБ     Push the array of code points (in Jelly's code page) of these
                  characters, i.e., 0xB, 0xE, 0xE, and 0xF.
     w€           Window-index each; in each row, find the index of the contiguous
                  subarray [0xB, 0xE, 0xE, 0xF] (0 if not found).
                  Since the matrix contains on one BEEF, this will yield an array
                  of zeroes, with a single non-zero Y at index X.
             Ė    Enumerate; prefix each integer with its index.
              U   Upend; reverse the pairs to brings the zeroes to the beginning.
               Ṁ  Take the maximum. This yields the only element with positive
                  first coordinate, i.e., the pair [Y, X].
Dennis
la source
14
Je ne comprends pas ... comment pouvez-vous coder quelque chose qui n'est pas lisible par l'homme?
L3n
12
La gelée est de loin plus facile à écrire qu'à lire. : P
Dennis
45
@ L3n vous semblez impliquer que Dennis est un humain. Même si c'est une possibilité, étant donné le genre d'astuces qui se produit régulièrement, je ne négligerais pas les autres ... disons, plus d'alternatives cyberpunk ;-)
Francesco
1
Vous pouvez afficher (x, y) avecṡ4Z€Ḅw€“Ье‘ĖUṀ
Jonathan Allan
2
@ JonathanAllan Nice. Il existe également une ṡ€4ḄZjw“¿ÇÇБ’d24indexation basée sur 0, mais malheureusement, il s'agit d'un octet de plus.
Dennis
40

vim, 126 80 77 76

/\v1011\_.{9}(1110\_.{9}){2}1111<cr>:exe'norm Go'.join(getpos('.'))<cr>xxdawhPXXd{

Attend l'entrée dans le formulaire

111001111110
110100100000
010001111101
100100100100
100101100111
111111000010
110111000001
100111100001
100111011111
111110011111
100001010111
110011000011

Et les sorties (avec des indices basés sur 1) comme

4 5
/                      regex search for...
\v                     enable "very magic" mode (less escaping)
1011\_.{9}             find the first line ("B"), followed by 8 chars + 1 \n
(1110\_.{9}){2}        find the second and third lines ("EE")
1111<cr>               find the fourth line ("F")
:exe'norm Go'.         insert at the beginning of the file...
join(getpos('.'))<cr>  the current position of the cursor
xxdawhPXX              do some finagling to put the numbers in the right order
d{                     delete the input

Merci à Jörg Hülsermann pour avoir sauvé indirectement 46 octets en me faisant réaliser que ma regex était super bête, et à DJMcMayhem pour 3 octets supplémentaires.

Poignée de porte
la source
1
Quelques conseils: 1) Ypest meilleur que yyp(même si je sais que vous vous opposez à Y: P) 2) les espaces blancs exec 'norm Go'sont inutiles. Et 3) kd{est plus court que kdgg. (Je n'ai pas encore testé cela)
DJMcMayhem
1
@DJMcMayhem Oh, j'oublie toujours Yparce que je le fais rebondir dans mon vimrc. : P En fait, le kdggétait équivalent à just d{, ce qui, de manière surprenante, ne supprime pas la ligne actuelle.
Poignée de porte
Oh intéressant. Comme c'est pratique!
DJMcMayhem
Je suis toujours confus quand des choses comme qui {se révèlent être un mouvement de personnage; donc j'ai fait quelque chose comme {d''au lieu de supprimer des lignes entières.
Neil
1
Vous pouvez utiliser echo au lieu d'imprimer dans le tampon, je ne pense pas que rien ne l'empêche dans le défi. Cela réduirait environ 10 octets.
Christian Rondeau
22

JavaScript (ES6), 63 60 56 octets

s=>[(i=s.search(/1011.{9}(1110.{9}){2}1111/))%13,i/13|0]

Prend l'entrée en tant que chaîne de 12 chaînes binaires de 12 chiffres délimitée par des espaces de 155 caractères, renvoie des valeurs indexées à zéro. Edit: 3 octets sauvegardés grâce à @ JörgHülsermann. Sauvegardé 4 octets grâce à @ETHproductions.

Neil
la source
Pourriez-vous éventuellement utiliser s.search(r)au lieu de r.exec(s).index?
ETHproductions
1
@ETHproductions Bien sûr que je pourrais. Je devais être à moitié endormi hier ...
Neil
Pour moi, utiliser nodejs pour exécuter ne marche que si je change s=>[de mode (s,i)=>[, car vous devez définir i quelque part: /
Mijago
@Mijago Odd, cela fonctionnait dans le nœud 4 quand je l'ai essayé (j'utilise normalement le shell Spidermonkey JS). Remarquez qu'une faute de frappe s'est glissée dans le code, ce qui en a fait du bien!
Neil
Je pense que cela échoue pour 00001011001011001110001110001110001110001110001111001111000000000000000000000000000000000000000000000000000000000000000000000000000000
Taemyr
14

C, 146 177 173 163 octets

Merci à Numberknot d’ avoir corrigé le code (décalage des trois lignes inférieures).

Enregistrement de 4 octets en les remplaçant >>=1par /=24 endroits. Enregistrer 10 octets supplémentaires en laissant xet yêtre global et par défaut intgrâce à MD XF

#define T(i,n)(A[y+i]&15)==n
x,y;b(int A[12]){for(x=9;x--;){for(y=0;++y<9;A[y]/=2)if(T(0,11)&&T(1,14)&&T(2,14)&&T(3,15))return(x<<4)+y;A[9]/=2;A[10]/=2;A[11]/=2;}}

Ungolfed:

int b(int A[12]) {
 for (int x=8; x>=0; --x) {
  for (int y=0; y<9; ++y) {
   if ((A[y]&15)==11 && (A[y+1]&15)==14 && (A[y+2]&15)==14 && (A[y+3]&15)==15) { 
    return (x<<4) + y; 
   }
   A[y]/=2;
  }
  A[9]/=2; A[10]/=2; A[11]/=2;
 }
}

Renvoie x, y (base 0) dans le quartet haut et bas d'un octet.

Usage:

int temp=b(array_to_solve);
int x=temp>>4;
int y=temp&15;
printf("%d %d\n",x,y);
Karl Napf
la source
1
vous pouvez modifier votre définition dans #define T(i,n)if((A[y+i]&15)==n)et la section if afin T(0,11)T(1,14)T(2,14)T(3,15)returnde sauvegarder 6 octets. Modifiez également la signature de la fonction int b(int*A)sur 4 octets supplémentaires enregistrés.
Lince Assassino
163 octets
MD XF
9

MATL , 22 21 octets

Eq[ODDH]B~EqZ+16=&fhq

L'entrée est une matrice binaire, avec ;comme séparateur de lignes. La sortie est 1-basé dans l' ordre inverse: Y X.

Essayez-le en ligne! Ou vérifiez tous les tests avec le format d’entrée décimal.

Explication

Le motif est détecté par convolution 2D. Pour ça,

  • La matrice et le motif doivent être sous forme bipolaire, c'est-à-dire 1, -1au lieu de 1, 0. Comme le motif a une taille de 4 × 4, son occurrence est détectée par une entrée égale à 16dans la sortie de convolution.
  • Le noyau de convolution doit être défini comme le motif recherché inversé dans les deux dimensions.

De plus, comme la convolution introduit un décalage dans les index détectés, il doit être corrigé dans la sortie.

Eq      % Implicitly input binary matrix. Convert to bipolar form (0 becomes -1)
[ODDH]  % Push array [0 8 8 2]
B       % Convert to binary. Each number gives a row
~Eq     % Negate and convert to bipolar. Gives [1 1 1 1; 0 1 1 1; 0 1 1 1; 1 1 0 1]
        % This is the "BEEF" pattern reversed in the two dimensions. Reversal is
        % needed because a convolution will be used to detect that patter
Z+      % 2D convolution, keeping original size
16=&f   % Find row and column indices of 16 in the above matrix
h       % Concatenate horizontally
q       % Subtract 1. Implicitly display
Luis Mendo
la source
8

Mathematica, 62 octets

BlockMap[Fold[#+##&,Join@@#]==48879&,#,{4,4},1]~Position~True&

Renvoie toutes les positions de la matrice BEEF, indexé 1. L'entrée doit être une matrice de chiffres binaires. Les x et y dans la sortie sont commutés, cependant.

JungHwan Min
la source
Pas de soucis à propos xet d' yêtre échangé.
Arnauld
7

Slip , 28 octets

27 octets de code, +1 pour l' poption.

(?|1011)(\(?|1110)){2}\1111

Requiert une entrée sous forme de rectangle multiligne composé de 1 et de 0 sans espaces. Essayez-le ici (avec un troisième test en entrée).

Explication

Le glissement est une langue du défi de correspondance de modèles 2D . Sp3000 pourrait en dire beaucoup plus que moi, mais il s’agit en fait d’une forme étendue de regex avec des commandes directionnelles qui vous permettent d’être identiques dans deux dimensions. Le code ci-dessus utilise la commande éponyme "slip" \, qui ne modifie pas la direction du pointeur de correspondance mais le déplace latéralement d'un caractère. Il utilise également "groupe stationnaire" (?|...), qui correspond à quelque chose, puis réinitialise le pointeur à son emplacement précédent.

Le code se décompose comme suit:

(?|1011)                     Match 1011; reset pointer to beginning of match
        (         ){2}       Do the following twice:
         \                     Slip (moves pointer down one row)
          (?|1110)             Match 1110; reset pointer to beginning of match
                      \1111  Slip and match 1111

Cela correspond à la 0xBEEFplace. L' poption affiche les coordonnées du match, indexées par 0.

DLosc
la source
1
Nice :) Bizarrement, pour les motifs de bloc, il est parfois plus difficile de se promener en spirale:1011>001>1(11>){3}1>1
Sp3000
@ Sp3000 Ha! Spiral était la méthode la plus courte dans SnakeEx, mais je n’avais pas pensé à l’essayer dans Slip. Truc vraiment sympa avec le 1(11>){3}.
DLosc
7

PHP, 87 octets

chaîne binaire en entrée sans séparateurs, renvoie des valeurs indexées à zéro.

preg_match("#1011(.{8}1110){2}.{8}1111#",$argv[1],$c,256);echo($s=$c[0][1])%12,$s/12^0;

tableau de nombres en entrée 128 octets

<?foreach($_GET[a]as$a)$b.=sprintf("%012b",$a);preg_match("#1011(.{8}1110){2}.{8}1111#",$b,$c,256);echo($s=$c[0][1])%12,$s/12^0;

14 octets enregistrés par @Titus Merci

Jörg Hülsermann
la source
Utilisez ,plutôt que .dans echoet vous pouvez supprimer les parenthèses. (-4)
Titus
Dans les commentaires, Arnauld permet une sortie sans délimiteur. (-4)
Titus
Utiliser l'indicateur PREG_OFFSET_CAPTURE: ajouter ,256aux preg_matchparamètres, retirer ^(.*)de l'expression rationnelle $c[0][1]au lieu de strlen($c[1])(-6)
Titus
@Titus bien joué
Jörg Hülsermann
5

Java 7,182 177 octets

J'ai porté la réponse de Karl Napf C à JAVA Et merci à Karl Napf d' avoir sauvé 5 octets en me rappelant Bit Magic. (Au fait, j'ai aussi eu cette idée, mais @KarlNapf, l'idée de la pièce n'était pas la mienne). Désolé si je vous ai déplu.

(Basé sur 0)

int f(int[]a){int x=9,y,z=0;for(;x-->0;){for(y=0;y<9;a[y++]/=2) if((a[y]&15)==11&(a[y+1]&15)==14&(a[y+2]&15)==14&(a[y+3]&15)==15)z=(x<<4)+y;a[y]/=2;a[10]/=2;a[11]/=2;}return z;}

Ungolfed

class Beef {

    public static void main(String[] args) {
        int x = f(new int[] { 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 });
        System.out.println(x >> 4);
        System.out.println(x & 15);
    }

    static int f(int[] a) {
        int x = 9,
            y,
            z = 0;

        for (; x-- > 0; ) {
            for (y = 0; y < 9; a[y++] /= 2)
                if ((a[y] & 15) == 11 
                  & (a[y + 1] & 15) == 14
                  & (a[y + 2] & 15) == 14 
                  & (a[y + 3] & 15) == 15)
                    z = (x << 4) + y;

            a[y] /= 2;
            a[10] /= 2;
            a[11] /= 2;
        }
        return z;
    }

}
Numéro numéroté
la source
2
Quels sont ces quatre espaces entre a[y++]>>=1)et if((a[y]&15)==. Btw, je compte 182 octets au lieu de 183? : S
Kevin Cruijssen
@KevinCruijssen corrigé.
Numéro numéroté
1
Tout va bien ;-)
Karl Napf
1
Vous pouvez toujours supprimer l'espace entre ...a[y++]/=2)et if((a[y]&15)==....
Kevin Cruijssen
5

Retina, 47 octets

Je voudrais commencer par des excuses. Je pense que c'est probablement terrible et un mauvais exemple d'utilisation de la langue, mais comme j'ai utilisé un regex pour ma réponse en Perl, j'ai pensé essayer Retina. Je ne suis pas très bon. :( Les extraits sur github m'a beaucoup aidé!

Merci à @ wullzx pour son commentaire sur ma réponse Perl pour -3 octets et à @ Taemyr pour avoir signalé un problème avec ma méthode!

Attend l'entrée sous forme de chaîne binaire séparée par des espaces et génère des coordonnées séparées par des espaces.

(.{13})*(.)*1011(.{9}1110){2}.{9}1111.*
$#2 $#1

Essayez-le en ligne!

Vérifiez tous les tests à la fois.

Dom Hastings
la source
1
Echec pour '0000101100101100111000111000111000111000111100111100000000000000000000000000000000000000000000000000000000000000000000000000' Votre (.) * Doit être (.) {0,8}
Taemyr
Est-ce que cela est contré par You can safely assume that there is always exactly one 'beef' on the bun. Your code is not required to support cases with more than one beef or no beef at all.? Il peut être résolu avec des modificateurs ungreedy si nécessaire (.{12})*?(.)*?.
Dom Hastings
1
Regardez encore, il n'y a qu'un seul bœuf dans cette entrée - et ce n'est pas au point indiqué par votre programme. Le problème ne serait pas résolu en utilisant des modificateurs enthousiastes, car je peux remplacer le faux boeuf par le vrai boeuf. le problème est que votre expression rationnelle correspond à un "boeuf" qui commence à moins de 4 bits à partir de la fin d'une ligne de la matrice.
Taemyr
Vous pouvez également résoudre ce problème en modifiant {8} en {9} et en demandant que les lignes de l'entrée soient séparées par un espace, pour un correctif de coût égal à zéro octet.
Taemyr
@Taemyr Ahhh! Je vois! J'ai mal compris votre propos ... Vous avez effectivement raison. Ma solution Perl est potentiellement passionnante. Est-ce que cela changera dès que possible. Merci pour vos commentaires et suggestions!
Dom Hastings
4

Scala, 90 octets

("1011.{8}(1110.{8}){2}1111".r.findAllMatchIn(_:String).next.start)andThen(i=>(i/12,i%12))

Explication:

(
  "1011.{8}(1110.{8}){2}1111" //The regex we're using to find the beef
  .r                          //as a regex object
  .findAllMatchIn(_:String)   //find all the matches in the argument thats going to be passed here
  .next                       //get the first one
  .start                      //get its start index
)                             //this is a (String -> Int) function
andThen                       //
(i=>                          //with the found index
  (i/12,i%12)                 //convert it to 2d values
)                             

(a -> b) andThen (b -> c)résulte en une (a -> c)fonction, c'est comme l'inverse de compose, mais nécessite moins d'annotations de type dans scala. Dans ce cas, il prend une chaîne de chiffres binaires en entrée et renvoie un tuple d'index de base zéro.

corvus_192
la source
4

J, 31 29 octets

[:($#:I.@,)48879=4 4#.@,;._3]

L'entrée est formatée sous la forme d'un tableau 2D de valeurs binaires et la sortie correspond aux coordonnées de base zéro sous la forme d'un tableau [y, x].

L’aplatissement et la conversion de base pour trouver l’index sont quelque chose que j’ai appris de ce commentaire de Dennis.

Usage

   f =: [:($#:I.@,)48879=4 4#.@,;._3]
   ] m =: _12 ]\ 1 1 1 0 0 1 1 1 1 1 1 0 1 1 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 0 0 0 1 0 1 0 1 1 1 1 1 0 0 1 1 0 0 0 0 1 1
1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
   f m
4 3
   f (#:~2#~#) 3710 3360 1149 2340 2407 4034 3521 2529 2527 3999 2135 3267
4 3
   f (#:~2#~#) 1222 3107 1508 3997 1906 379 2874 2926 1480 1487 3565 633
7 3
   f (#:~2#~#) 2796 206 148 763 429 1274 2170 2495 42 1646 363 1145
4 6
   f (#:~2#~#) 3486 3502 1882 1886 2003 1442 2383 2808 1416 1923 2613 519
1 1
   f (#:~2#~#) 3661 2382 2208 1583 1865 3969 2864 3074 475 2382 1838 127
8 8
   f (#:~2#~#) 361 1275 3304 2878 3733 3833 3971 3405 2886 448 3101 22
3 0
   f (#:~2#~#) 3674 2852 1571 3582 1402 3331 1741 2678 2076 2685 734 261
7 7

Explication

[:($#:I.@,)48879=4 4#.@,;._3]  Input: 2d array M
                            ]  Identity. Get M
                 4 4    ;._3   For each 4x4 subarray of M
                       ,         Flatten it
                    #.@          Convert it to decimal from binary
           48879=              Test if equal to 48879 (decimal value of beef)
[:(       )                    Operate on the resulting array
         ,                       Flatten it
      I.@                        Find the indices where true
    #:                           Convert from decimal to radix based on
   $                               The shape of that array
                               Returns the result as coordinates [y, x]
milles
la source
4

Python 2, 98 95 92 octets

lambda x:'%x'%(`[''.join('%x'%int(s[i:i+4],2)for s in x)for i in range(9)]`.find('beef')+15)

L'entrée est une liste de chaînes, la sortie est la chaîne XY (index basés sur 1).

Testez-le sur Ideone .

Dennis
la source
Est-ce que ceci pourrait à tort trouver un "boeuf" à travers la frontière où deux lignes sont concaténées?
xnor
Ouais je pense que oui. Je vais annuler le montage jusqu'à ce que je puisse le tester correctement.
Dennis
2
C'est ce qui se passe lorsque vous utilisez un chignon toroïdal.
mbomb007
4

Perl, 54 octets

Code 53 octets + 1 pour -n. Utilisations -Esans frais supplémentaires.

Utilise des indices basés sur 0. Attend l'entrée sous la forme d'une chaîne de 1s et 0s et génère des coordonnées séparées par des espaces.

Merci à @ wullxz et @ GabrielBenamy de m'avoir aidé à économiser 9 octets et au commentaire de Taemyr sur ma réponse de Retina pour avoir signalé un problème!

/1011.{9}(1110.{9}){2}1111/;say$-[0]%13,$",$-[0]/13|0

Usage

perl -nE '/1011.{9}(1110.{9}){2}1111/;say$-[0]%13,$",$-[0]/13|0' <<< '111001111110 110100100000 010001111101 100100100100 100101100111 111111000010 110111000001 100111100001 100111011111 111110011111 100001010111 110011000011
010011000110 110000100011 010111100100 111110011101 011101110010 000101111011 101100111010 101101101110 010111001000 010111001111 110111101101 001001111001
101011101100 000011001110 000010010100 001011111011 000110101101 010011111010 100001111010 100110111111 000000101010 011001101110 000101101011 010001111001
110110011110 110110101110 011101011010 011101011110 011111010011 010110100010 100101001111 101011111000 010110001000 011110000011 101000110101 001000000111
111001001101 100101001110 100010100000 011000101111 011101001001 111110000001 101100110000 110000000010 000111011011 100101001110 011100101110 000001111111
000101101001 010011111011 110011101000 101100111110 111010010101 111011111001 111110000011 110101001101 101101000110 000111000000 110000011101 000000010110
111001011010 101100100100 011000100011 110111111110 010101111010 110100000011 011011001101 101001110110 100000011100 101001111101 001011011110 000100000101'
3 4
3 7
6 4
1 1
8 8
0 3
7 7
Dom Hastings
la source
1
Vous pouvez sauvegarder 3 caractères en combinant l'expression régulière pour le binaire EE: (.{8}1110){2}au lieu de.{8}1110.{8}1110
wullxz
1
Vous pouvez également enregistrer un autre 3 octets en changeant length$`en$-[0]
Gabriel Benamy
@wullxz Bien sûr! J'ai essayé \1mais je n'ai pas eu de chance, je n'ai pas pensé à essayer {2}! Merci!
Dom Hastings
@GabrielBenamy Incroyable, merci beaucoup! Mis à jour!
Dom Hastings
2
@ User112638726 " $-[0]est l'offset du début de la dernière correspondance. $-[n]Est l'offset du début de la sous-chaîne correspondant au nième sous-motif ou undefsi le sous-motif ne correspond pas." à: perldoc.perl.org/perlvar.html (cherchez @-)
Dom Hastings
1

Scala, 318 octets

Cette solution pourrait être encore améliorée ... mais je la gardais lisible et permettais à l'entrée d'être la matrice à lignes multiples.

Solution actuelle si tableau de chaînes binaires

def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}.map{_.zip(beef)}.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}.map{e=>s"(${e._1.head},${e._2})"}.head

Échantillon de travail

val bun = 
"""1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
""".replaceAll(" ","")
def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
val l = bun.split("\n").toList
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}
.map{_.zip(beef)}
.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex
.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}
.map{e=>s"(${e._1.head},${e._2})"}.head
Trevor Sibanda
la source
1

Python, 137 octets (selon Linux (merci ElPedro))

def f(s,q=0):import re
 i=s.index(re.findall('1011.{8}1110.{8}1110.{8}1111',s)[q])+1
 x=i%12
 y=(i-x)/12
 if x>8:x,y=f(s,q+1)
 return x,y

Pas exactement un décompte concurrentiel, mais l'algorithme est un peu intéressant. Prend l'entrée comme une chaîne de valeurs binaires.

Penalosa
la source
Si vous poursuivez des espaces simples au lieu de 4 et que vous vérifiez sous Linux, il s'agit de 137
ElPedro
1
Je pense que vous avez besoin d’une nouvelle ligne et d’un espace avant l’importation (je reçois un IndentError dans Python 2 sans ce dernier) qui coûte 2 octets, mais vous pouvez ensuite mettre i = ..., x = ... et y = ... sur le même ligne que et séparer avec; perdre 1 octet pour 136
ElPedro
@elpedro J'utilise Python 3, et l'importation est bien sur la même ligne.
Penalosa
Bien
Bon Dieu, il suffit de relire mes commentaires et je fais beaucoup de fautes de frappe ce soir. C'est une bonne chose que je
n'essaye
1

Ruby , 62 octets

def f(a);a=~/1011(.{8}1110){2}.{8}1111/;$`.size.divmod(12);end 

Il attend une chaîne de 0et 1et retourne un tableau de Y et X, basé sur zéro.

Essayez chez ideone .

undur_gongor
la source
1

F # - 260 octets

Programme complet, y compris l'indicatif EntryPoint requis (comptez donc moins si vous le souhaitez, je suppose).

Entrée: chaque ligne en tant que chaîne distincte: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111111111" "11111111111111"

Code:

[<EntryPoint>]
let main a=
 let rec f r:int=
  let b=a.[r].IndexOf"1011"
  if(b>0)then if(a.[r+1].[b..b+3].Equals"1110"&&a.[r+2].[b..b+3].Equals"1110"&&a.[r+3].[b..b+3].Equals"1111")then r else f(r+1)
  else f(r+1)
 printfn"%d%d"(a.[f 0].IndexOf"1011")(f 0);0

Ce n’est probablement pas la solution la plus élégante, mais je voulais rester avec des chaînes, c’est donc comme cela que je l’ai fait. Je pensais presque que c'était une simple ligne et plus petite avec des tuyaux, mais il y a quelque chose avec le double si bloc qui m'arrivait que je ne pouvais pas résoudre. Alors oh bien!

J'ai aussi pensé à porter la réponse de Karl dans fa #, car c'est une bonne réponse, et je peux toujours le faire pour le plaisir, mais je voulais rester avec celle-ci pour être différente.

magumbasauce
la source
1

Dyalog APL, 29 à 27 octets

Prend un tableau binaire 12x12 comme entrée utilisateur et renvoie les coordonnées dans l'ordre inverse, les index commencent à 1.

Merci à @ Adám pour la sauvegarde de nombreux octets. -2 octets parce que je suis idiot et tout laissé dans une fonction sans raison.

0~⍨∊{⍵×⍳⍴⍵}⎕⍷⍨~0 8 0 6⊤⍨4/2
Zacharý
la source
Économisez 2 en remplaçant ~2 8 12∊⍨4 4⍴⍳16par 15 7 15 9⊤⍨4/2. Notez que cette version 0~⍨∊{⍵×⍳⍴⍵}peut être remplacée à partir de la version 16.0 (votre code ne fonctionne que dans Dyalog APL).
Adám
Oui, Dyalog a des caractères différents de GNU. Ou s'agit-il d'autre chose?
Zacharý
Eh bien, étant ajouté à partir de la version 16, je n’ai pas trouvé de liste de primitives GNUAPL.
Adám
GNU APL est en cours d’exécution, il s’agit principalement de différences de points de code.
Zacharý
D'après ce que j'ai remarqué.
Zacharý
0

Elément , 130 octets

_144'{)"1-+2:';}144'["1-+19:~?1+~?!2+~?3+~?12+~?13+~?14+~?15+~?!24+~?25+~?26+~?27+~?!36+~?37+~?38+~?39+~?16'[&][12%2:`\ `-+12/`]']

Essayez-le en ligne!

Prend les entrées comme une longue chaîne de 1 et de 0 sans aucun délimiteur. Des sorties telles que 3 4(indexation basée sur 0).

Cela fonctionne en plaçant les données d'entrée dans un "tableau" (essentiellement un dictionnaire avec des clés entières) puis, pour chaque valeur de départ possible, teste les bits à des décalages particuliers (les 16 d'entre eux dans un processus très laborieux).

PhiNotPi
la source