เจ้านายของคุณต้องการให้คุณเขียนโค้ดแบบนี้:

public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

(Martin Smith ที่/codereview//a/117294/61929 )

ซึ่งมีประสิทธิภาพและอื่น ๆ แต่ไม่สนุกกับการพิมพ์ เนื่องจากคุณต้องการลดจำนวนการกดคีย์ที่คุณต้องทำคุณจึงเขียนโปรแกรมหรือฟังก์ชั่นที่สั้นลง (หรือเมธอด) ที่ให้เอาต์พุตฟังก์ชั่นนี้สำหรับคุณ (หรือส่งคืนสตริงไปยังเอาต์พุต) และเนื่องจากคุณมีแป้นพิมพ์ยูนิโคดแบบเต็มรูปแบบที่กำหนดเองของคุณเองพร้อมกับคีย์ทั้งหมด 120,737 คีย์ที่จำเป็นสำหรับยูนิโค้ด 8.0 ทั้งหมดเราจึงนับอักขระยูนิโค้ดแทนการกดปุ่ม หรือไบต์หากภาษาของคุณไม่ได้ใช้ซอร์สโค้ดแบบ Unicode

การป้อนข้อมูลโปรแกรมหรือฟังก์ชั่นใด ๆ ของคุณจะนับรวมคะแนนของคุณเนื่องจากคุณต้องพิมพ์ลงในนั้นด้วย

คำชี้แจงและการแก้ไข:

• ลบช่องว่างต่อท้าย 3 หลังหลังสุด }
• ลบช่องว่างท้ายเดียวออก return
• การส่งคืนสตริงของเอาต์พุตจากฟังก์ชัน / เมธอดก็โอเค

PostgreSQL 158 ตัว

select'public static boolean isPowerOfTen(long input) {
  return
   '||string_agg(' input == 1'||repeat('0',x)||'L','
  ||')||';
}'from generate_series(0,18)x

กดแป้น 97

ipublic static boolean isPowerOfTen(long input) {
  return
  || input == 1L<esc>qyYpfLi0<esc>q16@yo}<esc>3Gxx

เอาล่ะวันนี้ฉันมีจาวาผลิต vim แล้วทำไมไม่ทำต่อไปล่ะ!

05AB1E , 99 97 96 94 93 87 ไบต์

รหัส:

“‚Æ£‹ÒŒ€ˆPowerOfTen(“?“¢„î®) {
 «‡
   “?19FN0›i"  ||"?}’ î® == ’?N°?'L?N18Qi';,"}"?}"",

ลองออนไลน์!

ใช้การเข้ารหัสCP-1252

CJam, 52 ตัวอักษร

YA#_("𐀑򀺸󆚜񸎟񜏓񞍁򛟯󩥰󾐚򉴍􍼯𹾚򶗜򳙯󭧐񹷜񊽅𸏘򴂃򦗩󧥮𤠐𰑈򶂤𘏧󔆧򇃫󡀽򊠑񊩭򯐙񛌲񊚩𤱶𻺢"f&bY7#b:c~

ลองออนไลน์!

ด่าน 1

การใช้อักขระ Unicode U + 10000 ถึง U + 10FFFF เราสามารถเข้ารหัส 20 บิตในอักขระเดียว CJam ใช้อักขระ 16 บิตภายในดังนั้นแต่ละรายการจะถูกเข้ารหัสเป็นคู่ของตัวแทนหนึ่งในช่วงตั้งแต่ U + D800 ถึง U + DBFF ตามด้วยหนึ่งในช่วงตั้งแต่ U + DC00 ถึง U + DFFF

โดยการใช้ค่าบิตและของตัวแทนแต่ละคนด้วย 1,023 เราได้รับข้อมูล 10 บิตที่เข้ารหัส เราสามารถแปลงอาร์เรย์ผลลัพธ์จากฐาน 1024 เป็นฐาน 128 เพื่อถอดรหัสสตริงของอักขระ Unicode นอก BMP เป็นสตริง ASCII

รหัสทำสิ่งต่อไปนี้:

YA#    e# Push 1024 as 2 ** 10.
_(     e# Copy and decrement to push 1023.

"𑅰󻢶񹱨񉽌񍍎񄆋򎿙򧃮񑩹󠷽􂼩􉪦񭲣񶿝򭁩󭰺􄔨񍢤𘎖񮧗򦹀𹀠񐢑񜅈𠟏򘍎󾇗򲁺􅀢򅌛񎠲򦙤򃅒𹣬񧵀򑀢"

f&     e# Apply bitwise AND with 1023 to each surrogate character.
b      e# Convert the string from base 1024 to integer.
Y7#    e# Push 128 as 2 ** 7.
b      e# Convert the integer to base 128.
:c     e# Cast each base-128 to an ASCII character.
~      e# Evaluate the resulting string.

ด่าน 2

กระบวนการถอดรหัสจากด้านบนให้ผลซอร์สโค้ดต่อไปนี้ ( 98 ไบต์ )

"public static boolean isPowerOfTen(long input) {
  return
   ""L
  || input == ":S6>AJ,f#S*"L;
}"

ลองออนไลน์!

รหัสทำสิ่งต่อไปนี้:

e# Push the following string.

"public static boolean isPowerOfTen(long input) {
  return
   "

e# Push the following string and save it in S.

"L
  || input == ":S

e# Discard the first 6 characters of S. The new string begins with " input".

6>

e# Elevate 10 (A) to each exponent below 19 (J).

AJ,f#

e# Join the resulting array, using the string L as separator.

S*

e# Push the following string.

"L;
}"

Java, 217 215 220 219 192 ไบต์

แข็งแรงเล่นกอล์ฟ:

public static String b(){String s="public static boolean isPowerOfTen(long input) {\n  return\n    input == 1L",z="";for(int i=0;i++<18;){z+="0";s+="\n  || input == 1"+z+"L";}return s+";\n}";}

Ungolfed:

  public static String a(){
    String s = "public static boolean isPowerOfTen(long input) {\n  return\n    input == 1L", z="";
    for (int i=0; i++ < 18;) {
        z += "0";
        s += "\n  || input == 1"+z+"L";
    }
    return s + ";\n}";
  }

(คำตอบแรก wuhu)

ขอบคุณ!
-2 ไบต์: user902383
-1 ไบต์: Denham Coote

การเปลี่ยนแปลง:

• แท็บที่ใช้แทนช่องว่าง
• พลาดบรรทัดสุดท้ายของเอาต์พุต: 18 -> 19
• ลบวงด้านใน
• เปลี่ยนจากการพิมพ์เป็นสตริงที่ส่งคืน

PowerShell ขนาด 120 ไบต์

'public static boolean isPowerOfTen(long input) {'
'  return'
"   $((0..18|%{" input == 1"+"0"*$_})-join"L`n  ||")L;`n}"

สองบรรทัดแรกเป็นเพียงตัวอักษรสตริงซึ่งเป็นผลลัพธ์ตาม -

บรรทัดที่สามเริ่มต้นด้วยช่องว่างสามช่องและลงท้ายด้วยL;`n}"เพื่อสิ้นสุดไบต์คู่สุดท้าย บิตกลางภายในบล็อกสคริปต์$(...)ถูกสร้างขึ้นโดย for-looping %จาก0ถึง18และแต่ละการวนซ้ำการสร้างสตริงที่เริ่มต้นด้วยการinput == 1ต่อกับจำนวนศูนย์ที่สอดคล้องกัน สิ่งนี้จะคายอาร์เรย์ของสตริงออกมา จากนั้นเรา-joinแต่ละองค์ประกอบของอาร์เรย์ด้วยL`n ||เพื่อให้บรรลุ newline-pipes สตริงขนาดใหญ่นั้นเป็นผลลัพธ์ของบล็อกสคริปต์ซึ่งจะถูกแทรกโดยอัตโนมัติในกลางและเอาท์พุท

PS C:\Tools\Scripts\golfing> .\go-generate-some-java.ps1
public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

Pyth, 118 106 103 ไบต์

s[."
{Z-L¡JxÙÿ
LæÝ<­í?¢µb'¥ÜA«Ç}h¹äÚÏß"\nb*4dj"\n  || "ms[." uøs|ÀiÝ"*d\0\L)U19\;b\}

ลองออนไลน์!

การเข้ารหัสสตริงทั้งหมดนี้กินจำนวนไบต์ขึ้นจริงๆ แต่ไม่มีอะไรที่ฉันสามารถทำได้แต่ไม่มีอะไรที่ฉันจะทำอย่างไรกับมัน

อัปเดต:บันทึกแล้ว 3 ไบต์โดยใช้สตริงที่รวบรวม ขอบคุณ @ user81655 สำหรับคำใบ้!

C # (CSI) 181 180 179 ไบต์

string i=" input == 1",e="public static bool";Console.Write(e+@"ean isPowerOfTen(long input) {
  return
   "+i+string.Join(@"L
  ||"+i,e.Select((_,x)=>new string('0',x)))+@"L;
}")

มีกลอุบายเพียงเล็กน้อยเท่านั้นที่เกี่ยวข้อง วิธีการเขียนสิ่งนี้ตรงไปตรงมาคือ:

string.Join("L\n  || input == 1",Enumerable.Range(0,18).Select(x=>new string('0',x)))

โดยใช้สตริงที่มี 18 ตัวอักษรแรกของข้อความที่ฉันต้องการต่อไปฉันสามารถกำจัด Enumerable ที่มีความยาวได้ ใช้งานได้เนื่องจากสตริงใช้ IEnumerable และมี Select รุ่นที่ส่งไอเท็ม (ไม่จำเป็น) และดัชนีที่เราต้องการไปยังฟังก์ชัน lambda

Javascript, 172 157 152 150 148 bytes

p=>`public static boolean isPowerOfTen(long input) {
  return${[...Array(19)].map((x,i)=>`
  ${i?'||':' '} input == 1${'0'.repeat(i)}L`).join``};
}`

f=p=>`public static boolean isPowerOfTen(long input) {
  return${[...Array(19)].map((x,i)=>`
  ${i?'||':' '} input == 1${'0'.repeat(i)}L`).join``};
}`

document.body.innerHTML = '<pre>' + f() + '</pre>'

C, 158 155 bytes

i;main(){for(puts("public static boolean isPowerOfTen(long input) {\n  return");i<19;)printf("  %s input == 1%0.*dL%s\n",i++?"||":" ",i,0,i<18?"":";\n}");}

Try it online here.

Jelly, 75 bytes

(These are bytes in Jelly's custom codepage.)

0r18⁵*;@€⁶j“¢œḤḅg^NrÞḢ⁷ẉ»“⁵®UẆƓḃÐL⁴ṖịṛFþẈ¹9}¶ ƁḋȮ¦sẒẆd€Ḟɼ¿ỌṀP^µ\f@»;;“L;¶}”

Try it here.

Explanation

0r18      Range [0..18]
⁵*        Take the 10^ of each number
;@€⁶      Prepend a space to each number
j“...»    Join by compressed string "L\n  || input =="
“...»;    Prepend compressed string "public static ... =="
;“L;¶}”   Append "L;\n}"

Vimscript, 120 bytes

Might as well use the right tool for the job.

This assumes that autoindent, etc have not been set. ^[ and ^M are escape characters for the ESC and CR characters respectively.

The a macro duplicates the current line and adds a 0 to the copy. The :norm line generates all the boilerplate and the indent == 1L line, then uses a to create the others.

:let @a='yyp$i0^['
:norm ipublic static boolean isPowerOfTen(long input) {^M  return^M  || input == 1L^[18@a$a;^M}
:3s/||/ /

In case the trailing spaces the sample output had on two lines weren't typos, here's a 126 byte version that includes them.

:let @a='yyp/L^Mi0^['
:norm ipublic static boolean isPowerOfTen(long input) {^M  return ^M  || input == 1L^[18@a$a;^M}   
:3s/||/ /

Oracle SQL 9.2, 311 bytes

SELECT REPLACE(REPLACE('public static boolean isPowerOfTen(long input) {'||CHR(10)||'  return'||c||';'||'}', 'n  ||', 'n'||CHR(10)||'   '),CHR(10)||';', ';'||CHR(10)) FROM(SELECT LEVEL l,SYS_CONNECT_BY_PATH('input == '||TO_CHAR(POWER(10,LEVEL-1))||'L'||CHR(10),'  || ')c FROM DUAL CONNECT BY LEVEL<20)WHERE l=19

Perl 5 - 130 141

@s=map{'input == 1'.0 x$_."L\n  ||"}0..18;$s[$#s]=~s/\n  \|\|/;\n}/g;print"public static boolean isPowerOfTen(long input){\n  return\n    @s"

EDIT: fixed to have exact indentation

ES6, 139 bytes

_=>"0".repeat(19).replace(/./g,`
 || input == 1$\`L`).replace(`
 ||`,`public static boolean isPowerOfTen(long input) {
  return\n  `)+`;
}`

I do so love these triangle generation questions.

Kotlin, 194 193 characters

fun main(u:Array<String>){var o="public static boolean isPowerOfTen(long input) {\n\treturn"
var p:Long=1
for(k in 0..18){
o+="\n\t"
if(k>0)o+="||"
o+=" input == ${p}L"
p*=10
}
print("$o;\n}")}

Test it at http://try.kotlinlang.org/

Ruby, 125 119 bytes

$><<'public static boolean isPowerOfTen(long input) {
  return
   '+(0..19).map{|i|" input == #{10**i}L"}*'
  ||'+';
}'

Thanks to manatwork for -6 bytes!

jq, 123 characters

(121 characters code + 2 characters command line option.)

"public static boolean isPowerOfTen(long input) {
  return
   \([range(19)|" input == 1\("0"*.//"")L"]|join("
  ||"));
}"

Sample run:

bash-4.3$ jq -nr '"public static boolean isPowerOfTen(long input) {
>   return
>    \([range(19)|" input == 1\("0"*.//"")L"]|join("
>   ||"));
> }"'
public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

Javascript 175 bytes

Let's do this regularly

var s = "public static boolean isPowerOfTen(long input) {\n\treturn\n\t\tinput == 1";
for (var i = 1; i < 20; i++) {
    s += "\n\t|| input == 1";
    for (var j = 0; j < i; j++) {
        s += "0";
    }
    s += "L" ;
}
s += ";\n}";
alert(s);

Pretty small. Now, some javascript magic, like no semicolons needed, or no var's, etc.:

k="input == 1"
s="public static boolean isPowerOfTen(long input) {\n\treturn\n\t\t"+k+"L"
for(i=1;i<20;i++){s+="\n\t|| "+k
for(j=0;j<i;j++)s+="0";s+="L"}s+=";\n}"
alert(s)

Python (3.5) 137 136 bytes

print("public static boolean isPowerOfTen(long input) {\n  return\n   ",'\n  || '.join("input == %rL"%10**i for i in range(19))+";\n}")

Previous version

print("public static boolean isPowerOfTen(long input) {\n  return\n   ",'\n  || '.join("input == 1"+"0"*i+"L"for i in range(19))+";\n}")

ANSI-SQL, 252 characters

WITH t as(SELECT '   'x,1 c,1 l UNION SELECT'  ||',c*10,l+1 FROM t WHERE l<19)SELECT 'public static boolean isPowerOfTen(long input) {'UNION ALL SELECT'  return 'UNION ALL SELECT x||' input == '||c||'L'||SUBSTR(';',1,l/19)FROM t UNION ALL SELECT'}   ';

Ungolfed:

WITH t as (SELECT '   ' x,1 c,1 l UNION
           SELECT '  ||',c*10,l+1 FROM t WHERE l<19)
SELECT 'public static boolean isPowerOfTen(long input) {' UNION ALL
SELECT '  return ' UNION ALL
SELECT x||' input == '||c||'L'||SUBSTR(';',1,l/19) FROM t UNION ALL
SELECT '}   ';

Not a serious attempt, just poking at the Oracle SQL/T-SQL entries.

JavaScript (Node.js), 156 bytes

s="public static boolean isPowerOfTen(long input) {\n  return "
for(i=1;i<1e19;i*=10)s+="\n  "+(i-1?"||":" ")+" input == "+i+"L"
console.log(s+";\n}   \n")

The i-1 will only be 0 (and thus falsey) on the very first round (it's just slightly shorter than i!=1.

Suggestions welcome!

Perl 5, 137 bytes

Not based on the previous Perl answer, but it is somehow shorter. I believe it can be shortened down again by taking care of the first "input" inside the loop, but I didn't try anything yet (at work atm)

$i="input";for(1..18){$b.="  || $i == 1"."0"x$_."L;\n"}print"public static boolean isPowerOfTen(long $i) {\n  return\n    $i == 1L;\n$b}"

CJam, 112 chars

"public static boolean isPowerOfTen(long input) {
  return
    input == 1"19,"0"a19*.*"L
  || input == 1"*"L;
}"

AWK+shell, 157 bytes

echo 18|awk '{s="input == 1";printf"public static boolean isPowerOfTen(long input) {\n return\n    "s"L";for(;I<$1;I++)printf"\n  ||%sL",s=s"0";print";\n}"}'

The question did say to count everything you would have to type. This does have the added bonus of being able to select how many lines would be placed in the isPowersOfTen method when the boss inevitably changes his mind.

T-SQL 289, 277, 250, 249 bytes

SELECT'public static boolean isPowerOfTen(long input){return '+STUFF((SELECT'||input=='+N+'L 'FROM(SELECT TOP 19 FORMAT(POWER(10.0,ROW_NUMBER()OVER(ORDER BY id)),'F0')N FROM syscolumns)A FOR XML PATH(''),TYPE).value('.','VARCHAR(MAX)'),1,2,'')+';}'

Update: Thanks @Bridge, I found a few more spaces too :)

Update2: Changed CTE to subquery -27 chars :) Update3: Another space bites the dust @bridge :)

R, 185 bytes

Golfed

options(scipen=999);p=paste;cat(p("public static boolean isPowerOfTen(long input) {"," return",p(sapply(0:19,function(x)p(" input == ",10^x,"L",sep="")),collapse="\n ||"),"}",sep="\n"))

Ungolfed

options(scipen=999)
p=paste
cat(
  p("public static boolean isPowerOfTen(long input) {",
        " return",
        p(sapply(0:19,function(x)p(" input == ",10^x,"L",sep="")),collapse="\n ||"),
        "}",
        sep="\n")
)

Perl 6 (115 bytes)

say "public static boolean isPowerOfTen(long input) \{
  return
   {join "L
  ||",(" input == "X~(10 X**^19))}L;
}"

X operator does list cartesian product operation, for example 10 X** ^19 gives powers of ten (from 10 to the power of 0 to 19, as ^ is a range operator that counts from 0). Strings can have code blocks with { (which is why I escape the first instance of it).

Java, 210 / 166

Score is depending on whether returning the input from a function meets the definition of 'output'.

Console output (210):

class A{public static void main(String[]z){String a=" input == 1",t="L\n  ||"+a,s="public static boolean isPowerOfTen(long input) {\n  return\n   "+a;for(int i=0;++i<19;)s+=t+="0";System.out.print(s+"L;\n}");}}

String return (166):

String a(){String a=" input == 1",t="L\n  ||"+a,s="public static boolean isPowerOfTen(long input) {\n  return\n   "+a;for(int i=0;++i<19;)s+=t+="0";return s+"L;\n}";}

Legible version:

String a() {
    String a=" input == 1", t = "L\n  ||"+a,
        s = "public static boolean isPowerOfTen(long input) {\n  return\n   "+a;
    for (int i = 0; ++i < 19;)
        s += t += "0";
    return s + "L;\n}";
}

Batch, 230 208 206 205 bytes

@echo off
echo public static boolean isPowerOfTen(long input) {
echo   return
set m=input == 1
echo    %m%L
for /l %%a in (1,1,17)do call:a
call:a ;
echo }
exit/b
:a
set m=%m%0
echo  ^|^| %m%L%1

Edit: Saved 22 bytes by avoiding repeating input == and reusing the subroutine for the line with the extra semicolon. Saved 2 3 bytes by removing unnecessary spaces.