Afficher la résolution de l'écran du périphérique au format spécifique de [width]x[height](sans les crochets). Par exemple, une sortie pourrait être 1440x900.

Voici un testeur en ligne que vous pouvez utiliser pour vérifier votre propre résolution d'écran.

JavaScript (ES6), 32 octets

(_=screen)=>_.width+"x"+_.height

Sorties en fonction return. Ajouter f=au début et invoquer comme f(). Utilise l'initialisation des paramètres _pour initialiser le paramètre à l' screenobjet. Le reste est explicite.

f=(_=screen)=>_.width+"x"+_.height
console.log(f())

Remarque: le fait de passer un argument à cette fonction entraînera son échec.

JavaScript (solution précédente), 35 octets

with(screen)alert(width+"x"+height)

Jamais pensé que je vais utiliser un jour with! Je ne pense pas que cela puisse être joué plus loin.

TI-BASIC, 30 32 29 octets (non concurrent?)

* sigh * TI-BASIC prend un octet supplémentaire pour chaque lettre minuscule.

+2 grâce à @Timtech

-3 grâce à @Timtech

:If ΔX>.1
:Then
:Disp "96x64
:Else
:Disp "320x240

Cela ne fonctionne que parce que TI-BASIC ne peut être exécuté que sur des calculatrices avec deux résolutions d'écran différentes: 96 sur 64 et 320 sur 240. afficher la résolution correcte.

Je marque ceci comme non compétitif pour le moment, car c'est codé en dur.

JavaScript (ES6), 32 octets

_=>(s=screen).width+'x'+s.height

console.log((_=>(s=screen).width+'x'+s.height)())

macOS, bash, awk, grep, tr, 51 52 octets

/*/*/sy*r SPDisplaysDataType|awk '/so/{print$2$3$4}'

Fonctionne system_profiler, obtient les SPDisplaysDataTypeinformations, recherche le premier soenResolution , et imprime la résolution d'écran. Pour plusieurs écrans, cela imprime toutes les résolutions.

La variante antérieure non conforme:

/*/*/sy*r SPDisplaysDataType|grep so|tr -d 'R :a-w'

Javascript, 36 octets

s=screen;alert(s.width+"x"+s.height)

Traitement 3, 37 octets

fullScreen();print(width+"x"+height);

fullScreen()provoque le lancement de l’application avec les dimensions maximales - la résolution de l’affichage. Un octet de moins que l'évidence

print(displayWidth+"x"+displayHeight);

AutoHotKey, 34 octets

SysGet,w,0
SysGet,h,1
Send,%w%x%h%

Enregistrez ceci dans un fichier avec l'extension .AHK et exécutez-le à partir d'une invite de commande.

C (Windows), 79 78 77 octets

Merci à @Johan du Toit pour avoir sauvegardé un octet!

#import<windows.h>
#define G GetSystemMetrics
f(){printf("%dx%d",G(0),G(1));}

PowerShell, 67 60 55 octets

-7 grâce à Martin Ender

-5 (en fait 12!) De Leaky Nun , la magie de Regex me dépasse.

C'est long mais pas plus long que la System.Windows.Forms.SystemInformation.PrimaryMonitorSizesolution épouvantable

(gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"

d’abord nous Get-WmiObject( gwmi) pour récupérer l’ Win32_VideoControllerobjet, qui contient un membre nommé VideoModeDescription, qui est une chaîne au format 1920 x 1080 x 4294967296 colors, puis j’exécute un remplacement de regex pour obtenir le format correct.

PS H:\> (gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"
1920x1080

Mathematica, 51 octets

SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]~Infix~x

Cela peut ne pas fonctionner pour vous en fonction des appareils que vous avez connectés (je ne sais pas). Cela devrait toujours fonctionner (en supposant que vous ayez au moins un écran connecté):

Infix[Last/@("FullScreenArea"/.SystemInformation["Devices","ScreenInformation"][[1]]),x]

Explication

SystemInformation[] retourne une expression de la forme

SystemInformationData[{
  "Kernel" -> {__},
  "FrontEnd" -> {__},
  "Links" -> {__},
  "Parallel" -> {__},
  "Devices" -> {__},
  "Network" -> {__},
}]

Nous sommes intéressés à "Devices", ce qui peut être consulté directement comme SystemInformation["Devices"]ou comme SystemInformation[][[1,5,2]]. Le résultat sera une liste du formulaire

{
  "ScreenInformation" -> {__},
  "GraphicsDevices" -> {__},
  "ControllerDevices" -> {__}
}

Nous voulons "ScreenInformation", qui peut être consulté soit comme SystemInformation["Devices","ScreenInformation"]ou plus succinctement comme SystemInformation[][[1,5,2,1,2]]. Le résultat sera de la forme

{
  {
  "ScreenArea" -> {__},
  "FullScreenArea" -> {{0,w_},{0,h_}},
  "BitDepth" -> _,
  "Resolution" -> _
  },
  ___
}

La longueur de la liste sera le nombre d'écrans que vous avez connectés. Le premier écran est SystemInformation[][[1,5,2,1,2,1]]et la largeur et la hauteur peuvent être extraites en tant que SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]Ensuite, nous insérons simplement un Infix xpour le format de sortie.

Java 7, 123 114 bytes

String f(){java.awt.Dimension s=java.awt.Toolkit.getDefaultToolkit().getScreenSize();return s.width+"x"+s.height;}

This method will not work in a headless installation of Java (like on TIO) because it uses the awt libraries. Under the hood, calling getScreenSize uses the Java Native Interface to call out (typically into a C library) for the screen width and screen height.

-9 bytes thanks to Olivier Grégoire for reminding me that I can return the string instead of printing it.

C#, 101 95 89 bytes

_=>{var s=System.Windows.Forms.Screen.PrimaryScreen.Bounds;return s.Width+"x"+s.Height;};

-6 bytes thanks to @TheLethalCoder by reminding me OP didn't mention about printing, so returning a string is also fine. And an additional -6 bytes by changing it to a lambda.

Bash + xrandr, 44 characters

read -aa<<<`xrandr`
echo ${a[7]}x${a[9]::-1}

xrandr belongs to the X server, on Ubuntu is provided by x11-xserver-utils package.

Sample run:

bash-4.3$ read -aa<<<`xrandr`;echo ${a[7]}x${a[9]::-1}
1920x1080

xrandr + grep + util-linux, 30 characters

xrandr|grep -oP '\d+x\d+'|line

Thanks to:

• Markasoftware for the regular expression (-11 characters)

Sample run:

bash-4.3$ xrandr|grep -oP '\d+x\d+'|line
1920x1080

Python 2, 73 bytes

from ctypes import*
u=windll.user32.GetSystemMetrics;
print u(0),'x',u(1)

Octave, 41 bytes

Thanks to @Arjun and @StephenS for corrections.

fprintf('%ix%i',get(0,'ScreenSize')(3:4))

0 is a handle to the root graphics object. Its property 'ScreenSize' contains the coordinates of the screen in pixels. The third and fourth entries give the desired information.

APL (Dyalog), 23 bytes

' '⎕R'x'⍕⌽⊃⎕WG'DevCaps'

⎕WG'DevCaps' Window Get Device Capabilities

⊃ pick the first property (height, width)

⌽ reverse

⍕ format as text

' '⎕R'x' Replace spaces with "x"s

Japt, 24 bytes

Ox`ØP(s×Çn)±d+"x"+ight

Test it online!

The compressed string represents with(screen)width+"x"+height. Ox evaluates this as JavaScript, and the result is implicitly printed.

C (SDL2 library) 113 88 84

(-4 chars due to @AppleShell 's help)

Yes. it compiles.

m[3];main(){SDL_Init(32);SDL_GetDesktopDisplayMode(0,m);printf("%dx%d",m[1],m[2]);}

Run with : gcc snippet.c -lSDL2 && ./a.out

Python 2, 61 49 bytes

Thanks @Jonathan-allan, @felipe-nardi-batista

from Tkinter import*
print'%sx%s'%Tk().maxsize()

For single display setups, this matches the output from the site. This gives entire resolution for multiple displays.

bash + xdpyinfo 42 31 bytes

xdpyinfo|grep dim|cut -d' ' -f7

From man page:

xdpyinfo - is  a utility for displaying information about an X server.

@Floris @manatwork Thanks for saving a few bytes!

xrandr + awk, 25 bytes

xrandr|awk /\*/{print\$1}

ZX Spectrum Basic, 10 bytes

just for completeness:

PRINT "256x192"

outputs 256x192. The Spectrum has a fixed hardwired screen resolution.

Processing, 51 bytes

void setup(){fullScreen();print(width+"x"+height);}

This outputs in this format: width height. Also, the program creates a window that is the size of the screen you are using (because every Processing program creates a window by default) and this program just outputs the height and the width of this window/sketch.

xdpyinfo + awk, 28 bytes

$ xdpyinfo|awk /dim/{print\$2}
3360x1050

Tested on Cygwin with dual heads.

Tcl/Tk, 40

puts [winfo screenw .]x[winfo screenh .]

Lithp, 116 bytes

((import html-toolkit)
(htmlOnLoad #::((var S(index(getWindow)screen))
(print(+(index S width)"x"(index S height))))))

(Line breaks added for readability)

Try it online!

Finally, my html-toolkit module gets some use! Only works in the Try it Online link, will not work from command line.

A few bytes could be saved if 1024 x 768 could be valid output. We just use (+ .. "x" .. ) to avoid print's implicit spacing.

Lua (löve framework),116 bytes

f,g=love.window.setFullscreen,love.graphics function love.draw()f(1)w,h=g.getDimensions()f(0>1)g.print(w.."x"..h)end

The programm changes first to fullscreen then it gets the width and height and prints it then :)

xrandr and sh, 23 bytes

$ set `xrandr`;echo $6x$8
3360x1050

Tested on a CentOS 5 box with display redirected to a Cygwin machine with two monitors. Here the full xrandr output is

$ xrandr
 SZ:    Pixels          Physical       Refresh
*0   3360 x 1050   ( 889mm x 278mm )  *0
Current rotation - normal
Current reflection - none
Rotations possible - normal
Reflections possible - none

Ruby + xrandr, 37 bytes

puts `xrandr`.split[7..9].join[0..-2]

Alternate solution (52 bytes):

puts `xrandr`.match(/t (\d+) (x) (\d+),/)[1..3].join

Red, 26 Bytes

system/view/screens/1/size

Outputs for example:

1920x1080

The code is pretty self explanatory. The 1 refers to the first screen