Sếp của bạn muốn bạn viết mã như thế này:

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, tại /codereview//a/117294/61929 )

đó là hiệu quả và như vậy, nhưng không phải là thú vị để gõ. Vì bạn muốn giảm thiểu số lần nhấn phím bạn phải thực hiện, bạn viết một chương trình hoặc hàm (hoặc phương thức) ngắn hơn để xuất hàm này cho bạn (hoặc trả về một chuỗi cho đầu ra). Và vì bạn có bàn phím unicode toàn dải tùy chỉnh rất riêng của mình với tất cả 120.737 phím cần thiết cho tất cả các unicode 8.0, chúng tôi đếm các ký tự unicode, thay vì nhấn phím. Hoặc byte, nếu ngôn ngữ của bạn không sử dụng mã nguồn unicode.

Bất kỳ đầu vào chương trình hoặc chức năng của bạn đều được tính vào điểm số của bạn, vì rõ ràng bạn cũng phải nhập nó vào.

Làm rõ và chỉnh sửa:

• Đã xóa 3 dấu cách sau lần cuối }
• Đã xóa một dấu cách đơn sau return
• Trả về một chuỗi đầu ra từ một hàm / phương thức là ok

PostgreSQL, 158 ký tự

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

Tổ hợp phím Vim 97

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

Chà, hôm nay tôi đang bắt đầu với vim sản xuất java, vậy tại sao không tiếp tục xu hướng!

05AB1E , 99 97 96 94 93 87 byte

Mã số:

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

Hãy thử trực tuyến!

Sử dụng mã hóa CP-1252 .

CJam, 52 ký tự

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

Hãy thử trực tuyến!

Giai đoạn 1

Sử dụng các ký tự Unicode U + 10000 đến U + 10FFFF, chúng ta có thể mã hóa 20 bit trong một ký tự. CJam sử dụng các ký tự 16 bit bên trong, do đó, mỗi ký tự sẽ được mã hóa thành một cặp thay thế , một trong phạm vi từ U + D800 đến U + DBFF, tiếp theo là một trong phạm vi từ U + DC00 đến U + DFFF.

Bằng cách lấy bit AND của mỗi thay thế bằng 1023, chúng ta thu được 10 bit thông tin mà nó mã hóa. Chúng ta có thể chuyển đổi mảng kết quả từ cơ sở 1024 sang cơ sở 128 để giải mã một chuỗi ký tự Unicode tùy ý bên ngoài BMP thành chuỗi ASCII.

Mã này làm như sau:

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.

Giai đoạn 2

Quá trình giải mã từ trên mang lại mã nguồn sau ( 98 byte ).

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

Hãy thử trực tuyến!

Mã này làm như sau:

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 byte

Chơi gôn

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}";}

Ung dung:

  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}";
  }

(câu trả lời đầu tiên, wuhu)

Cảm ơn!
-2 byte: user902383
-1 byte: Denham Coote

Thay đổi:

• sử dụng các tab thay vì dấu cách
• bỏ lỡ dòng đầu ra cuối cùng: 18 -> 19
• loại bỏ vòng lặp bên trong
• thay đổi từ in sang chuỗi trả về

Pyth, 118 106 103 byte

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

Hãy thử trực tuyến!

Tất cả mã hóa chuỗi này thực sự ăn rất nhiều byte , nhưng tôi không thể làm gì về nó .

Cập nhật: Đã lưu 3 byte bằng cách sử dụng chuỗi đóng gói. Cảm ơn @ user81655 cho gợi ý!

C # (CSI) 181 180 179 byte

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;
}")

Chỉ có một mẹo nhỏ liên quan. Cách thẳng về phía trước để viết này sẽ là:

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

bằng cách sử dụng chuỗi có 18 ký tự đầu tiên của văn bản mà tôi cần bằng mọi cách tôi có thể thoát khỏi Enumerable.Range dài. Điều này hoạt động vì chuỗi thực hiện IEnumerable và có một phiên bản Chọn để trao vật phẩm (không cần thiết) và chỉ mục mà chúng ta muốn cho hàm lambda.

PowerShell, 120 byte

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

Hai dòng đầu tiên chỉ đơn giản là chuỗi ký tự, là đầu ra nguyên trạng.

Dòng thứ ba bắt đầu bằng ba khoảng trắng và kết thúc bằng L;`n}"để kết thúc vài byte cuối cùng. Bit giữa bên trong khối tập lệnh $(...)được xây dựng bằng cách lặp %từ và 0đến 18mỗi lần lặp xây dựng một chuỗi bắt đầu bằng input == 1nối với số 0 tương ứng. Điều này sẽ nhổ ra một chuỗi các chuỗi. Chúng tôi sau đó -jointừng phần tử của mảng với L`n ||để đạt được các đường ống mới. Chuỗi lớn đó là đầu ra của khối tập lệnh, được chèn tự động vào giữa và đầu ra.

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;
}

Javascript, 172 157 152 150 148 byte

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 byte

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}");}

Hãy thử trực tuyến tại đây .

Thạch, 75 byte

(Đây là các byte trong bảng mã tùy chỉnh của Jelly .)

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

Hãy thử nó ở đây.

Giải trình

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 byte

Cũng có thể sử dụng các công cụ phù hợp cho công việc.

Điều này giả định rằng autoindent, vv chưa được thiết lập. ^[và ^Mlà nhân vật thoát cho ESCvàCR ký tự tương ứng.

Các avĩ mô bản sao dòng hiện tại và bổ sung thêm một 0 để sao chép. Các :normdòng tạo ra tất cả các soạn sẵn và các indent == 1Ldòng, sau đó sử dụng ađể tạo ra những người khác.

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

Trong trường hợp khoảng trắng theo sau, đầu ra mẫu có hai lỗi chính tả, đây là phiên bản 126 byte bao gồm chúng.

: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 byte

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: cố định để thụt chính xác

ES6, 139 byte

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

Tôi rất thích những câu hỏi thế hệ tam giác.

Kotlin, 194 193 ký tự

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}")}

Kiểm tra nó tại http://try.kotlinlang.org/

Ruby, 125 119 byte

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

Nhờ manatwork cho -6 byte!

jq, 123 ký tự

(Mã 121 ký tự + tùy chọn dòng lệnh 2 ký tự.)

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

Chạy mẫu:

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;
}

Kiểm tra trực tuyến (Chuyển -rqua URL không được hỗ trợ - hãy tự kiểm tra Đầu ra thô.)

Javascript 175 byte

Hãy làm điều này thường xuyên

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);

Khá nhỏ. Bây giờ, một số phép thuật javascript, như không cần dấu chấm phẩy, hoặc không có var, v.v.:

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 byte

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

Phiên bản trước

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 ký tự

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'}   ';

Ung dung:

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 '}   ';

Không phải là một nỗ lực nghiêm túc, chỉ chọc vào các mục Oracle SQL / T-SQL.

JavaScript (Node.js), 156 byte

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")

Ý i-1chí chỉ là 0 (và do đó là falsey) ngay từ vòng đầu tiên (nó chỉ ngắn hơn một chút so vớii!=1 .

Đề nghị chào mừng!

Perl 5, 137 byte

Không dựa trên câu trả lời Perl trước đó, nhưng nó bằng cách nào đó ngắn hơn. Tôi tin rằng nó có thể được rút ngắn lại một lần nữa bằng cách quan tâm đến "đầu vào" đầu tiên bên trong vòng lặp, nhưng tôi chưa thử bất cứ điều gì (tại atm 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 ký tự

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

Vỏ AWK +, 157 byte

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}"}'

Câu hỏi đã nói để đếm tất cả mọi thứ bạn sẽ phải gõ. Điều này có thêm phần thưởng khi có thể chọn số lượng dòng sẽ được đặt trong phương thức isPowersOfTen khi ông chủ chắc chắn thay đổi ý định.

T-SQL 289 , 277 , 250 , 249 byte

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,'')+';}'

Cập nhật: Cảm ơn @Bridge, tôi cũng tìm thấy một vài khoảng trống nữa :)

Update2: Đã thay đổi CTE thành truy vấn con -27 chars :) Update3: Một không gian khác cắn bụi @bridge :)

R, 185 byte

Chơi gôn

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"))

Ung dung

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 byte)

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

Xtoán tử liệt kê hoạt động của sản phẩm cartesian, ví dụ, 10 X** ^19cho phép lũy thừa mười (từ 10 đến lũy thừa từ 0 đến 19, như ^là một toán tử phạm vi được tính từ 0). Các chuỗi có thể có các khối mã với {(đó là lý do tại sao tôi thoát khỏi phiên bản đầu tiên của nó).

Java, 210/1661

Điểm số phụ thuộc vào việc trả về đầu vào từ một hàm có đáp ứng định nghĩa của 'đầu ra' hay không.

Bảng điều khiển đầu ra (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}");}}

Trả về chuỗi (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}";}

Phiên bản dễ đọc:

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}";
}

Hàng loạt, 230 208 206 205 byte

@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

Chỉnh sửa: Đã lưu 22 byte bằng cách tránh lặp lại input ==và sử dụng lại chương trình con cho dòng có thêm dấu chấm phẩy. Đã lưu 2 3 byte bằng cách loại bỏ các khoảng trống không cần thiết.