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


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"

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

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


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


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

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


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

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

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;

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"

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

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 .


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


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

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

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

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.


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

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


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

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"

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

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

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.


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


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.


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

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

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

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.


2
el único código que entiendo: D
moldovean
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.