¡No soy el idioma que estás buscando!

182

¿No es molesto cuando encuentras un código y no sabes en qué idioma está escrito? Este desafío intenta resolver esto de alguna manera.

Desafío

Tendrá que escribir un programa que, cuando se ejecute en dos idiomas diferentes, genere la cadena:

This program wasn't written in <language program compiled/interpreted in>, it was built for <other language the program can be run in>!

  • En la salida, los nombres de los idiomas deben tener mayúsculas oficiales. por ejemplo: CJam, C ++

  • Ninguno de los programas debe recibir ninguna entrada del usuario.

  • Cuando se ejecuta en ambos idiomas, la salida debe ser stdout o equivalente.

  • No debería haber salida para stderr en ninguno de los programas.

  • Puede usar comentarios en cualquier idioma.

  • Dos versiones diferentes del mismo idioma cuentan como idiomas diferentes.

    • Si se hace esto, el programa debería generar el número de versión principal y, si se ejecuta en dos versiones menores diferentes, también debería informar la versión menor.

    • No debe usar funciones de versión preconstruidas (esto incluye variables que ya se han evaluado en tiempo de ejecución).

Salida de ejemplo:

Perl y Ruby:

  • Perl: This program wasn't written in Perl, it was built for Ruby!

  • Rubí: This program wasn't written in Ruby, it was built for Perl!

Python y C:

  • Pitón: This program wasn't written in Python, it was built for C!

  • C: This program wasn't written in C, it was built for Python!

Python 2 y Python 3:

  • Python 2: This program wasn't written in Python 2, it was built for Python 3!

  • Python 3: This program wasn't written in Python 3, it was built for Python 2!

Python 2.4 y Python 2.7:

  • Python 2.4: This program wasn't written in Python 2.4, it was built for Python 2.7!

  • Python 2.7: This program wasn't written in Python 2.7, it was built for Python 2.4!

Este es el código de golf, por lo que gana el código más corto en bytes.

Azul
fuente
2
"Dos versiones diferentes del mismo idioma cuentan como idiomas diferentes". Entonces, ¿es válido engañar como con C comentarios anteriores y anteriores de 99? ^^
Zaibis
1
Agregado, se siente paradójico pero se ajusta a tus reglas.
Zaibis
1
¿Nadie está haciendo un políglota de espacio en blanco / Python?
No es que Charles
no importa. Vi la implementación 23
No es que Charles
¿Confiar en el programa que se ejecutará con cierto intérprete cuenta como entrada? es decir, encendido argv[0]?
gato

Respuestas:

86

Foo / CJam, 70 bytes

"This program wasn't written in ""Foo"", it was built for ""CJam"\@"!"

En Foo, como muchos han descubierto, simplemente imprime todo entre comillas dobles e ignora la mayoría de los otros caracteres o hace algo que no afecta la salida en la mayoría de los casos. En resumen, \@no hace nada y las cadenas se imprimen tal cual.

En CJam, \intercambia los dos elementos superiores y @mueve el tercer elemento a la parte superior, que organiza las cadenas en el orden correcto. Y una vez que finaliza el programa, todo lo que queda en la pila se imprime automáticamente.

jimmy23013
fuente
77
Y solo por diversión, hay una solución similar de 75 bytes para Fission / CJam:R"This program wasn't written in ""Fission"", it was built for ""CJam"\@'!O
Martin Ender
3
Agradable. Tenía "This program wasn't written in Clip, it was built for CJam!"3{4-_36+e\}/para Clip / CJam.
Dennis
55
Entré en este hilo para publicar una solución Foo, debería haberme dado cuenta de que todo el mundo ya sabe lo fácil que es escribir un políglota Foo.
histocrat
¿Hay un enlace a la especificación del lenguaje de programación Foo?
justhalf
1
@ErikE Agregó alguna explicación.
jimmy23013
140

C89 / C99, 171 152 136 114 111 107 105 bytes

Gracias a @Hurkyls, @Qwertiys, @ jimmy23013 y @MD XF por sus sugerencias.

versión de golf:

c;main(){c=-4.5//**/
-4.5;printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);}

versión sin golf:

c;

main()
{
    c = -4.5//**/
    -4.5;
    printf("This program wasn't written in C%d, it was built for C%d!",90-c,98+c);
}

Pequeña descripción:

Las versiones C anteriores a C99 solo tenían el comentario de varias líneas como este:

/*foo*/

con C99 se introdujo el comentario de una sola línea. Me gusta esto:

//foo

así que si compilas una línea como esta:

c =-4.5//**/
-4.5;

el código relacionado con la compilación del compilador c99 sería:

c = -4.5 -4.5;

mientras que el código relevante para un compilador c89 sería:

(ya que el primero /no es parte de un comentario y por lo tanto se trata como operador)

c = -4.5 / -4.5;
Zaibis
fuente
10
+1 para una respuesta maravillosa. Sin embargo, un poco de explicación para aquellos que no están familiarizados con C sería bueno.
ace_HongKongIndependence
44
@ace Creo que esto se basa en comentarios de estilo C99. En la cuarta línea, observe el //**/. En C89, ese es el operador de división seguido de un comentario vacío. En C99, //comienza un comentario de una sola línea, por lo que el resto de la línea está en blanco. Por lo tanto, en el C89, se convierte (90-(-4.5/-4.5)), que es 89, mientras que en el C99, se convierte (90-(-4.5-4.5)), que es de 99.
kirbyfan64sos
14
Para guardar algunos bytes, use en 188-clugar de c==99?89:99.
1
No creo que necesites el espacio y el paréntesis externo con la tarea.
PurkkaKoodari
1
105 bytes
MD XF
88

JavaScript / Ruby, 170 bytes

Podría ser solo 2.0, no parece funcionar en al menos 2.1.5 ... Editar: Actualizaciones según el consejo de @Jordan, ¡ espero que funcione en algunas versiones más ahora!

a='1';c=console=console||eval('def c.log s;$><<s end;c');c.log("This program wasn't written in "+(d=['JavaScript','Ruby'])[b= ~(a=~/1/)]+', it was built for '+d[b+1]+'!')

Abusa del ~operador porque Ruby tratará =~como una coincidencia de expresiones regulares que devuelve la posición de la primera coincidencia en la cadena ( 0), pero JavaScript lo tratará como lo = ~/1/que es -1(ya que /1/se convierte NaNpara operaciones numéricas, que tiene 0valor).

Dom Hastings
fuente
Esta respuesta no me funciona en Ruby 2.1.5. Obtengo:NoMethodError: undefined method `log' for :log:Symbol
EMBLEMA
@EMBLEM Mi prueba se realizó en Ruby 2.0 integrado en OS X, no he probado nada más allá de eso, ¡pero ciertamente agregaré un comentario que indica que podría estar roto en otra versión!
Dom Hastings
En las versiones más recientes de Ruby, una definición de método devuelve el nombre del método como un símbolo, por lo que evalestá regresando :log. Creo que podrías arreglarlo poniendo ;cdespués end. ¡ Pero el =~/ = ~truco es genial!
Jordan
También podrías ahorrar. Algunos bytes usando en $><<slugar de puts sy usando comillas dobles para que pueda colocar la barra invertida wasn\'t.
Jordan
@ Jordan Gracias! Sin embargo, no estoy seguro de cómo no detecté la eliminación de las \'comillas dobles, y $><<significa que puedo aplicar la corrección que mencionó y mantener el mismo recuento de bytes.
Dom Hastings
82

Python 2 / Python 3, 92

Utiliza la verificación de versión de Python "estándar" (división de enteros vs.

print("This program wasn't written in Python %d, it was built for Python %d!"%(3/2*2,4-3/2))
Feersum
fuente
3
Se habló de esto en la caja de arena y el consenso fue permitir este tipo de cosas
Azul
14
@flawr ¿Se permitirían Python y Cobra? ;)
Beta Decay
77
@flawr Python en realidad lleva el nombre de la comedia ~~ grupo ~~ dioses, Monty Python.
Mutantoe
@Mutantoe Puede parecerle que "Monty" no es el nombre de un animal, el juego de palabras no funcionaría.
Pierre Arlaud
57

Pesca / > <> 233 217 bytes

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC
\   "This program wasn't written in ""><>"  ", it was built for Fishing!"
>r!`ol?!;32.                         Fishing                     ><>!`N

La pesca es un lenguaje basado en un pescador que anda pescando . Para hacer un programa en este idioma, primero tiene que definir un muelle en el que camina. El dock solo proporciona flujo de control a un programa. El muelle en este programa es:

v++C-CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+CCCCCCC-CCCCCCCCCCCCCCCCCCC+CCCCCC

Cada vez que Cse encuentra el comando, el pescador lanza su línea para atrapar una instrucción. Las instrucciones +y -disminuyen y aumentan la longitud de su línea respectivamente. vcambia su dirección de lanzamiento hacia abajo. Los peces que atrapa en este programa son:

`This program wasn't written in Fishing, it was built for ><>!`N

> <> es un lenguaje basado en un pez que se mueve a través del agua. El vcomando comienza a mover el pez hacia abajo, donde luego se refleja a la derecha con el \comando. Todo entre comillas se empuja a la pila. Después de que la cuerda se empuja hacia la pila, el pez se enrolla hacia el otro lado donde se refleja hacia abajo \. Luego imprime el contenido de la pila con:

>r!`ol?!;32.
El numero uno
fuente
Puede reducir su código en 13 bytes colocando su ciclo de impresión para> <> en el espacio en blanco en la tercera línea (que no creo que interfiera con la parte de pesca, aunque no conozco ese idioma). No estoy seguro de cómo este comentario manejará todo el código, así que aquí hay un enlace hastebin: hastebin.com/quqinozizi (puede que haya estropeado el espacio en la tercera línea pero creo que todo está alineado correctamente).
cole
@Cole funciona. De hecho, su sugerencia en realidad elimina 16 caracteres.
TheNumberOne
14
Políglotas de pesca y pesca ... ¡posiblemente el primero de su tipo!
Mark K Cowan
esto es tan gracioso que!
D.Tate
55

23 / Malbolge, 5688 bytes

                    bCBA@?>=<;:987
                                                                                        6543210/.-,+*)
                                                                                          ('&%$#"!~}|{zy
                                                                                               xwvutsrqponmlk
                                                                                                  jihgfedcba`_^]
                                                                                     \[ZYXWVUTSRQPO
                                                                                               NMLKJIHGFEDCBA
                                                                                    @?>=<;:9y76543
                                                                210/(L,l*)(!E}
                   |B"!~}|{zyxwvu
                                                                                                     tsrqponmlkjiha
                                                                                                  fed]#a`_^]?zZY
                                                                                         XWVUTSRQ3ONMLK
                   JIHGFEDCBA:^>=
                                                                                                       <;:98705.R21q/
                                                                                               .-,+*#G'&%${"!
                                                                                            x>|{zyxwYutm3k
                                                                                                        ponmlkjihg`&^c
                                                                                     ba`_^]\[ZYXWVO
                   sSRQPONMLEi,HG
                                                                                                      FEDCBA@?>=6Z:9
                                                                                    y76543210/.-,+
                                                                                                          *)('&%$#"y?w|u
                   ;sxwvutm3qSonm
                                                                                                       fkjiha'edcba`_
                                                                                            ^]\[ZYXWVUTSRQ
                   PONM/EiIHGFEDC
                               BA@?>7[;:987w5
                                      432+O/o-,%I)('
                                     &}$#z@~}|{zsxw
                   vutsrqponmlkji
                                                                                                 ha'&dFba`_^]\U
                                                                                            yYXWVUTMRQPONM
                   LKDhH*F?DCBA@?
                                                                                                 8\<;:98765432r
                                                                                        0/.-&J*)('&f$#
                                                                                                       "!~}|{zyxwvuts
                                                                                                       rqj0nmOkjihaf_
                                                                                            %cE[!_^]\[=SwW
                                                                                                     VU7SLpPONMLEJI
                                                                                                          HAeEDC%A@?>=<;
                   :9876543210/.-
                                                                                                       ,+$H('&}${A!xw
                          ={]yxwvutsrk1o
                                                                                                 nmOejib(fedcE"
                                                                                                      `_^]?[ZYRvVUT6
                                                                                     RKo2HMLKJIHAe
                                                                                                           EDCBA@?>=<;:9
                    87w5432+O/.-,
                                                                                                 +*)('&%e#"y?w
                                                                                     |{zs9wvun4rqp
                                                                                                      onmlNjib(fedc
                                                                                           ba`_^]\[ZYXWV
                                                                                                   8TMqKPONMLKDh
                                                                                                      +GFEDCB;_?>=<
                                                                                                    ;:9y7654321*N
                    .-,+*)('&f|{A
                                                                                                       !~}|{]yxwvo5s
                                                                                             rqpinmlkjihg`
                                                                                            &dcbD`_^]\[Tx
                                                                        ;WVUTMRQJnN0F
                                                 KDhH*FEDC<A@?
     >=<5Y92765.R?

Tenga en cuenta que el programa requiere un salto de línea final. Ninguna línea contiene espacios en blanco al final, por lo que copiar / pegar debería funcionar bien.

Verificación

Para probar el código de Malbolge en este intérprete en línea , péguelo en el área de código de Malbolge y haga clic en Load/Reset, luego Execute.

Para probar el código 23 en este intérprete en línea , péguelo en el área Fuente , presione Enterpara insertar el salto de línea final, escriba 23en el área Consola (para cambiar de la notación 23.dezsy predeterminada a la detección automática) y haga clic Run Interpreter!.

Dennis
fuente
20
Amigo ... ¡parece que una bomba explotó en tu código!
D.Tate
8
o_0 cómo escribiste el código de Malbolge
Pavel
Outgolfed! codegolf.stackexchange.com/questions/55960/…
Krzysztof Szewczyk
55

Lua / C - 182 164 bytes

#if 0
print"This program wasn't written in Lua, it was built for C!"--[[
#endif
main(){printf("This program wasn't written in C, it was built for Lua!\n");}/*]]--*/

Aprovecha la función donde Lua trata una marca de hash en la primera línea como un comentario para permitir shebangs de Unix. De lo contrario, envuelve los comentarios del otro idioma en sus propios comentarios.

Para reducir bytes, confío en el comportamiento implícito que solo emite advertencias en GCC y Clang: declaración implícita de int para la definición principal e implícita de printf.

benpop
fuente
3
Muy hábilmente hecho!
vacas graznan el
2
Si eliminar "include <stdio.h>" es demasiado extremo, revertiré la respuesta.
benpop
2
¿Por qué no usar el //comentario en la parte C? Guarda 2 bytes.
BrainStone
54

JavaScript / Haskell, 158 bytes 147 bytes

Idea general: introducir la sintaxis de comentarios de cada uno en el otro.

En una linea:

u="This program wasn't written in ";v=", it was built for ";j="JavaScript";h="Haskell";{-console.log(u+j+v+h+"!")}//-}main=putStrLn$u++h++v++j++"!"

Cómo se ve esto para Haskell:

-- some variable definitions
u = "This program wasn't written in "
v = ", it was built for "
j = "JavaScript"
h = "Haskell"

-- a comment
{-console.log(u+j+v+h+"!")}//-}

-- the main method that does the dirty deed
main = putStrLn $ u ++ h ++ v ++ j ++ "!"

Cómo se ve esto en JavaScript:

/* variables can be declared without `var` */
u = "This program wasn't written in ";
v = ", it was built for ";
j = "JavaScript";
h = "Haskell";

/* hey look, an anonymous block! */
{ 
  /* we negate the `undefined` that comes out of console.log */
  -console.log(u+j+v+h+"!")
} 
/* there are two automatic semicolon insertions here:
   one before `}` and one before EOF. */

/* a one-line comment. */
//-}main=putStrLn$u++h++v++j++"!"
CR Drost
fuente
3
alertEs más golfista.
wizzwizz4
51

Brainfuck / Foo, 769 bytes

-[--->+<]>-.[---->+++++<]>-.+.++++++++++.+[---->+<]>+++.[-->+++++++<]>.++.---.--------.+++++++++++.+++[->+++<]>++.++++++++++++.[->+++++<]>-.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.-----.[++>---<]>++.[->+++<]>-.[---->+<]>+++.--[->++++<]>-.-----.---------.+++++++++++..+++[->+++<]>.+++++++++.-[->+++++<]>-.-[--->++<]>-.+++++.-[->+++++<]>-.+[->++<]>.---[----->+<]>-.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.+++[----->++<]>.------------.-[--->++<]>-.+++++++++++.[---->+<]>+++.--[->++++<]>-.-[->+++<]>-.--[--->+<]>--.+[---->+<]>+++.[->+++<]>++.[--->+<]>-.------------.+++.++++++++.[---->+<]>+++.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.+++[->++<]>.+[--->+<]>++..[--->+<]>----."This program wasn't written in Foo, it was built for Brainfuck!"

Una respuesta extremadamente compleja y compleja ... o no.

Fatalizar
fuente
21
Maldita sea, no otra vez Foo: D
Beta Decay
55
Me gusta como piensas.
Pierre Arlaud
13
Al ejecutar esto en Brainfuck, Brainfuck esperará la entrada debido ,al texto en el final. Creo que eso va en contra de las reglas de asignación.
Simon Forsberg
1
@SimonForsberg es mucho tiempo, pero en un intérprete como probarlo en línea, y creo que la mayoría de los demás, ,simplemente establece la celda en 0, para EOF
Destructible Lemon
41

C / Python, 238 caracteres

Esto no imprime 100% exactamente lo que se solicita, pero está bastante cerca.
Un reinicio de mi tarjeta de San Valentín .

#define def main(){0?
#define print printf(
#define return 0)));}
#define pass 0);

def main():
    print "This program wasn't written in ",
    pass
    print "Python",
    print ", it was built for ",
    print "C",
    return

main();
Ugoren
fuente
55
¿Qué imprime si no es exacto?
Beta Decay
44
Esa cosa
impresa
44
Esto no es válido. C. Clang se queja defy :después def main(), y en realidad no abre un cuerpo de función para main. ¿Realmente intentaste compilar tu respuesta en C?
C0deH4cker
55
#define def main(){0?Falta la línea
kay
3
#define returnme hace llorar un poco ...
corsiKa
32

C / C ++, 136

#include<stdio.h>
int main(){
char*a="++",z=sizeof'c'/2;
printf("This program wasn't written in C%s, it was built for C%s!\n",a+z,a+2-z);
}

Nuevas líneas agregadas para formatear. Pruébalo en C o C ++ .

grc
fuente
32
¿Qué pasa si estoy en una plataforma donde int es de 2 bytes? ¿Dónde puedo obtener un compilador de C +?
immibis
@immibis jaja: P pero en una nota seria el truco de estructura vacía podría funcionar:struct{}s;z=2*sizeof s
grc
31

Befunge / > <> , 141 138 134 133 130 bytes

3 bytes guardados gracias a @Cole .

Para ser exactos, estoy usando Befunge-98.

\"!><> rof tliub saw ti ,egnufeB"   >" rof nettirw t'nsaw margorp sih"'T>:#,_@'~~~~~~
>l?v"!egnufeB rof tliub saw ti ,><>"^
?!;>ol

Usando los hechos que:

  • \ es un espejo en> <> e intercambia en Befunge
  • 'string'es una cadena en> <> y 'ces un carácter en Befunge
PurkkaKoodari
fuente
A menos que lo necesite para el código Befunge (que no creo que lo haga), puede reducir 3 bytes reemplazando la línea inferior con?!;>ol
cole
23

PHP / MySQL, 147 bytes

-- $argc;die("This program wasn't written in PHP, it was built for MySQL!");
SELECT("This program wasn't written in MySQL, it was built for PHP!");
Razvan
fuente
17
Finalmente, uno que entiendo.
MikeTheLiar
1
Debería poder deshacerse de los paréntesis de la segunda línea, por dos bytes menos:SELECT"This program wasn't written in MySQL, it was built for PHP!";
msh210
2
Pero eso ya no funcionará en PHP, causará un error de análisis. SELECT "..." no es una expresión PHP válida.
Razvan
22

Python 3 / > <> , 177 173 172 167 Bytes

¡Gracias a @mathmandan por eliminar 5 bytes!

Bueno, esta fue una experiencia, y también una prueba. Cualquier sugerencia de golf es bienvenida, ya que esto es bastante largo. Hice todo lo posible para reutilizar el texto, pero fue bastante difícil.

Técnicamente, sería Python 3 el que debería generar este programa (y podría cambiarlo si no cumpliera con las especificaciones, pero en el ejemplo Pythonse enumeró la salida de Python / C ).

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"                 #v   "><>"r~/
a=", it was built for "+v#\a
print(aa[-3::-1]+"Pytho" +"n"+a)
#  .4b;!?lor"!nohtyP r"~/

Pruébelo en un intérprete en línea> <> y en un intérprete de Python 3 (el intérprete > <> requiere que ingrese el código manualmente)

Devoluciones

This program wasn't written in ><>, it was built for Python!

en> <> y

This program wasn't written in Python, it was built for ><>!

en Python

Explicación (Python)

Para el lado de Python, es bastante simple. Aquí está el código que nos interesa (básicamente el código sin comentarios, que se denota con un #en Python). Tenga en cuenta que en Python \es un carácter de escape cuando se usa en cadenas, por lo que se \"evalúa "en la cadena.

aa=" ni nettirw t'nsaw margorp sihT\"\""
v="><>!"
a=", it was built for "+v
print(aa[-3::-1]+"Pytho" +"n"+a)

Lo que más nos importa aquí son las operaciones realizadas en la variable aa:

aa[-3::-1]: reverses the string and chops off the quotation marks (thanks to @mathmandan)

La declaración impresa se evalúa así

"This program wasn't written in " + "Pytho" + "n" + ", it was built for ><>!"

Explicación (> <>)

Ahora llegamos a la parte más difícil. Una vez más, aquí está el código con los bits innecesarios eliminados.

aa=" ni nettirw t'nsaw margorp sihT\"\
                          v   "><>"r~/
a=", it was built for "+v \a

   .4b;!?lor"!nohtyP r"~/

Línea 1:

aa=" ni nettirw t'nsaw margorp sihT\"\

aa=         pushes 1 onto the stack (evaluates 10==10, basically)
" ni ... \" pushes the first part plus a \ onto the stack.
\           deflects the pointer downwards

La pila en este momento (si está impresa): \This program wasn't written in

Línea 2:

Tenga en cuenta que la línea 2 comienza en la /posición del puntero desde la línea 1 y se mueve de derecha a izquierda.

v   "><>"r~/

/     deflects the pointer leftwards
~r    pops the / off the stack and then reverses it
"><>" pushes ><> onto the stack
v     deflects the pointer downwards

La pila en este momento: ><> ni nettirw t'nsaw margorp sihT

Línea 3:

Al igual que la línea anterior, esta comienza en \, que es donde la línea 2 envía el puntero. Tenga en cuenta que debido a que el puntero se ajusta alrededor de la línea cuando llega al primero a, escribiré mi explicación en orden de dónde va el puntero (y, por lo tanto, qué se ejecuta)

a=", it was built for "+v \a

\aa=       deflect and push 1 onto the stack
", i ... " push the string onto the stack
+v         sum the last two values pushed and deflect

La pila en este momento ( xes el personaje formado por la adición de "r" y un espacio. No es el personaje real, solo un marcador de posición de mi parte):

xof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

Línea 4:

El puntero simplemente continúa hacia abajo, por lo que esta línea no garantiza más explicaciones.

Línea 5:

Comenzando en /y yendo hacia la izquierda.

.4b;!?lor"!nohtyP r"~/

~"r Python!" pops x off and adds back r and a space
r            reverses the stack
o            pops and prints a character
l?!;         pushes the length of the stack and stops if it's 0
b4.          pushes 11 then 4 then moves to that location (where o is)

La pila en este momento (la salida se invirtió):

!nohtyP rof tliub saw ti ,><> ni nettirw t'nsaw margorp sihT

Y eso debería ser todo por la explicación. Avíseme si hay alguna inconsistencia entre la explicación / código o si hice algo mal; Aprendí un poco más mi código mientras estaba escribiendo la explicación para poder mezclar fragmentos de código antiguo y nuevo.

col
fuente
Estaría mal si dijera que tienes que agregar el 3 porque no es Python 2. Está bien.
Azul
Si esto fuera sólo Python, creo que podría reemplazar aa[:-2][::-1]con aa[-3::-1]. En este caso, por supuesto, eso puede interferir con el formato> <>, pero quizás valga la pena considerarlo si aún no lo ha hecho. En particular, estoy bastante seguro de que necesita un espacio debajo vde la línea anterior, pero parece print(aa[-3::-1]+"Pytho"que encajaría en los 24 caracteres a continuación a=", it was built for "+, y luego podría poner un espacio seguido por +"n"+a). No estoy seguro de si esto rompería algo más, pero si funciona, ahorrará algunos bytes.
mathmandan
@mathmandan Gran idea, actualizaré mi código y le daré crédito.
cole
¡Buen trabajo! FYI, creo que esto funcionaría bien en Python 2, y en Python 2 puede ahorrar un byte dejando caer paréntesis en la declaración de impresión: print aa[-3::-1]+"Pytho" +"n"+a. Sin embargo, otra pregunta: en la versión> <>, ¿qué sucede con el 1que originalmente se introdujo en la pila?
mathmandan
@mathmandan Creo que el intérprete que utilicé no imprime el carácter si no es válido o el carácter impreso no aparece en absoluto. Sinceramente, no estoy 100% seguro de por qué no importa imprimir ese personaje; Lo descubrí accidentalmente.
cole
19

Batch .BAT File / Batch .CMD File, 194185 Bytes

@ECHO OFF
SET a=BAT
SET b=CMD
CALL :F&&GOTO :C||GOTO :O
:C
SET a=CMD
SET b=BAT
:O
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF
:F
md;2>nul
SET v=1

Editar: se guardaron 9 bytes y se corrigió la falta !gracias a DLosc

Sí, hay diferencias entre los archivos BAT y CMD. Referencia. Esencialmente, CMD establece el comando ERRORLEVELen un SETcomando, mientras que BAT no lo hace, lo que significa que aquí el ERRORLEVELconjunto del mdcomando con formato incorrecto se borra SET v=1en una versión pero no en la otra. Este script se basa en el ejemplo proporcionado por "Ritchie" en ese hilo del grupo de noticias.

Tenga en cuenta que la secuencia de comandos abreviada de arriba se supone ENABLEEXTENSIONSque se establece ON(de forma predeterminada en todas las plataformas). El script expandido a continuación lo establece explícitamente para garantizar la funcionalidad correcta. Sin eso, el SETcomando para CMD no permite todas las extensiones, y (en algunos sistemas, tal vez) podría no establecerlo ERRORLEVELadecuadamente.

Ampliado y remarcado

@ECHO OFF
setlocal ENABLEEXTENSIONS

REM Call the :FUNC subroutine and branch based on the resulting errorlevel
CALL :FUNC&&GOTO :CMD||GOTO :BAT

REM Just in case. If we reach this, though, hoo-boy ...
GOTO :EOF

:BAT
REM We're a BAT file, so set variables and goto output
SET a=BAT
SET b=CMD
GOTO :OUTPUT

:CMD
REM We're a CMD file, so set variables and goto output
SET a=CMD
SET b=BAT
GOTO :OUTPUT

:OUTPUT
REM Print out the result, then go to end of file
ECHO This program wasn't written for %a% File, it was built for %b% File!
GOTO :EOF

:FUNC
REM Simple subroutine to set the ERRORLEVEL appropriately
md;2>nul
REM Right now, ERRORLEVEL on both CMD and BAT is 1
SET v=1
REM Right now, ERRORLEVEL on CMD is 0, but BAT is still 1
AdmBorkBork
fuente
... hay una diferencia entre CMD y BAT?
Stan Strum el
16

CJam / GolfScript, 81 78 bytes

"This program wasn't written in "o"GolfScript"", it was built for ""CJam"oo"!"

Versión original de 81 bytes:

"This program wasn't written in "["CJam"", it was built for ""GolfScript"]-1a%"!"
jimmy23013
fuente
14

PHP / Perl, 98 96 bytes

$a="HP";$b="erl";
//;$a=$b;$b=HP;
print"This code wasn't written in P$a, it was built for P$b!";

No sé si esto es trampa o no, ya que, por lo que puedo decir, la única forma de ejecutar PHP sin una <?etiqueta de apertura es algo así php -r $(cat codefile.php). Pero suponiendo que sea legal ... //es un comentario de PHP, pero en Perl es una expresión regular (que, en una declaración en sí misma, no hace nada). El resto debería explicarse por sí mismo.

Editar: ahora usando una palabra desnuda en la parte de solo Perl. En primer lugar, quería usarlos para ambos idiomas, pero PHP muestra una advertencia cuando lo hace, contrario a "No debería haber salida para stderr".

DLosc
fuente
1
<?'>#';es una sintaxis válida en ambos idiomas.
primo
14

Ruby / Python, 105 caracteres

a=["Ruby","Python"];a.sort();print("This program wasn't written in "+a[0]+", it was built for "+a[1]+"!")
prensado
fuente
¡Esto es realmente bueno! Me gusta especialmente que no se utilicen comentarios.
styfle
14

JavaScript 1.8 / JavaScript 1.7, 89 bytes

a=![].reduce;`This program wasn't written in JS 1.${8-a}, it was built for JS 1.${7+a}!`

Porque Array.prototype.reduce es nuevo en 1.8

EDITAR: Golfed 7 bytes inicializando directamente en alugar de usarreverse()

EDITAR: JavaScriptse puede escribir comoJS , ahorrando 8 bytes

EDIT: Gracias por Hedi señalando que puedo ahorrar 3 bytes más si yo no uso la variable bmás

EDITAR: Golfed 6 bytes calculando 7+ay 8-a, donde a=1si se define la reducción (JS 1.8) y a=0si no está definido (JS 1.7)

EDITAR: Hedi jugó 6 bytes más, lo que sugiere el uso de una cadena de plantilla

EDITAR: ETHproductions arrojó 2 bytes sugiriendo en a=!![].reduce;lugar dea=[].reduce?1:0;

EDITAR: no1xsyzy jugó un byte más sugiriendo revertir el cheque booleano

Mario Trucco
fuente
Con "JS" en lugar de "JavaScript", usando dos veces "JS 1". en su cadena es más corto que usar la variable b.
Hedi
Puede usar la cadena de plantilla para acortarla: `Este programa no se escribió en JS 1. $ {7 + a}, ¡se creó para JS 1. $ {8 + a}!`
Hedi
2
Yo creo que se puede guardar dos bytes cambiando a=[].reduce?1:0;a a=!![].reduce;.
ETHproductions
@ETHproductions Gracias, pero no creo que funcione. Necesito apara mantener el valor 1o 0no true, ofalse
Mario Trucco
@ETHproductions lo siento, tienes razón, lo intenté y funciona. ¡Gracias!
Mario Trucco el
13

SWI-Prolog 6 / SWI-Prolog 7, 156 bytes

P='SWI-Prolog ',A=6,B=7,(is_list(""),N=A,M=B;N=B,M=A),atomic_list_concat(['This program wasn\'t written in ',P,N,', it was built for ',P,M,'!'],W),write(W).

Utiliza el hecho de que las comillas dobles ""son códigos de cadena (es decir, una lista de códigos de caracteres) en las versiones SWI-Prolog anteriores a 7, y son un tipo de cadena adecuado en la versión 7. is_list(""), por lo tanto, será falso en la versión 7 y verdadero en las versiones anteriores.

Fatalizar
fuente
12

BF / SPL, 5342 bytes

Estoy bastante seguro de que este es el primer políglota del lenguaje de programación de Shakespeare en este sitio.

Probablemente no gane ningún premio. Funciona infiltrando el código BF en los títulos de acto / escena / programa. El código SPL usa puntos de exclamación en lugar de puntos, excepto en algunos casos. Se supone que los programas no deben ingresar datos, por lo que las comas en las declaraciones de caracteres se "comentan" al poner a cero las celdas y poner corchetes alrededor de las comas. El mismo procedimiento se aplica al ocultar los corchetes alrededor de las instrucciones enter / exeunt.

[-][.
Ford,.
Page,.
Act I:]+++++++++[>+++++++++<-]>+++.
Scene I:>[.
[Enter Ford and Page]
Ford:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad day and bad bad day!Speak thy mind!
Scene II:]<<++[>++++++++++<-]>.
Page:
You is sum of bad bad bad bad bad bad day and sum of bad bad bad bad bad day and bad bad bad day!Speak thy mind!
Scene III:+.
Page:
You is sum of thyself and day!Speak thy mind!
Scene IV:++++++++++.
Page:
You is sum of thyself and sum of bad bad bad day and bad day!Speak thy mind!
Scene V:>++++[>++++++++<-]>.
Ford:
You is fat fat fat fat fat cat!Speak thy mind!
Scene VI:[-<+>]<<---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene VII:++.
Page:
You is sum of thyself and fat cat!Speak thy mind!
Scene VIII:---.
Page:
You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene IX:--------.
Page:
You is sum of thyself and big big big pig!Speak thy mind!
Scene X:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XI:<++++[->----<]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XII:++++++++++++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and big big pig!Speak thy mind!
Scene XIII:>.
Ford:
Speak thy mind!
Scene XIV:<++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XV:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XVI:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XVII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XVIII:>+++++++.
Ford:
You is sum of thyself and sum of fat fat fat cat and pig!Speak thy mind!
Scene XIX:<++++++.
Page:
You is sum of thyself and sum of fat fat cat and fat cat!Speak thy mind!
Scene XX:>-------.
Ford:
You is sum of thyself and sum of big big big pig and cat!Speak thy mind!
Scene XXI:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXII:-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIII:---------.
Page:
You is sum of thyself and sum of big big big pig and pig!Speak thy mind!
Scene XXIV:+++++++++++.
Page:
You is sum of thyself and sum of cat and sum of fat cat and fat fat fat cat.Speak thy mind!Speak thy mind!
Scene XXV:<+++[>-----<-]>.
Page:
You is sum of thyself and sum of big big big big pig and cat!Speak thy mind!
Scene XXVI:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene XXVII:>.
Ford:
Speak thy mind!
Scene XXVIII:<-----.
Page:
You is sum of thyself and sum of big big pig and pig!Speak thy mind!
Scene XXIX:+++++.
Page:
You is sum of thyself and sum of fat fat cat and cat!Speak thy mind!
Scene XXX:>.
Ford:
Speak thy mind!
Scene XXXI:[->++<]>++.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat cat and cat!Speak thy mind!You is sum of thyself and sum of big pig and pig!Speak thy mind!
Scene XXXII:++++.
Page:
You is sum of thyself and big red hog!Speak thy mind!
Scene XXXIII:<+++++[>-----<-]>-.
Page:
You is sum of thyself and big big big big big pig!Speak thy mind!
Scene XXXIV:[-<+>]<------------.
Ford:
Speak thy mind!
Scene XXXV:<-----.
Page:
You is sum of thyself and sum of fat fat fat fat fat fat cat and sum of big pig and pig!Speak thy mind!
Scene XXXVI:+++++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XXXVII:>.
Ford:
Speak thy mind!
Scene XXXVIII:<+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XXXIX:<++++[->-----<]>--.
Page:
You is sum of thyself and sum of big big big big big pig and sum of fat fat fat cat and fat cat!Speak thy mind!
Scene XL:<++++[>++++<-]>++.
Page:
You is sum of thyself and sum of fat fat fat fat cat and fat cat!Speak thy mind!
Scene XLI:>.
Ford:
Speak thy mind!
Scene XLII:<<++++[>----<-]>-.
Page:
You is sum of thyself and sum of big big big big pig and pig!Speak thy mind!
Scene XLIII:<+++++[>++++<-]>-.
Page:
You is sum of thyself and sum of fat fat fat fat cat and sum of fat cat and cat!Speak thy mind!
Scene XLIV:------------.
Page:
You is sum of thyself and sum of big big big big pig and fat fat cat!Speak thy mind!
Scene XLV:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene XLVI:++++++++.
Page:
You is sum of thyself and fat fat fat cat!Speak thy mind!
Scene XLVII:>.
Ford:
Speak thy mind!
Scene XLVIII:<--------------.
Page:
You is sum of thyself and sum of big big big big pig and fat cat!Speak thy mind!
Scene XLIX:+++++++++.
Page:
You is sum of thyself and sum of fat fat fat cat and cat!Speak thy mind!
Scene L:+++.
Page:
You is sum of thyself and sum of fat cat and cat!Speak thy mind!
Scene LI:>.
Ford:
Speak thy mind!
Scene LII:>+++++++[<+++++++>-]<++.
Page:
You is sum of thyself and sum of big big big big big pig and big big big big pig!Speak thy mind!
Scene LIII:---.
Page:
You is sum of thyself and fat fat cat!Speak thy mind!
Scene LIV:----.
Ford:
You is sum of thyself and cat!Speak thy mind!
Scene LV:>+++++++[<------>-]<-.
Ford:
You is cat!
Scene LVI:>[.
[Exeunt]

Pruebe BF en https://repl.it/E8Hh/23 .

El código SPL se probó en el compilador que se encuentra aquí: https://github.com/drsam94/Spl/ .

clamchowder314
fuente
11

Ruby 1.8 / Ruby 1.9, 87

puts"This program wasn't written in Ruby 1.#{?9%49}, it was built for Ruby 1.#{?8%47}!"

En Ruby 1.8, ?9es el valor ASCII de "9", que es 8 módulo 49. En Ruby 1.9, es la cadena "9", y %49es una operación de formateo que no hace nada ya que "9" no tiene cadenas de formato en eso.

histocrat
fuente
11

Python 2.7.9 / Python 2.7.10, 127 bytes

Hemos tenido un par de publicaciones que utilizan versiones menores, pero ninguna que haya pasado al siguiente nivel ...

import types
n=len(dir(types))
print"This program wasn't written in Python 2.7.%d, it was made for Python 2.7.%d!"%(n%33,-n%52)

Pruébelo en Ideone (Python 2.7.10) y repl.it (técnicamente Python 2.7.2, pero debería dar el mismo resultado que 2.7.9).

Python 2.7.10, de acuerdo con el registro de cambios :

Se agregó una __all__al typesmódulo.

Esto pasó len(dir(types))de 42 a 43, dando una diferencia numérica que podemos explotar para generar la salida deseada.

DLosc
fuente
10

Python / QBasic, 160 142 bytes

Probado con Python 3 y QBasic 1.1 . No funcionará en Python 2 sin agregar from __future__ import print_functiona la línea 4.

1# DEFSTR A-B
a = "QBasic"
b = "Python"
'';a,b=b,a;PRINT=print
PRINT ("This program wasn't written in " + a + ", it was built for " + b + "!")
  • En Python, 1#es la expresión 1(no-op) seguida de un comentario. En QBasic, es un número de línea (con el sufijo de tipo que lo marca como a DOUBLE). La DEFSTRdeclaración le dice a QBasic que todas las variables cuyos nombres comienzan con Ao B(sin distinción entre mayúsculas y minúsculas) son variables de cadena. De esa manera, podemos llamar a nuestras variables ay en blugar de a$y b$(que no funcionaría en Python).
  • En QBasic, 'comienza un comentario. En Python, ''es la cadena vacía (no-op). Luego intercambiamos los nombres de los idiomas y definimos un alias paraprint función (dado que las palabras clave QBasic se formatean automáticamente en mayúsculas).
  • Los paréntesis en la línea final no son necesarios en QBasic, pero tampoco hacen daño a nada.

Si se me permite apagar el autoformatter (que es una opción en QB64 , aunque no en el QBasic original), puedo bajarlo a 114 bytes usando Python 2 :

1#DEFSTR A-B
a="QBasic"
b="Python"
'';a,b=b,a
print"This program wasn't written in "+a+", it was built for "+b+"!"
DLosc
fuente
-3 bytes: cambiar a QB64 real.
CalculatorFeline
Autoformato.
CalculatorFeline
¡QB64 / Python 2 tiene 131 bytes! O Python 3 para 133 bytes.
CalculatorFeline
9

Perl / Ruby, 129 bytes

0&&eval('def sort a,b;[b,a] end');printf"This program wasn't written in %s, it was built for %s!",(@a=sort"Perl","Ruby")[0],@a[1]

No hay abuso de expresiones regulares en este, solo aprovechando el hecho de que 0 es verdadero en Ruby para evaluna definición de sort(que realmente reversees) e printfing. A Ruby no le gustaba usar la lista para los argumentos, así que tuve que hacer cada uno individualmente.

Dom Hastings
fuente
¿Por qué atiene que ser una variable de instancia, en lugar de una local?
Nic Hartley
@QPaysTaxes el @sigilo en una variable en Perl denota que es una lista, en Perl almacenar, por ejemplo $a, no produce ningún resultado.
Dom Hastings
Ah, ya veo. Gracias por la explicación.
Nic Hartley
9

/// y Retina , 95 + 3 = 98 bytes

/
//

This program wasn't written in \/\/\/, it was built for Retina!
/?./....(.*)(R.*)!
$2$1///!

+3 bytes para el -s bandera en Retina.

Explicación para ///

La primera instrucción es

/
//

elimina todas las nuevas líneas del resto del código, lo que resulta en

This program wasn't written in \/\/\/, it was built for Retina!/?./....(.*)(R.*)!$2$1///!

Todo hasta el !es simplemente un literal e impreso en STDOUT. La siguiente instrucción es

/?./....(.*)(R.*)!$2$1/

Pero la cadena de búsqueda ?.no se puede encontrar, por lo que no sucede nada. Entonces, el código restante //!es una instrucción incompleta, por lo que el programa termina, después de haber impreso la cadena correcta.

Explicación para la retina

/
//

Esto le dice a la retina para sustituir /a //. Pero la entrada está vacía, por lo que esto no coincide con nada.

<empty>
This program wasn't written in \/\/\/, it was built for Retina!

Esto reemplaza la entrada con la cadena en la segunda línea.

/?./....(.*)(R.*)!
$2$1///!

Esto coincide con la cadena \/\/\/, it was built for Retina!y la reemplaza Retina, it was built for ///!para dar el resultado correcto.

Martin Ender
fuente
Sabes, creo que sería trivial hacer uno entre Retina y rs ...;)
kirbyfan64sos
@ kirbyfan64sos Probablemente, pero ¿qué tan corto sería? ;)
Martin Ender
Bueno, hasta ahora he obtenido alrededor de 85 bytes + 3 -s, ¡aunque decir lo que hice arruinaría la diversión! : D
kirbyfan64sos
1
@ kirbyfan64sos Sigue adelante y publícalo, no creo que tenga tiempo para investigar rs pronto.
Martin Ender
9

sed / Hexagony 251 Bytes

/$/cThis program wasn't written in sed, it was built for Hexagony!
#...>32;p;r;o;g;r;\+/;a;w;23+;m;a<.;.>s;n;+39;t;+32\s/;n;e;;t;i;r;w;<. |.>+32;i;n;+32;H;e\ ;/4+;y;n;o;g;a;x;< i>4;+32;i;t;+32;\;/u;b;23+;s;a;w<h>;i;l;t;+32;f\;/;s;23+;r;o;< T>e;d;+33;@

sed: ¡ Pruébelo en línea!
Hexagonía: ¡ Pruébelo en línea!


En sed, imprime la cadena correcta si coincide con la cadena vacía al final (siempre). La segunda línea es un comentario. Esto requiere una cadena en STDIN, pero puede estar vacío ( permitido según este consenso ).

Ejemplo:

echo '' | sed -f whatLanguage.sed

En Hexagony, el primero /redirige a la parte inferior izquierda, sigue el lado izquierdo hasta donde comienza la parte sed, luego se envuelve de izquierda a derecha, baja una línea, de derecha a izquierda, baja una línea, y así sucesivamente. El hexágono expandido se ve así:

         / $ / c T h i s p r 
        o g r a m w a s n ' t 
       w r i t t e n i n s e d 
      , i t w a s b u i l t f o 
     r H e x a g o n y ! # . . . 
    > 3 2 ; p ; r ; o ; g ; r ; \
   + / ; a ; w ; 2 3 + ; m ; a < .
  ; . > s ; n ; + 3 9 ; t ; + 3 2 \
 s / ; n ; e ; ; t ; i ; r ; w ; < . 
| . > + 3 2 ; i ; n ; + 3 2 ; H ; e \ 
 ; / 4 + ; y ; n ; o ; g ; a ; x ; < 
  i > 4 ; + 3 2 ; i ; t ; + 3 2 ; \
   ; / u ; b ; 2 3 + ; s ; a ; w <
    h > ; i ; l ; t ; + 3 2 ; f \
     ; / ; s ; 2 3 + ; r ; o ; < 
      T > e ; d ; @ . . . . . .
       . . . . . . . . . . . .
        . . . . . . . . . . .
         . . . . . . . . . .
Riley
fuente
Nunca entenderé Hexagony ...
DJgamer98
@ DJgamer98 Realmente tampoco lo entiendo. Esta es la primera vez que lo uso.
Riley
Puede acortar un poco la Hexagonía haciendo uso del hecho de que ;toma el mod 256 de celda actual para determinar un valor de byte (por ejemplo, puede imprimir un espacio P0;independientemente del valor de celda actual). Este script de CJam genera todos los pares: cjam.tryitonline.net/…
Martin Ender
9

Python / Retina, 133 120 119 117 115 bytes

Ahora que sé más sobre Retina y expresiones regulares, lo he jugado un poco más. También en realidad funciona ahora.

#?.*
print"This program wasn't written in Python, it was built for Retina!"
#?.*t"

#?(\w+)(,.* )(.+)!"
#$3$2$1!
#

Python solo imprime la declaración. Retina reemplaza cualquier cosa con la declaración de impresión de Python, luego elimina las printcomillas y cualquier. Entonces, me cambiaré Pythony Retinay quitar la #.

Probar en Python | Prueba en retina

mbomb007
fuente
@ jimmy23013 Los límites no existían en el momento en que se publicó este desafío. Esa es una característica relativamente nueva de Retina.
mbomb007
8

JavaScript / CoffeeScript, 125 124 bytes

console.log("This program wasn't written in",(a=['Coffee','Java'])[+(b=0=='0')]+"Script, it was built for",a[b^1]+"Script!")

En CoffeeScript, a==bse compila en a===b, lo que hace que la condición intermedia sea falsa. Usé un poco de magia para convertir el valor booleano en un entero.

¡Guardado 1 byte gracias a @DomHastings!

Versión de 125 bytes:

console.log("This program wasn't written in",(a=['Coffee','Java'])[(b=0=='0')+0]+"Script, it was built for",a[b^1]+"Script!")
kirbyfan64sos
fuente
¡Agradable! ¡Creo que puedes guardar un byte en +(b=0=='0')lugar de +0!
Dom Hastings
En lugar de b^1, creo que puedes usar~b
Ismael Miguel
@IsmaelMiguel Nope. Dice que fue construido para undefinedScript.
kirbyfan64sos
Olvidé que ~1 == -2. Pero (b=0=='0')+0se puede escribir como +(b=0=='0'). O b=+(0=='0'). Eso debería cortar 1 byte.
Ismael Miguel
@IsmaelMiguel Ya lo hice en la versión más reciente ...
kirbyfan64sos