Codez un programme ou une fonction pour construire une toile interactive sur l'écran d'au moins 400 pixels x 400 pixels. La toile peut être de n'importe quelle couleur, bordée ou sans bordures, avec ou sans barre de titre, etc., juste une forme de toile évidente.

L'utilisateur cliquera sur deux zones distinctes du canevas et le programme doit sortir la distance euclidienne (en pixels) entre ces deux clics d'une certaine manière (STDOUT, affichant une alerte, etc.). Les deux clics ne peuvent être que des clics gauche, uniquement des clics droit, un clic gauche pour le premier et un clic droit pour le second, deux clics double-gauche, etc., toute combinaison est acceptable. Remarque spéciale: cliquer et faire glisser (par exemple, en utilisant MOUSEUP comme deuxième point) n'est spécifiquement pas autorisé; il doit s'agir de deux clics distincts.

L'utilisateur doit pouvoir le faire plusieurs fois et doit obtenir une sortie à chaque fois, jusqu'à ce que le programme soit fermé / forcé à quitter / tué / etc. Vous pouvez choisir la méthode de fermeture (en cliquant sur un X, ctrl-C, etc.), quel que soit le golfeur de votre code.

Règles

• Un programme complet ou une fonction sont acceptables. Si une fonction, cependant, vous devez toujours afficher la sortie à l'utilisateur d'une manière ou d'une autre (le simple retour de la valeur n'est pas acceptable).
• La sortie peut être vers la console, affichée sous forme d'alerte, remplie sur la toile, etc.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

LOGO ( FMSLogo ), 54 52 octets

[mouseon[setpos mousepos]"[pr distance mousepos]"[]]

Malheureusement, je ne trouve aucun manipulateur de support en ligne de l'interpréteur de logo comme FMSLogo.

Il s'agit d'un "modèle à emplacement explicite", similaire à lambda dans d'autres langages de programmation. Cliquez sur la souris gauche pour le premier point et la souris droite pour le deuxième point (distance d'impression).

Explication: (le logo est un langage de programmation graphique de tortue)

mouseon                  Turn on mouse handling, with the following action:
[setpos mousepos]        Set the turtle to `mousepos` (the position of the mouse) on left mouse down
"                        Do nothing on left mouse up
[pr distance mousepos]   Print the distance from turtle position (`distance` is Logo builtin for that purpose) to `mousepos` on right mouse down
"                        Do nothing on right mouse up
[]                       Do nothing on mouse movement

Le "est un mot vide. Normalement, le modèle est censé être une liste (où [], une liste vide, ne fait rien), le passage d'un mot est acceptable (il est encapsulé dans une liste), et dans ce cas, il enregistre 2 octets.

Courir:

apply [... <put the code here> ...] []

C'est applyune façon d'exécuter le modèle dans Logo, la []liste des arguments is, pour laquelle le modèle n'en reçoit aucun.

Mathematica, 94 octets

e="MouseDown";m:=x=MousePosition[];1~RandomImage~400~EventHandler~{e:>m,{e,2}:>Echo@Norm[x-m]}

La toile est une image en niveaux de gris aléatoire, le premier clic doit être un clic gauche et le second un clic droit. Le comportement exact est en fait que le clic droit imprime la distance jusqu'au dernier clic (gauche ou droit), donc si vous utilisez le clic droit à plusieurs reprises, vous pouvez également obtenir des distances consécutives.

Les résultats sont exacts, ils peuvent donc contenir une racine carrée.

Si la résolution de votre webcam est d'au moins 400x400, vous pouvez utiliser CurrentImage[]au lieu de 1~RandomImage~400pour votre toile, en économisant 3 octets.

Java 8, 469 389 388 385 380 357 348 325 octets

import java.awt.event.*;interface F{static void main(String[]a){new java.awt.Frame(){{setSize(400,400);double[]a={-1,0};addMouseListener(new MouseAdapter(){public void mouseClicked(MouseEvent e){if(a[0]<0){a[0]=e.getX();a[1]=e.getY();}else{System.out.println(Math.hypot(e.getX()-a[0],e.getY()-a[1]));a[0]=-1;}}});}}.show();}}

import javafx.application.*;import javafx.scene.*;import javafx.scene.layout.*;import javafx.stage.*;public class E extends Application{double[]a={-1,0};public void start(Stage s)throws Exception{Pane p=new Pane();s.setScene(new Scene(p,400,400));s.show();p.setOnMouseClicked(e->{if(a[0]<0){a[0]=e.getX();a[1]=e.getY();}else {System.out.println(Math.sqrt(Math.pow(e.getX()-a[0],2)+Math.pow(e.getY()-a[1],2)));a[0]=-1;}});}public static void main(String[]a){launch(a);}}

Serait plus court avec AWT, mais je ne l'ai jamais utilisé.

Java (OpenJDK 8) , 282 octets

import java.awt.event.*;interface M{static void main(String[]a){new java.awt.Frame(){int k,x,y;{addMouseListener(new MouseAdapter(){public void mouseClicked(MouseEvent e){x=e.getX()-k*x;y=e.getY()-k*y;k^=1;if(k<1)System.out.prin‌​tln(Math.hypot(x,y))‌​;}});setSize(800,600‌​);show();}};}}

Je ne peux pas tester cela en ce moment; si quelqu'un pouvait me dire s'il y avait des erreurs de compilation ce serait génial.

AWT serait probablement plus court mais j'ai besoin d'un IDE réel pour ce lol. Je n'ai jamais utilisé AWT auparavant mais je pourrais le faire fonctionner si j'avais un IDE. Je pourrais utiliser les documents mais c'est vraiment dur lol

-10 octets en utilisant AWT grâce à Kevin Cruijssen
-44 octets en utilisant un bloc d'initialisation; développé indépendamment de Roberto Graham même si je vois maintenant qu'ils ont fait la même chose, je pense que
-6 octets combinant quelques déclarations grâce à Kevin
-11 octets utilisant un interfacemerci à Kevin
-35 octets éliminant certaines variables inutiles grâce à mellamokb
-9 octets supprimant l'importation inutile et l'utilisation d'un nom qualifié grâce à mellamokb
-44 octets grâce à mellamokb et aditsu

TI-Basic (TI-84 Plus CE), 49 octets (45 jetons) (éventuellement non concurrents)

0→Xmin
0→Ymin
8³→Xmax
Ans→Ymax
While 1
Input 
{X,Y
Input 
Ans-{X,Y
Disp √(sum(Ans²
Pause
End

-7 octets avec des suggestions de kamoroso94

L'utilisateur ne clique pas en soi, mais se déplace autour d'un curseur sur l'écran graphique avec les touches fléchées et frappe enterpour sélectionner un point, et le plus petit mouvement est ~ 1,5 pour x et ~ 2,4 pour y.

Explication:

0→Xmin                # 5 bytes
0→Ymin                # 5 bytes
8³→Xmax               # 6 bytes, 
Ans→Ymax              # 5 bytes, Set up graph screen size (512x512)
While 1               # 3 bytes, Until interrupted with `on` button
Input                 # 2 bytes, Get user input as a point on the graph screen in X and Y
{X,Y                  # 5 bytes, store the list {X,Y} in Ans
Input                 # 2 bytes, Get second user input as a point on the graph screen in X and Y
Ans-{X,Y              # 7 bytes, store {X1-X2,Y1-Y2} in Ans
Disp √(sum(Ans²       # 6 bytes, Display the distance between the two points
Pause                 # 2 bytes, Let the user see it (press `enter` to continue)
End                   # 1 bytes, End while loop

JavaScript (ES6) + HTML, 58 octets

La page Web elle-même sert de «toile» en question; Je pense qu'il est assez sûr de supposer que la fenêtre du navigateur sera d'au moins 400x400 pixels.

E=0,onclick=e=>(E&&alert(Math.hypot(E.x-e.x,E.y-e.y)),E=e)

JavaScript (ES6) + HTML, 51 octets

Nous pouvons économiser 7 octets si nous ignorons la NaNsortie au premier clic. ( @Nate )

E=onclick=e=>alert(Math.hypot(E.x-e.x,E.y-e.y),E=e)

JavaScript (ES6) + HTML + CSS, 58 + 0 + 13 = 71 octets

Edit : Avec 13 octets supplémentaires de CSS, nous pouvons nous assurer que la zone de défilement sera suffisamment grande pour répondre à l'exigence 400x400.

E=0,onclick=e=>(E&&alert(Math.hypot(E.x-e.x,E.y-e.y)),E=e)

*{padding:9in

Traitement / Java, 149 octets

void setup(){size(400,400);}void draw(){}int a,b;void mousePressed(){if(mouseButton==LEFT){a=mouseX;b=mouseY;}else println(dist(a,b,mouseX,mouseY));}

Assez simple, utilise 2 variables globales et 3 fonctions intégrées pour tout faire.

• Configuration: initialise simplement la fenêtre à 400x400
• Dessin: vide, mais doit exister pour que le traitement soit interactif pendant> 1 image
• MousePressed: si clic gauche, enregistrez les coordonnées de la souris dans les entiers a et b. Si vous faites un clic droit, mesurez la distance entre le point (a, b) et la position actuelle et imprimez sur la console.

Processing.org 126

float i,d,x,y;void setup(){fullScreen();}void draw(){}void mousePressed(){d=dist(x,y,x=mouseX,y=mouseY);print(i++%2<1?" ":d);}

Python 2, 144

Imprime la distance entre les derniers clics (le premier imprime la distance à partir de 400 400).

import Tkinter as t,math
r=t.Tk()
p=[400]*2
r.minsize(*p)
def f(e):print math.hypot(p[0]-e.x,p[1]-e.y);p[:]=e.x,e.y
r.bind('<1>',f)
r.mainloop()

Autohotkey, 146 octets

A=0
Gui,Add,Text,W400 H400 gC Border
Gui,Show
Return
C:
If A=0
MouseGetPos,A,B
Else{
MouseGetPos,C,D
Msgbox % Sqrt((A-C)**2+(B-D)**2)
A=0
}
Return

_{On pourrait penser qu'un langage spécialement conçu pour capturer et simuler les actions du clavier et de la souris serait plus efficace pour relever ce défi ...}

Cela crée une fenêtre avec une zone de texte 400 x 400 pixels avec une bordure pour le rendre évident. Sans la bordure, il y a un espace autour du bord qui est dans la fenêtre mais en dehors de la zone de texte et vous ne pouvez pas le dire. L'ajout d'une bordure était le moyen le plus court de les différencier. L' gCoption lui fait exécuter le sous-programme Cchaque fois que vous cliquez sur la zone de texte. La séquence de commandes est donc un clic gauche suivi d'un clic gauche différent.

J'ai trouvé une autre solution de 144 octets, mais elle permet des clics sur tout l'écran au lieu de se limiter à la "toile évidente". Il est également ennuyeux de terminer, car les clics gauche et droit sont capturés et cela ne se termine pas lorsque vous fermez l'interface graphique.

Gui,Add,Text,W400 H400 Border
Gui,Show
Return
LButton::
MouseGetPos,A,B
Return
RButton::
MouseGetPos,C,D
Msgbox % Sqrt((A-C)**2+(B-D)**2)
Return

Python 2 ( TigerJython ), 125 123 octets

from gturtle import*
n=0
def c(x,y):
 global n
 if n:print distance(x,y)
 else:setPos(x,y)
 n^=1
makeTurtle(mousePressed=c)

TigerJython est livré avec une taille par défaut de toile de taille (800x, 600y).

Cela génère une image de tortue temporaire pour chaque point de début cliqué, qui disparaît après la sélection du point de début suivant. Ce comportement est approuvé par l'OP.

SmileBASIC, 86 octets

@L
TOUCH OUT F,X,Y
S=S-X
T=T-Y
IF!O*F*M THEN?SQR(S*S+T*T)
S=X
T=Y
M=M!=!O*F
O=F
GOTO@L

Utilise l'écran tactile pour la saisie.

Java 8, 228 octets

interface A{static void main(String[]a){new java.awt.Frame(){{setSize(400,400);}int i,j,t;public boolean mouseDown(java.awt.Event e,int x,int y){if(t++%2==1)System.out.println(Math.hypot(x-i,y-j));i=x;j=y;return 1>0;}}.show();}}

Voici une solution Java qui utilise une méthode AWT obsolète mouseDownque vous devrez creuser profondément dans l'API pour trouver. Je ne le connais qu'à cause du cours de programmation que j'ai suivi en tant que étudiant en deuxième année du secondaire, et l'un des projets était de créer un petit programme de peinture en utilisant cela et des méthodes similaires. Je n'ai jamais pensé que j'aurais une bonne raison de l'utiliser jusqu'à présent.

Tcl / Tk, 94 104

wm ge . 400x400
bind . <1> {if [info ex x] {puts [expr hypot(%x-$x,%y-$y)]}
set x %x
set y %y}