Twoim zadaniem jest odwrócenie kolejności printswykonywania niektórych .

Specyfikacja:
Twój kod będzie w tej formie:

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

Będziesz musiał print(lub echo, lub writerównoważny) te ciągi znaków od czwartego do pierwszego.

• Ty decydujesz, które wiersze twojego programu muszą printbyć łańcuchami, ale muszą być one przyległe ;

• Każda linia może zawierać tylko jeden printi nie może przekraczać 60 bajtów ;

• Ponieważ jest to konkurs popularności , bądź kreatywny i unikaj pisania gotoprostych lub prostych rzeczyfor(i){if(i=4)print"Line1";if(i=3)...}

• Wygrywa to najbardziej pozytywna odpowiedź za 2 tygodnie.

• Twój wynik MUSI być Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 LUB Line4\nLine3\nLine2\nLine1 (gdzie \njest nowy wiersz) i musi być wygenerowany tylko przez wykonanie go printswstecz.

Miłego kodowania!

AKTUALIZACJA: Konkurs się zakończył! Dziękuję wam wszystkim :)

Commodore 64 BASIC

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

PHP

Nadużywanie pierwszeństwa ... :-)

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

do

Nieokreślone zachowanie jest najbardziej ekscytującym rodzajem zachowania!

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

Rzeczywista wydajność może się różnić w zależności od kompilatora, konsolidatora, systemu operacyjnego i procesora :)

Jawa

Korzystanie z odbicia

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

Wynik:

Line4
Line3
Line2
Line1

Wyjaśnienie, dlaczego to działa, można znaleźć tutaj .

C (i sortowanie Pythona)

Nowa wersja, wykorzystująca makro idealnie pasujące do formatu pytania. Po komentarzu Quincunx dodałem, returnżeby było ładniej.

Działa również w Pythonie, ale drukuje we właściwej kolejności.

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

Wersja oryginalna - obie są praktycznie takie same, po zastąpieniu makra:

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

ES6 (przy użyciu trybu wstecz;)

Wow, wygląda na to, że projektanci ECMAScript mieli niesamowitą dalekowzroczność, kiedy włączyli tryb wsteczny do specyfikacji:

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

Wynik (ocena, naprawdę):

"Line4Line3Line2Line1"

Zauważ, że jest to dokładnie żądana forma, z jedynie niewielkim wstecznym dopasowaniem, aby dopasować składnię trybu . Należy również zauważyć, że tryb ten jest obsługiwany tylko w nowszych wersjach Firefoksa w tej chwili .

Uwaga końcowa: w rzeczywistości nie ma trybu wstecznego. Ale nadal jest to prawidłowy skrypt działający w Firefoksie (skopiuj całość). :RE

ES6 „tryb lax”

BONUS : Oto zaktualizowana wersja, która nie korzysta z trybu wstecz, ale używa nowo określonego „trybu lax”, w którym silnik JS po prostu spróbuje odgadnąć, co powinien zrobić kod, bez względu na przestrzeganie określonej składni JS ( w zasadzie antyteza trybu ścisłego):

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

Należy pamiętać, że „ tryb lax ” jest obecnie dostępny tylko w przeglądarce Firefox> = 34.; P

do

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'

Edycja: Alternatywnie

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

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

Wiem, że to szaleństwo ...

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

To prawie idiomatyczny Haskell, ponieważ program wygląda teraz jak kompozycja funkcji od prawej do lewej. Gdyby funkcja nie była wypisana, ale coś, co zwróciłoby (użyteczną) wartość, deklaracja operatora byłaby niepotrzebna, a kod byłby czymś, co można zobaczyć w bibliotekach.

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}

Zobacz jsFiddle .

Edycja:
Aby lepiej dostosować się do reguł, oto wariant XML, który faktycznie używa 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>

gdzie powinien być style.css

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

HTML bez CSS

I do cholery, oto jedna bez 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>

Fiddle .

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

(Zmienne lokalne są niszczone w odwrotnej kolejności do deklaracji.)

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

(Tak samo, ale zamiast tego używa lambdas i elementu danych tablicy).

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

do

Starając się maksymalnie podpowiedzieć wskazówkom zawartym w pytaniu:

#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

Zakłada owijanie komórek.

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

Dlaczego to działa?

Pierwszy i ostatni wiersz składają się z pętli, która powtarza się cztery razy (counter = cell0 ).

Wewnątrz pętli znajduje się zmienna licznika (cell1 ), która jest zwiększana za każdym razem.

Każda linia sprawdza, czy zmniejszenie o cztery, trzy, dwa lub jeden jest równe zero. Dlatego przy pierwszym uruchomieniu licznik jest jeden i wykonywana jest ostatnia linia, przy drugim uruchomieniu wykonywana jest trzecia linia itp.

Te (line 1)pokazy gdzie trzeba wprowadzić tekst, który zostanie wydrukowany. Strzałki w pętlach przydzielają cell2do tego celu. [-]Czyści cell2po użyciu.

Grzmotnąć

Ku pamięci czcigodnych SleepSort i SleepAdd przedstawiam wam ... SleepReverse :

#!/bin/bash

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

print 1
print 2
print 3
print 4

Jawa

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

Wszystko we właściwym czasie ... ;-)

Python 3

import atexit

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

Grzmotnąć

Oto skrypt o podwójnych twarzach:

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

Wspólne Lisp nr 1

Łatwo jest napisać ngorpmakro, które wykonuje swoje formularze w odwrotnej kolejności:

(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

Wspólne Lisp nr 2

Oto jeden, który bierze problem bardzo dosłownie; kod z pytania pojawia się w programie bez modyfikacji:

(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

Kolejny evalwariant:

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

FA#

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

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

Właśnie utworzyłem niestandardowego operatora, który wykonuje funkcje w odwrotnej kolejności.

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

Wypróbuj: http://play.golang.org/p/fjsJLwOFn2

Python3

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

Może być o 6 bajtów krótszy, usuwając wszystkie spacje w ostatnim wierszu.

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

Partia

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

DO#

Zamiast bezpośrednio wywoływać metodę Run, tworzę metodę dynamiczną, która zawiera kopię kodu bajtowego Run IL, z wyjątkiem tego, że argumenty opcode łańcucha znaków są zamieniane. Co powoduje, że nowa metoda wyświetla ciągi w odwrotnej kolejności.

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

Pyton

jeszcze inne rozwiązanie eval()

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

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

nie jest to bardzo skomplikowane, ale łatwe do zrozumienia.