Trouver toutes les coordonnées sur un chemin

21

Étant donné une chaîne 2D en entrée, sous la forme d'une chaîne avec des sauts de ligne ou une liste de lignes, sortez les coordonnées (x, y)de tous les hachages ( #) de la liste. L'entrée ne contiendra que des hachages et des espaces. (et les sauts de ligne, si vous choisissez de prendre l'entrée comme une chaîne 2D)

S'il n'y a pas de hachage, vous pouvez tout afficher.

La sortie doit être sans ambiguïté quant à quels numéros sont associés à quels.

Exemple:

##

Devrait produire:

(0,0), (1,0)

Cela suppose une indexation basée sur 0, en partant du coin supérieur gauche. Vous pouvez commencer à partir de n'importe quel coin, utiliser une indexation basée sur 0 ou 1, et / ou produire en ypremier. (par exemple dans le formulaire y,x).

Plus de cas de test (encore une fois, tous utilisant l' (x, y)indexation en haut à gauche basée sur 0 ):

    #
#####
#

(4, 0), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (0, 2)


# ###
### #

(0, 0), (2, 0), (3, 0), (4, 0), (0, 1), (1, 1), (2, 1), (4, 1)

Notez que ces cas de test sont tous listés par lignes, pas en suivant le chemin.

Vous pouvez supposer que les hachages formeront une trace continue, c'est-à-dire # #ne seront jamais l'entrée. (probablement pas d'importance, mais au cas où quelqu'un voudrait regex cela)

Vous pouvez également sortir les coordonnées dans n'importe quel ordre, c'est-à-dire des colonnes verticales, des lignes horizontales ou simplement une liste non triée.

Rɪᴋᴇʀ
la source
Pouvons-nous supposer que l'entrée ne contient que des hachages et des espaces?
DJMcMayhem
@DJMcMayhem oui, éditant cela dans la question.
Rɪᴋᴇʀ
Serait- ce ou ce serait des formats de sortie valides?
Zgarb
@Zgarb essentiellement avec le supplément de 1,1 et le hachage? Eh bien sûr.
Rɪᴋᴇʀ
Est-ce que mon autre format valable?
ETHproductions

Réponses:

10

Glissement , 2 + 1 = 3 octets

+1 octet pour le pdrapeau. Code:

`#

Explication:

Le p-flag renvoie la position de chaque occurrence des éléments suivants:

`#      // The character '#'

Essayez-le ici!

Adnan
la source
1
Je pense que nous avons un gagnant
Adám
Une explication?
Rɪᴋᴇʀ
@EasterlyIrk Le backtick échappe un seul caractère sous forme de chaîne. Le drapeau demande des résultats positionnels.
Adám
@ Adám oh, cool!
Rɪᴋᴇʀ
8

Grime , 5 octets

pa`\#

Essayez-le en ligne! Le format de sortie est un peu génial, mais OP a déclaré qu'il était valide.

Explication

Grime est mon langage de correspondance de motifs 2D. La partie après `est le motif , dans ce cas un carré 1 × 1 contenant un #caractère. Grime recherchera une correspondance dans la grille d'entrée et imprime la première qu'il trouve par défaut. La partie précédente `contient des options, dans ce cas signifiant que toutes les correspondances ( a) doivent être imprimées, ainsi que leurs positions et tailles ( p).

Zgarb
la source
8

MATL , 7 6 5 octets

Il s'agit d'une indexation basée sur 1 avec (1,1)dans le coin supérieur gauche.

oo&fh

Explication:

o        % convert char to double 
 o       % remainder mod 2 ('#' == 35, ' '==32) makes spaces falsy
  &f     % apply `find` with 2d-output 
    h   % concatenate outputs to display x- and y-coordinates side by side

Merci @DJMcMayhem et @LuisMendo pour chaque -1 octet!

Essayez-le en ligne!

flawr
la source
3
Vous pourriez faire ooH#fhpour enregistrer un octet. (convertir en entiers, mod2) Puisque l'espace est pair (mod 2 == 0, faux) et #est impair (mod 1 == 1, véridique)
DJMcMayhem
Oh, super, merci beaucoup! =)
flawr
7

Python , 67 octets

Ceci est en fait juste un golf de ma réponse Stack Overflow sur un sujet similaire.

lambda a,e=enumerate:[[(i,j)for j,B in e(A)if'!'<B]for i,A in e(a)]

Essayez-le en ligne!

Les boucles à travers la liste 2D, enregistrant les caractères de hachage, et renvoie le résultat. Nous enregistrons un octet en utilisant char > '!'plutôt que char == '#', car l'entrée ne sera composée que de hachages et d'espaces, et donc hashes ( 0x23) sera les seuls caractères plus grands que les points d'exclamation ( 0x21).

FlipTack
la source
5

JavaScript (ES6), 70 67 octets

s=>s.replace(/./g,(c,i)=>c>' '?[i%l,i/-l|0]+' ':'',l=~s.indexOf`
`)

Affiche une liste de coordonnées séparées par des sauts de ligne et des espaces, par exemple

4,0
0,1 1,1 2,1 3,1 4,1
0,2

Vous pouvez devenir beaucoup plus court avec un format de sortie étrange:

s=>s.replace(/#/g,(c,i)=>[i%l,i/-l|0]+c,l=~s.indexOf`
`)

Cette sorties

    4,0#
0,1#1,1#2,1#3,1#4,1#
0,2#

pour le deuxième cas de test. Il est toujours clair quels numéros sont associés à quels ...

ETHproductions
la source
5

J , 12 octets

$#:'#'I.@:=,

Essayez-le en ligne!

Explication

$#:'#'I.@:=,  Input is y.
           ,  Flatten y
   '#'    =   and form bit vector of equality with #.
      I.@:    Compute positions of 1s
 #:           and convert each to base
$             shape of y.
Zgarb
la source
4

Gelée , 8 octets

n⁶T€,€"J

Essayez-le en ligne!

Étant donné un tableau 2D de caractères (= une liste de chaînes):

            Implicit input (example):
               [[' ', ' ', ' ', ' ', '#']
               ,['#', '#', '#', '#', '#']
               ,['#', ' ', ' ', ' ', ' ']]
n⁶          Not-equal to space (⁶).
               [[0, 0, 0, 0, 1]
               ,[1, 1, 1, 1, 1]
               ,[1, 0, 0, 0, 0]]
  T€        Indices of 1s in each row
               [[5], [1,2,3,4,5], [1]]
    ,€"J    Pair each, vectorizing, with y-indices
               [[[5,1]], [[1,2],[2,2],[3,2],[4,2],[5,2]], [[1,3]]]
Lynn
la source
3

Dyalog APL 16.0, 5 caractères = 9 octets ou 6 caractères = 8 octets

Donne la liste des paires (y, x) en haut à gauche.

⍸⎕='#'

contribution

= équivaut à

'#' ce personnage*

* Il est possible d'enregistrer un caractère au prix d'un octet en le remplaçant '#'par ⍕#(formater l'espace de noms racine)

TryAPL en ligne! Notez que cela a été émulé avec i car TryAPL exécute la version 14.0.

Adam
la source
Assez sûr dans Dyalog APL encodant 1 char = 1 octet, non?
devRicher
@devRicher Normalement, mais n'est pas inclus dans la version à un octet. Voir le lien "octets".
Adám
3

JavaScript (Firefox 30-57), 61 octets

s=>[for(c of(x=0,y=1,s))if(c<' '?(y++,x=0):(x++,c>' '))[y,x]]

Renvoie les coordonnées basées sur 1. Commutateur [y, x]et [x, y]commande faciles. Non golfé:

function coords(s) {
    var x = 0;
    var y = 1;
    for (Var c of s) {
        if (c == "\n") {
            y++;
            x=0;
        } else {
            x++;
        }
        if (c == "#") {
            console.log(y, x);
        }
    }
}
Neil
la source
2

Vim, 37 octets

:%s/#/\=line('.').','.col('.').' '/g<cr>

Puisque V est principalement rétrocompatible, vous pouvez l' essayer en ligne!

Une solution regex simple, où il remplace chaque «#» par l'emplacement dans lequel il a été trouvé (indexation sur une base). J'étais un peu inquiet en écrivant ceci que l'emplacement changerait après avoir remplacé le premier sur une ligne, mais cela ne semble pas être un problème. TBH Je suis agréablement choqué par la simplicité de cette solution.

Malheureusement, vimscript est très verbeux, donc la plupart des octets proviennent de la séparation des résultats, ce qui est toujours lisible. Sinon, on pourrait faire

:%s/#/\=line('.').col('.')/g

Mais cela crée une sortie assez difficile à interpréter. De plus, cela ne fonctionnera que si la grille est toujours 9x9 ou plus petite.

C'est une solution vraiment amusante car elle montre chaque paire de coordonnées à l'emplacement du hachage qu'elle représente. Par exemple, l'entrée

# ###
### #

les sorties

1,1  1,3 1,4 1,5 
2,1 2,2 2,3  2,5 

Bien sûr, si nous utilisions V, nous pourrions supprimer la nouvelle ligne de fin et compresser l'expression régulière. Alors ça pourrait être simplement

Í#/½line('.').','.col('.').' '/g

(32 octets)

Mais puisque c'est exactement la même approche et toujours douloureusement verbeux, il ne semble pas utile d'utiliser un langage de golf.

DJMcMayhem
la source
2
D'accord, l'ensemble "montre chaque paire de coordonnées à l'emplacement du hachage" est sacrément cool. +1
Rɪᴋᴇʀ
2

Haskell, 53 octets

concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..]

L'entrée est considérée comme une liste de chaînes. La sortie est une liste de (x,y)paires (0 indexées), par exemple

*Main> concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..] $ ["# ###","### #"]
[(0,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(4,1)]
nimi
la source
2

Lua, 141 octets

w=io.read()x=w:sub(1,w:find("\n")-1):len()_,c=w:gsub("\n","")for i=0,x do for j=0,c+1 do if w:sub(c*x+i,c*x+i)=="#"then print(i,j)end end end

Il est 2h30 du matin, je suis au lit, sur mon téléphone. Pourquoi est-ce que je fais cela?

devRicher
la source
1

Mathematica, 12 octets

Position@"#"

Forme d'opérateur de Position. Suppose un tableau 2D de caractères. 1 indexé à partir de l'entrée en haut à gauche. Affiche une liste de coordonnées dans le formulaire {row,column}.

ngenisis
la source
La façon dont je lis la description de la tâche, je ne pense pas que la prise d'un tableau 2D de caractères soit autorisée pour les langues qui prennent en charge les chaînes.
smls
Je ne suis pas convaincu. D'une part, cette question se concentre sur char[], qui est en fait un moyen courant de stocker des chaînes dans des langages basés sur C. De plus, cette description de tâche mentionne spécifiquement "soit comme une chaîne avec des sauts de ligne ou une liste de lignes", et ne mentionne pas la liste de listes de caractères ou la matrice 2D de caractères.
smls
@smls Exactement. Le consensus était que si une question spécifie une chaîne, cela signifie une séquence de caractères, et si votre langue a plus d'une façon de l'exprimer, alors vous êtes libre de choisir celle qui convient à vos besoins de golf. Spécifier "soit sous forme de chaîne avec des sauts de ligne ou une liste de lignes" ne change rien à cela, car si vous représentez chaque ligne comme un tableau de caractères, vous obtenez exactement un tableau 2D de caractères.
ngenisis
1

PHP, 69 octets

for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)echo$c>" "?"$j $i,":"";

Utilise l'indexation basée sur 1 en partant du coin supérieur gauche.
Utilisez comme:

php -r 'for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)if($c>" ")echo"$j $i,";' '    #' '#####' '#    '

Sortira:

5 1,1 2,2 2,3 2,4 2,5 2,1 3,
user59178
la source
1

C, 113 octets

i,j,k,l;f(char**p){i=strlen(*p);l=strlen(p);for(j=0;j<l;j++)for(k=0;k<i;k++)if(p[j][k]==35)printf("%d,%d ",k,j);}

Sorties des cas de test:

0,0 2,0 3,0 4,0 0,1 1,1 2,1 4,1 
4,0 0,1 1,1 2,1 3,1 4,1 0,2 

Essayez-le en ligne!

betseg
la source
1

RBX.Lua, 131 octets

Doit supposer que l'entrée est valide (Z est l'axe plat, les espaces blancs sont des Whitetuiles, les hachages peuvent être de toute autre couleur, la partie supérieure gauche est située à 0, 0, 0) et toutes les parties font partie du même modèle M, et le modèle est par ailleurs vide.

for k,v in pairs(workspace.M:GetChildren())do if v.BrickColor~=BrickColor.new("White")then print(v.Position.X,-v.Position.Y)end end

Exemple d'entrée / sortie:

Exemple

devRicher
la source
Pouvez-vous fournir un exemple d'E / S valide?
Rɪᴋᴇʀ
@EasterlyIrk Là, édité la réponse.
devRicher
1

Perl 6 , 25 octets (22 caractères)

{^∞ZX@_».indices("#")}

Prend l'entrée comme une liste de lignes.
Produit une liste par ligne, chacune contenant (y, x) des tuples pour les coordonnées.
Essayez-le en ligne!

Comment ça marche

{                    }  # A lambda.
{    @_»             }  # For each input line:
        .indices("#")   #    get x-coordinates.  (4) (0 1 2 3 4) (0)
 ^∞                     # Range from 0 to Inf.    0   1           2 ...
   Z                    # Zip with:              (0 (4)) (1 (0 1 2 3 4)) (2 (0))
    X                   #    Cartesian product.  ((0 4)) ((1 0) (1 1) (1 2) (1 3) (1 4)) ((2 0))
smls
la source
1

Groovy, 80 68 octets

{y=0;it.each{it.eachWithIndex{x,i->print(x=='#'?"($i,$y)":"")};y++}}

Exemple d'entrée:

[#   #,#   #,#####]

Exemple de sortie:

(0,0)(4,0)(0,1)(4,1)(0,2)(1,2)(2,2)(3,2)(4,2)
Urne de poulpe magique
la source
Pourquoi diviser l'entrée en lignes, alors que la description de la tâche permet de prendre une liste de lignes déjà divisée?
smls
1

Ruby , 24 + 1 = 25 octets

+1 octet pour le -ndrapeau. Les coordonnées sont basées sur 1, un nombre par ligne.

gsub(/#/){p$`.size+1,$.}

Essayez-le en ligne!

Jordan
la source
0

C, 80 octets

x,y;f(char*s){for(x=y=0;*s;printf(*s-35?"":"%d,%d ",x,y),*s++==10?++y,x=0:++x);}

Nécessite une entrée sous forme de tableau de caractères délimité par des sauts de ligne, imprime la sortie à l'écran.

Non golfé et utilisation:

x,y;

f(char*s){
 for(
  x = y = 0;             //init coordinates
  *s;                //iterate until end
  printf(*s-35 ? "" : "%d,%d ", x, y),     //print coordinates or empty string
  *s++==10 ? ++y, x=0 : ++x              //advance to the right or the next line
 );
}


main(){
 f("    #\n#####\n#    ");
 puts("");
 f("# ###\n### #");
}
Karl Napf
la source
1
78 octets:x,y;f(char*s){for(x=y=0;*s;*s++==10?++y,x=0:++x)*s==35&&printf("%d,%d ",x,y);}
gastropner