편집 규칙의 문구를 수정하여 암시적인 내용을보다 명확하게 만들었습니다. 또한 혼동의 명백한 부분을 해결하는 데 중점을 두 었으며 기능 대신 독립형 프로그램을 만드는 옵션을 명시 적으로 정의했습니다.

여기서 목표는 텍스트 파일 (또는 문자열)을 가져 와서 행이 열이되도록 그 반대로 변환하는 기능을 만드는 것입니다.

예:

나는 텍스트입니다.
전치하십시오.
당신은 그것을 할 수 있습니다?

결과 :

ITC
 ra
아안
mn
 싸이
아포
 ou
ts
eed
xo
tm
.ei
 .티
  ?

규칙:

• 당신이 사용하는 유일한 공백 문자가 있다고 가정 할 수 있습니다 " "및 "\n"및 회선에 후행 공백이 없다는 것을.
• 파일이 ASCII라고 가정 할 수 있습니다. 사용하려는 종료 마커는 귀하에게 달려 있습니다 (CRLF 또는 LF). 예제에서는 올바르게 작동해야하지만 위의 가정을 만족하는 모든 입력 에서도 작동해야합니다 .
• 열을 일렬로 유지하려면 공간이 없어야합니다 (예에서와 같이).
• 결과 는 어떤 행에도 후행 공백 이 없어야합니다 .
• 마지막 줄 바꿈 문자는 선택 사항입니다.
• 기능이거나 완전한 프로그램이어야합니다. 귀하의 경우 함수는 문자열을 받아, 다음은 문자열로 결과를 반환해야합니다. 파일 이름을 허용하면 결과를 저장 한 파일의 이름을 반환합니다. 또한 STDIN의 입력을 승인하고 올바른 결과를 STDOUT에 출력 하는 완전한 프로그램 을 작성할 수 있습니다 . 이렇게하면 STDERR에 아무것도 출력 하지 않아야합니다 .
• 가장 짧은 절차가이기는하지만, 내가 좋아하는 답변을 찬성합니다.

규칙에 따라 예제의 출력은 최종 개행 문자의 포함 여부에 따라 53 바이트 또는 52 바이트 (LF 개행 문자)입니다.

참고 : 특정 요구 사항은 아니지만 두 번 연속으로 실행할 때 함수가 원본과 동일하지 않은 경우 (마지막 줄 바꿈이 다를 수 있으며 파일 끝의 빈 줄이 삭제됩니다) 아마도 규칙 중 하나를 어길 것입니다.

Japt , 6 바이트

y mx1R

이 시도
두 번 실행 - 원래 문자열을 반환

설명

y

입력 조옮김

m  R

각 라인에지도

x1

오른쪽 다듬기

J ( 31 40)

f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

이것은 문자열을 취하고 문자열을 반환하는 함수입니다 (예 : 문자형 벡터) , 행렬이 아닌 올바른 위치에 줄 바꿈이 삽입 된 ).

편집 : 모든 줄에 공백이 없습니다.

테스트:

   f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

   string=:stdin''
I am a text.
Transpose me.
Can you do it?
^D

   $string
42
   $f string
53
   f string
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

루비 111

골프 :

def f t;s=t.lines;s.map{|l|l.chomp.ljust(s.map(&:size).max).chars}.transpose.map{|l|l.join.rstrip+?\n}.join;end

언 골프 드 :

def transpose_text(text)
  max_length = text.lines.map(&:size).max
  text.lines.map do |line|
    line.chomp.ljust(max_length).chars
  end.transpose.map do |chars|
    chars.join.rstrip + "\n"
  end.join
end

루비에는 배열 전치 함수가 있으므로 간단히 행을 채우고 문자 배열로 바꾸고 Ruby의 Array # transpose 함수를 사용하여 문자 배열을 다시 행으로 바꿉니다.

골퍼는 단순히 단일 문자 식별자를 사용하고 공백을 제거하고 text.lines에 임시를 사용하고 max_length를 인라인으로 계산하는 것입니다 (효율에는 포인트가 없습니다).

제 171 화

function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")}

사용 예 :

text <- "I am a text.
Transpose me.
Can you do it?"


(function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")})(text)

ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

후행 공백이 제거됩니다.

파이썬 2.7 ( 97 79 94 90)

편집 : 기능 요구 사항을 놓쳤다;

저는 여기 초보자가 되었기 때문에 이것이 개선 될 것이라고 확신합니다.

c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))

코드는 단순 split을 사용 하여 문자열을 행 벡터로 분할합니다. 그런 다음 map함수 값을 다음 과 같이 사용합니다.None (통합 함수)로 사용하고 splat 연산자를 사용하여 벡터를 조옮김하고 zip_longest채 웁니다 (Python3에서 와 유사한 기능 )

나머지 코드 None는 공간에 매핑 되고 행렬을 다시 단일 문자열로 자르고 다시 조립합니다.

>>> a = 'I am a text.\nTranspose me.\nCan you do it?'
>>> c(a)                                                                            
'ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?'
>>> len("""c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))""")
88
# (+2 since `\n` is considered by `len` to be a single char)

배쉬 + 코어 유틸리티 + sed, 83

eval paste `sed 's/.*/<(fold -w1<<<"&")/'`|expand -t2|sed 's/\(.\) /\1/g;s/ \+$//'

fold 과 paste 중요한 일을. 나머지는 형식입니다.

stdin의 입력과 stdout의 출력을 승인합니다.

$ < tr.txt ./transposefile.sh
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
$ < tr.txt ./transposefile.sh | ./transposefile.sh
I am a text.
Transpose me.?
Can you do it
$ 

C (278 바이트)

편집 : 파일 이름을 인수로 사용하지만 stdout에 기록하기 때문에 실제로 규칙을 위반합니다. 나중에 편집하여 파일에 쓴 다음 파일 이름을 stdout에 인쇄합니다.

이것은 내 첫 번째 코드 골프이므로 자비를 베푸십시오. 평범한 오래된 C. 입력을 test.txt넣고 실행하십시오!

clang transpose.c -o transpose && ./transpose test.txt

#import <stdio.h>
#import <stdlib.h>
#import <string.h>

#define BUFFER_SIZE 1024

#define MAX(A,B) ((A)>(B)?(A):(B))

int main(int argc, char **argv) {
    char line[BUFFER_SIZE];

    FILE *f; int nLines, maxLen;

    f = fopen(argv[1], "r");
    while(!feof(f) && fgets(line, BUFFER_SIZE, f)) {
        nLines++;
        maxLen = MAX(maxLen, strlen(line));
    }
    fclose(f);

    for (int charPos = 0; charPos < maxLen; charPos++) {
        f = fopen(argv[1], "r");
        for (int linePos = 0; linePos < nLines; linePos++) {
            fgets(line, BUFFER_SIZE, f);
            printf("%c", charPos < strlen(line) && line[charPos] != '\xA' ? line[charPos] : ' ');
        }
        printf("\n");
        fclose(f);
    }

    return 0;
}

짧은 변수 이름을 사용하고 무료 형식을 제거하고 파일 핸들이 누수되도록하고 모든 경고를 비활성화하면이 값이 278 바이트로 줄어 듭니다. (이것은 암시 적 가져 오기를 사용하므로 모든 시스템에서 제대로 링크되지 않을 수 있습니다. 내 컴퓨터에서 작동합니다!)

#import <stdio.h>
int main(int C,char**V){char L[1024];int A,B,D,I,J,*F=fopen(V[1],"r");while(!feof(F)&&fgets(L,1024,F)){A++;D=strlen(L);B=B>D?B:D;}for(I=0;I<B;I++){F=fopen(V[1],"r");for(J=0;J<A;J++)fgets(L,1024,F)&&printf("%c",I<strlen(L)&&L[I]!='\n'?L[I]:' ');printf("\n");}}

오토 핫키 210

f(i){
StringSplit,o,i,`n
m:=0
loop % o0 {
a:=A_index
if (t:=Strlen(p:=o%a%))>m
m:=t
StringSplit,l%a%,o%a%
}
loop % m {
a:=A_index,n:=""
loop % o0
n.=(j:=l%A_index%%a%)=""?" ":j
s.=Rtrim(n," ") "`n"
}
return s
}

테스트

text=
(
I am a text.
Transpose me.
Can you do it?
)
msgbox % f(text)

루비 : 88 자

(다른 Ruby 솔루션보다 짧기 때문에 게시되었습니다. 내 코드가 새로운 코드를 소개하는지 여부를 확인하지 않았습니다. 이미 Ruby 솔루션을 게시했는데 이것이 대부분 귀하의 사본이라고 생각하면 의견을 말하고 답변을 중단하겠습니다. )

f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}

샘플 실행 :

irb(main):001:0> f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}
=> #<Proc:0x99a9e68@(irb):1 (lambda)>

irb(main):002:0> sample='I am a text.
irb(main):003:0' Transpose me.
irb(main):004:0' Can you do it?'
=> "I am a text.\nTranspose me.\nCan you do it?"

irb(main):005:0> puts f[sample]
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
=> nil

irb(main):006:0> puts f[f[sample]]
I am a text.
Transpose me.
Can you do it?
=> nil

배쉬, 124 바이트

D=`mktemp -d`;split -l1 - $D/;for F in $D/*;do grep -o . $F>$F+
done;paste $D/*+|sed -e's/\([^\t]\)\t/\1/g;s/\t/ /g;s/ *$//'

표준 입력을 읽고 표준 출력을 씁니다. 시도 해봐:

echo $'I am a text.\nTranspose me.\nCan you do it?' | script.sh

작동 방식 :

• split 한 줄로 입력 (임시 디렉토리의 파일) $D )
• 를 사용하여 줄을 단일 문자로 나누기 grep(파일 * +)를
• 문자를 나란히 배치하여 배치 paste(TAB 구분 열)을
• 정렬 TAB 제거, 필러 TAB을 공백으로 교체, sed

편집하다:

• -9 : 깔끔한 코드 제거 ;rm -r $D (Tim 덕분에)
• -2 : 접미사 +대신 사용 _하고 단축${F}_ 에$F+
• -3 : L분할 결과 파일에서 접두사 제거

루비 — 144 자

골프를 치는 나의 첫 번째 시도는 다음과 같습니다.

def f t
t.split(?\n).each{|l|l<<' 'until l.size==t.split(?\n).map(&:size).max}.map{|x|x.split('')}.transpose.map{|l|l.join.rstrip}.join(?/n)
end

출력 하려면 위의 규칙을 준수하는 여러 줄 문자열이있는 puts f text곳 에서 실행 text하십시오. ungolfed 버전은 다음과 같습니다.

def text_transpose(text)
  lines = text.split(?\n)
  maxlen = lines.map(&:size).max
  lines.each { |line| line << ' ' until line.size == maxlen }
       .map  { |line| line.split('') }.transpose
       .map  { |char| char.join.rstrip }.join(?\n)
end

루비에서 비슷하지만 궁극적으로 더 나은 솔루션은 위의 Wayne Conrad의 코드를 확인하십시오.

PHP 194

function x($a){$a.="\n";$s=strlen($a);$i=0;while($c<$s)if($a{$c}!="\n")$b[$i++].=$a{$c++};else{$c++;for(;$i<$s;$i++)$b[$i].=" ";$i=0;}ksort($b);return rtrim(implode("\n",array_map("trim",$b)));}

골퍼가 아닌 :

function x($a) {
    $a.="\n";
    $s=strlen($a);
    $i=0;
    while($c<$s)
        if($a{$c}!="\n")
            $b[$i++].=$a{$c++};
        else{
            $c++;
            for(;$i<$s;$i++)
                $b[$i].=" ";$i=0;
        }
    ksort($b);
    return rtrim(implode("\n",array_map("trim",$b)));
}

이것은 나의 첫 번째 골프 시도이므로 친절하십시오! 또한, 팁 / 제안은 크게 감사하겠습니다!

MATHEMATICA 117 자

t = "I am a text.\nTranspose me.\nCan you do it?";

f=(m=Length/@(f=Flatten[Characters/@StringSplit[#,"\n"],{{2},{1}}])//Max;
StringJoin@@@(PadLeft[#,m," "]&/@f)//Column)&

펄 (92 + 1)

stdin을 읽고 stdout에 씁니다. 에 대한 점수에 1을 더함say

@L=map[grep!/\n/,split//],<>;do{$_=join'',map shift@$_||$",@L;s/ +$//;say}while grep@$_>0,@L

CJam, 32 25 바이트

CJam은이 도전보다 새로운 것이므로이 답변을 수락 할 수 없습니다.

user23013에 의해 상당히 단축되었습니다.

qN/_z,f{Se]}z{S+e`);e~N}%

여기에서 테스트하십시오.

qN/                       "Read input, split into lines.";
   _z,                    "Transpose, get length (find maximum line length).";
      f{Se]}              "Pad each line to that length with spaces.";
            z             "Transpose.";
             {         }% "Map this block onto each line in the result.";
              S+          "Add a space to ensure there's at least one.";
                e`        "Run-length encode.";
                  );      "Discard the trailing run of spaces.";
                    e~    "Run-length decode";
                      N   "Push a newline.";

자바 스크립트, 103

s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

덜 골프

s=>[...s].map(
     // we need 'i' ranging from 0 to the length of the longest input line
     // so we scan all the input string, that is surely longer
     // but we need to check that after some point the output must be empty
     (_, i) => ( 
       r = '', // the current output row, starts empty
       q = '', // flag to check if we are beyond the longest line
       s.split('\n') // split in rows
       .map( 
         b => ( // for each input row in b
           q = b[i] || q, // if there is a char at position i in b, i goes to q
           r += b[i] || ' ' // add to output the char at position i or a fill space
         )
       ),
       q // if q is still '', we are beyond the longest input line 
       ? r.replace(/ *$/,`\n`) // trim leading space and add newline
       : '' // no output 
     )
   ).join('')

테스트

F=
s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

function go() {
  var text=I.value
  var output = F(text)
  O.textContent = output
}

go()

#I { width:50%; height:5em }

<textarea id=I>I am a text.
Transpose me.
Can you do it?</textarea><br>
<button onclick='go()'>Transpose</button>
<pre id=O></pre>

레티 나 , 40 바이트

P`.+
~L0$`.
L,$.%'vs,$.(x$%=),`.+
m` *$

온라인으로 사용해보십시오!

내가 만든 크기의 사각형을 전치하기 위해 만든 이 프로그램 을 기반으로 알려진 크기의 사각형을 전치하기 위해 Leo의 제안 을 사용 합니다.

편집 : 더 많은 골프를하고 더 이상 줄에 후행 공백이 없습니다.

펄 5 , 25 바이트

이것은 ANSI 이스케이프 시퀀스를 사용하므로 TIO에서는 작동하지 않지만 여기서 작동하는 것을 볼 수 있습니다 .

$"="[1D";$_="[1;$.H@F"

설명

이 코드는 먼저 목록 구분 기호 ( $") 값을 세로 탭으로 변경 한 다음 '뒤로 1 열 이동'( \x1b[1D) 에 대한 ANSI 이스케이프 시퀀스를 변경 한 다음 암시 적으로 인쇄 된 변수 $_를 ANSI 이스케이프 시퀀스로 시작하는 문자열로 설정합니다. '행 1 열에서 인쇄 시작 $.( $.현재 텍스트 행)'( \x1b1;$.H)을 표시하고 목록 @F(해당 행의 모든 ​​문자 목록, 자동 -a분할 ( )로 채워진 빈 분할 패턴 (-F )으로 자동 ) $"각 문자 사이에 내용을 배치하고 이전 문자 다음에 출력을 계속하는 대신 커서를 세로로 아래로 이동합니다.

온라인으로 사용해보십시오!

C ++ (243 자)

다음은 문자열을 가져 와서 반환하는 함수입니다.

나는 수십 개의 문자를 면도 할 수 있었지만 어리석지 않은 코드로 유지하기로 결정했습니다 (빠르게 실행하고 읽습니다). 어쩌면 나는 이것이 첫 번째 코드 골프이기 때문에 그렇게하기로 결정했습니다 ... 아직 하드 코어가 아닙니다 :)

string f(string s){stringstream ss(s);vector<string> v;for(size_t i=0;getline(ss,s);++i){if(v.size() < s.size())v.resize(s.size());for(size_t j=0;j<s.size();++j){v[j].resize(i,' ');v[j].push_back(s[j]);}}s="";for(auto& i:v)s+=i+'\n';return s;}

형식화 :

string f(string s)
{
    stringstream ss(s);
    vector<string> v;

    for(size_t i = 0; getline(ss, s); ++i)
    {
        if(v.size() < s.size())
            v.resize(s.size());

        for(size_t j = 0; j < s.size(); ++j)
        {
            v[j].resize(i, ' ');
            v[j].push_back(s[j]);
        }
    }

    s = "";
    for(auto& i : v)
        s += i + '\n';

    return s;
}

파이썬 2.7- 자 :

짧막 한 농담:

>>> a
'I am a text.\nTranspose me.\nCan you do it?'

>>> "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
'ITC\n ra\naan\nmn \n sy\napo\n ou\nts \need\nx o\ntm \n.ei\n .t\n  ?\n'

깔끔한 인쇄 :

>>> print "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
ITC
 ra
aan
mn 
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

115 자 이내 :

>>> len(""""".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])""")
115

GolfScript, 51 자

n%.{,}%$-1=" "*:y;{y+y,<}%zip{n\+0{;).32=}do}%((;\+

이것은 첫 번째 시도입니다. 나는 그것이 향상 될 수 있다고 생각합니다. 코드의 대부분은 패딩 및 후행 공간 제거 요구 사항을 준수하는 것입니다.n%zip n* 것입니다.

추신. 다음 46 자 버전은 주어진 샘플 입력에 대해 작업을 수행하지만 입력 열이 공백으로 만 구성된 경우 충돌합니다.

n%.{,}%$-1=" "*:y;{y+y,<}%zip{0{;).32=}do]}%n*

도전이 명시 적으로 말하지 않아도 자격을 박탈하기에 충분하다고 생각합니다.

계획 / 라켓 113

텍스트 :

(define t (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

Without new lines and extra white spaces:

(define s(λ(v x)(if(= x 0)'()(cons(list->string(car v))(s(cdr v)(- x 1))))))(s(apply map list t)(length(car t)))

The user-friendly version

(define text (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

(define transpose
    (λ(text length)
        (if (= length 0)
            '()
            (cons (list->string (car text)) (transpose (cdr text) (- length 1)))
)))

(transpose (apply map list text) (length (car text)))

Haskell

import Data.List
main = interact (unlines . transpose . lines)

It was so short, I needed to add in white space...

Python 89 103 chars

def f(a):return'\n'.join([''.join(i).rstrip()for i in zip(*[j+' '*99 for j in a.split('\n')])]).rstrip()

I feel dirty. 90 104 chars for industrial strength version. :^)

Mathematica, 95 chars

f=""<>Riffle[Thread@PadRight@Characters@StringSplit[#,"\n"]//.{0->" ",{x___," "..}:>{x}},"\n"]&

K, 56

This should meet the spec now.

Accepts a string, returns a string.

{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}

.

k)f:{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}
k)f"I am a text.\nTranspose me.\nCan you do it?"
"ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?\n"
k)f f"I am a text.\nTranspose me.\nCan you do it?"
"I am a text.\nTranspose me.\nCan you do it?\n"

Groovy, 98 chars

{i->o=[].withDefault{''};i.readLines().each{it.toList().eachWithIndex{c,d->o[d]+=c}};o.join('\n')}

online

ungolfed:

{i->
o=[].withDefault{''};//create list with empty string as default value 
i.readLines()
.each{
    it.toList() //split every line to characters
    .eachWithIndex{ 
        c,d->o[d]+=c //append to string from list with right index
    }
};
o.join('\n')}//join list with newlines
}

Pyth, 11 bytes

# aYcw1;.tY

Try it online!

Takes input as a string, outputs a list of lists

Pyth, 25 bytes

# aYcw1=+Z1;jbcj"".n.tY)Z

Takes input as a string, outputs a string.

Try it online!

J, 28 26 Bytes

Saved 2 bytes thanks to frownyfrog

t=.,@:(,&LF"1)@|:@:>@cutLF

Takes a string, returns a string. I'm not sure if there's a shorter version of the 'cutopen' function verb that I could use.

There's also the shorter

t=.|:@:>@cutLF

But I'm not sure it falls within the OP's guidelines, as it returns an array of characters.

How it works:

                     cutLF   | Splits the input on new lines and boxes them
                    @        | Composes verbs (as does @:, but they're not equal)
                   >         | Unboxes this, forming an array of the lines
                 @:          |
               |:            | Transposes the array
      (      )@              |
       ,&LF                  | Appends a new line...
           "1                | To each row of the array
    @:                       |
   ,                         | Flatten the result
t=.                          | Assign this verb to t

The other version works the same, but doesn't convert the transposed array to a properly formatted string.

Examples:

NB. Define a multi-line string

    text =: 0 : 0
I am a text.
Transpose me.
Can you do it?
)

    t text
ITC
 ra
aan
mn    NB. There's whitespace after the 'n' here, but I assume it doesn't count as trailing since it's part of the original string
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

    t t text
I am a text.     NB. Again, whitespace here, but it's part of the argument of the second 't' (added by the first 't' to keep columns straight)
Transpose me. 
Can you do it?

Lua, 203 189 bytes

t={{}}i=1m=0(...):gsub(".",function(c)n=#t[i]if c=="\n"then i=i+1t[i]={}else t[i][n+1]=c end m=m<=n and n+1or m end)
for x=1,m do for p=1,i do io.write(t[p][x]or" ")end _=m<=x or print()end

Try it online!

I saw another Lua solution here, but I don't think there's a problem with posting 2 solutions on the same language. If there is, tell me :)