Ejecutar impresiones al revés

102

Su tarea es invertir el orden en que algunos printsse ejecutan.


Especificaciones:
su código tendrá este formato:

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

Tendrá que print(o echo, o write, o equivalente) esas cadenas del cuarto al primero.

  • Usted decide qué líneas de su programa deben ser printlas cadenas, pero deben ser adyacentes ;

  • Cada línea puede contener solo uno printy no puede exceder los 60 bytes de longitud;

  • Dado que este es , sea creativo y evite escribir solo uno gotoo un simplefor(i){if(i=4)print"Line1";if(i=3)...}

  • La respuesta más votada en 2 semanas gana esta.

  • Su salida DEBE ser Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 OR Line4\nLine3\nLine2\nLine1 (donde \nes una nueva línea), y debe generarse solo ejecutándolas al printsrevés.

¡Feliz codificación!

ACTUALIZACIÓN: ¡El concurso ha terminado! Gracias a todos :)

Vereos
fuente
15
¿Cuenta el árabe? :)
Si puede cumplir con las especificaciones, por supuesto: P
Vereos
Quería aclarar rápidamente una regla ... Cuando dice "Todo lo que puede contener solo una impresión", ¿quiere decir una línea de texto en el archivo de código o una LOC / declaración?
Ruslan
Cada línea de código puede contener solo una impresión
Vereos
¿tiene que pasar una revisión de código, adecuada para el código de producción?
Lance

Respuestas:

183

Commodore 64 BÁSICO

40 print "Line 1"
30 print "Line 2"
20 print "Line 3"
10 print "Line 4"
Danko Durbić
fuente
83
Nunca pude entender por qué se necesitan números de línea, hasta ahora.
ugoren
3
Iba a proponer, copiar ROM de caracteres ($ D000) a RAM ($ 3000), intercambiar mapas de bits de caracteres para "1" <-> "4" y "2" <-> "3", y luego ejecutar el programa en orden hacia adelante . Esto es más lindo.
Mark Lakata
Estoy bastante seguro de que no puede guardar / cargar o enumerar el código en el orden que se muestra con las herramientas estándar (de todos modos, definitivamente no puede hacerlo en Apple II), todo lo que podría hacer sería escribir esas líneas en la consola en ese orden. Y si eso está permitido, ¿podría simplemente usar, por ejemplo, la biblioteca C # SendKeys para escribir el código en cualquiera de los idiomas respondidos en un orden diferente con las teclas de flecha para moverse?
Lance
109

PHP

Abusar de la precedencia ... :-)

!print "Line1\n".
!print "Line2\n".
!print "Line3\n".
!print "Line4\n";
bwoebi
fuente
3
En PHP, printpuede usarse como una expresión, ya que puede estar en perl, cuyo valor de retorno es siempre 1. !1devuelve bool(false), que cuando se escribe como una cadena devuelve la cadena vacía. Una restricción más adecuada para PHP podría ser requerir en echolugar de print; lo anterior realmente es solo una declaración.
primo
1
@ kuldeep.kamboj Simplemente se agrupa de esa manera: print ("Line 1". !print ("Line2". !print ("Line 3". !print "Line4")));- todo lo que está a la derecha de una declaración impresa es parte de ella.
bwoebi
44
Parece que en todas las versiones 3v4l.org/dpSpK parece muy impresionante.
Eisberg
3
Me tomó un tiempo entenderlo (¡Gracias @eisberg por el enlace!), Pero lo entiendo ahora. Si bien el primero printse llama primero, no termina de evaluar lo que necesita imprimir hasta que los interiores (inferiores) printya se hayan llamado y evaluado por completo. Y los !s son solo para ocultar los 1 que se imprimirían de otra manera. ¡Brillante, @bwoebi!
sfarbota
1
@sfarbota Leer las reglas es difícil. Fijo. Gracias :-)
bwoebi
76

C

¡El comportamiento indefinido es el tipo de comportamiento más emocionante!

f(){}
main()
{
   f(printf("Line 1\n"), 
     printf("Line 2\n"), 
     printf("Line 3\n"), 
     printf("Line 4\n"));
}

La salida real puede variar según su compilador, vinculador, sistema operativo y procesador :)

Mella
fuente
22
No tengo ni idea de cómo funciona esto, +1.
svick
77
@svick: para admitir varargs, la mayoría de los compiladores de C colocan argumentos de función en la pila en orden inverso (por lo que el elemento superior en la pila es siempre el primer argumento), lo que significa que es probable que evalúen los argumentos de la misma manera. Por supuesto, esto supone que los argumentos se pasan en la pila, lo que se convierte cada vez menos en el caso de los compiladores más nuevos.
Guntram Blohm
Como dijo @GuntramBlohm, la idea básica es que los parámetros de la función C a menudo (pero no siempre) se insertan en la pila en un orden de derecha a izquierda. Como se trata de llamadas a funciones, las funciones probablemente también se invocan (pero no necesariamente) de derecha a izquierda. Sin embargo, todo esto no está definido por el estándar C, por lo que si bien produce el resultado correcto en GCC 4, depende totalmente del compilador y de la convención de llamada lo que realmente sucede.
Nick
1
@fluffy: Por desgracia, es al revés: C no trata las comas de arglista como puntos de secuencia, a diferencia de otras comas.
Williham Totland
66
@WillihamTotland bueno, entonces sé de algún código que realmente necesito arreglar ... gracias
esponjoso
74

Java

Usando la reflexión

public class ReversePrint {
    public static void main(String[]a) {
        System.out.println("Line1");
        System.out.println("Line2");
        System.out.println("Line3");
        System.out.println("Line4");
    }
    static {
        try{
            Field f=String.class.getDeclaredField("value");
            f.setAccessible(true);
            f.set("Line1","Line4".toCharArray());
            f.set("Line2","Line3".toCharArray());
            f.set("Line3","Line2 ".trim().toCharArray());
            f.set("Line4","Line1 ".trim().toCharArray());
        }catch(Exception e){}
    }
}

Salida:

Line4
Line3
Line2
Line1

Una explicación de por qué esto funciona se puede encontrar aquí .

Danny
fuente
61
Horrible. Me gusta.
Roger Lindsjö
44
+1 La gente siempre dice que las cadenas de Java son inmutables. Usted prueba que no lo son.
Victor Stafusa
16
Esto es deliciosamente desagradable, pero no se cumple el requisito de ejecución inversa.
Thorbjørn Ravn Andersen
44
@ ThorbjørnRavnAndersen shhhh ... se supone que no debes decirles eso. : p
Danny
55
@Victor En Java, las cadenas son inmutables. En todo Stackoverflow, hay preguntas como "Pensé que las cadenas eran inmutables". Usan la reflexión y les hace parecer inmutables. Las promesas de Java funcionan así: "Si usa nuestras cosas / clases de la manera que pretendíamos, entonces prometemos que nuestras afirmaciones son correctas". La reflexión no es la forma en que las clases deben usarse.
Justin
70

C (y una especie de Python)

Nueva versión, utilizando una macro para adaptarse perfectamente al formato de la pregunta. Siguiendo el comentario de Quincunx, agregué returnpara hacerlo más agradable.

También funciona en Python, pero se imprime en el orden correcto.

#define print"\n",printf(
#define return"\n"))));}
#define def main(){0?

def main():
    print "Line 1"
    print "Line 2"
    print "Line 3"
    print "Line 4"
    return

main();

Versión original: los dos son prácticamente iguales, después de la macro sustitución:

main(){
    printf("Line 1\n",
    printf("Line 2\n",
    printf("Line 3\n",
    printf("Line 4\n",
    0))));
}
Ugoren
fuente
1
+1 para la macro. Quizás incluir otro; algo así como #define } 0))));(no sé exactamente cómo funcionan las macros en C). De esa manera, podría tener las declaraciones de impresión en el método principal, nada más.
Justin
@Quincunx, no puedes definir }, pero puedes definir return, lo que ahora hice. Ahora es casi un políglota: la printsintaxis funciona en varios lenguajes de script, a #definemenudo es un comentario, pero main(){..}no funciona en ningún idioma que pueda encontrar.
ugoren
1
@Quincunx, y ahora es realmente un políglota.
ugoren
¿Cómo se definen los dos primeros trabajos sin espacios? ¿Haría printque ser reemplazado por "\n",printf(?
phuclv
@ LưuVĩnhPhúc: el espacio es opcional. Reemplaza como dices.
ugoren
61

ES6 (usando el modo hacia atrás;)

Wow, parece que los diseñadores de ECMAScript tuvieron una previsión increíble cuando hicieron del modo hacia atrás parte de la especificación:

// activate backwards mode:
'use backwardsˈ; \* mode backwards in now *\
code of lines some \
\*code*\ "Line1" print \*code*\
\*code*\ "Line2" print \*code*\
\*code*\ "Line3" print \*code*\
\*code*\ "Line4" print \*code*\
code of lines some \
⁏ˈforwards useˈ // back to ˈnormal'.

// So simple! No need to do anything this complicated:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Salida (evaluación, realmente):

"Line4Line3Line2Line1"

Tenga en cuenta que se trata exactamente de la forma solicitada, con solo un ligero retroceso para ajustarse a la sintaxis del modo . Tenga en cuenta también que este modo solo es compatible con versiones recientes de Firefox en este momento .

Nota final: en realidad, no hay modo hacia atrás. Pero este sigue siendo un script válido que se ejecuta en Firefox (copie todo). :RE


ES6 "modo laxo"

BONIFICACIÓN : Aquí hay una versión actualizada que no usa el modo hacia atrás, pero usa el "modo laxo" recién especificado donde el motor JS solo intentará adivinar qué se supone que debe hacer el código, independientemente de la adherencia a cualquier sintaxis JS especificada ( básicamente la antítesis del modo estricto):

// activate "lax" mode:
`use laxˋ; // also works: ˋuse relaxˋ, ˋuse guessingˋ, ˋuse whatevsˋ, etc.
//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code
ˋuse normalˋ; // same as ˋuse default`.

// Again, compare to inferior, illegible "traditional" ES6:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Tenga en cuenta que el " modo laxo " actualmente solo está disponible en Firefox> = 34.; P

No yo
fuente
77
Los 3 enlaces que publicaste conducen a 404. ¿Es este tipo de broma?
manatwork
8
Ah Ya lo veo. El resaltador de sintaxis fue tu cómplice aquí.
manatwork
12
Este es un concurso de popularidad combinado y trolling de código , ¿no? :) Me encanta.
No es que Charles
8
Este es un abuso fenomenal de Javascript. Me gusta.
Seiyria
2
Furtivo. Taaaan astuto ....
David Conrad
59

C

main()
{
  int i = 0;
  for(; i == 0; printf("Line 1\n"))
    for(; i == 0; printf("Line 2\n"))
      for(; i == 0; printf("Line 3\n"))
        for(; i == 0; printf("Line 4\n"))
          i = 1;
}
David Yaw
fuente
56

Rubí

print 'Line1' unless
print 'Line2' unless
print 'Line3' unless
print 'Line4'

Editar: Alternativamente,

def method_missing(meth,*)
  puts meth.to_s.sub('print'){}
end

printLine1(
printLine2(
printLine3(
printLine4)))
histocrat
fuente
38
Prefiero esto porque tiene metanfetamina
Ray
2
¿No publicaría normalmente dos respuestas si tuviera dos soluciones?
TheConstructor
3
¿No se vería más ruby-ish con bloques de código? pastebin.com/LDWpxKx8
manatwork
2
@PacMani esos padres no usan espacios en blanco, usan espacios en blanco.
corsiKa
@manatwork agradable! Sin method_missingembargo, creo que es bastante Ruby-ish.
histocrat
49

PHP

Lo sé, esto es una locura ...

goto d;
a: print "Line1\n"; goto end;
b: print "Line2\n"; goto a;
c: print "Line3\n"; goto b;
d: print "Line4\n"; goto c;
end: exit;
Florent
fuente
66
Ese ruido que escuchas es Dijkstra girando en su tumba. :-)
Gareth
24
Pensé que alguien dijo "sé creativo y evita escribir solo un goto" ;-)
TheConstructor
22
@TheConstructor La parte creativa está usando goto en PHP ;)
NikiC
1
Tan lleno de victoria.
Nick T
41

Haskell

Esto es casi idiomático Haskell, ya que el programa ahora parece una composición de función de derecha a izquierda. Si la función no se imprimiera, pero algo que devolvería un valor (útil), la declaración del operador sería innecesaria y el código sería algo que vería en las bibliotecas.

a << b = (const a =<< b)

main = putStrLn "Line1"
    << putStrLn "Line2"
    << putStrLn "Line3"
    << putStrLn "Line4"
shiona
fuente
55
consejo:(<<) = flip (>>)
Bergi
@ Bergi Esa es otra forma de escribirlo, supongo que incluso un poco más elegante. De hecho, me sorprendió un poco ver que la cosa no estaba definida en el preludio (o Control.Monad)
shiona
@shiona: Sí, es algo sorprendente perderse. Afortunadamente, tenemos ambos operadores para Solicitantes: <*y *>.
Tikhon Jelvis
@TikhonJelvis en realidad, el <*operador aplicativo es diferente a esto <<: a <* bes equivalente a do x<-a;b;return x, es decir, ejecuta ael efecto primero
orgulloso haskeller
40

Perl

use threads;

$a=threads->create(sub {sleep(5); print("Line1\n");});
$b=threads->create(sub {sleep(4); print("Line2\n");});
$c=threads->create(sub {sleep(3); print("Line3\n");});
$d=threads->create(sub {sleep(2); print("Line4\n");});

$a->join();
$b->join();
$c->join();
$d->join();
Gareth
fuente
22
En teoría, esto no está garantizado para imprimir en el orden inverso exacto.
Cruncher
44
@Cruncher, lo sé, pero con brechas de 1 segundo, las posibilidades de que se imprima en otra cosa que no sea el orden inverso son bastante escasas.
Gareth
3
@Gareth Por eso escribí en cursiva teóricamente :)
Cruncher
3
@Cruncher ¿No es eso lo que lo hace tan divertido?
Pierre Arlaud
¿@Cruncher de la misma manera que teóricamente mis átomos podrían atravesar una pared?
cdeange
37

HTML + CSS

<p>Line 1</p>
<p>Line 2</p>
<p>Line 3</p>
<p>Line 4</p>

CSS:

body {margin-top:7em}
p + p {margin-top:-4em}

Ver jsFiddle .

Editar:
para ajustarse mejor a las reglas, aquí hay una variante en XML que realmente utiliza print.

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="style.css"?>
<root>
  <print>Line 1</print>
  <print>Line 2</print>
  <print>Line 3</print>
  <print>Line 4</print>
</root>

donde style.css debería estar

* {display:block; margin-top:3em}
print + print {margin-top:-3em}

HTML sin CSS

Y para el gusto, aquí hay uno sin CSS.

<table>
<tfoot><tr><td><table><tfoot><tr><td>Line 1</tr></tfoot>
<tbody><tr><td>                      Line 2</table></tfoot>
<tbody><tr><td><table><tfoot><tr><td>Line 3</tr></tfoot>
<tbody><tr><td>                      Line 4</table></tbody>
</table>

Violín .

Señor lister
fuente
2
¿Alguien puede explicar el voto negativo? Esto funciona al imprimir, ya sabes.
Sr. Lister
También puedes hacerlop {float:right;}
Noyo,
¡Pero entonces los resultados estarán en una sola línea!
Sr. Lister
... y eso está permitido. :]
Noyo
1
... y eso no está prohibido. : D También podría envolverlo en un div y agregar la regla CSS div {float:left}.
Noyo
23

C ++

#include <iostream>
#define Q(x,y) x ## y
#define P(x,y) Q(x, y)
#define print S P(s, __LINE__) =
struct S { const char *s; S(const char *s): s(s) {} ~S() { std::cout << s << std::endl; } };
int main() {
    print "Line1";
    print "Line2";
    print "Line3";
    print "Line4";
}

(Las variables locales se destruyen en orden inverso a la declaración).

C ++ 11

#include <iostream>
int main() {
    struct S { void (*f)(); S(void (*f)()): f(f) {} ~S() { f(); } } s[] = {
        {[](){ std::cout << "Line1" << std::endl; }},
        {[](){ std::cout << "Line2" << std::endl; }},
        {[](){ std::cout << "Line3" << std::endl; }},
        {[](){ std::cout << "Line4" << std::endl; }},
    };
}

(Casi lo mismo, pero usando lambdas y un miembro de datos de matriz en su lugar).

ecatmur
fuente
Publiqué una solución usando std::function, y estaba tratando de deshacerme de ella. ¡Ahora no necesito porque lo tienes!
sergiol
21

Haskell

main = sequence_ $ reverse [
    putStr "Line1",
    putStr "Line2",
    putStr "Line3",
    putStr "Line4"]
mniip
fuente
21

Javascript

setTimeout(function(){console.log("Line 1");},900);
setTimeout(function(){console.log("Line 2");},800);
setTimeout(function(){console.log("Line 3");},700);
setTimeout(function(){console.log("Line 4");},600);
JoshWillik
fuente
Usar 1,2,3,4como tiempos de espera también funciona para mí. (Sin embargo, no sé si este comportamiento está estandarizado en ECMAScript.)
ComFreek
1
@ComFreek: setTimeoutestá estandarizado en HTML5 / temporizadores, no en ES. Además, especifica un tiempo de espera mínimo de 4 ms :-)
Bergi
1
@ Bergi Sí, tienes razón, por supuesto! Estándar HTML - Temporizadores - si alguien está interesado.
ComFreek
1
Ejecute esto en una máquina lo suficientemente lenta (por ejemplo, ¿un 8086 que ejecuta varias otras aplicaciones?) Y fallará. (Por falla, quiero decir que el orden no se revertirá, ya que tomará> = 100 ms para ejecutar cada declaración.
Jeff Davis
1
@ lastr2d2 Simular una computadora lenta con bucles while es bastante subjetivo, pero creo que esto sería más parecido: jsfiddle.net/7zbKw/1 . Nota de whatwg.org/specs/web-apps/current-work/multipage/… "Esta API no garantiza que los temporizadores se ejecuten exactamente a tiempo. Se esperan demoras debido a la carga de la CPU, otras tareas, etc."
Jeff Davis
20

C

Tratando de hacer que los consejos de la pregunta sean lo más creativos posible:

#include <stdio.h>
#define print if (i == __LINE__) puts
static unsigned i;
int main(void) {
  while (--i) {
    print("Line 1");
    print("Line 2");
    print("Line 3");
    print("Line 4");
  }
  return 0;
}
hvd
fuente
3
Buen
15

BF

Asume envoltura celular.

++++[->+
----[> (line 1) .[-]<]++++
---[> (line 2) .[-]<]+++
--[> (line 3) .[-]<]++
-[> (line 4) .[-]<]+
<]

Por que funciona

La primera y la última línea se componen de un bucle que se repite cuatro veces (contador = cell0).

Dentro del bucle, hay una variable de contador ( cell1) que se incrementa en cada ejecución.

Cada línea verifica si disminuir en cuatro, tres, dos o uno es igual a cero. Por lo tanto, en la primera ejecución, el contador es uno y se ejecuta la última línea, en la segunda ejecución, se ejecuta la tercera línea, etc.

La (line 1)muestra dónde debe hacer el texto que se imprime. Las flechas en los bucles se asignan cell2para este propósito. Se [-]limpia cell2después de usarlo.

Timtech
fuente
14

Golpetazo

En memoria del venerado SleepSort y SleepAdd , te presento ... SleepReverse :

#!/bin/bash

function print(){(sleep $((4-$1));echo "Line $1";)&}

print 1
print 2
print 3
print 4
Alboroto
fuente
Para que se parezca más a las especificaciones, use $1y $2: function print(){(sleep $((4-$2));echo "$1 $2";)&}; print Line 1
ThinkChaos
13

Java

import java.io.PrintStream;
import java.util.concurrent.FutureTask;

public class Print {
  public static void main(String[] args) {
    new FutureTask<PrintStream>(new Runnable() {
      public void run() {
        new FutureTask<PrintStream>(new Runnable() {
          public void run() {
            new FutureTask<PrintStream>(new Runnable() {
              public void run() {
                System.out.append("Line1"); }
            }, System.out.append("Line2")).run(); }
        }, System.out.append("Line3")).run(); }
    }, System.out.append("Line4")).run();
  }
}

Todo está en el momento adecuado ... ;-)

El constructor
fuente
Las líneas tienen que ser adyacentes.
Timtech
No son menos adyacentes que, por ejemplo, con codegolf.stackexchange.com/a/20660/16293 nadie dijo que deberían tener el mismo aspecto. Eliminará algunos caracteres de nueva línea ;-)
TheConstructor
Bien, genial :-)
Timtech
12

Python 3

import atexit

atexit.register(print,"Line1")
atexit.register(print,"Line2")
atexit.register(print,"Line3")
atexit.register(print,"Line4")
Mark Plotnick
fuente
12

Golpetazo

Aquí viene el guión de doble cara:

#!/bin/bash
s=1
if [ $s -ne 0 ]; then tac $0 | bash; exit; fi
s=0
echo "Line1"
echo "Line2"
echo "Line3"
echo "Line4"
Matteo Italia
fuente
2
¡Nunca supe que tacexistía! Jaja gracias.
Noyo
11

Lisp común № 1

Es fácil escribir una ngorpmacro que ejecute sus formularios en orden inverso:

(macrolet ((ngorp (&body ydob) `(progn ,@(reverse ydob))))
  (ngorp
   (write-line "Line 1")
   (write-line "Line 2")
   (write-line "Line 3")
   (write-line "Line 4")))
Line 4
Line 3
Line 2
Line 1

Lisp común № 2

Aquí hay uno que toma el problema muy literalmente; El código de la pregunta aparece en el programa sin modificación:

(macrolet ((execute-prints-backwards (&body body)
             `(progn 
                ,@(nreverse (mapcar (lambda (string)
                                      (list 'write-line string))
                                    (remove-if-not 'stringp body))))))
  (execute-prints-backwards

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

  ))
Line4
Line3
Line2
Line1
Joshua Taylor
fuente
10

PHP

Otra evalvariante:

$lines=array_slice(file(__FILE__),-4); // get last 4 lines of current file
eval(implode('',array_reverse($lines)));exit; // eval lines reversed and exit
print "Line1\n";
print "Line2\n";
print "Line3\n";
print "Line4\n";
Dabbler decente
fuente
1
¡Mancha! Sin embargo, me siento obligado a señalar que esta es una muy mala idea.
David Kryzaniak
9

F#

let inline (?) f g x = g x; f x

(printfn "Line1%s") ?
 (printfn "Line2%s") ?
  (printfn "Line3%s") ?
   (printfn "Line4%s") ""

Acabo de crear un operador personalizado que ejecuta funciones en orden inverso.

pswg
fuente
3
Estoy bastante seguro (?) F (g (x)) = g (x); f (x) es cálculo y no programación.
Jeff Davis
2
@JeffDavis: Bastante seguro se (?) f g xlee más o menos como (?)(f, g, x), nof(g(x))
Eric
9

Go (Golang)

package main

import "fmt"

func main() {
    defer fmt.Println("Line 1")
    defer fmt.Println("Line 2")
    defer fmt.Println("Line 3")
    defer fmt.Println("Line 4")
}

Pruébelo: http://play.golang.org/p/fjsJLwOFn2

cory.todd
fuente
Quería publicar exactamente el mismo código. Literalmente, byte por byte exactamente igual.
Arte
@Art, ¡genial! Espero ver más Go usado en Code Golf.
cory.todd
Probablemente no sucederá. Ir no es realmente bueno ser comprimido, limitan deliberadamente construcciones extrañas para que no puedas crear un lío ilegible. Pero en este caso (y tal vez otros concursos de popularidad) tiene una posibilidad.
Arte
8

Python3

print("Line1",
print("Line2",
print("Line3",
print("Line4") or '') or '') or '')

Puede ser 6 bytes más corto al eliminar todos los espacios en la última línea.

aragaer
fuente
7

Javascript

[
  "console.log('Line1')",
  "console.log('Line2')",
  "console.log('Line3')",
  "console.log('Line4')"
].reverse().forEach(function(e){eval(e)})

C ++ 11

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::function<void()>> functors;
    functors.push_back([] { std::cout << "Line1"; });
    functors.push_back([] { std::cout << "Line2"; });
    functors.push_back([] { std::cout << "Line3"; });
    functors.push_back([] { std::cout << "Line4"; });
    std::reverse(functors.begin(),functors.end());
    std::for_each (functors.begin(), functors.end(), [](std::function<void()> f) {f();});
    return 0;
}
Michael M.
fuente
En lugar del std::reversey std::for_each, simplemente usewhile (! functors.empty()) { functors.back()(); functors.pop_back(); }
David Hammen
7

Lote

echo off

call :revers ^
echo.line1 ^
echo.line2 ^
echo.line3 ^
echo.line4

:revers
if not "%2"=="" call :revers %2 %3 %4 %5 %6 %7 %8 %9
%1
hmilch
fuente
Bienvenido a codegolf! Buen post.
Cruncher
7

C#

En lugar de llamar directamente al método Run, estoy creando un método dinámico que contiene una copia del código de bytes IL de Run, excepto que los operandos de código de operación de cadena de carga se intercambian. Lo que hace que el nuevo método muestre las cadenas en orden inverso.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace TestApp
{
    class Program
    {
        public static void Run()
        {
            Console.WriteLine("Line 1");
            Console.WriteLine("Line 2");
            Console.WriteLine("Line 3");
            Console.WriteLine("Line 4");
        }


        static void Main(string[] args)
        {
            var method = typeof(Program).GetMethod("Run");
            var il = method.GetMethodBody().GetILAsByteArray();
            var loadStringOperands = new Stack<int>();
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    loadStringOperands.Push(BitConverter.ToInt32(il, i + 1));
                    i += 4;
                }
            }

            var run = new DynamicMethod("Run", typeof(void), null);
            var gen = run.GetILGenerator(il.Length);
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    var str = method.Module.ResolveString(loadStringOperands.Pop());
                    gen.Emit(OpCodes.Ldstr, str);
                    i += 4;
                }
                else if (il[i] == OpCodes.Call.Value)
                {
                    var mInfo = method.Module.ResolveMethod(BitConverter.ToInt32(il, i + 1)) as MethodInfo;
                    gen.Emit(OpCodes.Call, mInfo);
                    i += 4;
                }
                else if (il[i] == OpCodes.Ret.Value)
                {
                    gen.Emit(OpCodes.Ret);
                }
            }

            run.Invoke(null, null);
        }
    }
}
Pieter Witvoet
fuente
6

Pitón

otra solución más usando eval()

a = [
"print('Line1')",
"print('Line2')",
"print('Line3')",
"print('Line4')"]

for line in reversed(a):
    eval(line)

No es muy complejo, pero fácil de entender.

davidak
fuente
2
el único código que entiendo: D
moldovean