Output the device's screen resolution in the specific format of [width]x[height]
(without the brackets). For example, an output could be 1440x900
.
Here's an online tester that you can use to check your own screen resolution.
Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this communityOutput the device's screen resolution in the specific format of [width]x[height]
(without the brackets). For example, an output could be 1440x900
.
Here's an online tester that you can use to check your own screen resolution.
(_=screen)=>_.width+"x"+_.height
Outputs as function return
. Add f=
at the beginning and invoke like f()
. Uses parameter-initializing to initialize the parameter _
to screen
object. The rest is self-explanatory.
f=(_=screen)=>_.width+"x"+_.height
console.log(f())
Note: Passing an argument to this function will cause it to fail.
with(screen)alert(width+"x"+height)
Never thought I will one day use with
! I don't think this can be golfed further.
s=screen,s.width+"x"+s.height
(29 characters) also works.
\$\endgroup\$
alert
: with(screen)(width+'x'+height)
just returns the appropriate string.
\$\endgroup\$
_=screen,_.width+"x"+_.height
, 29 bytes
\$\endgroup\$
*sigh* TI-BASIC takes an extra byte for every lowercase letter.
+2 thanks to @Timtech
-3 thanks to @Timtech
:If ΔX>.1
:Then
:Disp "96x64
:Else
:Disp "320x240
This only works because TI-BASIC can only be run on calculators with two different screen resolutions: 96 by 64 and 320 by 240. I just test to see which screen I have by setting the Zoom to something that is different depending on screen resolution then outputting the correct resolution.
I'm marking this as non-competing for now, since it is hard coded.
ZDecimal
and then using a different Xmax
comparison, at least one byte. Also, I think you need to use lowercase x
which is two bytes (x2) instead of the one-byte uppercase equivalent.
\$\endgroup\$
ZDecimal
) because the default zoom (ZStandard
) is the same on both calculators. I'll fix the capitalization, though.
\$\endgroup\$
May 2, 2017 at 22:47
ZStandard
though, would ΔX
be different then between the calculators? Also, ZDecimal
is only one byte, so this is 31 bytes.
\$\endgroup\$
_=>(s=screen).width+'x'+s.height
console.log((_=>(s=screen).width+'x'+s.height)())
_=>(s=screen).width+'x'+s.height
saves a byte
\$\endgroup\$
May 2, 2017 at 14:38
/*/*/sy*r SPDisplaysDataType|awk '/so/{print$2$3$4}'
Runs system_profiler
, gets the SPDisplaysDataType
information, searches for the first so
in Resolution
, and prints the screen resolution. For multiple screens, this prints all resolutions.
The prior, malcompliant variant:
/*/*/sy*r SPDisplaysDataType|grep so|tr -d 'R :a-w'
2880x1800\n1920x1080@60Hz
(two lines). I don't know if that disqualifies this... or?
\$\endgroup\$
@60Hz
is clearly not in spec.
\$\endgroup\$
|sed 1q
, bringing the byte count up to 58 bytes.
\$\endgroup\$
awk
and having one extra byte. :)
\$\endgroup\$
s=screen;alert(s.width+"x"+s.height)
fullScreen();print(width+"x"+height);
fullScreen()
causes the app to launch with the maximum dimensions - the display resolution.
One byte less than the obvious
print(displayWidth+"x"+displayHeight);
SysGet,w,0
SysGet,h,1
Send,%w%x%h%
Save this in a file with extension .AHK and run it from a command prompt
Send
rather than MsgBox
?
\$\endgroup\$
May 2, 2017 at 14:57
Thanks to @Johan du Toit for saving a byte!
#import<windows.h>
#define G GetSystemMetrics
f(){printf("%dx%d",G(0),G(1));}
#define G GetSystemMetrics f(){printf("%dx%d",G(0),G(1));}
\$\endgroup\$
-7 thanks to Martin Ender
-5 (actually 12!) from Leaky Nun , Regex wizardry is beyond me.
This is long but not longer than the horrendous System.Windows.Forms.SystemInformation.PrimaryMonitorSize
solution
(gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"
first we Get-WmiObject
(gwmi
) to retrieve the Win32_VideoController
object, which contains a member named VideoModeDescription
, which is a string in the format of 1920 x 1080 x 4294967296 colors
, then I run a regex replace to get correct format.
PS H:\> (gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"
1920x1080
(gwmi win32_videocontroller|% v*n)-replace" |x[^x]+$"
shaves a couple of bytes by tweaking the regex.
\$\endgroup\$
May 11, 2017 at 16:49
SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]~Infix~x
This may not work for you depending on what devices you have connected (I don't know). This should always work (assuming you have at least one screen hooked up):
Infix[Last/@("FullScreenArea"/.SystemInformation["Devices","ScreenInformation"][[1]]),x]
SystemInformation[]
returns an expression of the form
SystemInformationData[{
"Kernel" -> {__},
"FrontEnd" -> {__},
"Links" -> {__},
"Parallel" -> {__},
"Devices" -> {__},
"Network" -> {__},
}]
We are interested in "Devices"
, which can be accessed directly as SystemInformation["Devices"]
or as SystemInformation[][[1,5,2]]
. The result will be a list of the form
{
"ScreenInformation" -> {__},
"GraphicsDevices" -> {__},
"ControllerDevices" -> {__}
}
We want "ScreenInformation"
, which can be accessed either as SystemInformation["Devices","ScreenInformation"]
or more succinctly as SystemInformation[][[1,5,2,1,2]]
. The result will be of the form
{
{
"ScreenArea" -> {__},
"FullScreenArea" -> {{0,w_},{0,h_}},
"BitDepth" -> _,
"Resolution" -> _
},
___
}
The length of the list will be the number of screens you have connected. The first screen is SystemInformation[][[1,5,2,1,2,1]]
and the width and height can be extracted as SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]
Then we just insert an Infix
x
for the output format.
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.
...x...
, because void f(){System.out.print((java.awt.Toolkit.getDefaultToolkit().getScreenSize()+"").replaceAll("[^\\d,]",""));}
which outputs 1920,1200
is shorter..
\$\endgroup\$
May 2, 2017 at 14:21
x
instead of ,
by using some regex replacement, but it's five bytes more than your current answer: void f(){System.out.print((java.awt.Toolkit.getDefaultToolkit().getScreenSize()+"").replaceAll("[^\\d,]","").replace(",","x"));}
or void f(){System.out.print((java.awt.Toolkit.getDefaultToolkit().getScreenSize()+"").replaceAll(".*?(\\d+).*?(\\d+).*","$1x$2"));}
Ah well, what isn't heavy in Java.. ;p
\$\endgroup\$
May 2, 2017 at 15:02
_=>{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.
Func<string>
: ()=>{var s=System.Windows.Forms.Screen.PrimaryScreen.Bounds;return s.Width+"x"+s.Height;};
. However, you have a return of void
but you are returning a string
so you need to add 2 bytes for that.
\$\endgroup\$
May 3, 2017 at 9:48
_=>{var s=System.Windows.Forms.Screen.PrimaryScreen.Bounds;return s.Width+"x"+s.Height;};
\$\endgroup\$
May 3, 2017 at 9:49
var s=System.Windows.Forms.Screen.AllScreens[0].Bounds;
would also be the same count but you could golf it with that idea in mind.
\$\endgroup\$
May 3, 2017 at 9:52
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 -oP '\d+x\d+'|line
Thanks to:
Sample run:
bash-4.3$ xrandr|grep -oP '\d+x\d+'|line
1920x1080
xrandr|grep *
work?
\$\endgroup\$
May 2, 2017 at 13:13
grep
and sed
attempts to parse xrandr
's output (pastebin.com/uTVcjWCq) were longer.
\$\endgroup\$
May 2, 2017 at 13:15
xrandr|grep *|cut -d' ' -f1
? (using the matching line from your paste @TIO)
\$\endgroup\$
May 2, 2017 at 13:29
from ctypes import*
u=windll.user32.GetSystemMetrics;
print u(0),'x',u(1)
print u(0),'x',u(1)
is smaller and his example (link) allows it
\$\endgroup\$
May 2, 2017 at 14:20
To clarify, If it's equivalent to the output from What is my screen resolution, It's valid.
in that website, there is space between each part
\$\endgroup\$
May 2, 2017 at 14:22
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.
' '⎕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
Ox`ØP(s×Çn)±d+"x"+ight
The compressed string represents with(screen)width+"x"+height
. Ox
evaluates this as JavaScript, and the result is implicitly printed.
(-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
m
global and omitting int
: m[3];main(){...
\$\endgroup\$
May 2, 2017 at 15:39
m+1
should be shorter than m[1]
right? or isn't that possible in C but only in C++? surely printf has some dereference token
\$\endgroup\$
grep *
expands the asterisk to all files in the directory.
\$\endgroup\$
grep|cut
is awk
.
\$\endgroup\$
*0
. My xrandr output is *0 3360 x 1050 ( 889mm x 278mm ) *0
.
\$\endgroup\$
-f2
Btw, Can you check xrandr|awk '/\*/{print $2}'
?
\$\endgroup\$
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.
v=Tk().maxsize()
, print'%sx%s'%v
saves 9 bytes.
\$\endgroup\$
May 3, 2017 at 13:04
print'%sx%s'%Tk().maxsize()
saves another 4 >_<
\$\endgroup\$
May 3, 2017 at 13:14
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!
-d\
instead of -d' '
. Then when it comes to both grep
for a line and cut
a part of that line, usually is shorter with a single awk
call: xdpyinfo|awk '/dim/&&$0=$2'
.
\$\endgroup\$
May 2, 2017 at 15:32
dimensions
but I don't have xdpyinfo
on my system...
\$\endgroup\$
just for completeness:
PRINT "256x192"
outputs 256x192
. The Spectrum has a fixed hardwired screen resolution.
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.
xdpyinfo|awk /dim/{print\$2}
takes 28 bytes not 24
\$\endgroup\$
#!racket/gui
(let-values([(x y)(get-display-size #t)])(printf"~ax~a"x y))
Just discovered the (discouraged) shorthand for #lang
. Saves a few bytes! Documentation for get-display-size
.
((import html-toolkit)
(htmlOnLoad #::((var S(index(getWindow)screen))
(print(+(index S width)"x"(index S height))))))
(Line breaks added for readability)
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.
2048x1080
for a true 4K screen that's actually 4096x2160
. Any idea why? Firefox 52.0 on FreeBSD 11.
\$\endgroup\$
window.screen
and getting the width
and height
attributes from it. I imagine if you opened up the Firefox console and typed in window.screen
you'll see the apparently incorrect 2048x1080
.
\$\endgroup\$
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 :)
$ 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
puts `xrandr`.split[7..9].join[0..-2]
Alternate solution (52 bytes):
puts `xrandr`.match(/t (\d+) (x) (\d+),/)[1..3].join
'0x0'
\$\endgroup\$