Offline-Echtzeit-Schreibweise Implementierungsbeispiel für das Problem in E05 (Ruby, C11)

Problem http://nabetani.sakura.ne.jp/hena/orde05dokitruck/ Implementierungslinks http://qiita.com/Nabetani/items/c516875b13a4d282affe ist.

damit.

Es gibt verschiedene Implementierungsrichtlinien.

• Ob von rechts oder links.
• Gehst du eins nach dem anderen oder alle auf einmal?
• Was soll die Daten haben

Ich werde frei wählen.

Ich habe sofort von hinten gerechnet und die Daten sind ein bisschen.

Erstens die Implementierung durch C11 oder C99:

// clang -std=c11 -Wall
// clang x86_64-apple-darwin15.5.0
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <memory.h>

char * build_ans( int s )
{
  char * r = calloc(4, 1);
  for( int i=0 ; i<3 ; ++i ){
    if ( s&(1<<i) ){
      strcat( r, (char[2]){'a'+i});
    }
  }
  if ( !*r ){
    r[0]='-';
  }
  return r;
}

char * solve( char const * src )
{
  int s=7;
  for( char const * it = src + strlen( src ) -1 ; src<=it ; --it ){
    switch(*it-'0'){
    case 1: s|=s/2; break;
    case 2: s|=(s&2)*2+!!(s&4); break;
    case 3: s|=!!(s&4)+(s&1)*2; break;
    case 4: s|=s*2; break;
    case 5: s|=(s&1)*4+(s&4)/2; break;
    case 6: s|=(s&1)*4+!!(s&2); break;
    case 7: s&=5; break;
    case 8: s&=6; break;
    case 9: s&=3; break;
    }
  }
  return build_ans(s);
}

void test( char const * src, char const * expected )
{
  char const * actual = solve( src );
  bool okay = 0==strcmp( actual, expected );
  printf( "%s %s->%s ( e:%s )\n", ( okay ? "ok" : "**NG**" ), src, actual , expected );
  free( actual );
}

int main()
{
  /*0*/ test( "1728398", "bc" );    
  //Abkürzung
  /*36*/ test( "697535114542", "ac" );
  return 0;
}

Wie üblich werden die meisten Testdaten weggelassen.

Da es drei Zustände gibt, Leben und Tod, kann es in 3 Bits ausgedrückt werden. Da das Leben auf 1 gesetzt ist, bringt "& =" den Tod und "| =" erhöht die Lebensmöglichkeit.

Das Innere von "lösen" ist durcheinander, aber es kann nicht geholfen werden, weil es die Unordnung der Blöcke ausdrückt, aus denen der Kurs besteht. Es wäre cool, es in Daten zu haben, aber diesmal wird es in Code ausgedrückt. Zur Erinnerung bedeutet "!!" eine Berechnung dahingehend, dass die logische Ablehnung zweimal durchgeführt wird und Nicht-Null auf 1 gesetzt wird.

Das Folgende ist eine in Ruby geschriebene Berechnung mit genau demselben Zweck. Oder besser gesagt, ich habe es früher in Rubin geschrieben.

def apply( s, c )
  case c
  when "0";    s
  when "1";    s | s[1] | s[2]*2
  when "2";    s | s[1]*4 | s[2]
  when "3";    s | s[0]*2 | s[2]
  when "4";    s | s[0]*2 | s[1]*4
  when "5";    s | s[0]*4 | s[2]*2
  when "6";    s | s[0]*4 | s[1]
  when "7";    s & 5
  when "8";    s & 6
  when "9";    s & 3
  end
end

def solve( src )
  r=src.chars.reverse.inject(7) do |s,c|
    apply( s, c )
  end
  %w( a b c ).each.with_index(0).map{ |c,ix|
    r[ix]==0 ? "" : c
  }.join.tap{ |x| return x.empty? ? "-" : x }
end

$stdout.sync=true

DATA.map do |line|
  num, src, expected = line.split(/\s+/)
  actual = solve( src )
  okay = actual==expected
  puts( "%s %2d %s->%s ( e:%s )" % [ ( okay ? "ok" : "**NG**" ), num, src, actual, expected ] )
  okay
end.all?.tap{|x| puts( x ? "everything is ok" : "something wrong" ) }

__END__
0 1728398 bc  
1 789 - 
2 274 ac  
3 185 abc 

36  697535114542  ac  

Sogar Bitoperationen sind mit Ruby einfacher zu schreiben.