Allez générer du Java

14

Votre patron veut que vous écriviez du code comme ceci:

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 )

qui est efficace et donc, mais pas si amusant à taper. Étant donné que vous souhaitez minimiser le nombre de pressions de touches que vous devez effectuer, vous écrivez un programme ou une fonction (ou méthode) plus courte qui génère cette fonction pour vous (ou renvoie une chaîne à afficher). Et puisque vous avez votre propre clavier unicode pleine gamme personnalisé avec toutes les 120 737 touches requises pour l'ensemble de l'unicode 8.0, nous comptons les caractères unicode, au lieu des touches. Ou octets, si votre langue n'utilise pas de code source unicode.

Toute entrée de votre programme ou fonction compte pour votre score, car vous devez évidemment le saisir également.

Clarifications et modifications:

  • Suppression de 3 espaces de fin après le dernier }
  • Suppression d'un seul espace de fin après return
  • Le retour d'une chaîne de sortie d'une fonction / méthode est correct
Filip Haglund
la source
12
0==Math.log10(input)%1
SuperJedi224
7
Vous dites « nous comptons les caractères Unicode », mais vous dites immédiatement « Ou octets ». Laquelle est-ce?
Poignée de porte
2
Celui que vous préférez, c'est-à-dire celui qui vous donne le score le plus bas. Octets ajoutés pour autoriser les langues qui n'utilisent pas de source de texte.
Filip Haglund
1
while(input%10==0) input/=10; return input == 1;
PSkocik
4
05AB1E utilise Windows CP1252, qui est des octets, pas unicode. Je vise des règles standard, mais on me dit que je me trompe tout le temps.
Filip Haglund

Réponses:

15

PostgreSQL, 158 caractères

select'public static boolean isPowerOfTen(long input) {
  return
   '||string_agg(' input == 1'||repeat('0',x)||'L','
  ||')||';
}'from generate_series(0,18)x
homme au travail
la source
Je n'ai jamais vu un SGBDR utilisé comme réponse de golf de code ... doux! +1
Chris Cirefice
@ChrisCirefice SQL est en fait quelque peu courant sur ce site. (Ou au moins plus commun que ce à quoi on pourrait s'attendre.)
Alex A.
@AlexA. Hm, eh bien PCG est l'un de mes sites SE les moins fréquentés, donc je n'ai jamais vu de réponse SQL :)
Chris Cirefice
7

Vim 97 touches

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

Eh bien, je suis sur une lancée aujourd'hui avec vim produisant du java, alors pourquoi ne pas poursuivre la tendance!

James
la source
le remplacement fLpar $pourrait vous faire économiser une touche
Leaky Nun
De plus, la troisième ligne input == 1Lest décalée d'un octet ...
Leaky Nun
Donc, le dernier xdevrait être changé en r<sp>puis le nombre de frappes serait inchangé
Leaky Nun
7

05AB1E , 99 97 96 94 93 87 octets

Code:

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

Essayez-le en ligne!

Utilise l' encodage CP-1252 .

Adnan
la source
7

CJam, 52 caractères

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

Essayez-le en ligne!

Étape 1

En utilisant les caractères Unicode U + 10000 à U + 10FFFF, nous pouvons coder 20 bits en un seul caractère. CJam utilise des caractères 16 bits en interne, donc chacun sera codé comme une paire de substituts , un dans la plage de U + D800 à U + DBFF, suivi par un dans la plage de U + DC00 à U + DFFF.

En prenant le ET au niveau du bit de chaque substitut avec 1023, nous obtenons les 10 bits d'information qu'il code. Nous pouvons convertir le tableau résultant de la base 1024 en base 128 pour décoder une chaîne arbitraire de caractères Unicode en dehors du BMP en une chaîne ASCII.

Le code effectue les opérations suivantes:

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.

Étape 2

Le processus de décodage ci-dessus donne le code source suivant ( 98 octets ).

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

Essayez-le en ligne!

Le code effectue les opérations suivantes:

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;
}"
Dennis
la source
Vous pourriez vous attendre à ce qu'un site SE comme le judaïsme teste le support unicode du site, mais c'est fou: D
Filip Haglund
Je peux voir exactement deux des caractères entre les guillemets. Pouvez-vous publier un hexdump?
Pavel
Vous pouvez réellement en voir deux? Je n'ai pas de chance ... Encodant les personnages en UTF-8, le hexdump ressemblerait à ceci. tio.run/nexus/bash#AagAV///eHhkIC1nIDH//…
Dennis
6

Java, 217 215 220 219 192 octets

Golfé:

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

Non golfé:

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

(première réponse, wuhu)

Merci!
-2 octets: user902383
-1 octet: Denham Coote

Changements:

  • tabulations utilisées au lieu d'espaces
  • a raté la dernière ligne de sortie: 18 -> 19
  • boucle intérieure supprimée
  • changé de l'impression à la chaîne de retour
Filip Haglund
la source
4
votre boucle for intérieure n'a pas besoin de supports
user902383
Utilisez la syntaxe Java 8, également raccourcie d'autres éléments: ()->{String s="public static boolean isPowerOfTen(long input) {\n\treturn input == 1L";for(int i=0,k;i++<18;){s+="\n\t|| input == 1";for(k=0;k++<i;)s+="0";s+="L";}return s+";\n}";}(180 octets) renvoie maintenant la chaîne au lieu de l'impression, mais c'est plus court.
Addison Crump
1
+1 pour l'écriture d'un programme Java détaillé pour générer un programme Java encore plus détaillé.
Cyoce
au lieu de for(int i=1;i<19;i++)vous pouvez écrire for(int i=1;i++<19;)ce qui sauve un octet
Denham Coote
Aussi, déclarez int i=1,k;et ensuite vous pouvez écrire for(;i++<19;)etfor(k=0;k++<i;)
Denham Coote
4

Pyth, 118 106 103 octets

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

Essayez-le en ligne!

Tout ce codage en chaîne prend vraiment beaucoup d'octets , mais je ne peux rien y faire .

Mise à jour: enregistré 3 octets en utilisant une chaîne compressée. Merci @ user81655 pour l'astuce!

Denker
la source
Vous pouvez utiliser des chaînes compressées ...
user81655
Je ne connais pas Pyth et je ne suis pas sûr s'il existe un moyen de compresser la chaîne complète (le programme de conditionnement la modifierait toujours), mais de compresser ret de concaténer les nrésultats dans ce (98 octets).
user81655
@ user81655 Merci, je ne savais pas que Pyth avait ça. :) Cela n'a de sens que d'emballer la première grosse chaîne, la surcharge que vous produisez lors du déballage ne vaut pas la peine pour une chaîne plus petite.
Denker
@ user81655 J'en suis conscient, mais je compte 103 caractères. Comment êtes-vous arrivé à 97?
Denker
Oups, mon erreur, je les ai mal comptés.
user81655
4

C # (CSI) 181 180 179 octets

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

Il n'y a qu'une petite astuce impliquée. La façon simple d'écrire ceci serait:

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

en utilisant la chaîne avec les 18 premiers caractères du texte dont j'ai besoin de toute façon, je peux me débarrasser du long Enumerable.Range. Cela fonctionne car la chaîne implémente IEnumerable et il existe une version de Select qui remet l'élément (non nécessaire) et l'index que nous voulons à la fonction lambda.

raggy
la source
1
@WashingtonGuedes Thanks
raggy
1
ajouter quelques explications s'il vous plaît
Eumel
1
Le CSI soutient-il les organismes d'expression? Si c'est le cas, le { return ... }peut être remplacé par =>....
mınxomaτ
Pas actuellement sur ordinateur, je ne peux donc pas tester cela. La dernière chaîne textuelle s'échappe-t-elle du crochet à l'intérieur? Ou est-ce une super astuce que je ne connaissais pas? :)
Yytsi
4

PowerShell, 120 octets

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

Les deux premières lignes sont simplement des littéraux de chaîne, qui sont sortis tels quels.

La troisième ligne commence par trois espaces et se termine par L;`n}"pour terminer les deux derniers octets. Le bit du milieu à l'intérieur du bloc de script $(...)est construit en forçant en boucle %de 0à 18et à chaque itération en construisant une chaîne qui commence par input == 1concaténée avec le nombre correspondant de zéros. Cela crachera un tableau de chaînes. Nous avons ensuite -joinchaque élément du tableau avec L`n ||pour réaliser les newline-pipes. Cette grosse chaîne est la sortie du bloc de script, qui est insérée automatiquement au milieu et sortie.

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;
}
AdmBorkBork
la source
3

Javascript, 172 157 152 150 148 octets

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

supprimé
la source
2
Dans ES7, vous pouvez enregistrer 9 octets en utilisant ${10**i}au lieu de 1${'0'.repeat(i)}.
Neil
3

C, 158 155 octets

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

Essayez-le en ligne ici .

Cole Cameron
la source
Vous pouvez raser un octet si vous utilisez la valeur de retour de printf:i;main(){for(puts("public static boolean isPowerOfTen(long input) {\n return");printf(" %s input == 1%0.*dL%s\n",i++?"||":" ",i,0,i<18?"":";\n}")-37);}
algmyr
3

Gelée, 75 octets

(Ce sont des octets dans la page de code personnalisée de Jelly .)

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

Essayez-le ici.

Explication

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}"
Lynn
la source
3

Vimscript, 120 octets

Autant utiliser le bon outil pour le travail.

Cela suppose que l'indentation automatique, etc. n'a pas été définie. ^[et ^Msont des caractères d'échappement pour les caractères ESCet CRrespectivement.

La amacro duplique la ligne actuelle et ajoute un 0 à la copie. La :normligne génère tout le passe-partout et la indent == 1Lligne, puis utilise apour créer les autres.

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

Dans le cas où les espaces de fin que l'échantillon de sortie avait sur deux lignes n'étaient pas des fautes de frappe, voici une version de 126 octets qui les inclut.

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

Oracle SQL 9.2, 311 octets

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
Jeto
la source
2

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

ChatterOne
la source
No need to use parenthesis around the range. In change would be nice to reproduce the exact indentation.
manatwork
Thanks for the parenthesis that I forgot. I've fixed it to have the exact indentation.
ChatterOne
There is no need for the g flag for the substitution. Also as you have a single \n in that string, you can simply match it and everything after it: $s[$#s]=~s/\n.+/;\n}/. But a join based one would still be shorter: pastebin.com/hQ61Adt8
manatwork
Thank you, but I don't think it would be nice if I just copied and pasted your solution, so I'll just leave it as it is as my own best effort. In time, I'll get better at golfing :-)
ChatterOne
2

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.

Neil
la source
2

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/

Sean
la source
Welcome to Programming Puzzles & Code Golf. Nice first answer, but please add a link to an online interpreter or add an example on how to run this program, so others can verify it. However, have a great time here! :)
Denker
2

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!

Doorknob
la source
Not much original as most of the solutions are doing this way, but still shorter: pastebin.com/1ZGF0QTs
manatwork
2

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

manatwork
la source
1

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)
Bálint
la source
Can you explain how that magic works? :)
Marv
3
Javascript doesn't care about semicolons, at least until the keywords (for, while, var, etc.) aren't "touching" anything else. Also, if you don't use the var keyword, you get global variables, wich is the worst feature I have ever seen in a programming language thus far.
Bálint
@Bálint. Why this would be the worst feature?
removed
@WashingtonGuedes You know, most languages remind you if you misstyped something inside a function. Because javascript takes that as if you made a whole new variable, it does not going to say anything about that.
Bálint
Also, same one applies to = returning a true.
Bálint
1

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}")
Erwan
la source
135 with Python 2.7: print "public static boolean isPowerOfTen(long input) {\n return\n %s;\n}"%"\n || ".join("input == %r"%10L**i for i in range(19))
moooeeeep
@moooeeeep you're right, the use of %r win 1 bytes and the python 2 print (without parenthesis ) win another one
Erwan
0

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.

user1361991
la source
For 40 additional chars I can add "from dual " and make it an "Oracle SQL" entry.
user1361991
0

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!

Nateowami
la source
0

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}"
Paul Picard
la source
0

CJam, 112 chars

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

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.

Robert Benson
la source
Passing a here-string is shorter than piping from echo: awk '…'<<<18
manatwork
I knew about here-file but not here-string. Thanks for the info.
Robert Benson
0

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

Liesel
la source
1
I was able to trim off 7 more spaces (282 bytes) without changing the rest of the code: WITH A AS(SELECT CAST('1'AS VARCHAR(20))N UNION ALL SELECT CAST(CONCAT(N,'0')AS VARCHAR(20))FROM A WHERE LEN(N)<20)SELECT'public static boolean isPowerOfTen(long input){return '+STUFF((SELECT'|| input=='+N+'L 'FROM A FOR XML PATH(''),TYPE).value('.', 'VARCHAR(MAX)'), 1, 3, '')+';}'
Bridge
1
Now I look back I can see all the extra spaces in my original comment! I've found one more space you can get rid of - the one immediately after ROW_NUMBER()
Bridge
0

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")
)
Argenis García
la source
0

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

Konrad Borowski
la source
0

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}";
}
Kevin K
la source
0

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.

Neil
la source
Do you need spaces around ==?
Pavel
@Pavel That's not code; it's part of the output.
Dennis