당신의 임무는 일부 prints실행 순서를 반대로하는 것 입니다.

사양 :
코드는 다음과 같은 형식입니다.

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

네 번째에서 첫 번째까지 해당 문자열 을 print(또는 echo, write또는 이와 동등한) 해야합니다.

• 프로그램의 어떤 줄이 print문자열 이어야하는지 결정 하지만 인접 해야합니다 .

• 모든 줄은 하나만 포함 할 수 있으며 길이 print는 60 바이트 를 초과 할 수 없습니다 .

• 이것은 인기있는 경연 대회 이므로 창의력을 발휘하고 a goto또는 simple 을 쓰지 마십시오.for(i){if(i=4)print"Line1";if(i=3)...}

• 2 주 만에 가장 많이지지 된 답이 이깁니다.

• 귀하의 출력이 해야 할 Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 OR Line4\nLine3\nLine2\nLine1 ( \n개행 문자입니다), 그리고들만을 실행하여 생성되어야 prints뒤로.

행복한 코딩!

업데이트 : 컨테스트가 끝났습니다! 다들 감사 해요 :)

코모도어 64 베이직

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

PHP

우선 순위 남용 ... :-)

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

씨

정의되지 않은 행동은 가장 흥미로운 종류의 행동입니다!

f(){}
main()
{
   f(printf("Line 1\n"), 
     printf("Line 2\n"), 
     printf("Line 3\n"), 
     printf("Line 4\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){}
    }
}

산출:

Line4
Line3
Line2
Line1

왜 이것이 작동하는지에 대한 설명은 여기 에서 찾을 수 있습니다 .

C (그리고 일종의 파이썬)

질문 형식에 완벽하게 맞도록 매크로를 사용하는 새로운 버전. Quincunx의 의견에 따라, 나는 return그것을 더 멋지게 만들기 위해 추가 했습니다.

파이썬에서도 작동하지만 올바른 순서로 인쇄됩니다.

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

원래 버전-매크로 대체 후 두 가지가 거의 동일합니다.

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

ES6 (후진 모드 사용;)

와, ECMAScript의 설계자들이 사양의 일부를 역전 모드 로 만들었을 때 놀라운 예측력을 가진 것 같습니다.

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

결과 (실제로 평가) :

"Line4Line3Line2Line1"

그것의 참고 정확히 맞게에만 약간의 backwardification로, 요청의 형식 모드의 구문을 . 이 모드는 현재 Firefox 최신 버전에서만 지원됩니다 .

마지막 참고 사항 : 실제로 역방향 모드는 없습니다. 그러나 이것은 여전히 ​​Firefox에서 실행되는 유효한 스크립트입니다 (모든 것을 복사하십시오). :디

ES6 "휴식 모드"

보너스 : 여기에는 역방향 모드를 사용하지 않고 JS 엔진이 지정된 JS 구문의 준수 여부에 관계없이 코드가 수행해야 할 작업을 추측하려고하는 새로 지정된 "lax 모드"를 사용하는 업데이트 된 버전이 있습니다 ( 기본적으로 엄격 모드의 대립) :

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

" lax mode "는 현재 Firefox> = 34에서만 사용할 수 있습니다.; P

씨

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

루비

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

편집 : 또는

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

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

알아, 이건 광기 야 ...

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입니다. 함수가 인쇄되지 않았지만 (유용한) 값을 반환하는 것이면 연산자 선언이 필요하지 않으며 코드는 라이브러리에서 볼 수 있습니다.

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

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

펄

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}

jsFiddle을 참조하십시오 .

편집 :
규칙을 더 잘 준수하기 위해 실제로 사용하는 XML의 변형이 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>

style.css는 어디에 있어야

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

CSS없는 HTML

그리고 그것을 위해 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>

바이올린 .

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

(로컬 변수는 선언 순서와 반대로 파괴됩니다.)

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

(동일하지만 람다와 배열 데이터 멤버를 대신 사용합니다.)

하스켈

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

자바 스크립트

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

씨

질문의 팁을 최대한 창의적으로 만들려고합니다.

#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

셀 랩핑을 가정합니다.

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

작동하는 이유

첫 번째 줄과 마지막 줄은 4 번 반복되는 루프를 구성합니다 (카운터 = cell0).

루프 안에는 cell1매 실행마다 증가 하는 카운터 변수 ( )가 있습니다.

각 줄은 4, 3, 2 또는 1 씩 감소하는 것이 0인지 확인합니다. 따라서 첫 번째 실행에서 카운터는 1이고 마지막 행이 실행되고 두 번째 실행에서 세 번째 행이 실행됩니다.

(line 1)당신이 인쇄 된 텍스트를해야 보여줍니다. 루프의 화살표는 cell2이 목적으로 할당 됩니다. 는 [-]밖으로 청소 cell2당신이 그것을 사용 후.

세게 때리다

존경받는 SleepSort 와 SleepAdd를 기억 하면서 , 나는 당신에게 선물합니다 ... SleepReverse :

#!/bin/bash

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

print 1
print 2
print 3
print 4

자바

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

그것은 모두 올바른 타이밍에 있습니다 ... ;-)

파이썬 3

import atexit

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

세게 때리다

다음은 양면 스크립트입니다.

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

커먼 리스프 № 1

ngorp양식을 역순으로 실행 하는 매크로 를 작성하는 것은 쉽습니다 .

(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

커먼 리스프 № 2

문자 그대로 문제를 해결하는 것이 있습니다. 질문의 코드는 수정없이 프로그램에 나타납니다.

(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

다른 eval변형 :

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

함수를 역순으로 실행하는 사용자 정의 연산자를 방금 만들었습니다.

이동 (골랑)

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

사용해보십시오 : http://play.golang.org/p/fjsJLwOFn2

파이썬 3

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

마지막 행에서 모든 공백을 제거하여 6 바이트 더 짧을 수 있습니다.

자바 스크립트

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

일괄

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

씨#

Run 메서드를 직접 호출하는 대신로드 문자열 opcode 피연산자가 교체되는 것을 제외하고 Run의 IL 바이트 코드 복사본이 포함 된 동적 메서드를 만들고 있습니다. 새 메소드가 문자열을 역순으로 표시합니다.

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

파이썬

또 다른 솔루션을 사용하여 eval()

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

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

매우 복잡하지는 않지만 이해하기 쉽습니다.