Stampa la risoluzione dello schermo del dispositivo nel formato specifico di [width]x[height](senza parentesi). Ad esempio, un output potrebbe essere 1440x900.

Ecco un tester online che puoi usare per controllare la tua risoluzione dello schermo.

JavaScript (ES6), 32 byte

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

Uscite come funzione return. Aggiungi f=all'inizio e invoca like f(). Utilizza l'inizializzazione dei parametri _per inizializzare il parametro screensull'oggetto. Il resto è autoesplicativo.

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

Nota: il passaggio di un argomento a questa funzione comporta un errore.

JavaScript (soluzione precedente), 35 byte

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

Non avrei mai pensato di usarlo un giorno with! Non credo che questo possa essere ulteriormente approfondito.

TI-BASIC, 30 32 29 byte (non in competizione?)

* sigh * TI-BASIC richiede un byte in più per ogni lettera minuscola.

+2 grazie a @Timtech

-3 grazie a @Timtech

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

Questo funziona solo perché TI-BASIC può essere eseguito solo su calcolatori con due diverse risoluzioni dello schermo: 96 per 64 e 320 per 240. Ho appena testato per vedere quale schermo ho impostando lo Zoom su qualcosa di diverso a seconda della risoluzione dello schermo quindi fornire la risoluzione corretta.

Sto contrassegnando questo come non competitivo per ora, dal momento che è hard coded.

JavaScript (ES6), 32 byte

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

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

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

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

Corre system_profiler, ottiene le SPDisplaysDataTypeinformazioni, cerca il primo soin Resolutione stampa la risoluzione dello schermo. Per più schermi, questo stampa tutte le risoluzioni.

La variante precedente, non conforme:

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

Javascript, 36 byte

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

Elaborazione di 3, 37 byte

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

fullScreen()provoca l'avvio dell'app con le dimensioni massime: la risoluzione del display. Un byte in meno dell'ovvio

print(displayWidth+"x"+displayHeight);

AutoHotKey, 34 byte

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

Salvalo in un file con estensione .AHK ed eseguilo da un prompt dei comandi

C (Windows), 79 78 77 byte

Grazie a @Johan du Toit per aver salvato un byte!

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

PowerShell, 67 60 55 byte

-7 grazie a Martin Ender

-5 (in realtà 12!) Da Leaky Nun , la magia di Regex è oltre me.

Questo è lungo ma non più lungo della System.Windows.Forms.SystemInformation.PrimaryMonitorSizesoluzione orrenda

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

prima dobbiamo Get-WmiObject( gwmi) recuperare l' Win32_VideoControlleroggetto, che contiene un membro chiamato VideoModeDescription, che è una stringa nel formato di 1920 x 1080 x 4294967296 colors, quindi eseguo un regex sostituto per ottenere il formato corretto.

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

Mathematica, 51 byte

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

Questo potrebbe non funzionare per te a seconda dei dispositivi che hai collegato (non lo so). Questo dovrebbe sempre funzionare (supponendo che tu abbia almeno uno schermo collegato):

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

Spiegazione

SystemInformation[] restituisce un'espressione del modulo

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

Siamo interessati a "Devices"cui è possibile accedere direttamente come SystemInformation["Devices"]o come SystemInformation[][[1,5,2]]. Il risultato sarà un elenco del modulo

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

Vogliamo "ScreenInformation", a cui è possibile accedere in modo più SystemInformation["Devices","ScreenInformation"]o meno succinto SystemInformation[][[1,5,2,1,2]]. Il risultato sarà del modulo

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

La lunghezza dell'elenco sarà il numero di schermate che hai collegato. La prima schermata è SystemInformation[][[1,5,2,1,2,1]]e la larghezza e l'altezza possono essere estratte come SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]Quindi inseriamo semplicemente una Infix xper il formato di output.

Java 7, 123 114 byte

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

Questo metodo non funzionerà in un'installazione senza testa di Java (come su TIO) perché utilizza le librerie awt. Sotto il cofano, chiamandogetScreenSize utilizza l'interfaccia nativa Java per chiamare (in genere in una libreria C) per la larghezza e l'altezza dello schermo.

-9 byte grazie a Olivier Grégoire per avermi ricordato che posso restituire la stringa invece di stamparla.

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