Göreviniz, bazılarının printsyürütüldüğü sırayı tersine çevirmektir .

Özellikler:
Kodunuz bu biçimde olacak:

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

Bu dizeleri dördüncüden birinciye kadarprint (veya echo, veya writeeşdeğer) kullanmanız gerekecektir.

• Programınızın hangi satırlarının karakter printdizileri olması gerektiğine siz karar verin , ancak bitişik olmaları gerekir ;

• Her satır yalnızca bir tane içerebilir printve uzunluğu 60 baytı aşamaz ;

• Bu popülerlik yarışması olduğu için yaratıcı olun ve sadece bir gotoveya basit yazmaktan kaçınınfor(i){if(i=4)print"Line1";if(i=3)...}

• 2 hafta içinde en çok oy alan cevap bunu kazanıyor.

• Çıktınız GEREKİR olmak Line4 Line3 Line2 Line1 YA Line4Line3Line2Line1 YA Line4\nLine3\nLine2\nLine1 ( \nbir satır olduğu) ve sadece o yürüterek oluşturulmalıdır printsgeriye.

Mutlu kodlama!

GÜNCELLEME: Yarışma bitti! Hepinize teşekkür ederim :)

Commodore 64 TEMEL

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

PHP

Kötüye öncelik ... :-)

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

C

Tanımsız davranış en heyecan verici davranış türüdür!

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

Gerçek çıktı derleyicinize, bağlayıcınıza, işletim sisteminize ve işlemcinize bağlı olarak değişebilir :)

Java

Yansıma kullanma

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

Çıktı:

Line4
Line3
Line2
Line1

Bu eserin neden burada bulunduğunun bir açıklaması .

C (ve Python tür)

Yeni sürüm, soru biçimine mükemmel bir şekilde uyması için bir makro kullanıyor. Quincunx'un yorumunu takiben returndaha güzel yapmak için ekledim .

Ayrıca Python'da da çalışır, ancak doğru sırada yazdırır.

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

Orijinal versiyon - Makro ikame edildikten sonra ikisi pratik olarak aynıdır:

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

ES6 (geri modunu kullanarak;)

Vay canına, ECMAScript tasarımcılarının teknik özelliklerin geriye doğru modda yapılmasında inanılmaz bir öngörü olduğunu düşünüyorlar :

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

Çıktı (değerlendirme, gerçekten):

"Line4Line3Line2Line1"

Öyle unutmayın tam olarak uyacak şekilde sadece hafif backwardification ile istenen formun modunun sözdizimi . Bu mod yalnızca Firefox'un yeni sürümlerinde desteklenir da unutmayın anda .

Son not: Aslında geri mod yok. Ancak bu, Firefox'ta çalışan geçerli bir komut dosyasıdır (her şeyi kopyalayın). : D

ES6 "gevşek modu"

BONUS : İşte geriye dönük modu kullanmayan, ancak yeni tanımlanmış "lax modunu" kullanan, JS motorunun kodun ne yapması gerektiğini, sadece herhangi bir JS sözdizimine uymadan bağımsız olarak çalışmayı deneyeceği bir sürüm. temel olarak katı kip antitezi):

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

Lütfen " lax modunun " şu anda yalnızca Firefox> = 34’de kullanılabildiğini unutmayın; 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;
}

Yakut

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

Düzenleme: Alternatif olarak,

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

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

Biliyorum, bu delilik.

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

Bu neredeyse deyimsel Haskell, çünkü program sağdan sola bir fonksiyon kompozisyonuna benziyor. İşlev yazdırılmadıysa ancak (yararlı) bir değer döndüren bir şey operatörün bildirgesine gerek duymaz ve kod kütüphanelerde göreceğiniz bir şey olur.

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}

JsFiddle'a bakınız .

Düzenleme:
Kurallara daha iyi uymak için, işte XML kullanan, gerçekte kullanan bir değişken 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 nerede olmalı

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

CSS'siz HTML

Ve bunun için, CSS'siz bir tane.

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

Keman .

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

(Yerel değişkenler ters bildirim sırasına göre imha edilir.)

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

(Çok aynı, ancak lambda ve bunun yerine bir dizi veri üyesi kullanıyor.)

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

Söz konusu ipuçlarına karşı çıkmayı mümkün olduğunca yaratıcı kılmaya çalışmak:

#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

Hücre sarımını varsayar.

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

Neden çalışıyor

İlk ve son satırlar dört kez tekrar eden bir döngüden oluşur (counter = cell0).

Döngünün içinde cell1her çalıştırmada artan bir sayaç değişkeni ( ) vardır.

Her satır dört, üç, iki veya bir azalmanın sıfıra eşit olup olmadığını kontrol eder. Bu nedenle, ilk çalıştırmada, sayaç birdir ve son satır çalıştırılır, ikinci çalıştırmada üçüncü satır çalıştırılır vb.

(line 1)Eğer basılı metni yapmalıdır gösterilmektedir. Döngülerdeki oklar cell2bu amaç için tahsis edilir . Kullandıktan sonra [-]temizler cell2.

darbe

Saygı anısına SleepSort ve SleepAdd , sana ... takdim 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();
  }
}

Hepsi doğru zamanlamada ... ;-)

Python 3

import atexit

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

darbe

İşte çift yüzlü senaryo geliyor:

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

Ortak Lisp № 1

ngorpFormlarını ters sırada uygulayan bir makro yazmak kolaydır :

(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

Ortak Lisp № 2

İşte problemi tam anlamıyla alan bir tane; sorudan çıkan kod programda değişiklik yapmadan görünür:

(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

Başka bir evaldeğişken:

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

Az önce fonksiyonları ters sırayla yürüten özel bir operatör yarattı.

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

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

Python3

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

Son satırdaki tüm boşlukları kaldırarak 6 bayt daha kısa olabilir.

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

Grup, yığın, parça, bir defada alınan miktar

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 #

Doğrudan Run yöntemini çağırmak yerine, yük dizesi opcode işlenenlerinin değiştirilmesi dışında, Run'ın IL bayt kodunun bir kopyasını içeren dinamik bir yöntem oluşturuyorum. Bu, yeni yöntemin dizeleri ters sırada göstermesine neden olur.

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

piton

kullanarak başka bir çözüm eval()

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

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

çok karmaşık değil, anlaşılması kolay.