Nhiệm vụ của bạn là đảo ngược thứ tự mà một số printsđược thực thi.

Thông số kỹ thuật:
Mã của bạn sẽ ở dạng này:

//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ạn sẽ phải print(hoặc echo, hoặc write, hoặc tương đương) các chuỗi từ thứ tư đến thứ nhất.

• Bạn quyết định dòng nào trong chương trình của bạn phải có printchuỗi, nhưng chúng phải liền kề ;

• Mỗi dòng chỉ có thể chứa một printvà không thể vượt quá 60 byte chiều dài;

• Vì đây là cuộc thi phổ biến , hãy sáng tạo và tránh viết chỉ một gotohoặc đơn giảnfor(i){if(i=4)print"Line1";if(i=3)...}

• Câu trả lời được đánh giá cao nhất trong 2 tuần sẽ chiến thắng điều này.

• Đầu ra của bạn PHẢI có Line4 Line3 Line2 Line1 HOẶC Line4Line3Line2Line1 HOẶC Line4\nLine3\nLine2\nLine1 (nơi \nlà một dòng mới), và nó phải được tạo ra chỉ bằng cách thực hiện những printsngược.

Chúc mừng mã hóa!

CẬP NHẬT: Cuộc thi đã kết thúc! Cảm ơn tất cả :)

Hàng hóa 64 CƠ BẢN

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

PHP

Lạm dụng ưu tiên ... :-)

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

C

Hành vi không xác định là loại hành vi thú vị nhất!

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

Đầu ra thực tế có thể thay đổi tùy thuộc vào trình biên dịch, trình liên kết, hệ điều hành và bộ xử lý của bạn :)

Java

Sử dụng sự phản chiếu

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

Đầu ra:

Line4
Line3
Line2
Line1

Một lời giải thích tại sao công trình này có thể được tìm thấy ở đây .

C (và sắp xếp của Python)

Phiên bản mới, sử dụng macro để phù hợp với định dạng câu hỏi một cách hoàn hảo. Theo nhận xét của Quincunx, tôi đã thêm vào returnđể làm cho nó đẹp hơn.

Nó cũng hoạt động trong Python, nhưng nó in đúng thứ tự.

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

Phiên bản gốc - cả hai thực tế giống nhau, sau khi thay thế macro:

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

ES6 (sử dụng chế độ lùi;)

Ồ, có vẻ như các nhà thiết kế của ECMAScript đã có một tầm nhìn xa đáng kinh ngạc khi họ thực hiện một phần chế độ ngược của thông số kỹ thuật:

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

Đầu ra (đánh giá, thực sự):

"Line4Line3Line2Line1"

Lưu ý rằng đó chính xác là hình thức được yêu cầu, chỉ lùi một chút để phù hợp với cú pháp của chế độ . Cũng lưu ý rằng chế độ này chỉ được hỗ trợ trong các phiên bản gần đây của Firefox vào lúc này .

Lưu ý cuối cùng: Trên thực tế, không có chế độ lùi. Nhưng đây vẫn là một tập lệnh hợp lệ chạy trong Firefox (sao chép toàn bộ). :CƯỜI MỞ MIỆNG

ES6 "chế độ lỏng lẻo"

THƯỞNG : Đây là phiên bản cập nhật không sử dụng chế độ lùi, nhưng sử dụng "chế độ lỏng lẻo" mới được chỉ định trong đó công cụ JS sẽ chỉ cố đoán xem mã phải làm gì, bất kể tuân thủ bất kỳ cú pháp JS được chỉ định nào ( về cơ bản là phản đề của chế độ nghiêm ngặt):

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

Xin lưu ý rằng " chế độ lỏng lẻo " hiện chỉ khả dụng trong Firefox> = 34 .; 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;
}

Hồng ngọc

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

Chỉnh sửa: Hoặc,

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

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

Tôi biết, đây là sự điên rồ ...

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

Đây là Haskell gần như thành ngữ, vì chương trình bây giờ trông giống như một thành phần chức năng từ phải sang trái. Nếu hàm không được in, nhưng thứ gì đó sẽ trả về giá trị (hữu ích) thì khai báo toán tử sẽ không cần thiết và mã sẽ là thứ bạn thấy trong các thư viện.

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}

Xem jsFiddle .

Chỉnh sửa:
Để tuân thủ các quy tắc tốt hơn, đây là một biến thể trong XML, thực sự sử dụng 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>

nơi style.css nên

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

HTML không có CSS

Và cho cái quái gì đó, đây là một cái không có 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";
}

(Biến cục bộ bị hủy theo thứ tự ngược lại của khai bá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; }},
    };
}

(Rất giống nhau, nhưng sử dụng lambdas và một thành viên dữ liệu mảng thay thế.)

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

Cố gắng làm cho bất chấp các mẹo trong câu hỏi sáng tạo nhất có thể:

#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

Giả sử bọc tế bào.

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

Tại sao nó hoạt động

Các dòng đầu tiên và cuối cùng bao gồm một vòng lặp lặp lại bốn lần (counter = cell0).

Trong vòng lặp, có một biến đếm ( cell1) được tăng lên mỗi lần chạy.

Mỗi dòng kiểm tra nếu giảm bốn, ba, hai hoặc một bằng không. Do đó, ở lần chạy đầu tiên, bộ đếm là một và dòng cuối cùng được thực thi, ở lần chạy thứ hai, dòng thứ ba được thực thi, v.v.

Các (line 1)chương trình mà bạn nên làm cho văn bản được in. Các mũi tên trong các vòng lặp phân bổ cell2cho mục đích này. Làm [-]sạch cell2sau khi bạn sử dụng nó.

Bash

Trong ký ức của những tôn kính SleepSort và SleepAdd , tôi trình bày cho bạn ... 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();
  }
}

Đó là tất cả trong thời gian thích hợp ... ;-)

Con trăn 3

import atexit

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

Bash

Đây là kịch bản hai mặt:

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

Lisp thường gặp 1

Thật dễ dàng để viết một ngorpmacro thực thi các biểu mẫu của nó theo thứ tự ngược lại:

(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 thường gặp 2

Đây là một vấn đề rất đúng theo nghĩa đen; mã từ câu hỏi xuất hiện trong chương trình mà không sửa đổi:

(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

Một evalbiến thể khác :

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

ĐỤ#

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

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

Chỉ cần tạo một toán tử tùy chỉnh thực hiện các chức năng theo thứ tự ngược lại.

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

Dùng thử: http://play.golang.org/p/fjsJLwOFn2

Python3

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

Có thể ngắn hơn 6 byte bằng cách loại bỏ tất cả các khoảng trắng ở dòng cuối cùng.

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

Mẻ

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 #

Thay vì gọi trực tiếp phương thức Run, tôi đang tạo một phương thức động có chứa một bản sao mã byte IL của Run, ngoại trừ các toán hạng opcode chuỗi tải được hoán đổi. Điều này làm cho phương thức mới hiển thị các chuỗi theo thứ tự ngược lại.

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

Con trăn

một giải pháp khác sử dụng eval()

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

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

nó không phức tạp lắm, nhưng dễ hiểu