Il y a quelque temps, la question suivante a été posée: GolfScript, CJam ou Pyth? Basé sur le titre seulement, je pensais que ce serait un très beau défi, mais malheureusement, il s’est avéré que c’était une question demandant des conseils. Voici le défi que je voulais lire:

Qui a dit que les langues de golf n'étaient pas utilisées dans le monde réel? Comme tout le monde le sait, le rapport de bogues par ligne de code est le même quel que soit le langage de programmation utilisé. Il est donc tout à fait possible de réduire les coûts de débogage et de maintenance avec ces langages. Votre entreprise a finalement vu le jour et a décidé d'utiliser Golfscript, CJam et Pyth pour développer ses produits.

Malheureusement, après quelques mois, vos disques durs sont encombrés d'extraits de code et vous ne savez même pas lesquels sont écrits dans quelles langues (vous soupçonnez même certains de vos programmeurs d'utiliser Perl).

Vous devez écrire un outil pour détecter lequel de CJam, Golfscript ou Pyth est le langage dans lequel un programme est écrit. La situation est critique, vous pouvez utiliser n’importe quelle langue, mais soyez bref (le stockage de données coûte cher: plus nous utilisons d’octets, plus les coûts sont élevés).

Général

• Le code le plus court
• Lacunes standard, etc.
• N'utilisez pas d'interprète en ligne
• Vous pouvez écrire une fonction ou un programme
• Vous pouvez utiliser eval pour détecter votre propre langue

Contribution

• Votre entrée provient du flux d’entrée standard ou sous forme de chaîne
• L'entrée ne contient que des caractères imprimables ASCII et des sauts de ligne
• La taille de l'entrée est jusqu'à 256 octets

Sortie

• La sortie est imprimée dans le flux de sortie ou renvoyée sous forme d'une séquence de chaînes / symboles

• Si l'entrée est sans aucun doute un programme X valide , imprimez ou renvoyez X , X ∈ {CJam, Pyth, Golfscript}

  Remarque : "sans aucun doute" ne signifie pas que vous êtes autorisé à répondre avec un analyseur muet qui ne détecte systématiquement aucune langue. Pour Pyth , je m'attends à ce que les programmes simples soient reconnus (mais pas de codage en dur). La même chose vaut pour CJAM ( antisèche , exemples ) et Golfscript ( exemples ). Les liens précédents pointent vers les spécifications de chaque langue. Si vous utilisez une approche floue / bayésienne, "sans aucun doute" signifie avec un niveau de confiance élevé (vous marquez 99% avec votre classification, par exemple). Voir ci-dessous pour la suite de tests réelle.

• Si la saisie est valide dans plusieurs langues, chaque langue détectée doit être imprimée / renvoyée. Une fois imprimé, il doit exister un séparateur entre plusieurs sorties (par exemple, espace, nouvelle ligne, virgule, etc.).

• L'ordre dans lequel les langues sont essayées n'a pas d'importance
• Je me fiche de l'affaire (CJam, cjam, CJAM, SPAM) ^[1]
• Si aucune des langues ci-dessus n'est détectée, imprimez " Probably Perl" . Grâce à ce commentaire de mbomb007 , dans le cas ci-dessus, vous pouvez également générer " Seriously" une pénalité de 4 octets (la différence entre les deux chaînes).

_{[1] Pour être clair, le spam est invalide}

Exemples

• Contribution

  "Crime predicted: --
  Calling: 1--555-
  
  "30*{_5<{iAa*:mr}&}/
  

• Sortie (exemple de valeurs de retour multiples)

  ["Golfscript", "Cjam"]
  

• Contribution

  3
  

• Sortie (exemple sur la sortie standard)

  golfscript
  cjam
  pyth
  

• Contribution

  if {} aazd
  

• Sortie

  Probably Perl
  

Dans le dernier cas, le programme en entrée génère une erreur avec les trois interprètes en ligne.

Scoring, critère gagnant

Le code le plus court gagne. Ajoutez 4 octets si vous produisez "Sérieusement". Ensuite, appliquez des bonus.

Échec des tests

Les extraits suivants ne doivent pas être reconnus comme l’une des trois langues ci-dessus.

$^X=~/([a-z]+)[^\/]+$/;print$1,$/
<>;map($s-=(-1)**$_/(2*$_-1),1..$_),$s=!print$s,$/for<>
((THIS IS LISP HAIKU) (TRULY THIS IS LISP HAIKU) (THIS IS LISP HAIKU))
(format t"~@(~{~R~^, ~}~).~%~:*~@(~{~:R~^, ~}~)."(loop for i to 99 collect(1+ i)))
print sum(ord(c) for c in 'Happy new year to you!')

>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
++++++++++++++++++++++++++++++++++++++++++++++++.
-----------------.
++++++++.
+++++.
--------.
+++++++++++++++.
------------------.
++++++++.

@list=( "aaaa", 
        "aaaaaaaa", 
        "aaaaaaaaaaaaaaa", 
        "aaaaaaaaaaaaaaaa", 
        "aaaaaaaaaaaaaaaaaaaaaaa", 
        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

while (@list) {
    for($i=0;$i<6;$i++){
        print length($list[$i])." ";
    }
    print "\n";
}

#ifndef __linux
#include "x.h"
#define X/*\
a=1 set -e
+++++++++++++++++++++_+++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int m(){}

Suite de test de base

Ce sont des tests qui doivent passer. Belows sont une seule ligne pour chaque langue où votre programme doit détecter la langue , il est écrit (je n'ai pas vérifié quels sont les polyglottes).

Pyth

*2Q
FNrZTN
FNrZhTN
FNUhTN
VhTN
FNr1hQN
=N5N
K5K
K1FNr1hQ=K*KN
K1FNr1hQ=K*KNK
K1FNr1hQ=K*KN;K
DhZK*3ZRK
L?b*bytb1yQ
A(Z1)VQHA(H+HG

Golfscript

;'2706 410'~{.@\%.}do;
;''6666,-2%{2+.2/@*\/10.3??2*+}*`50<~\;
'Hello, world!'
1 2 [\]

CJam

"Hello, world"
{`"_~"}_~
"`_~"`_~
T1{_2$+}A*]`
{__'`>\'x>26*2-*-}/
Y38#
N/s:X,8-,{X>9<__{'a<},,\4%{'Z>},,*I={4=}{;}?}/

Bonus d'argent: nombre d'octets * 0.6

Tous les tests précédents doivent réussir, ainsi que les tests suivants. Tous ces extraits sont tirés des réponses réelles de CodeGolf.

Pyth

VzJ:zZhZpkJ~Zhy}rJ0-G"aeoui
Vzjdm?@zd}N,dt-lzd\ Uz
jd.iSQs*RtQ,\?":0
rsXOtQmO*-GJ"aeiou"J/Q2*%Q2O"hy"4
VhQIq`N_`NN
s["$$\\varphi=1+"*Q"\cfrac1{1+"\\<\dQ"dots"*Q\}"$$
@c"weak trick fair"d-!JlfhT-M.:us_cG.u+NYtKrH7-52hK.zU52 2>J26

Golfscript

);:|;{0):0;|$:§-1%" - "§" = ""0"4$~§~-+-4>:|n|6174`=!}do"Iterations: "0"."
'-+,/'{)))))}%
4:echo(2+2);
#undef X;A!"$%&'()*+-[,.]/0123456789:<=>?@BCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcghijklmopqrstvwxyz{|}~
{`),32>^.}.~
"126,32>''+".~\-'.~\-"'-
"),@`^^32>#.~".~
...[[]]{{}}&%%++++5i
  *++..0011125::::;;;?bbbbcccc{}
"This program wasn't written in "o"GolfScript"", it was built for ""CJam"oo"!"

CJam

"Q"c("ASSW"1$("aRD"(((T1
%\@_@){;_0}*__*)\15
"This program wasn't written in "o"GolfScript"", it was built for ""CJam"oo"!"
"P2"1e3K51_,1>K*$K*~]N*
li__,\mf:i2m1+:*/fb:+
ri:B__(^2/):G/,{_BBG/@-(#G@*G(B2/*+*}/]:+
{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~
[S'-26*N]:Z[S'|:PS24*PN]:RR'(PS5*qi:XD=X0<-X2%2*+:Y[" ^ "_" > ""(O)"" - "__]=S8*Y[" ^ ""   "" < ""(O)"" - "__]=S5*P')NRRXD=[SPS7*'oA*S7*PN]:QR?Y[[SPS5*'oSC*'oS5*PN]:T_R[SPS7*'oS8*'oS7*PN]RRR]=QY2=TR?RRZ
li4H#+2bW%32<2b
q~:R100:H*\d:T/i){R-H*HT-/m]}6*_H)<*
"JamesBdo,"YZ+/)BA*c+Y*Y%:BS@SB)))[JW:Z____)ci+*]U*

Bonus d'or: score précédent * 0.8

Pyth

jdm@cd)._-FQcj"
is
equal greater less
to than
"Qb

M@GCHgc"  ___

  ___
   _"bhzgc" (_*_)
 _===_
 .....
  /_\\"bhzs[g"  \ "@z4\(g"-.oO"@z2g" ,._"@z1g"-.oO"@z3\)g"  / "@z5)s[g" < /"@z4\(gc"   
 : 
] [
> <"b@z6\)g" > \\"@z5)++" ("gc"   
 : 
\" \"
___"bez\)

CJam

rri:Hri:Vri:Q[q~]3/_Qa3*a+_|$W%:Pf{\a#}:AH/:B0ff*
P,,[AHAW%HBz:+_W%V\V]2/
ff{~@@f=/::|1#}0Ua4*t:R;
P0f<
V{H{BI=J=_2$=
0R{"I>! I+V<J>! J+H<"4/+4/z{~~}%:&1$*\)}%);2$-|t
}fJ}fI
[P,{_La#\1$0t1$f-}*;;]
{:TR=2/~\~V\-,>\f{\_3$=@~H\-,>{Tt}/t}~}/
:~Pf=:~
~]S*N

q:Q;SS"
 _===_,___
 ....., _
  /_\,___
 (_*_)"',/0{Q=~(=}:G~N" \ "4G'(".oO-"_2G",._ "1G@3G')" / "5GN"< / "4G'(" : ] [> <   "3/6G')"> \ "5GNS'(" : \" \"___   "3/7G')

Golfscript

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras imperdiet est ut sem commodo scelerisque. Sed ut ultricies enim. Nam eget lectus suscipit, gravida turpis a, volutpat tellus. Cras efficitur luctus neque, at semper massa condimentum at posuere.

:*{32' _':$@'14'{?~!=}:&~32}%n*{:x' |':|\'1237'&$x'017'&|x'56'&}%n*{:x|\'134579'&$x'147'&|x'2'&}%

4,{"Happy Birthday "["To You""Dear GolfScript"]@2==n}%

~:c[,{){.}c(*}%.c/zip{+}*]zip{~{.@\%.}do;1=},{~<},{~\10c?*\/}${'/'*}%', '*'F'c`+' = {0/1, '+\', 1/1}'

Rubis, (135 + 4) * 0,6 * 0,8 = 66,72

Cela fonctionne sous Windows et je suis trop fatigué pour le raccourcir en utilisant Unix.

(a=[%w(javaw -jar cjam),%w(python pyth),%w(rubyw golfscript)].map{|c|c[-1]if system(*c,?f,'> NUL','2>','NUL')}-[nil])==[]?'Seriously':a

J'ai fait ces choses mais je ne sais pas si elles sont autorisées:

• Renommer cjam-[version].jarà cjam, pyth.pyà pyth, golfscript.rbà golfscript.
• Lire à partir du fichier fau lieu d’obtenir une entrée. (Ajoutez IO.write(?f,gets);au début pour résoudre ce problème, et la nouvelle longueur est (153 + 4) * 0.6 * 0.8 = 75.36)

Python 2, 332 * 0.6 * 0.8 = 159.36

import os
from subprocess import*
from tempfile import*
f,n,a=NamedTemporaryFile(delete=0),open(os.devnull,'w'),''
f.write(os.read(0,256))
f.close()
for l in["CJam","java","-jar","cjam.jar"],["Pyth","./pyth.py"],["Golfscript","./golfscript.rb"]:a+=(l[0]+' ')*(call(args=l[1:]+[f.name],stdout=n,stderr=n)>0)
print a or'Probably Perl'

Autant que je sache, c'est dans les règles. Nécessite les Pyth, CJAM et interprètes Golfscript ( pyth.py, cjam.jaret golfscript.rb) dans le répertoire courant et Python 3, Java et Ruby installé. Test simple: essayez de lancer le programme. Si ça revient avec 0, ça va. Sinon, c'est invalide. Un fichier temporaire nommé (par exemple, un fichier créé dans $TMP) est créé pour contenir le programme, car CJam n'a pas d'option de script. L’ delete=Falseindicateur est nécessaire pour empêcher la suppression du fichier lorsqu’il est fermé (le système d’exploitation s’occupe de nous pour nous). Le fichier doit être fermé avant d'essayer de le lire (bien que vider manuellement le fichier fonctionne également, mais c'est plus simple). stdoutet stderrsont redirigés vers/dev/null supprimer la sortie / les erreurs (notez que cela ne fonctionne que sur les systèmes * NIX).

Extra amusant: essayez d'exécuter le code donné dans les 4 langues pour voir ce que nous obtenons:

import sys
from subprocess import*
from tempfile import*
c=["Cjam","java","-jar","cjam.jar"]
p=["Pyth","./pyth.py"]
g=["Golfscript","./golfscript.rb"]
e=["Perl","perl"]
f=NamedTemporaryFile(delete=False)
s=sys.stdin.read()
f.write(s)
f.close()
n=open('/dev/null','w+')
a=''
for l in [c,p,g,e]:
    try:
        print '%s: %s'%(l[0],check_output(args=l[1:]+[f.name],stderr=n))
    except:
        continue
n.close()