Przesyłaj rozdzielczość ekranu urządzenia w określonym formacie [width]x[height](bez nawiasów). Na przykład wyjście może być 1440x900.

Oto tester online, którego można użyć do sprawdzenia własnej rozdzielczości ekranu.

JavaScript (ES6), 32 bajty

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

Wyjścia jako funkcja return. Dodaj f=na początku i wywołaj jak f(). Używa inicjalizacji parametru do inicjalizacji parametru _do screenobiektu. Reszta jest oczywista.

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

Uwaga: przekazanie argumentu do tej funkcji spowoduje jej niepowodzenie.

JavaScript (poprzednie rozwiązanie), 35 bajtów

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

Nigdy nie myślałem, że pewnego dnia skorzystam with! Nie sądzę, że można to dalej pograć w golfa.

TI-BASIC, 30 32 29 bajtów (niekonkuruje?)

* westchnienie * TI-BASIC zajmuje dodatkowy bajt na każdą małą literę.

+2 dzięki @Timtech

-3 dzięki @Timtech

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

Działa to tylko dlatego, że TI-BASIC można uruchomić tylko na kalkulatorach o dwóch różnych rozdzielczościach ekranu: 96 na 64 i 320 na 240. Po prostu testuję, aby zobaczyć, który ekran mam, ustawiając Zoom na coś, co jest różne w zależności od rozdzielczości ekranu, a następnie wyświetlanie prawidłowej rozdzielczości.

Na razie zaznaczam to jako niekonkurujące, ponieważ jest mocno zakodowane.

JavaScript (ES6), 32 bajty

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

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

macOS, bash, awk, grep, tr, 51 52 bajtów

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

Uruchamia się system_profiler, pobiera SPDisplaysDataTypeinformacje, szuka pierwszego sow Resolutioni drukuje rozdzielczość ekranu. W przypadku wielu ekranów powoduje to wydrukowanie wszystkich rozdzielczości.

Wcześniejszy wariant niezgodny:

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

JavaScript, 36 bajtów

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

Przetwarzanie 3, 37 bajtów

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

fullScreen()powoduje uruchomienie aplikacji z maksymalnymi wymiarami - rozdzielczością wyświetlacza. Jeden bajt mniej niż oczywiste

print(displayWidth+"x"+displayHeight);

AutoHotKey, 34 bajty

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

Zapisz to w pliku z rozszerzeniem .AHK i uruchom z wiersza polecenia

C (Windows), 79 78 77 bajtów

Dzięki @Johan du Toit za uratowanie bajtu!

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

PowerShell, 67 60 55 bajtów

-7 dzięki Martinowi Enderowi

-5 (właściwie 12!) Od Leaky Nun , magia Regex jest poza mną.

To jest długie, ale nie dłuższe niż przerażające System.Windows.Forms.SystemInformation.PrimaryMonitorSizerozwiązanie

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

najpierw my Get-WmiObject( gwmi), aby pobrać Win32_VideoControllerobiekt, który zawiera element o nazwie VideoModeDescription, który jest łańcuchem w formacie 1920 x 1080 x 4294967296 colors, a następnie uruchamiam zamianę wyrażenia regularnego, aby uzyskać poprawny format.

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

Mathematica, 51 bajtów

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

Może to nie działać w zależności od podłączonych urządzeń (nie wiem). Powinno to zawsze działać (zakładając, że masz podłączony przynajmniej jeden ekran):

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

Wyjaśnienie

SystemInformation[] zwraca wyrażenie formularza

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

Jesteśmy zainteresowani "Devices", do których można uzyskać bezpośredni dostęp jako SystemInformation["Devices"]lub jako SystemInformation[][[1,5,2]]. Rezultatem będzie lista formularza

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

Chcemy "ScreenInformation", do którego można uzyskać dostęp tak SystemInformation["Devices","ScreenInformation"]zwięźle lub bardziej zwięźle SystemInformation[][[1,5,2,1,2]]. Wynik będzie miał formę

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

Długość listy będzie liczbą podłączonych ekranów. Pierwszy ekran jest, SystemInformation[][[1,5,2,1,2,1]]a szerokość i wysokość można wyodrębnić, ponieważ SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]Następnie wstawiamy tylko Infix xdla formatu wyjściowego.

Java 7, 123 114 bajtów

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

Ta metoda nie będzie działać w bezobsługowej instalacji Java (jak w TIO), ponieważ używa bibliotek awt. Dzwonię pod maskągetScreenSize uses the Java Native Interface to call out (typically into a C library) for the screen width and screen height.

-9 bajtów dzięki Olivierowi Grégoire'owi za przypomnienie, że mogę zwrócić ciąg zamiast go wydrukować.

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