Ihre Aufgabe ist es, die Reihenfolge umzukehren, in der einige printsausgeführt werden.

Specs:
Ihr Code wird in dieser Form sein:

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

Sie müssen diese Zeichenfolgen von der vierten bis zur ersten Zeichenfolge print(oder echooder writeoder eine gleichwertige Zeichenfolge) eingeben .

• Sie entscheiden, welche Zeilen Ihres Programms printdie Zeichenfolgen enthalten müssen, aber sie müssen benachbart sein .

• Jede Zeile kann nur eine enthalten printund darf nicht länger als 60 Byte sein .

• Da dies ein Beliebtheitswettbewerb ist , sei kreativ und vermeide es, nur ein gotooder ein einfaches zu schreibenfor(i){if(i=4)print"Line1";if(i=3)...}

• Die am besten bewertete Antwort in 2 Wochen gewinnt dies.

• Ihre Ausgabe MUST seine Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 OR Line4\nLine3\nLine2\nLine1 (wobei \neine Neue - Zeile ist), und es muß nur die erzeugt wird durch die Ausführung printsnach hinten.

Viel Spaß beim Codieren!

UPDATE: Wettbewerb ist vorbei! Danke euch allen :)

Commodore 64 BASIC

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

PHP

Vorrang missbrauchen ... :-)

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

C

Undefiniertes Verhalten ist die aufregendste Art von Verhalten!

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

Die tatsächliche Ausgabe kann je nach Compiler, Linker, Betriebssystem und Prozessor variieren :)

Java

Reflexion verwenden

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

Ausgabe:

Line4
Line3
Line2
Line1

Eine Erklärung, warum dies funktioniert, finden Sie hier .

C (und eine Art Python)

Neue Version mit einem Makro, das perfekt zum Fragenformat passt. Nach dem Kommentar von Quincunx fügte ich hinzu return, um es schöner zu machen.

Es funktioniert auch in Python, wird jedoch in der richtigen Reihenfolge gedruckt.

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

Originalversion - die beiden sind nach Makrosubstitution praktisch gleich:

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

ES6 (im Rückwärtsmodus;)

Wow, es sieht so aus, als ob die Designer von ECMAScript eine unglaubliche Voraussicht hatten, als sie den Rückwärtsmodus zu einem Teil der Spezifikation machten :

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

Ausgabe (Bewertung, wirklich):

"Line4Line3Line2Line1"

Beachten Sie, dass es genau der gewünschten Form entspricht und nur eine geringfügige Rückwärtsbewegung vorliegt, um der Syntax des Modus zu entsprechen . Beachten Sie auch, dass dieser Modus derzeit nur in neueren Versionen von Firefox unterstützt wird .

Letzte Anmerkung: Eigentlich gibt es keinen Rückwärtsmodus. Dies ist jedoch immer noch ein gültiges Skript, das in Firefox ausgeführt wird (kopieren Sie das Ganze). : D

ES6 "lax mode"

BONUS : Hier ist eine aktualisierte Version, die nicht den Rückwärtsmodus verwendet, sondern den neu festgelegten "Lax-Modus", in dem die JS-Engine nur versucht, zu erraten, was der Code tun soll, unabhängig von der Einhaltung der angegebenen JS-Syntax ( im Grunde das Gegenteil von Strict Mode):

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

Bitte beachten Sie, dass " lax mode " derzeit nur in Firefox> = 34 verfügbar ist.; P

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

Rubin

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

Bearbeiten: Alternativ

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

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

Ich weiß, das ist Wahnsinn ...

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;

Haskell

Dies ist beinahe idiomatisch für Haskell, da das Programm jetzt wie eine Komposition von rechts nach links aussieht. Wenn die Funktion nicht print wäre, aber einen (nützlichen) Wert zurückgeben würde, wäre die Operatordeklaration unnötig und der Code wäre etwas, das Sie in Bibliotheken sehen würden.

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

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

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

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}

Siehe jsFiddle .

Bearbeiten:
Um den Regeln besser zu entsprechen, gibt es hier eine Variante in XML, die tatsächlich verwendet wird 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>

wo style.css sein sollte

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

HTML ohne CSS

Und zum Teufel, hier ist eine ohne 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>

Geige .

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

(Lokale Variablen werden in umgekehrter Reihenfolge der Deklaration zerstört.)

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

(Ähnlich, aber mit Lambdas und einem Array-Datenelement.)

Haskell

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

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

C

Der Versuch, den Tipps in der Frage so kreativ wie möglich zu trotzen:

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

BF

Übernimmt die Zellenumhüllung.

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

Warum es funktioniert

Die erste und die letzte Zeile bestehen aus einer Schleife, die sich viermal wiederholt (counter = cell0).

Innerhalb der Schleife gibt es eine Zählervariable ( cell1), die bei jedem Durchlauf erhöht wird.

Jede Zeile prüft, ob eine Verringerung um vier, drei, zwei oder eins gleich Null ist. Daher ist der Zähler beim ersten Durchlauf eins und die letzte Zeile wird ausgeführt, beim zweiten Durchlauf wird die dritte Zeile usw. ausgeführt.

Das (line 1)zeigt, wo Sie den Text machen sollen, der gedruckt wird. Die Pfeile in den Schleifen weisen cell2diesem Zweck zu. Das [-]Gerät wird cell2nach Gebrauch gereinigt.

Bash

In Erinnerung an die verehrten SleepSort und SleepAdd präsentiere ich Ihnen ... SleepReverse :

#!/bin/bash

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

print 1
print 2
print 3
print 4

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

Es ist alles zum richtigen Zeitpunkt ... ;-)

Python 3

import atexit

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

Bash

Hier kommt das doppelseitige Skript:

#!/bin/bash
s=1
if [ $s -ne 0 ]; then tac $0 | bash; exit; fi
s=0
echo "Line1"
echo "Line2"
echo "Line3"
echo "Line4"

Common Lisp № 1

Es ist einfach, ein ngorpMakro zu schreiben , das seine Formulare in umgekehrter Reihenfolge ausführt:

(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

Common Lisp № 2

Hier ist eine, die das Problem sehr wörtlich nimmt; Der Code aus der Frage erscheint im Programm ohne Änderung:

(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

PHP

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

F #

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

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

Soeben wurde ein benutzerdefinierter Operator erstellt, der Funktionen in umgekehrter Reihenfolge ausführt.

Los (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")
}

Probieren Sie es aus: http://play.golang.org/p/fjsJLwOFn2

Python3

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

Kann durch Entfernen aller Leerzeichen in der letzten Zeile um 6 Byte kürzer sein.

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

Stapel

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

C #

Anstatt die Run-Methode direkt aufzurufen, erstelle ich eine dynamische Methode, die eine Kopie des IL-Bytecodes von Run enthält, mit der Ausnahme, dass die Opcode-Operanden der Ladezeichenfolge ausgetauscht werden. Dadurch zeigt die neue Methode die Zeichenfolgen in umgekehrter Reihenfolge an.

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

Python

noch eine andere lösung mit eval()

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

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

es ist nicht sehr komplex, aber leicht zu verstehen.