DouKaku?beta

challenge リストを逆順に表示

簡単な問題です。 リスト状のものを逆順に表示するプログラムを書いてください。 Haskellで表現するなら、 
given_list = [1, 2, 3, 4, 5]
main = ?????

5
4
3
2
1
という感じになります。

出題の意図は「副作用のあるループをどう表現するか」という所にあるのですが、 あまりに簡単にかけすぎて何が問題なのかもわからない言語が多いかと思うので 「リストを逆順にする処理が簡単にかけるかどうか」と抱き合わせにしました。

post comment

Posted feedbacks - Flatten

Nested Hidden
芸無し・・・。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
"""
>>> rprint([1, 2, 3, 4, 5])
5
4
3
2
1
"""

def rprint(xs):
  ys = list(xs)
  ys.reverse()
  for y in ys:
    print y

import doctest
doctest.testmod()

普通に。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>

int main()
{
    const int a[] = { 1, 2, 3, 4, 5 };

    std::vector<int> v(a, a + sizeof(a) / sizeof(*a));

    std::copy(v.rbegin(), v.rend(), std::ostream_iterator<int>(std::cout, "\n"));
}

再帰・・・。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
"""
>>> rprint([1, 2, 3, 4, 5])
5
4
3
2
1
"""

def rprint(xs):
  if xs:
    print xs[-1]
    rprint(xs[:-1])

import doctest
doctest.testmod()

ついでに配列のまま逆順出力。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#include <iostream>
#include <algorithm>
#include <iterator>

int main()
{
    const int a[] = { 1, 2, 3, 4, 5 };

    std::reverse_copy(a, a + sizeof(a) / sizeof(*a), std::ostream_iterator<int>(std::cout, "\n"));
}


簡単すぎてごめんなさい。
1
2
given_list = [1, 2, 3, 4, 5]
given_list.reverse!.each{ |i| puts i}

Rは一応関数型言語らしいのですが、副作用とか考えたことない・・・ 
1
2
given.list <- c(1, 2, 3, 4, 5)
cat(rev(given.list), sep="\n")

すみません、出題意図にやや沿った形で書き直します。 
1
dummy <- sapply(rev(given.list), print)

多相的にならないのがいまいちなのかなあと。 
1
2
let given_list = [1; 2; 3; 4; 5];;
List.fold_right (fun x -> print_int x; print_newline) given_list ();;

reverseせずに、再帰で。 
1
(fold-right (lambda (x c) (print x)) #f '(1 2 3 4 5))

たまには、早めに。多分、題意に沿って。 
1
2
3
revp([]).
revp([X|Xs]):-revp(Xs),writeln(X).
:-revp([1,2,3,4,5]),halt.


破壊的にひっくり返すreverseの他にも
組み込み関数のreversedがありますよ。
1
2
3
given_list = [1, 2, 3, 4, 5]
for x in reversed(given_list):
    print x

そのまんまreverseがあるｗ 
1
2
(let ((given-list '(1 2 3 4 5)))
  (loop for x in (reverse given-list) do (print x)))

普通に 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#include <stdio.h>

int main()
{
    int i;
    int given_list[] = {1, 2, 3, 4, 5};

    for (i = sizeof(given_list)/sizeof(given_list[0])-1; i >= 0; i--) {
        printf("%d\n", given_list[i]);
    }

    return 0;
}


1
2
3
4
var given_list = [1, 2, 3, 4, 5]; 
while(given_list.length > 0) {
    print(given_list.pop())
}


1
2
3
4
5
6
7
function print_reverse(given_list)
  for i = table.getn(given_list), 1, -1 do
    print(given_list[i])
  end
end

print_reverse({1,2,3,4,5})


1
2
3
(require 'cl)
(let ((given-list '(1 2 3 4 5)))
  (loop for x in (reverse given-list) do (print x)))

Prolog です。芸無し。短くもない。 
1
2
3
4
5
printReverse([],Ts,Ts).
printReverse([Item|Xs],Ts,Ys) :- printReverse(Xs,[Item|Ts],Ys), print(Item).
printReverse(Xs) :- printReverse(Xs,[],Ys).

?- printReverse([1,2,3,4,5]).

Prolog です。無駄なコードを省いて少し短くしました。 
1
2
3
4
printReverse([]).
printReverse([Item|Xs]) :- printReverse(Xs), print(Item).

?- printReverse([1,2,3,4,5]).

あらま。katsu さんが既に投稿されてたんですねぇ。

一応、要素の出力ごとに改行が入るように 
1
2
3
$\ = "\n";
my @given_list = (1, 2, 3, 4, 5);
print for reverse(@given_list);

題意に沿ってるかどうかわかりませんが、Javascript にも Array.reverse() があります。 
1
2
3
4
5
6
7
8
9
var reverse_print = function (arr)
{
  arr.reverse();
  for (var i = 0; i < arr.length; ++i)
  {
    alert(arr[i]);
  }
}
reverse_print([1,2,3,4,5]);

もしくは、副作用のあるループって、こういうことでしょうか？ 
1
2
3
$\ = "\n";
my @given_list = ( 1, 2, 3, 4, 5 );
print pop(@given_list) while (@given_list);


とりあえずreverseあります。reverseMapもあります。
1
List(1,2,3,4,5).reverseMap(println(_))


reverseMapを自前で。
1
2
3
4
5
6
def reverseMap[A](l:Seq[A],f:A=>unit):unit = l match {
  case Nil => ()
  case x::Nil => f(x)
  case x => f(x.last);reverseMap[A](l.slice(0, l.length-1),f)
}
reverseMap(List(1,2,3,4,5), println)

pythonだと::-1でも逆順作れます。 
1
2
for i in [1,2,3,4,5][::-1]:
  print i


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
using System;
class Program
{
  static void Main()
  {
    string[] lst ={ "1", "2", "3", "4", "5" };
    Array.Reverse(lst);
    Console.WriteLine(string.Join(", ", lst));
  }
}


すでに、reversedと[::-1]形式が紹介されているので
reverseフラグ付きsortedで、for文を使わない
ワンライナーでいきます。

1
print '\n'.join(map(str, sorted([1, 2, 3, 4, 5], reverse=True)))

Array#reverse_eachでもいいですね。 
1
given_list.reverse_each{|i| puts i}

案の定reverseは使われてたんで、ちょっと変な方法... 
1
given_list.size.times {|i| puts given_list[-i - 1]}

array_reverseですぐ書ける 
1
2
3
4
5
<?php
$given_list = array(1, 2 ,3, 4, 5);
foreach (array_reverse($given_list) as $item) {
	echo "$item\n";
}

何にも考えてないけど，まだHaskellが出てないようなので。 
1
2
3
givenList = [1,2,3,4,5]

main = mapM_ print $ reverse $ givenList

given_listは変更されない 
1
2
given_list = [1, 2, 3, 4, 5];
alert(Array.apply(null, given_list).reverse().join("\n"));

LinkedListを使っています（ArrayListだと実質は単なる配列操作になってしまうので）。従って、効率は悪くないはずです。逆順にする操作は9〜11行目だけですが、リストの初期化のほうがこったコードになってしまったかもしれません…… 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import java.util.LinkedList;
import java.util.Arrays;

public class Sample {
    public static void main(String[] args) {
        LinkedList<Integer> l = new LinkedList<Integer>(Arrays.asList(
              new Integer[]{1, 2, 3, 4, 5}));
        LinkedList<Integer> rev = new LinkedList<Integer>();
        for (int i : l) {
            rev.addFirst(i);
        }
        System.out.println(rev);
    }
}

Collections.reverse()を使ってみました。（でもArrays.reverse()はなかった。なぜ？） 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import java.util.*;

class MeApp
{
    public static void main(String[] args)
    {
        final ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));

        Collections.reverse(list);

        System.out.println(list);
    }
}


そ、それはこの入力データでは動きますけど
「リスト状のものを逆順に表示する」ではないですよね…(^^;
given_listが[3, 1, 4, 1, 5]のようなソートされていないものだと逆順にならないですから…

reversedと[::-1]とforを使わないとなると下のようになるでしょうか。
for文でなければOKなら3行目の書き方の方が好みです。
1
2
3
print '\n'.join(map(lambda x:str(x[1]), sorted(enumerate(given_list), reverse=True)))

print '\n'.join(str(x[1]) for x in sorted(enumerate(given_list), reverse=True))

Squeak Smalltalk で。 
1
#(1 2 3 4 5) reverseDo: [:x | Transcript cr; show: x]


再帰で。
(reverse-print '(1 2 3 4 5))
5
4
3
2
1

1
2
3
4
(define (reverse-print ls)
  (unless (null? ls)
    (reverse-print (cdr ls))
    (print (car ls))))


Mapで逆順にしたリストそれぞれにPrintを適用．
Mathematicaの/@はMapなので
Map[Print, Reverse[{1, 2, 3, 4, 5}]];
ともかけます．
1
Print /@ Reverse[{1, 2, 3, 4, 5}];


普通に…

erl -noshell -eval 'listrev:listrev([1,2,3,4,5]), init:stop().'

のように実行します．
1
2
3
4
5
-module(listrev).
-export([listrev/1]).

listrev(List) ->
        lists:map(fun(E) -> io:format("~w~n", [E]) end, lists:reverse(List)).


EAFP(ゴメンナサイはオネガイシマスより楽)を利用。
参考: http://www.python.jp/doc/2.4/tut/node19.html#l2h-45

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def rprint(L):
  i = 0
  while True:
    i -= 1
    try:
      yield L[i]
    except:
      break

for n in rprint([1,2,3,4,5]):
  print n


1
2
3
def rprint(x):
	if type(x) is list:
		for i in xrange(1,len(x)+1): print x[-i]

まーた肝心な物を忘れて… 
1
2
given_list = [1, 2, 3, 4, 5]
rprint(given_list)

ループは書きたくないよねー 
1
2
3
4
<?php
$list=range(1,5);
echo(strrev(join("\n",$list)));
?>


非実用的解です。
考え方自体は、言語非依存です。
一秒おきに、逆順に表示します。

1
2
3
4
5
6
7
wait_do(P,T):-thread_create((sleep(T),P),_,[]).

revp(L):-length(L,LL),
        (between(1,LL,I),nth1(I,L,C),T is LL - I,wait_do(writeln(C),T),fail
        ;true).

:-revp([a,b,c,d,e,f,g]).


うーむ、Delphiで短く書くのは難しい…。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
program gerogero;

{$APPTYPE CONSOLE}

procedure WriteReverse(const given_list: array of Integer);
var
    i: Integer;
begin
    for i := High(given_list) downto Low(given_list) do
        Writeln(given_list[i]);
end;

begin
    WriteReverse([1, 2, 3, 4, 5]);
end.

BASHの配列って(実装はどうか知らないけど)「キーに数値しかとれない連想配列」っぽいので、これ以外にも答えがあるかと。 
1
2
3
4
5
6
print_rev () {
  local -a given_list=("$@");
  for ((i=${#given_list[@]}-1; i>=0; i--)); do
    echo "${given_list[i]}"
  done
}

たんじゅんに 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import System.Environment
main = putStr . unlines . reverse =<< getArgs

{-
*Main> :main 1 2 3 4 5
5
4
3
2
1
-}



	

	
	
	
    

      
1
printAll(reverse([1,2,3,4,5]))




    

	

  
  





  
  


  
  






  
  

	

	  
DrSchemeで。
> (reverse (list 1 2 3 4 5))
(5 4 3 2 1)

	

	
	
	
    

      
1
2
3
(define (reverse args)
  (cond ((null? args) null)
        (else (append (reverse (cdr args)) (list (car args))))))




    

	

  
  





  
  


  
  






  
  

	

	  
入力を行単位で逆順に表示します。
逆順の本体は function reverse です。普通の実装です。
表示はENDです。

	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
function reverse(array, size,   i) {
	for(i = 0; i < size / 2; i++) {
		tmp = array[size - i - 1]
		array[size - i - 1] = array[i]
		array[i] = tmp
	}
}

{
	input[NR - 1] = $0
}

END {
	reverse(input, NR)
	for(i = 0; i < NR; i++) {
		print input[i]
	}
}




    

	

  
  





  
  


  
  






  
  

	

	  
配列をスタックにpushして、表示してるだけすｗ


	

	
	
	
    

      
1
2
3
4
5
6
7
8
9
%!
/Helvetica 24 selectfont
/given_list [1 2 3 4 5] def

100 100 moveto
given_list aload pop
given_list length { 3 string cvs show } repeat

showpage




    

	

  
  





  
  


  
  






  
  

	

	  再帰呼び出しを使ってみました。
	

	
	
	
    

      
1
2
3
4
5
6
7
8
def rev(list)
	unless list.empty? then
		puts list.pop
		rev(list)
	end
end

rev(given_list)




    

	

  
  





  
  


  
  






  
  

	

	  
java.lang.System の import は
やらなくても済むようになって欲しいなぁ

	

	
	
	
    

      
1
2
3
4
import java.lang.System;
for (i in reverse[1,2,3,4,5]){
  System.out.println(i);
}




    

	

  
  





  
  


  
  






  
  

	

	  MATLABは多くの関数が入力としてスカラーだけでなくベクトルを受け入れる。fprintfもそういう関数の一つなのでベクトルを与えると個々の要素に対してフォーマット付き出力をしてくれる。これを利用。ただし要素の型に応じてフォーマット指定文字列の部分を変更しないといけないのが難点。投稿のコードは整数を想定。ベクトルを逆順にする部分はfliplrという関数が用意されてるけどあえて違う書き方で。
	

	
	
	
    

      
1
2
function revdisp(v)
fprintf('%d\n',v(length(v):-1:1));




    

	

  
  





  
  


  
  






  
  

	

	  

	

	
	
	
    

      
1
2
3
4
5
6
7
8
9
Iterator::reverse: method fiber {
    arr: this.to_a;
    while (!arr.empty()) {
        yield arr[arr.size - 1];
        arr.pop_back();
    }
}

[1, 2, 3, 4, 5].each.reverse.to_a.p;




    

	

  
  





  
  


  
  






  
  

	

	  

	

	
	
	
    

      
1
2
given_list := list(1, 2, 3, 4, 5)
given_list reverse foreach(i, i println)




    

	

  
  





  
  


  
  






  
  

	

	  
使いどころによっては応用性あるかも。

	

	
	
	
    

      
1
2
3
>>> a = [1, 2, 3, 4, 5]
>>> [a[~i] for i in range(len(a))]
[5, 4, 3, 2, 1]




    

	

  
  





  
  


  
  






  
  

	

	  

	

	
	
	
    

      
1
2
3
4
5
6
var given_list = [1, 2, 3, 4, 5]
Array.prototype.reverse_print = function() {
    if(this.length == 1) return this[0];
    return this.pop() + "\n" + this.reverse_print();
}
alert(given_list.reverse_print());




    

	

  
  





  
  


  
  






  
  

	

	  
多相的じゃないのと、括弧が多いのがあれだなぁ。

	

	
	
	
    

      
1
foldr (fn (x, ()) => print ((Int.toString x) ^ "\n")) () given_list;




    

	

  
  





  
  


  
  






  
  

	

	  
おっと、リストを作ってなかった。

	

	
	
	
    

      
1
2
val given_list = [1, 2, 3, 4, 5];
foldr (fn (x, ()) => print ((Int.toString x) ^ "\n")) () given_list;




    

	

  
  





  
  


  
  






  
  

	

	  
Perl6でsayとreverseを使う例

	

	
	

	  see: どう書くでリハビリ
	
  
	
	
	

  
  





  
  


  
  






  
  

	

	  
Haskellで副作用のあるforループっぽく書く。
それっぽく見えるようにあえて;を入れてみたけど、微妙でした。

	

	
	
	
    

      
1
2
3
4
5
6
7
import Data.Traversable
givenList = [1, 2, 3, 4, 5]

main = do
    for (reverse givenList)
        print;
    return ();




    

	

  
  





  
  


  
  






  
  

	

	  

	

	
	
	
    

      
1
2
$list = 1..5
[array]::reverse($list)




    

	

  
  





  
  


  
  






  
  

	

	  
VB8.0までReverseは値を返しませんでしたが、
9.0からはオーバーロードが増えて以下の書き方ができるようです。
当然xsの中身は逆順になりません。
VBの話というか.NET Frameworkのクラスライブラリの話ですけど。

	

	
	
	
    

      
1
2
3
4
Dim xs() As Integer = {1, 2, 3, 4, 5}
For Each x In xs.Reverse
    Console.WriteLine(x)
Next




    

	

  
  





  
  


  
  






  
  

	

	  1.1-beta-2で動作確認しました。

	

	
	
	
    

      
1
[1, 2, 3, 4, 5].reverse( ).each { println it }




    

	

  
  





  
  


  
  






  
  

	

	  
なかったので取り敢えず…

	

	
	
	
    

      
1
2
3
4
5
6
import std.stdio;

void main(){
	auto list = [1, 2, 3, 4, 5];
	foreach_reverse(a; list) writefln(a);
}




    

	

  
  





  
  


  
  


  
  






  
  

	

	  
これまたperlがないので。

	

	
	
	
    

      
1
2
% perl -le 'print reverse @ARGV' 0 1 2 3
3210




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    #list[0] = 1;
    #list[1] = 2;
    #list[2] = 3;
    #list[3] = 4;
    #list[4] = 5;

    #i = 4;
    while( #i >= 0 ) {
        message str( #list[#i] );
        #i = #i - 1;
    }




    

	

  
  





  
  


  
  






  
  

	

	  配列に長さを返すメソッドが無いらしい(!!)ので簡易実装。
	

	
	
	
    

      
1
2
3
4
5
配列：長さ＝「｜ｓ｜ｓ＝０。「未定義！＝(！(ｓ＋１)見る)」！の間「ｓ＝ｓ＋１」実行。ｓ」。
配列：逆順＝「｜ｒ　ｓ｜ｒ＝配列！作る。ｓ＝！長さ。
　「ｓ＞０」！の間「ｒ！(！(ｓ)見る)入れる。ｓ＝ｓ－１」実行。ｒ」。

ラベル！(配列！1 2 3 4 5 作る　逆順)作る。




    

	

  
  





  
  


  
  






  
  

	

	  
前半2行は配列に整形しているだけなので実質1行です。

	

	
	
	
    

      
1
2
3
list="1,2,3,4,5"
array=listを","で区切る
arrayを配列逆順して表示




    

	

  
  





  
  


  
  






  
  

	

	  
reverseObjectEnumeratorで。


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#import <Foundation/Foundation.h>

int main()
{
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
    NSArray *givenList = [NSArray arrayWithObjects:@"a", @"b", @"c", @"d", @"e", nil];
    for (id obj in [givenList reverseObjectEnumerator]) NSLog(obj);
    [pool release];
    return 0;
}




    

	

  
  





  
  


  
  






  
  

	

	  
はつける。


	

	
	
	
    

      
1
2
3
4
5
6
r :: [a] -> [a]
r [] = []
r (x:xs) = (r xs) ++ [x]

main :: IO ()
main = putStr $ show $ r [1,2,3,4,5]




    

	

  
  





  
  


  
  






  
  

	

	  
リストの要素数を調べてその回数分、「末尾の要素をプリントして、
末尾の要素を除いたリストを返す」を繰り返しています。
組み込みのリバースは「|.」です。

   rev_print 1 2 3 4 5
5
4
3
2
1


	

	
	
	
    

      
1
2
print=.(1!:2)&2
rev_print=.(}:[print&{:)^:(#&])




    

	

  
  





  
  


  
  






  
  

	

	  
cmd.exeで。cmd.exeのsetとかforは、command.comよりずいぶん拡張されているんですね。

>rev_list 1 2 3 4 5
5
4
3
2
1


	

	
	
	
    

      
1
2
3
4
@setlocal enabledelayedexpansion
@set a=
@for %%i in (%*) do @set a=%%i !a!
@for %%i in (!a!) do @echo %%i




    

	

  
  





  
  


  
  






  
  

	

	  
あけましておめでとうございます。
今年は、Lisp誕生50周年ということもあり、
最初期のLispの実装である、Lisp 1.5で挑戦してみることにしました!
動作は、IBM7094のエミュレータ上で確認しています。

エミュレータの詳細については、参考リンクが非常に参考になります。
実行結果：
---
 FUNCTION   EVALQUOTE   HAS BEEN ENTERED, ARGUMENTS..
PROG

(NIL (MAP (REVERSE GIVEN-LIST) (QUOTE (LAMBDA (X) (PRINT (CAR X))))))


5

4

3

2

1

END OF EVALQUOTE, VALUE IS ..
NIL

	

	
	

	  see: LISP 1.5 for the IBM 7090
	
  
	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
CSETQ(GIVEN-LIST (QUOTE (1 2 3 4 5)))

DEFINE ((
(REVERSE (LAMBDA (LST) (PROG (L RES)
                  (SETQ L LST)
            L     (COND ((NULL L) (RETURN RES)))
                  (SETQ RES (CONS (CAR L) RES))
                  (SETQ L (CDR L))
                  (GO L)))) ))

PROG(()
    (MAP (REVERSE GIVEN-LIST) (QUOTE (LAMBDA (X) (PRINT (CAR X)))))
)




    

	

  
  





  
  


  
  






  
  

	

	  
downtoメソッドで.


	

	
	
	
    

      
1
given_list.size.downto(0){|i| p given_list[i]}




    

	

  
  





  
  


  
  






  
  

	

	  
Mac OS X (PowerPC 32bit) アセンブリで、スタックを使って。


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
        .machine ppc
        .globl  _main

;; r6: リストのポインタ
;; r7: リストの要素数
;; r8: カウント
_main:
        ;; 初期化
        lis     r6, hi16(list)
        addi    r6, r6, lo16(list)
        lis     r7, hi16(list_size)
        addi    r7, r7, lo16(list_size)

        li      r8, 0

_push:
        lbz     r10, 0(r6)
        stbu    r10, -1(r1)
        addi    r6, r6, 1
        addi    r8, r8, 1
        cmpl    cr7, r7, r8
        bgt     cr7, _push

        li      r8, 0
        
_pop:
        lbz     r10, 0(r1)
        stwu    r8,-4(r1)       ; スタックに退避
        
        ;; 表示 
        li      r3, 1           ; stdout
        lis     r4, hi16(format)
        addi    r4, r4, lo16(format)
        addi    r10, r10, 48    ; ASCII
        stb     r10, 0(r4)
        li      r5, 2
        li      r0, 4           ; sys_write
        sc
        lwz     r8, 0(r1)       ; スタックから復帰
        addi    r1, r1, 4
        
        addi    r1, r1, 1
        addi    r8, r8, 1
        cmpl    cr7, r7, r8
        bgt     cr7, _pop
        
        ;; sys_exit()
        li      r3, 0
        li      r0, 1
        sc


        .data
        .align  2

list:
        .byte   1,2,3,4,5
        .align  2
        list_size = 5

format:
        .asciz  " \n"
        .align  2




    

	

  
  





  
  


  
  






  
  

	

	  
XPath Functions の reverse で逆順になります。


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:fn="http://www.w3.org/2005/xpath-functions"
  >

  <xsl:output method="text" />

  <xsl:template match="/" >
    <xsl:variable name="seq" as="xs:integer*" select="(1,2,3,4,5)" />
    <xsl:for-each select="fn:reverse($seq)" >
      <xsl:value-of select="." />
      <xsl:text>&#xA;</xsl:text>
    </xsl:for-each>
  </xsl:template>

</xsl:stylesheet>




    

	

  
  





  
  


  
  






  
  

	

	  
副作用を破壊的であるととりました。


	

	
	
	
    

      
1
2
3
4
5
6
7
8
9
<?php
// 配列へ整形
$given_list = "1,2,3,4,5";
$array = explode(',', $given_list);

// 出力
while(count($array)){
    echo array_pop($array)."\n";
}




    

	

  
  





  
  


  
  






  
  

	

	  
やっぱりこれしかないですかね。


	

	
	
	
    

      
1
println [1, 2, 3, 4, 5].reverse()




    

	

  
  





  
  


  
  






  
  

	

	  reverseで普通に。



Clojureでは、コンマは空白と同じ扱いになるようなので、お題のデータをそのまま加工しないで利用できて便利です :)
	

	
	
	
    

      
1
2
3
4
(def given-list [1, 2, 3, 4, 5])

(doseq item (reverse given-list)
  (prn item))




    

	

  
  





  
  


  
  






  
  

	

	  
Boost 1.36には逆順foreachが追加されました。それを使うと、こう書けます。


<algorithm>などの関数でかけるならそっちのほうが私の好みですが。


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include <iostream>
#include <boost/foreach.hpp>

int main()
{
    static const int a[] = {1, 2, 3, 4, 5};
    BOOST_REVERSE_FOREACH(int i, a)
    {
        std::cout << i << '\n';
    }
    std::cout << std::flush;
}




    

	

  
  





  
  


  
  






  
  

	

	  
LINQ使って無難に反転。
どう書くの”各言語の特徴を生かす”という題意にそう意味で。


	

	
	
	
    

      
1
2
3
List<object> ary = new List<object>() { 1, 4, 2, 4, 5 };
ary.Reverse();
ary.ForEach(Console.WriteLine);




    

	

  
  





  
  


  
  






  
  

	

	  
「LINQを使えば部分的な反転も出来ます」という例です。


	

	
	
	
    

      
1
2
3
4
5
6
List<object> ary = new List<object>() { 1, 4, 2, 4, 5 };
int index = 2; 
int count = 3;
ary.Reverse(index,count);
ary.ForEach(Console.WriteLine);
// 1, 4, 5, 4, 2




    

	

  
  





  
  


  
  






  
  

	

	  
なかったので。おもしろくも何ともないですが。


	

	
	
	
    

      
1
2
3
4
5
6
7
given_list = [1, 2, 3, 4, 5]
puts given_list.reverse
# >> 5
# >> 4
# >> 3
# >> 2
# >> 1




    

	

  
  





  
  


  
  






  
  

	

	  
あれ？「文字列の反転」でも、こんなコードを書いたような…?


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using System;
using System.Text;
class P
{
    static void Main(string[] args)
    {
        var tmp = new object[] { 1, 2, 3, 4, 5 };
        ReverseSlow(tmp).PrintArray();
        ReverseFast(tmp).PrintArray();
    }
    static T[] ReverseSlow<T>(T[] array)
    {
        return array.Reverse();
    }
    static T[] ReverseFast<T>(T[] array)
    {
        int length = array.Length;
        T[] tmp = new T[length];
        for (int i = 0; i < length; i++)
            tmp[i] = array[length - i - 1];
        return tmp;
    }
    static void PrintArray<T>(this T[] array)
    {
        string str = ToRawString<T>(array);
        Console.Write(str);
    }
    static string ToRawString<T>(this T[] array)
    {
        var sb = new StringBuilder(3 * array.Length);
        sb.Append("{ ");
        for (int i = 0; i < array.Length - 1; i++)
            sb.Append(array[i] + ", ");
        sb.Append(array[array.Length - 1] + " }");
        return sb.ToString();
    }
}




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
1
2
3
4
5
6
7
8
9
program doukaku27
  implicit none

  integer :: i, list(5) = (/ 1, 2, 3, 4, 5 /)

  print *, (list(i), i = 5, 1, -1)

  stop
end program doukaku27




    

	

  
  





  
  


  
  






  
  

	

	  
いったん文字列に保存しちゃうのは反則でしょうか？


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
\documentclass{article}

\begin{document}

\def\list{1,2,3,4,5}

\makeatletter
\def\tsil{}%
\@for\c:=\list\do{\edef\tsil{\c, \tsil}}%
\makeatother

\tsil

\end{document}




    

	

  
  





  
  


  
  






  
  

	

	  
こんな方法もあったりして．


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
\documentclass{article}

\begin{document}

\def\list{1,2,3,4,5}

\makeatletter
\setbox0=\hbox{\list}%
\null\hskip\wd0
\newlength\TempDim
\TempDim 0pt
\@for\c:=\list\do{%
  \llap{\c,\hskip\TempDim}%
  \advance\TempDim 1em}%
\makeatother

\end{document}




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
component doukaku239
  import List.{...}
  export Executable

  run(args: String...): () = do

    l = <|1, 2, 3, 4, 5|>

    println l.reverse()

  end
end




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
1
2
let given_list = [1; 2; 3; 4; 5];;
List.iter (Printf.printf "%d\n") (List.rev given_list);;




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
1
2
val given_list = [1, 2, 3, 4, 5];
app (fn x => print (Int.toString x ^ "\n")) (rev given_list);




    

	

  
  





  
  


  
  






  
  

	

	  
	

	
	
	
    

      
1
2
givenList = [1,2,3,4,5]
main = foldr (\x -> (>> print x)) (return ()) givenList




    

	

  
  





  
  


  
  






  
  

	

	  
アドレス０から連続して文字が格納されている場合。


	

	
	
	
    

      
1
[>]<[.<]>




    

	

  
  





  
  


  
  






  
  

	

	  
SQL Server 2008 で確認しました。


	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
WITH
  Input(i, n) AS (
    SELECT 1, 1
    UNION SELECT 2, 2
    UNION SELECT 3, 3
    UNION SELECT 4, 4
    UNION SELECT 5, 5
  )
SELECT
    n
FROM
    Input
ORDER BY
    i DESC




    

	

  
  





  
  


  
  






  
  

	

	  
PHP勉強中。

	

	
	
	
    

      
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
print <<< END_DOC
<HTML>
<HEAD><title>doukaku27</title>
</HEAD><BODY>
END_DOC;

function doukaku27()
{
    $l = array(1,2,3,4,5,6,7,8,9,10);
    
    foreach(array_reverse($l) as $t){
        print "$t,";
    }
}

doukaku27();

print <<< END_DOC
</BODY>
</HTML>
END_DOC;
?>




    

	

  
  





  
  


  
  






  
  

	

	  
非破壊(?)です


	

	
	
	
    

      
1
2
3
4
$given_list = 1..5
function reverse([array]$t){ $t[($t.Length-1)..0] }

reverse $given_list




    

	

  
  





  
  

















Index





Feed










Other





Link




Pathtraq



loading...














Creative Commons License
このサイトの内容は、
クリエイティブ・コモンズ・ライセンスの下でライセンスされています。
[詳細]