Executar impressões ao contrário


102

Sua tarefa é reverter a ordem em que alguns printssão executados.


Especificações:
seu código estará neste 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

Você terá que print(ou echo, ou writeou equivalente) as cadeias de caracteres do quarto ao primeiro.

  • Você decide quais linhas do seu programa devem ser printas strings, mas elas devem ser adjacentes ;

  • Cada linha pode conter apenas um printe não pode exceder 60 bytes de comprimento;

  • Como esse é , seja criativo e evite escrever apenas um gotoou umfor(i){if(i=4)print"Line1";if(i=3)...}

  • A resposta mais votada em duas semanas ganha isso.

  • Sua saída deve ser Line4 Line3 Line2 Line1 OU Line4Line3Line2Line1 OU Line4\nLine3\nLine2\nLine1 (onde \né uma nova linha), e deve ser gerada apenas por executar aqueles printspara trás.

Feliz codificação!

UPDATE: O concurso acabou! Obrigado a todos :)


15
O árabe conta? :)

Se você é capaz de atender às especificações, é claro: P
Vereos

Queria esclarecer rapidamente uma regra ... Quando você diz "Todos os gostos podem conter apenas uma impressão", você quer dizer uma linha de texto no arquivo de código ou uma instrução LOC /?
Ruslan

Cada linha de código pode conter apenas um print
Vereos

ele precisa passar por uma revisão de código - adequado para o código de produção?
Lance

Respostas:


183

Commodore 64 BASIC

40 print "Line 1"
30 print "Line 2"
20 print "Line 3"
10 print "Line 4"

83
Eu nunca consegui entender por que os números de linha são necessários, até agora.
ugoren

3
Eu ia propor, copiar ROM de caracteres ($ D000) para RAM ($ 3000), trocar bitmaps de caracteres por "1" <-> "4" e "2" <-> "3" e, em seguida, executar o programa em ordem progressiva . Isso é mais bonito.
MarkLakata

Tenho certeza de que você não pode realmente salvar / carregar ou listar o código na ordem mostrada usando as ferramentas padrão (definitivamente não pode no Apple II de qualquer maneira), tudo que você poderia fazer seria digitar essas linhas no console naquela ordem. E se isso for permitido, você não pode simplesmente usar, por exemplo, a biblioteca C # SendKeys para digitar o código em qualquer um dos idiomas respondidos em uma ordem diferente, com as teclas de seta para mover-se.
Lance

109

PHP

Abuso de precedência ... :-)

!print "Line1\n".
!print "Line2\n".
!print "Line3\n".
!print "Line4\n";

3
Em PHP, printpode ser usado como uma expressão, como em perl, cujo valor de retorno é sempre 1. !1retorna bool(false), que quando digitado como uma string retorna a string vazia. Uma restrição mais apropriada para o PHP pode ser exigir echoe não print; o acima é realmente apenas uma afirmação.
primo

1
@ kuldeep.kamboj É apenas agrupado dessa maneira: print ("Line 1". !print ("Line2". !print ("Line 3". !print "Line4")));- tudo o que está à direita de uma declaração impressa faz parte dela.
22414 bwoebi

4
Parece funcionar em todas as versões 3v4l.org/dpSpK muito impressionante!
Eisberg

3
Demorei um pouco para entender (Obrigado @eisberg pelo link!), Mas entendi agora. Enquanto o primeiro printé chamado primeiro, ele não termina de avaliar o que precisa imprimir até que o interior (inferior) printjá tenha sido chamado e avaliado completamente. E os !são apenas para ocultar os 1s que seriam impressos de outra forma. Brilhante, @bwoebi!
sfarbota

1
@sfarbota As regras de leitura são difíceis. Fixo. Obrigado :-)
bwoebi

76

C

Comportamento indefinido é o tipo de comportamento mais emocionante!

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

A saída real pode variar dependendo do compilador, vinculador, sistema operacional e processador :)


22
Não tenho absolutamente nenhuma idéia de como isso funciona, +1.
svick 12/02

7
@svick: para suportar varargs, a maioria dos compiladores C coloca argumentos de função na pilha na ordem inversa (para que o item superior na pilha seja sempre o 1º argumento), o que significa que é provável que eles avaliem os argumentos da mesma maneira. Obviamente, isso pressupõe que os argumentos sejam passados ​​na pilha, o que se torna cada vez menor nos compiladores mais novos.
Guntram Blohm

Como o @GuntramBlohm disse, a idéia básica é que os parâmetros da função C são frequentemente (mas nem sempre) empurrados para a pilha na ordem da direita para a esquerda. Como essas são chamadas de função, as funções provavelmente são (mas não necessariamente) chamadas da direita para a esquerda. No entanto, tudo isso não é definido pelo padrão C, portanto, embora ele produza o resultado certo no GCC 4, depende totalmente do compilador e da convenção de chamada o que realmente acontece.
13134 Nick

1
@ macio: Infelizmente, é o contrário: C não trata vírgulas arglist como pontos de sequência, ao contrário de outras vírgulas.
Williham Totland

6
@WillihamTotland bem, então eu sei de algum código que eu realmente precisa corrigir ... obrigado
fofo

74

Java

Usando reflexão

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

Resultado:

Line4
Line3
Line2
Line1

Uma explicação de por que isso funciona pode ser encontrada aqui .


61
Horrível. Eu gosto disso.
Roger Lindsjö 12/02/2014

4
As pessoas sempre dizem que as strings java são imutáveis. Você prova que eles não são.
Victor Stafusa

16
Isso é deliciosamente desagradável, mas o requisito de execução reversa não é atendido.
Thorbjørn Ravn Andersen

4
@ ThorbjørnRavnAndersen shhhh ... você não deveria dizer isso a eles. : p
Danny

5
@ Victor Em Java, Strings são imutáveis. Em todo o Stackoverflow, há perguntas como "Eu pensei que as strings eram imutáveis". Eles usam reflexão e isso os faz parecer imutáveis. As promessas de Java funcionam assim: "Se você usar nossas coisas / classes da maneira que pretendíamos, prometemos que nossas afirmações estão corretas". Reflexão não é a maneira como as classes se destinam a usar.
Justin

70

C (e tipo de Python)

Nova versão, usando uma macro para ajustar-se perfeitamente ao formato da pergunta. Após o comentário de Quincunx, adicionei returnpara torná-lo melhor.

Também funciona em Python, mas é impresso na ordem correta.

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

Versão original - os dois são praticamente os mesmos, após a substituição da macro:

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

1
+1 para a macro. Talvez inclua outro; algo como #define } 0))));(não sei exatamente como as macros funcionam em C). Dessa forma, você poderia apenas ter as instruções de impressão no método principal, nada mais.
Justin

@ Quincunx, você não pode definir }, mas você pode definir return, o que eu fiz agora. Agora é quase um poliglota - a printsintaxe funciona em várias linguagens de script, #definegeralmente é um comentário, mas main(){..}não funciona em nenhum idioma que eu pudesse encontrar.
ugoren

1
@ Quincunx, e agora é realmente um poliglota.
ugoren

como os dois primeiros definem trabalho sem espaços? Seria printsubstituído por "\n",printf(?
phuclv

@ LưuVĩnhPhúc - O espaço é opcional. Ele substitui como você diz.
Ugoren

61

ES6 (usando o modo reverso;)

Uau, parece que os designers do ECMAScript tiveram uma previsão incrível quando fizeram do modo reverso parte das especificações:

// 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,'')

Resultado (avaliação, na verdade):

"Line4Line3Line2Line1"

Observe que é exatamente da forma solicitada, com apenas uma pequena retro-justificação para ajustar a sintaxe do modo . Observe também que esse modo é suportado apenas nas versões recentes do Firefox no momento .

Nota final: Na verdade, não há modo inverso. Mas esse ainda é um script válido que roda no Firefox (copie a coisa toda). : D


ES6 "modo relaxado"

BÔNUS : Aqui está uma versão atualizada que não usa o modo reverso, mas usa o "modo lax" recém-especificado, em que o mecanismo JS apenas tenta adivinhar o que o código deve fazer, independentemente da adesão a qualquer sintaxe JS especificada ( basicamente a antítese do modo estrito):

// 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,'')

Observe que o " modo lax " atualmente está disponível apenas no Firefox> = 34.; P


7
Todos os 3 links que você postou estão levando ao 404. É esse tipo de piada?
manatwork

8
Ah Eu vejo agora. O marcador de sintaxe foi seu cúmplice aqui.
manatwork

12
Este é um concurso de popularidade combinado e trollagem de código , não? :) Eu amo isso.
Não que Charles

8
Este é um abuso fenomenal de Javascript. Eu gosto disso.
Seiyria

2
Sorrateiro. MUUUUITO sorrateira ....
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

Rubi

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

Editar: Como alternativa,

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

printLine1(
printLine2(
printLine3(
printLine4)))

38
Eu prefiro este porque tem meth
Ray

2
Você normalmente não postaria duas respostas se tivesse duas soluções?
TheConstructor

3
Isso não ficaria mais parecido rubycom os blocos de código? pastebin.com/LDWpxKx8
manatwork

2
@PacMani esses parênteses não usam espaço em branco, eles usam espaço em branco.
CorsiKa

@manatwork nice one! Eu acho que method_missingé bastante Ruby-ish, no entanto.
histocrat 12/02

49

PHP

Eu sei, isso é loucura ...

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
Esse barulho que você ouve é Dijkstra girando em seu túmulo. :-)
Gareth

24
Pensei que alguém disse "ser criativo e evitar a escrever apenas um goto" ;-)
TheConstructor

22
@TheConstructor A parte criativa é usando Goto em PHP ;)
Nikić

1
Tão cheio de vitórias.
Nick T

41

Haskell

Isso é quase idiomático do Haskell, já que o programa agora parece uma composição de funções da direita para a esquerda. Se a função não fosse impressa, mas algo que retornasse um valor (útil), a declaração do operador seria desnecessária e o código seria algo que você veria nas bibliotecas.

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

main = putStrLn "Line1"
    << putStrLn "Line2"
    << putStrLn "Line3"
    << putStrLn "Line4"

5
Dica:(<<) = flip (>>)
Bergi 12/02

@ Bergi Essa é outra maneira de escrever, acho que é um pouco mais elegante. Eu estava realmente um pouco surpreso ao ver a coisa não foi definido no prelúdio (ou Control.Monad)
Shiona

@ shiona: Sim, é uma coisa surpreendente de se perder. Felizmente, temos os dois operadores de candidatos: <*e *>.
Tikhon Jelvis

@TikhonJelvis, na verdade, o <*operador do aplicativo é diferente disso <<: a <* bé equivalente a do x<-a;b;return x, ou seja, ele executa ao efeito primeiro
orgulhoso haskeller de

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
Isto é , teoricamente, não é garantido para imprimir em ordem inversa exato.
Cruncher

4
@ Cruncher eu sei, mas com intervalos de 1 segundo, as chances de impressão em algo que não seja a ordem inversa são muito pequenas.
Gareth

3
@Gareth É por isso que em itálico teoricamente :)
Cruncher

3
@Cruncher Não é isso que o torna tão divertido?
Pierre Arlaud 17/02

@ Cruncher da mesma maneira que teoricamente meus átomos poderiam atravessar uma parede?
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}

Veja jsFiddle .

Editar:
Para se adequar melhor às regras, aqui está uma variante do XML que realmente usa 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>

onde style.css deve estar

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

HTML sem CSS

E para o que interessa, aqui está um sem 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>

Violino .


2
Alguém pode explicar o voto negativo? Isso funciona durante a impressão, você sabe.
Sr. Lister

Você também pode fazerp {float:right;}
Noyo

Mas todos os resultados estarão em uma linha!
Sr. Lister

... e isso é permitido. :]
Noyo 14/02

1
... e isso não é permitido. : D Você também pode agrupá-lo em uma div e adicionar a regra 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";
}

(Variáveis ​​locais são destruídas na ordem inversa da declaração.)

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

(Muito parecido, mas usando lambdas e um membro de dados da matriz.)


Postei uma solução usando std::functione estava tentando me livrar dela. Agora eu não preciso porque você entendeu!
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 timeouts também funciona para mim. (No entanto, eu não sei se esse comportamento é padronizado em ECMAScript.)
ComFreek

1
@ComFreek: setTimeouté padronizado em HTML5 / timers, não em ES. Além disso, ele especifica um tempo limite mínimo de 4ms :-)
Bergi

1
@ Bergi Sim, você está certo, é claro! Padrão HTML - Temporizadores - se alguém estiver interessado.
ComFreek 12/02

1
Execute isso em uma máquina lenta o suficiente (por exemplo, um 8086 executando vários outros aplicativos?) E ele falhará. (Por falhar, eu quero dizer a ordem não será revertida, uma vez que levará> = 100ms para executar cada instrução.
Jeff Davis

1
@ lastr2d2 Simular um computador lento com loops while é bastante subjetivo, mas acho que seria mais assim: jsfiddle.net/7zbKw/1 . Nota de whatwg.org/specs/web-apps/current-work/multipage/… "Esta API não garante que os cronômetros sejam executados exatamente dentro do cronograma. Devem ser esperados atrasos devido à carga da CPU, outras tarefas etc.".
21414 Jeff Jeff Davis

20

C

Tentando desafiar as dicas da pergunta da maneira mais criativa possível:

#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
bom abuso de um #define: P +1
masterX244

15

BF

Supõe quebra de célula.

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

Por que funciona

A primeira e a última linha compõem um loop que se repete quatro vezes (contador = cell0).

Dentro do loop, há uma variável de contador ( cell1) que é aumentada a cada execução.

Cada linha verifica se a redução em quatro, três, dois ou um é igual a zero. Portanto, na primeira execução, o contador é um e a última linha é executada, na segunda execução, a terceira linha é executada etc.

Os (line 1)shows onde você deve fazer o texto impresso. As setas nos loops são alocadas cell2para esse fim. A [-]limpeza cell2depois de você usá-lo.


14

Bater

Em memória do reverenciado SleepSort e SleepAdd , apresento a você ... SleepReverse :

#!/bin/bash

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

print 1
print 2
print 3
print 4

Para que ele se pareça mais com as especificações, use $1e $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();
  }
}

Está tudo no momento certo ... ;-)


As linhas devem ser adjacentes.
Timtech 12/02

Eles não são menos adjacentes do que, por exemplo, com codegolf.stackexchange.com/a/20660/16293 ninguém disse que deveria ter a mesma aparência.
Removerá

Ok, ótimo :-)
Timtech 12/02/14

12

Python 3

import atexit

atexit.register(print,"Line1")
atexit.register(print,"Line2")
atexit.register(print,"Line3")
atexit.register(print,"Line4")

12

Bater

Aí vem o script de dupla face:

#!/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
Eu nem sabia que tacexistia! Haha, obrigada.
Noyo

11

Lisp comum № 1

É fácil escrever uma ngorpmacro que executa seus formulários na ordem inversa:

(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 comum № 2

Aqui está um que leva o problema muito literalmente; o código da pergunta aparece no programa sem modificação:

(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

Outra 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
Liso! No entanto, sinto-me compelido a salientar que é uma péssima ideia.
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") ""

Acabou de criar um operador personalizado que executa funções na ordem inversa.


3
Tenho certeza de que (?) F (g (x)) = g (x); f (x) é cálculo e não programação.
22414 Jeff Jeff

2
@JeffDavis: Com certeza, (?) f g xlê- se aproximadamente como (?)(f, g, x), nãof(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")
}

Experimente: http://play.golang.org/p/fjsJLwOFn2


Eu queria postar exatamente o mesmo código. Literalmente, byte por byte exatamente o mesmo.
Art

@Art, incrível! Espero ver mais Go usado no Code Golf.
cory.todd

Provavelmente não vai acontecer. Ir não é realmente bom ser compactado, eles deliberadamente limitam construções estranhas para que você não possa criar uma bagunça ilegível. Mas, neste caso (e talvez em outros concursos de popularidade), há uma chance.
Art

8

Python3

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

Pode ser 6 bytes mais curto removendo todos os espaços na última linha.


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

Em vez de a std::reversee std::for_each, simplesmente usarwhile (! 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

Bem-vindo ao codegolf! Bela postagem.
Cruncher

7

C #

Em vez de chamar diretamente o método Run, estou criando um método dinâmico que contém uma cópia do bytecode IL da Run, exceto que os operandos opcode da string de carregamento são trocados. O que faz com que o novo método exiba as seqüências de caracteres na ordem inversa.

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ão

ainda outra solução usando eval()

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

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

não é muito complexo, mas fácil de entender.


2
o único código que eu entendo: D
moldovean 13/02/14
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.